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
)
3435 switch (bfd_get_arch (abfd
))
3438 /* For some reasons stabs adds 2 to the floating point register
3445 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3446 32 to 35 for fp0 to fp3. */
3454 /* Convert a generic register number to an IEEE specific one. */
3457 ieee_genreg_to_regno (abfd
, r
)
3461 switch (bfd_get_arch (abfd
))
3464 /* For some reason stabs add 2 to the floating point register
3471 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3472 32 to 35 for fp0 to fp3. */
3480 /* These routines build IEEE debugging information out of the generic
3481 debugging information. */
3483 /* We build the IEEE debugging information byte by byte. Rather than
3484 waste time copying data around, we use a linked list of buffers to
3487 #define IEEE_BUFSIZE (490)
3492 struct ieee_buf
*next
;
3493 /* Number of data bytes in this buffer. */
3496 bfd_byte buf
[IEEE_BUFSIZE
];
3499 /* A list of buffers. */
3504 struct ieee_buf
*head
;
3505 /* Tail--last buffer on list. */
3506 struct ieee_buf
*tail
;
3509 /* In order to generate the BB11 blocks required by the HP emulator,
3510 we keep track of ranges of addresses which correspond to a given
3511 compilation unit. */
3516 struct ieee_range
*next
;
3523 /* This structure holds information for a class on the type stack. */
3525 struct ieee_type_class
3527 /* The name index in the debugging information. */
3529 /* The pmisc records for the class. */
3530 struct ieee_buflist pmiscbuf
;
3531 /* The number of pmisc records. */
3532 unsigned int pmisccount
;
3533 /* The name of the class holding the virtual table, if not this
3536 /* Whether this class holds its own virtual table. */
3538 /* The largest virtual table offset seen so far. */
3540 /* The current method. */
3542 /* Additional pmisc records used to record fields of reference type. */
3543 struct ieee_buflist refs
;
3546 /* This is how we store types for the writing routines. Most types
3547 are simply represented by a type index. */
3549 struct ieee_write_type
3553 /* The size of the type, if known. */
3555 /* The name of the type, if any. */
3557 /* If this is a function or method type, we build the type here, and
3558 only add it to the output buffers if we need it. */
3559 struct ieee_buflist fndef
;
3560 /* If this is a struct, this is where the struct definition is
3562 struct ieee_buflist strdef
;
3563 /* If this is a class, this is where the class information is built. */
3564 struct ieee_type_class
*classdef
;
3565 /* Whether the type is unsigned. */
3566 unsigned int unsignedp
: 1;
3567 /* Whether this is a reference type. */
3568 unsigned int referencep
: 1;
3569 /* Whether this is in the local type block. */
3570 unsigned int localp
: 1;
3571 /* Whether this is a duplicate struct definition which we are
3573 unsigned int ignorep
: 1;
3576 /* This is the type stack used by the debug writing routines. FIXME:
3577 We could generate more efficient output if we remembered when we
3578 have output a particular type before. */
3580 struct ieee_type_stack
3582 /* Next entry on stack. */
3583 struct ieee_type_stack
*next
;
3584 /* Type information. */
3585 struct ieee_write_type type
;
3588 /* This is a list of associations between a name and some types.
3589 These are used for typedefs and tags. */
3591 struct ieee_name_type
3593 /* Next type for this name. */
3594 struct ieee_name_type
*next
;
3595 /* ID number. For a typedef, this is the index of the type to which
3596 this name is typedefed. */
3599 struct ieee_write_type type
;
3600 /* If this is a tag which has not yet been defined, this is the
3601 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
3602 enum debug_type_kind kind
;
3605 /* We use a hash table to associate names and types. */
3607 struct ieee_name_type_hash_table
3609 struct bfd_hash_table root
;
3612 struct ieee_name_type_hash_entry
3614 struct bfd_hash_entry root
;
3615 /* Information for this name. */
3616 struct ieee_name_type
*types
;
3619 /* This is a list of enums. */
3621 struct ieee_defined_enum
3624 struct ieee_defined_enum
*next
;
3632 bfd_signed_vma
*vals
;
3635 /* We keep a list of modified versions of types, so that we don't
3636 output them more than once. */
3638 struct ieee_modified_type
3640 /* Pointer to this type. */
3641 unsigned int pointer
;
3642 /* Function with unknown arguments returning this type. */
3643 unsigned int function
;
3644 /* Const version of this type. */
3645 unsigned int const_qualified
;
3646 /* Volatile version of this type. */
3647 unsigned int volatile_qualified
;
3648 /* List of arrays of this type of various bounds. */
3649 struct ieee_modified_array_type
*arrays
;
3652 /* A list of arrays bounds. */
3654 struct ieee_modified_array_type
3656 /* Next array bounds. */
3657 struct ieee_modified_array_type
*next
;
3658 /* Type index with these bounds. */
3663 bfd_signed_vma high
;
3666 /* This is a list of pending function parameter information. We don't
3667 output them until we see the first block. */
3669 struct ieee_pending_parm
3671 /* Next pending parameter. */
3672 struct ieee_pending_parm
*next
;
3677 /* Whether the type is a reference. */
3680 enum debug_parm_kind kind
;
3685 /* This is the handle passed down by debug_write. */
3689 /* BFD we are writing to. */
3691 /* Whether we got an error in a subroutine called via traverse or
3692 map_over_sections. */
3694 /* Current data buffer list. */
3695 struct ieee_buflist
*current
;
3696 /* Current data buffer. */
3697 struct ieee_buf
*curbuf
;
3698 /* Filename of current compilation unit. */
3699 const char *filename
;
3700 /* Module name of current compilation unit. */
3701 const char *modname
;
3702 /* List of buffer for global types. */
3703 struct ieee_buflist global_types
;
3704 /* List of finished data buffers. */
3705 struct ieee_buflist data
;
3706 /* List of buffers for typedefs in the current compilation unit. */
3707 struct ieee_buflist types
;
3708 /* List of buffers for variables and functions in the current
3709 compilation unit. */
3710 struct ieee_buflist vars
;
3711 /* List of buffers for C++ class definitions in the current
3712 compilation unit. */
3713 struct ieee_buflist cxx
;
3714 /* List of buffers for line numbers in the current compilation unit. */
3715 struct ieee_buflist linenos
;
3716 /* Ranges for the current compilation unit. */
3717 struct ieee_range
*ranges
;
3718 /* Ranges for all debugging information. */
3719 struct ieee_range
*global_ranges
;
3720 /* Nested pending ranges. */
3721 struct ieee_range
*pending_ranges
;
3723 struct ieee_type_stack
*type_stack
;
3724 /* Next unallocated type index. */
3725 unsigned int type_indx
;
3726 /* Next unallocated name index. */
3727 unsigned int name_indx
;
3729 struct ieee_name_type_hash_table typedefs
;
3731 struct ieee_name_type_hash_table tags
;
3733 struct ieee_defined_enum
*enums
;
3734 /* Modified versions of types. */
3735 struct ieee_modified_type
*modified
;
3736 /* Number of entries allocated in modified. */
3737 unsigned int modified_alloc
;
3738 /* The depth of block nesting. This is 0 outside a function, and 1
3739 just after start_function is called. */
3740 unsigned int block_depth
;
3741 /* The name of the current function. */
3743 /* List of buffers for the type of the function we are currently
3745 struct ieee_buflist fntype
;
3746 /* List of buffers for the parameters of the function we are
3747 currently writing out. */
3748 struct ieee_buflist fnargs
;
3749 /* Number of arguments written to fnargs. */
3750 unsigned int fnargcount
;
3751 /* Pending function parameters. */
3752 struct ieee_pending_parm
*pending_parms
;
3753 /* Current line number filename. */
3754 const char *lineno_filename
;
3755 /* Line number name index. */
3756 unsigned int lineno_name_indx
;
3757 /* Filename of pending line number. */
3758 const char *pending_lineno_filename
;
3759 /* Pending line number. */
3760 unsigned long pending_lineno
;
3761 /* Address of pending line number. */
3762 bfd_vma pending_lineno_addr
;
3763 /* Highest address seen at end of procedure. */
3767 static boolean ieee_init_buffer
3768 PARAMS ((struct ieee_handle
*, struct ieee_buflist
*));
3769 static boolean ieee_change_buffer
3770 PARAMS ((struct ieee_handle
*, struct ieee_buflist
*));
3771 static boolean ieee_append_buffer
3772 PARAMS ((struct ieee_handle
*, struct ieee_buflist
*,
3773 struct ieee_buflist
*));
3774 static boolean ieee_real_write_byte
PARAMS ((struct ieee_handle
*, int));
3775 static boolean ieee_write_2bytes
PARAMS ((struct ieee_handle
*, int));
3776 static boolean ieee_write_number
PARAMS ((struct ieee_handle
*, bfd_vma
));
3777 static boolean ieee_write_id
PARAMS ((struct ieee_handle
*, const char *));
3778 static boolean ieee_write_asn
3779 PARAMS ((struct ieee_handle
*, unsigned int, bfd_vma
));
3780 static boolean ieee_write_atn65
3781 PARAMS ((struct ieee_handle
*, unsigned int, const char *));
3782 static boolean ieee_push_type
3783 PARAMS ((struct ieee_handle
*, unsigned int, unsigned int, boolean
,
3785 static unsigned int ieee_pop_type
PARAMS ((struct ieee_handle
*));
3786 static void ieee_pop_unused_type
PARAMS ((struct ieee_handle
*));
3787 static unsigned int ieee_pop_type_used
3788 PARAMS ((struct ieee_handle
*, boolean
));
3789 static boolean ieee_add_range
3790 PARAMS ((struct ieee_handle
*, boolean
, bfd_vma
, bfd_vma
));
3791 static boolean ieee_start_range
PARAMS ((struct ieee_handle
*, bfd_vma
));
3792 static boolean ieee_end_range
PARAMS ((struct ieee_handle
*, bfd_vma
));
3793 static boolean ieee_define_type
3794 PARAMS ((struct ieee_handle
*, unsigned int, boolean
, boolean
));
3795 static boolean ieee_define_named_type
3796 PARAMS ((struct ieee_handle
*, const char *, unsigned int, unsigned int,
3797 boolean
, boolean
, struct ieee_buflist
*));
3798 static struct ieee_modified_type
*ieee_get_modified_info
3799 PARAMS ((struct ieee_handle
*, unsigned int));
3800 static struct bfd_hash_entry
*ieee_name_type_newfunc
3801 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
3802 static boolean ieee_write_undefined_tag
3803 PARAMS ((struct ieee_name_type_hash_entry
*, PTR
));
3804 static boolean ieee_finish_compilation_unit
PARAMS ((struct ieee_handle
*));
3805 static void ieee_add_bb11_blocks
PARAMS ((bfd
*, asection
*, PTR
));
3806 static boolean ieee_add_bb11
3807 PARAMS ((struct ieee_handle
*, asection
*, bfd_vma
, bfd_vma
));
3808 static boolean ieee_output_pending_parms
PARAMS ((struct ieee_handle
*));
3809 static unsigned int ieee_vis_to_flags
PARAMS ((enum debug_visibility
));
3810 static boolean ieee_class_method_var
3811 PARAMS ((struct ieee_handle
*, const char *, enum debug_visibility
, boolean
,
3812 boolean
, boolean
, bfd_vma
, boolean
));
3814 static boolean ieee_start_compilation_unit
PARAMS ((PTR
, const char *));
3815 static boolean ieee_start_source
PARAMS ((PTR
, const char *));
3816 static boolean ieee_empty_type
PARAMS ((PTR
));
3817 static boolean ieee_void_type
PARAMS ((PTR
));
3818 static boolean ieee_int_type
PARAMS ((PTR
, unsigned int, boolean
));
3819 static boolean ieee_float_type
PARAMS ((PTR
, unsigned int));
3820 static boolean ieee_complex_type
PARAMS ((PTR
, unsigned int));
3821 static boolean ieee_bool_type
PARAMS ((PTR
, unsigned int));
3822 static boolean ieee_enum_type
3823 PARAMS ((PTR
, const char *, const char **, bfd_signed_vma
*));
3824 static boolean ieee_pointer_type
PARAMS ((PTR
));
3825 static boolean ieee_function_type
PARAMS ((PTR
, int, boolean
));
3826 static boolean ieee_reference_type
PARAMS ((PTR
));
3827 static boolean ieee_range_type
PARAMS ((PTR
, bfd_signed_vma
, bfd_signed_vma
));
3828 static boolean ieee_array_type
3829 PARAMS ((PTR
, bfd_signed_vma
, bfd_signed_vma
, boolean
));
3830 static boolean ieee_set_type
PARAMS ((PTR
, boolean
));
3831 static boolean ieee_offset_type
PARAMS ((PTR
));
3832 static boolean ieee_method_type
PARAMS ((PTR
, boolean
, int, boolean
));
3833 static boolean ieee_const_type
PARAMS ((PTR
));
3834 static boolean ieee_volatile_type
PARAMS ((PTR
));
3835 static boolean ieee_start_struct_type
3836 PARAMS ((PTR
, const char *, unsigned int, boolean
, unsigned int));
3837 static boolean ieee_struct_field
3838 PARAMS ((PTR
, const char *, bfd_vma
, bfd_vma
, enum debug_visibility
));
3839 static boolean ieee_end_struct_type
PARAMS ((PTR
));
3840 static boolean ieee_start_class_type
3841 PARAMS ((PTR
, const char *, unsigned int, boolean
, unsigned int, boolean
,
3843 static boolean ieee_class_static_member
3844 PARAMS ((PTR
, const char *, const char *, enum debug_visibility
));
3845 static boolean ieee_class_baseclass
3846 PARAMS ((PTR
, bfd_vma
, boolean
, enum debug_visibility
));
3847 static boolean ieee_class_start_method
PARAMS ((PTR
, const char *));
3848 static boolean ieee_class_method_variant
3849 PARAMS ((PTR
, const char *, enum debug_visibility
, boolean
, boolean
,
3851 static boolean ieee_class_static_method_variant
3852 PARAMS ((PTR
, const char *, enum debug_visibility
, boolean
, boolean
));
3853 static boolean ieee_class_end_method
PARAMS ((PTR
));
3854 static boolean ieee_end_class_type
PARAMS ((PTR
));
3855 static boolean ieee_typedef_type
PARAMS ((PTR
, const char *));
3856 static boolean ieee_tag_type
3857 PARAMS ((PTR
, const char *, unsigned int, enum debug_type_kind
));
3858 static boolean ieee_typdef
PARAMS ((PTR
, const char *));
3859 static boolean ieee_tag
PARAMS ((PTR
, const char *));
3860 static boolean ieee_int_constant
PARAMS ((PTR
, const char *, bfd_vma
));
3861 static boolean ieee_float_constant
PARAMS ((PTR
, const char *, double));
3862 static boolean ieee_typed_constant
PARAMS ((PTR
, const char *, bfd_vma
));
3863 static boolean ieee_variable
3864 PARAMS ((PTR
, const char *, enum debug_var_kind
, bfd_vma
));
3865 static boolean ieee_start_function
PARAMS ((PTR
, const char *, boolean
));
3866 static boolean ieee_function_parameter
3867 PARAMS ((PTR
, const char *, enum debug_parm_kind
, bfd_vma
));
3868 static boolean ieee_start_block
PARAMS ((PTR
, bfd_vma
));
3869 static boolean ieee_end_block
PARAMS ((PTR
, bfd_vma
));
3870 static boolean ieee_end_function
PARAMS ((PTR
));
3871 static boolean ieee_lineno
3872 PARAMS ((PTR
, const char *, unsigned long, bfd_vma
));
3874 static const struct debug_write_fns ieee_fns
=
3876 ieee_start_compilation_unit
,
3887 ieee_reference_type
,
3895 ieee_start_struct_type
,
3897 ieee_end_struct_type
,
3898 ieee_start_class_type
,
3899 ieee_class_static_member
,
3900 ieee_class_baseclass
,
3901 ieee_class_start_method
,
3902 ieee_class_method_variant
,
3903 ieee_class_static_method_variant
,
3904 ieee_class_end_method
,
3905 ieee_end_class_type
,
3911 ieee_float_constant
,
3912 ieee_typed_constant
,
3914 ieee_start_function
,
3915 ieee_function_parameter
,
3922 /* Initialize a buffer to be empty. */
3926 ieee_init_buffer (info
, buflist
)
3927 struct ieee_handle
*info
;
3928 struct ieee_buflist
*buflist
;
3930 buflist
->head
= NULL
;
3931 buflist
->tail
= NULL
;
3935 /* See whether a buffer list has any data. */
3937 #define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL)
3939 /* Change the current buffer to a specified buffer chain. */
3942 ieee_change_buffer (info
, buflist
)
3943 struct ieee_handle
*info
;
3944 struct ieee_buflist
*buflist
;
3946 if (buflist
->head
== NULL
)
3948 struct ieee_buf
*buf
;
3950 buf
= (struct ieee_buf
*) xmalloc (sizeof *buf
);
3953 buflist
->head
= buf
;
3954 buflist
->tail
= buf
;
3957 info
->current
= buflist
;
3958 info
->curbuf
= buflist
->tail
;
3963 /* Append a buffer chain. */
3967 ieee_append_buffer (info
, mainbuf
, newbuf
)
3968 struct ieee_handle
*info
;
3969 struct ieee_buflist
*mainbuf
;
3970 struct ieee_buflist
*newbuf
;
3972 if (newbuf
->head
!= NULL
)
3974 if (mainbuf
->head
== NULL
)
3975 mainbuf
->head
= newbuf
->head
;
3977 mainbuf
->tail
->next
= newbuf
->head
;
3978 mainbuf
->tail
= newbuf
->tail
;
3983 /* Write a byte into the buffer. We use a macro for speed and a
3984 function for the complex cases. */
3986 #define ieee_write_byte(info, b) \
3987 ((info)->curbuf->c < IEEE_BUFSIZE \
3988 ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), true) \
3989 : ieee_real_write_byte ((info), (b)))
3992 ieee_real_write_byte (info
, b
)
3993 struct ieee_handle
*info
;
3996 if (info
->curbuf
->c
>= IEEE_BUFSIZE
)
4000 n
= (struct ieee_buf
*) xmalloc (sizeof *n
);
4003 if (info
->current
->head
== NULL
)
4004 info
->current
->head
= n
;
4006 info
->current
->tail
->next
= n
;
4007 info
->current
->tail
= n
;
4011 info
->curbuf
->buf
[info
->curbuf
->c
] = b
;
4017 /* Write out two bytes. */
4020 ieee_write_2bytes (info
, i
)
4021 struct ieee_handle
*info
;
4024 return (ieee_write_byte (info
, i
>> 8)
4025 && ieee_write_byte (info
, i
& 0xff));
4028 /* Write out an integer. */
4031 ieee_write_number (info
, v
)
4032 struct ieee_handle
*info
;
4040 if (v
<= (bfd_vma
) ieee_number_end_enum
)
4041 return ieee_write_byte (info
, (int) v
);
4052 if (c
> (unsigned int) (ieee_number_repeat_end_enum
4053 - ieee_number_repeat_start_enum
))
4055 fprintf (stderr
, "IEEE numeric overflow: 0x");
4056 fprintf_vma (stderr
, v
);
4057 fprintf (stderr
, "\n");
4061 if (! ieee_write_byte (info
, (int) ieee_number_repeat_start_enum
+ c
))
4063 for (; c
> 0; --c
, ++p
)
4065 if (! ieee_write_byte (info
, *p
))
4072 /* Write out a string. */
4075 ieee_write_id (info
, s
)
4076 struct ieee_handle
*info
;
4084 if (! ieee_write_byte (info
, len
))
4087 else if (len
<= 0xff)
4089 if (! ieee_write_byte (info
, (int) ieee_extension_length_1_enum
)
4090 || ! ieee_write_byte (info
, len
))
4093 else if (len
<= 0xffff)
4095 if (! ieee_write_byte (info
, (int) ieee_extension_length_2_enum
)
4096 || ! ieee_write_2bytes (info
, len
))
4101 fprintf (stderr
, "IEEE string length overflow: %u\n", len
);
4105 for (; *s
!= '\0'; s
++)
4106 if (! ieee_write_byte (info
, *s
))
4112 /* Write out an ASN record. */
4115 ieee_write_asn (info
, indx
, val
)
4116 struct ieee_handle
*info
;
4120 return (ieee_write_2bytes (info
, (int) ieee_asn_record_enum
)
4121 && ieee_write_number (info
, indx
)
4122 && ieee_write_number (info
, val
));
4125 /* Write out an ATN65 record. */
4128 ieee_write_atn65 (info
, indx
, s
)
4129 struct ieee_handle
*info
;
4133 return (ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
4134 && ieee_write_number (info
, indx
)
4135 && ieee_write_number (info
, 0)
4136 && ieee_write_number (info
, 65)
4137 && ieee_write_id (info
, s
));
4140 /* Push a type index onto the type stack. */
4143 ieee_push_type (info
, indx
, size
, unsignedp
, localp
)
4144 struct ieee_handle
*info
;
4150 struct ieee_type_stack
*ts
;
4152 ts
= (struct ieee_type_stack
*) xmalloc (sizeof *ts
);
4153 memset (ts
, 0, sizeof *ts
);
4155 ts
->type
.indx
= indx
;
4156 ts
->type
.size
= size
;
4157 ts
->type
.unsignedp
= unsignedp
;
4158 ts
->type
.localp
= localp
;
4160 ts
->next
= info
->type_stack
;
4161 info
->type_stack
= ts
;
4166 /* Pop a type index off the type stack. */
4169 ieee_pop_type (info
)
4170 struct ieee_handle
*info
;
4172 return ieee_pop_type_used (info
, true);
4175 /* Pop an unused type index off the type stack. */
4178 ieee_pop_unused_type (info
)
4179 struct ieee_handle
*info
;
4181 (void) ieee_pop_type_used (info
, false);
4184 /* Pop a used or unused type index off the type stack. */
4187 ieee_pop_type_used (info
, used
)
4188 struct ieee_handle
*info
;
4191 struct ieee_type_stack
*ts
;
4194 ts
= info
->type_stack
;
4195 assert (ts
!= NULL
);
4197 /* If this is a function type, and we need it, we need to append the
4198 actual definition to the typedef block now. */
4199 if (used
&& ! ieee_buffer_emptyp (&ts
->type
.fndef
))
4201 struct ieee_buflist
*buflist
;
4203 if (ts
->type
.localp
)
4205 /* Make sure we have started the types block. */
4206 if (ieee_buffer_emptyp (&info
->types
))
4208 if (! ieee_change_buffer (info
, &info
->types
)
4209 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4210 || ! ieee_write_byte (info
, 1)
4211 || ! ieee_write_number (info
, 0)
4212 || ! ieee_write_id (info
, info
->modname
))
4215 buflist
= &info
->types
;
4219 /* Make sure we started the global type block. */
4220 if (ieee_buffer_emptyp (&info
->global_types
))
4222 if (! ieee_change_buffer (info
, &info
->global_types
)
4223 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4224 || ! ieee_write_byte (info
, 2)
4225 || ! ieee_write_number (info
, 0)
4226 || ! ieee_write_id (info
, ""))
4229 buflist
= &info
->global_types
;
4232 if (! ieee_append_buffer (info
, buflist
, &ts
->type
.fndef
))
4236 ret
= ts
->type
.indx
;
4237 info
->type_stack
= ts
->next
;
4242 /* Add a range of bytes included in the current compilation unit. */
4245 ieee_add_range (info
, global
, low
, high
)
4246 struct ieee_handle
*info
;
4251 struct ieee_range
**plist
, *r
, **pr
;
4253 if (low
== (bfd_vma
) -1 || high
== (bfd_vma
) -1 || low
== high
)
4257 plist
= &info
->global_ranges
;
4259 plist
= &info
->ranges
;
4261 for (r
= *plist
; r
!= NULL
; r
= r
->next
)
4263 if (high
>= r
->low
&& low
<= r
->high
)
4265 /* The new range overlaps r. */
4271 while (*pr
!= NULL
&& (*pr
)->low
<= r
->high
)
4273 struct ieee_range
*n
;
4275 if ((*pr
)->high
> r
->high
)
4276 r
->high
= (*pr
)->high
;
4285 r
= (struct ieee_range
*) xmalloc (sizeof *r
);
4286 memset (r
, 0, sizeof *r
);
4291 /* Store the ranges sorted by address. */
4292 for (pr
= plist
; *pr
!= NULL
; pr
= &(*pr
)->next
)
4293 if ((*pr
)->low
> high
)
4301 /* Start a new range for which we only have the low address. */
4304 ieee_start_range (info
, low
)
4305 struct ieee_handle
*info
;
4308 struct ieee_range
*r
;
4310 r
= (struct ieee_range
*) xmalloc (sizeof *r
);
4311 memset (r
, 0, sizeof *r
);
4313 r
->next
= info
->pending_ranges
;
4314 info
->pending_ranges
= r
;
4318 /* Finish a range started by ieee_start_range. */
4321 ieee_end_range (info
, high
)
4322 struct ieee_handle
*info
;
4325 struct ieee_range
*r
;
4328 assert (info
->pending_ranges
!= NULL
);
4329 r
= info
->pending_ranges
;
4331 info
->pending_ranges
= r
->next
;
4333 return ieee_add_range (info
, false, low
, high
);
4336 /* Start defining a type. */
4339 ieee_define_type (info
, size
, unsignedp
, localp
)
4340 struct ieee_handle
*info
;
4345 return ieee_define_named_type (info
, (const char *) NULL
,
4346 (unsigned int) -1, size
, unsignedp
,
4347 localp
, (struct ieee_buflist
*) NULL
);
4350 /* Start defining a named type. */
4353 ieee_define_named_type (info
, name
, indx
, size
, unsignedp
, localp
, buflist
)
4354 struct ieee_handle
*info
;
4360 struct ieee_buflist
*buflist
;
4362 unsigned int type_indx
;
4363 unsigned int name_indx
;
4365 if (indx
!= (unsigned int) -1)
4369 type_indx
= info
->type_indx
;
4373 name_indx
= info
->name_indx
;
4379 /* If we were given a buffer, use it; otherwise, use either the
4380 local or the global type information, and make sure that the type
4381 block is started. */
4382 if (buflist
!= NULL
)
4384 if (! ieee_change_buffer (info
, buflist
))
4389 if (! ieee_buffer_emptyp (&info
->types
))
4391 if (! ieee_change_buffer (info
, &info
->types
))
4396 if (! ieee_change_buffer (info
, &info
->types
)
4397 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4398 || ! ieee_write_byte (info
, 1)
4399 || ! ieee_write_number (info
, 0)
4400 || ! ieee_write_id (info
, info
->modname
))
4406 if (! ieee_buffer_emptyp (&info
->global_types
))
4408 if (! ieee_change_buffer (info
, &info
->global_types
))
4413 if (! ieee_change_buffer (info
, &info
->global_types
)
4414 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4415 || ! ieee_write_byte (info
, 2)
4416 || ! ieee_write_number (info
, 0)
4417 || ! ieee_write_id (info
, ""))
4422 /* Push the new type on the type stack, write out an NN record, and
4423 write out the start of a TY record. The caller will then finish
4425 if (! ieee_push_type (info
, type_indx
, size
, unsignedp
, localp
))
4428 return (ieee_write_byte (info
, (int) ieee_nn_record
)
4429 && ieee_write_number (info
, name_indx
)
4430 && ieee_write_id (info
, name
)
4431 && ieee_write_byte (info
, (int) ieee_ty_record_enum
)
4432 && ieee_write_number (info
, type_indx
)
4433 && ieee_write_byte (info
, 0xce)
4434 && ieee_write_number (info
, name_indx
));
4437 /* Get an entry to the list of modified versions of a type. */
4439 static struct ieee_modified_type
*
4440 ieee_get_modified_info (info
, indx
)
4441 struct ieee_handle
*info
;
4444 if (indx
>= info
->modified_alloc
)
4446 unsigned int nalloc
;
4448 nalloc
= info
->modified_alloc
;
4451 while (indx
>= nalloc
)
4453 info
->modified
= ((struct ieee_modified_type
*)
4454 xrealloc (info
->modified
,
4455 nalloc
* sizeof *info
->modified
));
4456 memset (info
->modified
+ info
->modified_alloc
, 0,
4457 (nalloc
- info
->modified_alloc
) * sizeof *info
->modified
);
4458 info
->modified_alloc
= nalloc
;
4461 return info
->modified
+ indx
;
4464 /* Routines for the hash table mapping names to types. */
4466 /* Initialize an entry in the hash table. */
4468 static struct bfd_hash_entry
*
4469 ieee_name_type_newfunc (entry
, table
, string
)
4470 struct bfd_hash_entry
*entry
;
4471 struct bfd_hash_table
*table
;
4474 struct ieee_name_type_hash_entry
*ret
=
4475 (struct ieee_name_type_hash_entry
*) entry
;
4477 /* Allocate the structure if it has not already been allocated by a
4480 ret
= ((struct ieee_name_type_hash_entry
*)
4481 bfd_hash_allocate (table
, sizeof *ret
));
4485 /* Call the allocation method of the superclass. */
4486 ret
= ((struct ieee_name_type_hash_entry
*)
4487 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
4490 /* Set local fields. */
4494 return (struct bfd_hash_entry
*) ret
;
4497 /* Look up an entry in the hash table. */
4499 #define ieee_name_type_hash_lookup(table, string, create, copy) \
4500 ((struct ieee_name_type_hash_entry *) \
4501 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
4503 /* Traverse the hash table. */
4505 #define ieee_name_type_hash_traverse(table, func, info) \
4506 (bfd_hash_traverse \
4508 (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \
4511 /* The general routine to write out IEEE debugging information. */
4514 write_ieee_debugging_info (abfd
, dhandle
)
4518 struct ieee_handle info
;
4523 memset (&info
, 0, sizeof info
);
4525 info
.type_indx
= 256;
4526 info
.name_indx
= 32;
4528 if (! bfd_hash_table_init (&info
.typedefs
.root
, ieee_name_type_newfunc
)
4529 || ! bfd_hash_table_init (&info
.tags
.root
, ieee_name_type_newfunc
))
4532 if (! ieee_init_buffer (&info
, &info
.global_types
)
4533 || ! ieee_init_buffer (&info
, &info
.data
)
4534 || ! ieee_init_buffer (&info
, &info
.types
)
4535 || ! ieee_init_buffer (&info
, &info
.vars
)
4536 || ! ieee_init_buffer (&info
, &info
.cxx
)
4537 || ! ieee_init_buffer (&info
, &info
.linenos
)
4538 || ! ieee_init_buffer (&info
, &info
.fntype
)
4539 || ! ieee_init_buffer (&info
, &info
.fnargs
))
4542 if (! debug_write (dhandle
, &ieee_fns
, (PTR
) &info
))
4545 if (info
.filename
!= NULL
)
4547 if (! ieee_finish_compilation_unit (&info
))
4551 /* Put any undefined tags in the global typedef information. */
4553 ieee_name_type_hash_traverse (&info
.tags
,
4554 ieee_write_undefined_tag
,
4559 /* Prepend the global typedef information to the other data. */
4560 if (! ieee_buffer_emptyp (&info
.global_types
))
4562 if (! ieee_change_buffer (&info
, &info
.global_types
)
4563 || ! ieee_write_byte (&info
, (int) ieee_be_record_enum
))
4566 if (! ieee_append_buffer (&info
, &info
.global_types
, &info
.data
))
4568 info
.data
= info
.global_types
;
4571 /* Make sure that we have declare BB11 blocks for each range in the
4572 file. They are added to info->vars. */
4574 if (! ieee_init_buffer (&info
, &info
.vars
))
4576 bfd_map_over_sections (abfd
, ieee_add_bb11_blocks
, (PTR
) &info
);
4579 if (! ieee_buffer_emptyp (&info
.vars
))
4581 if (! ieee_change_buffer (&info
, &info
.vars
)
4582 || ! ieee_write_byte (&info
, (int) ieee_be_record_enum
))
4585 if (! ieee_append_buffer (&info
, &info
.data
, &info
.vars
))
4589 /* Now all the data is in info.data. Write it out to the BFD. We
4590 normally would need to worry about whether all the other sections
4591 are set up yet, but the IEEE backend will handle this particular
4592 case correctly regardless. */
4593 if (ieee_buffer_emptyp (&info
.data
))
4595 /* There is no debugging information. */
4599 s
= bfd_make_section (abfd
, ".debug");
4601 err
= "bfd_make_section";
4604 if (! bfd_set_section_flags (abfd
, s
, SEC_DEBUGGING
| SEC_HAS_CONTENTS
))
4605 err
= "bfd_set_section_flags";
4612 for (b
= info
.data
.head
; b
!= NULL
; b
= b
->next
)
4614 if (! bfd_set_section_size (abfd
, s
, size
))
4615 err
= "bfd_set_section_size";
4622 for (b
= info
.data
.head
; b
!= NULL
; b
= b
->next
)
4624 if (! bfd_set_section_contents (abfd
, s
, b
->buf
, offset
, b
->c
))
4626 err
= "bfd_set_section_contents";
4635 fprintf (stderr
, "%s: %s: %s\n", bfd_get_filename (abfd
), err
,
4636 bfd_errmsg (bfd_get_error ()));
4640 bfd_hash_table_free (&info
.typedefs
.root
);
4641 bfd_hash_table_free (&info
.tags
.root
);
4646 /* Write out information for an undefined tag. This is called via
4647 ieee_name_type_hash_traverse. */
4650 ieee_write_undefined_tag (h
, p
)
4651 struct ieee_name_type_hash_entry
*h
;
4654 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4655 struct ieee_name_type
*nt
;
4657 for (nt
= h
->types
; nt
!= NULL
; nt
= nt
->next
)
4659 unsigned int name_indx
;
4662 if (nt
->kind
== DEBUG_KIND_ILLEGAL
)
4665 if (ieee_buffer_emptyp (&info
->global_types
))
4667 if (! ieee_change_buffer (info
, &info
->global_types
)
4668 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4669 || ! ieee_write_byte (info
, 2)
4670 || ! ieee_write_number (info
, 0)
4671 || ! ieee_write_id (info
, ""))
4678 name_indx
= info
->name_indx
;
4680 if (! ieee_write_byte (info
, (int) ieee_nn_record
)
4681 || ! ieee_write_number (info
, name_indx
)
4682 || ! ieee_write_id (info
, nt
->type
.name
)
4683 || ! ieee_write_byte (info
, (int) ieee_ty_record_enum
)
4684 || ! ieee_write_number (info
, nt
->type
.indx
)
4685 || ! ieee_write_byte (info
, 0xce)
4686 || ! ieee_write_number (info
, name_indx
))
4698 case DEBUG_KIND_STRUCT
:
4699 case DEBUG_KIND_CLASS
:
4702 case DEBUG_KIND_UNION
:
4703 case DEBUG_KIND_UNION_CLASS
:
4706 case DEBUG_KIND_ENUM
:
4710 if (! ieee_write_number (info
, code
)
4711 || ! ieee_write_number (info
, 0))
4721 /* Start writing out information for a compilation unit. */
4724 ieee_start_compilation_unit (p
, filename
)
4726 const char *filename
;
4728 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4729 const char *modname
;
4733 if (info
->filename
!= NULL
)
4735 if (! ieee_finish_compilation_unit (info
))
4739 info
->filename
= filename
;
4740 modname
= strrchr (filename
, '/');
4741 if (modname
!= NULL
)
4745 modname
= strrchr (filename
, '\\');
4746 if (modname
!= NULL
)
4751 c
= xstrdup (modname
);
4752 s
= strrchr (c
, '.');
4757 if (! ieee_init_buffer (info
, &info
->types
)
4758 || ! ieee_init_buffer (info
, &info
->vars
)
4759 || ! ieee_init_buffer (info
, &info
->cxx
)
4760 || ! ieee_init_buffer (info
, &info
->linenos
))
4762 info
->ranges
= NULL
;
4764 /* Always include a BB1 and a BB3 block. That is what the output of
4765 the MRI linker seems to look like. */
4766 if (! ieee_change_buffer (info
, &info
->types
)
4767 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4768 || ! ieee_write_byte (info
, 1)
4769 || ! ieee_write_number (info
, 0)
4770 || ! ieee_write_id (info
, info
->modname
))
4773 nindx
= info
->name_indx
;
4775 if (! ieee_change_buffer (info
, &info
->vars
)
4776 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4777 || ! ieee_write_byte (info
, 3)
4778 || ! ieee_write_number (info
, 0)
4779 || ! ieee_write_id (info
, info
->modname
))
4785 /* Finish up a compilation unit. */
4788 ieee_finish_compilation_unit (info
)
4789 struct ieee_handle
*info
;
4791 struct ieee_range
*r
;
4793 if (! ieee_buffer_emptyp (&info
->types
))
4795 if (! ieee_change_buffer (info
, &info
->types
)
4796 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4800 if (! ieee_buffer_emptyp (&info
->cxx
))
4802 /* Append any C++ information to the global function and
4803 variable information. */
4804 assert (! ieee_buffer_emptyp (&info
->vars
));
4805 if (! ieee_change_buffer (info
, &info
->vars
))
4808 /* We put the pmisc records in a dummy procedure, just as the
4809 MRI compiler does. */
4810 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4811 || ! ieee_write_byte (info
, 6)
4812 || ! ieee_write_number (info
, 0)
4813 || ! ieee_write_id (info
, "__XRYCPP")
4814 || ! ieee_write_number (info
, 0)
4815 || ! ieee_write_number (info
, 0)
4816 || ! ieee_write_number (info
, info
->highaddr
- 1)
4817 || ! ieee_append_buffer (info
, &info
->vars
, &info
->cxx
)
4818 || ! ieee_change_buffer (info
, &info
->vars
)
4819 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
4820 || ! ieee_write_number (info
, info
->highaddr
- 1))
4824 if (! ieee_buffer_emptyp (&info
->vars
))
4826 if (! ieee_change_buffer (info
, &info
->vars
)
4827 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4831 if (info
->pending_lineno_filename
!= NULL
)
4833 /* Force out the pending line number. */
4834 if (! ieee_lineno ((PTR
) info
, (const char *) NULL
, 0, (bfd_vma
) -1))
4837 if (! ieee_buffer_emptyp (&info
->linenos
))
4839 if (! ieee_change_buffer (info
, &info
->linenos
)
4840 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4842 if (strcmp (info
->filename
, info
->lineno_filename
) != 0)
4844 /* We were not in the main file. We just closed the
4845 included line number block, and now we must close the
4846 main line number block. */
4847 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4852 if (! ieee_append_buffer (info
, &info
->data
, &info
->types
)
4853 || ! ieee_append_buffer (info
, &info
->data
, &info
->vars
)
4854 || ! ieee_append_buffer (info
, &info
->data
, &info
->linenos
))
4857 /* Build BB10/BB11 blocks based on the ranges we recorded. */
4858 if (! ieee_change_buffer (info
, &info
->data
))
4861 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4862 || ! ieee_write_byte (info
, 10)
4863 || ! ieee_write_number (info
, 0)
4864 || ! ieee_write_id (info
, info
->modname
)
4865 || ! ieee_write_id (info
, "")
4866 || ! ieee_write_number (info
, 0)
4867 || ! ieee_write_id (info
, "GNU objcopy"))
4870 for (r
= info
->ranges
; r
!= NULL
; r
= r
->next
)
4879 /* Find the section corresponding to this range. */
4880 for (s
= info
->abfd
->sections
; s
!= NULL
; s
= s
->next
)
4882 if (bfd_get_section_vma (info
->abfd
, s
) <= low
4883 && high
<= (bfd_get_section_vma (info
->abfd
, s
)
4884 + bfd_section_size (info
->abfd
, s
)))
4890 /* Just ignore this range. */
4894 /* Coalesce ranges if it seems reasonable. */
4895 while (r
->next
!= NULL
4896 && high
+ 64 >= r
->next
->low
4898 <= (bfd_get_section_vma (info
->abfd
, s
)
4899 + bfd_section_size (info
->abfd
, s
))))
4905 if ((s
->flags
& SEC_CODE
) != 0)
4907 else if ((s
->flags
& SEC_READONLY
) != 0)
4912 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4913 || ! ieee_write_byte (info
, 11)
4914 || ! ieee_write_number (info
, 0)
4915 || ! ieee_write_id (info
, "")
4916 || ! ieee_write_number (info
, kind
)
4917 || ! ieee_write_number (info
, s
->index
+ IEEE_SECTION_NUMBER_BASE
)
4918 || ! ieee_write_number (info
, low
)
4919 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
4920 || ! ieee_write_number (info
, high
- low
))
4923 /* Add this range to the list of global ranges. */
4924 if (! ieee_add_range (info
, true, low
, high
))
4928 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4934 /* Add BB11 blocks describing each range that we have not already
4938 ieee_add_bb11_blocks (abfd
, sec
, data
)
4943 struct ieee_handle
*info
= (struct ieee_handle
*) data
;
4945 struct ieee_range
*r
;
4947 low
= bfd_get_section_vma (abfd
, sec
);
4948 high
= low
+ bfd_section_size (abfd
, sec
);
4950 /* Find the first range at or after this section. The ranges are
4951 sorted by address. */
4952 for (r
= info
->global_ranges
; r
!= NULL
; r
= r
->next
)
4958 if (r
== NULL
|| r
->low
>= high
)
4960 if (! ieee_add_bb11 (info
, sec
, low
, high
))
4967 if (! ieee_add_bb11 (info
, sec
, low
, r
->low
))
4979 /* Add a single BB11 block for a range. We add it to info->vars. */
4982 ieee_add_bb11 (info
, sec
, low
, high
)
4983 struct ieee_handle
*info
;
4990 if (! ieee_buffer_emptyp (&info
->vars
))
4992 if (! ieee_change_buffer (info
, &info
->vars
))
4997 const char *filename
, *modname
;
5000 /* Start the enclosing BB10 block. */
5001 filename
= bfd_get_filename (info
->abfd
);
5002 modname
= strrchr (filename
, '/');
5003 if (modname
!= NULL
)
5007 modname
= strrchr (filename
, '\\');
5008 if (modname
!= NULL
)
5013 c
= xstrdup (modname
);
5014 s
= strrchr (c
, '.');
5018 if (! ieee_change_buffer (info
, &info
->vars
)
5019 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
5020 || ! ieee_write_byte (info
, 10)
5021 || ! ieee_write_number (info
, 0)
5022 || ! ieee_write_id (info
, c
)
5023 || ! ieee_write_id (info
, "")
5024 || ! ieee_write_number (info
, 0)
5025 || ! ieee_write_id (info
, "GNU objcopy"))
5031 if ((sec
->flags
& SEC_CODE
) != 0)
5033 else if ((sec
->flags
& SEC_READONLY
) != 0)
5038 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
5039 || ! ieee_write_byte (info
, 11)
5040 || ! ieee_write_number (info
, 0)
5041 || ! ieee_write_id (info
, "")
5042 || ! ieee_write_number (info
, kind
)
5043 || ! ieee_write_number (info
, sec
->index
+ IEEE_SECTION_NUMBER_BASE
)
5044 || ! ieee_write_number (info
, low
)
5045 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
5046 || ! ieee_write_number (info
, high
- low
))
5052 /* Start recording information from a particular source file. This is
5053 used to record which file defined which types, variables, etc. It
5054 is not used for line numbers, since the lineno entry point passes
5055 down the file name anyhow. IEEE debugging information doesn't seem
5056 to store this information anywhere. */
5060 ieee_start_source (p
, filename
)
5062 const char *filename
;
5067 /* Make an empty type. */
5073 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5075 return ieee_push_type (info
, 0, 0, false, false);
5078 /* Make a void type. */
5084 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5086 return ieee_push_type (info
, 1, 0, false, false);
5089 /* Make an integer type. */
5092 ieee_int_type (p
, size
, unsignedp
)
5097 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5103 indx
= (int) builtin_signed_char
;
5106 indx
= (int) builtin_signed_short_int
;
5109 indx
= (int) builtin_signed_long
;
5112 indx
= (int) builtin_signed_long_long
;
5115 fprintf (stderr
, "IEEE unsupported integer type size %u\n", size
);
5122 return ieee_push_type (info
, indx
, size
, unsignedp
, false);
5125 /* Make a floating point type. */
5128 ieee_float_type (p
, size
)
5132 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5138 indx
= (int) builtin_float
;
5141 indx
= (int) builtin_double
;
5144 /* FIXME: This size really depends upon the processor. */
5145 indx
= (int) builtin_long_double
;
5148 indx
= (int) builtin_long_long_double
;
5151 fprintf (stderr
, "IEEE unsupported float type size %u\n", size
);
5155 return ieee_push_type (info
, indx
, size
, false, false);
5158 /* Make a complex type. */
5161 ieee_complex_type (p
, size
)
5165 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5177 fprintf (stderr
, "IEEE unsupported complex type size %u\n", size
);
5181 /* FIXME: I don't know what the string is for. */
5182 return (ieee_define_type (info
, size
, false, false)
5183 && ieee_write_number (info
, code
)
5184 && ieee_write_id (info
, ""));
5187 /* Make a boolean type. IEEE doesn't support these, so we just make
5188 an integer type instead. */
5191 ieee_bool_type (p
, size
)
5195 return ieee_int_type (p
, size
, true);
5198 /* Make an enumeration. */
5201 ieee_enum_type (p
, tag
, names
, vals
)
5205 bfd_signed_vma
*vals
;
5207 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5208 struct ieee_defined_enum
*e
;
5209 boolean localp
, simple
;
5213 for (e
= info
->enums
; e
!= NULL
; e
= e
->next
)
5223 || tag
[0] != e
->tag
[0]
5224 || strcmp (tag
, e
->tag
) != 0)
5228 if (names
!= NULL
&& e
->names
!= NULL
)
5230 for (i
= 0; names
[i
] != NULL
&& e
->names
[i
] != NULL
; i
++)
5232 if (names
[i
][0] != e
->names
[i
][0]
5233 || vals
[i
] != e
->vals
[i
]
5234 || strcmp (names
[i
], e
->names
[i
]) != 0)
5239 if ((names
== NULL
&& e
->names
== NULL
)
5240 || (names
[i
] == NULL
&& e
->names
[i
] == NULL
))
5242 /* We've seen this enum before. */
5243 return ieee_push_type (info
, e
->indx
, 0, true, false);
5248 /* We've already seen an enum of the same name, so we must make
5249 sure to output this one locally. */
5255 /* If this is a simple enumeration, in which the values start at 0
5256 and always increment by 1, we can use type E. Otherwise we must
5262 for (i
= 0; names
[i
] != NULL
; i
++)
5272 if (! ieee_define_named_type (info
, tag
, (unsigned int) -1, 0,
5273 true, localp
, (struct ieee_buflist
*) NULL
)
5274 || ! ieee_write_number (info
, simple
? 'E' : 'N'))
5278 /* FIXME: This is supposed to be the enumeration size, but we
5279 don't store that. */
5280 if (! ieee_write_number (info
, 4))
5285 for (i
= 0; names
[i
] != NULL
; i
++)
5287 if (! ieee_write_id (info
, names
[i
]))
5291 if (! ieee_write_number (info
, vals
[i
]))
5299 e
= (struct ieee_defined_enum
*) xmalloc (sizeof *e
);
5300 memset (e
, 0, sizeof *e
);
5302 e
->indx
= info
->type_stack
->type
.indx
;
5307 e
->next
= info
->enums
;
5314 /* Make a pointer type. */
5317 ieee_pointer_type (p
)
5320 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5323 struct ieee_modified_type
*m
= NULL
;
5325 localp
= info
->type_stack
->type
.localp
;
5326 indx
= ieee_pop_type (info
);
5328 /* A pointer to a simple builtin type can be obtained by adding 32.
5329 FIXME: Will this be a short pointer, and will that matter? */
5331 return ieee_push_type (info
, indx
+ 32, 0, true, false);
5335 m
= ieee_get_modified_info (p
, indx
);
5339 /* FIXME: The size should depend upon the architecture. */
5341 return ieee_push_type (info
, m
->pointer
, 4, true, false);
5344 if (! ieee_define_type (info
, 4, true, localp
)
5345 || ! ieee_write_number (info
, 'P')
5346 || ! ieee_write_number (info
, indx
))
5350 m
->pointer
= info
->type_stack
->type
.indx
;
5355 /* Make a function type. This will be called for a method, but we
5356 don't want to actually add it to the type table in that case. We
5357 handle this by defining the type in a private buffer, and only
5358 adding that buffer to the typedef block if we are going to use it. */
5361 ieee_function_type (p
, argcount
, varargs
)
5366 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5368 unsigned int *args
= NULL
;
5370 unsigned int retindx
;
5371 struct ieee_buflist fndef
;
5372 struct ieee_modified_type
*m
;
5378 args
= (unsigned int *) xmalloc (argcount
* sizeof *args
);
5379 for (i
= argcount
- 1; i
>= 0; i
--)
5381 if (info
->type_stack
->type
.localp
)
5383 args
[i
] = ieee_pop_type (info
);
5386 else if (argcount
< 0)
5389 if (info
->type_stack
->type
.localp
)
5391 retindx
= ieee_pop_type (info
);
5394 if (argcount
< 0 && ! localp
)
5396 m
= ieee_get_modified_info (p
, retindx
);
5400 if (m
->function
> 0)
5401 return ieee_push_type (info
, m
->function
, 0, true, false);
5404 /* An attribute of 0x41 means that the frame and push mask are
5406 if (! ieee_init_buffer (info
, &fndef
)
5407 || ! ieee_define_named_type (info
, (const char *) NULL
,
5408 (unsigned int) -1, 0, true, localp
,
5410 || ! ieee_write_number (info
, 'x')
5411 || ! ieee_write_number (info
, 0x41)
5412 || ! ieee_write_number (info
, 0)
5413 || ! ieee_write_number (info
, 0)
5414 || ! ieee_write_number (info
, retindx
)
5415 || ! ieee_write_number (info
, (bfd_vma
) argcount
+ (varargs
? 1 : 0)))
5419 for (i
= 0; i
< argcount
; i
++)
5420 if (! ieee_write_number (info
, args
[i
]))
5426 /* A varargs function is represented by writing out the last
5427 argument as type void *, although this makes little sense. */
5428 if (! ieee_write_number (info
, (bfd_vma
) builtin_void
+ 32))
5432 if (! ieee_write_number (info
, 0))
5435 /* We wrote the information into fndef, in case we don't need it.
5436 It will be appended to info->types by ieee_pop_type. */
5437 info
->type_stack
->type
.fndef
= fndef
;
5440 m
->function
= info
->type_stack
->type
.indx
;
5445 /* Make a reference type. */
5448 ieee_reference_type (p
)
5451 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5453 /* IEEE appears to record a normal pointer type, and then use a
5454 pmisc record to indicate that it is really a reference. */
5456 if (! ieee_pointer_type (p
))
5458 info
->type_stack
->type
.referencep
= true;
5462 /* Make a range type. */
5465 ieee_range_type (p
, low
, high
)
5468 bfd_signed_vma high
;
5470 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5472 boolean unsignedp
, localp
;
5474 size
= info
->type_stack
->type
.size
;
5475 unsignedp
= info
->type_stack
->type
.unsignedp
;
5476 localp
= info
->type_stack
->type
.localp
;
5477 ieee_pop_unused_type (info
);
5478 return (ieee_define_type (info
, size
, unsignedp
, localp
)
5479 && ieee_write_number (info
, 'R')
5480 && ieee_write_number (info
, (bfd_vma
) low
)
5481 && ieee_write_number (info
, (bfd_vma
) high
)
5482 && ieee_write_number (info
, unsignedp
? 0 : 1)
5483 && ieee_write_number (info
, size
));
5486 /* Make an array type. */
5490 ieee_array_type (p
, low
, high
, stringp
)
5493 bfd_signed_vma high
;
5496 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5497 unsigned int eleindx
;
5499 struct ieee_modified_type
*m
= NULL
;
5500 struct ieee_modified_array_type
*a
;
5502 /* IEEE does not store the range, so we just ignore it. */
5503 ieee_pop_unused_type (info
);
5504 localp
= info
->type_stack
->type
.localp
;
5505 eleindx
= ieee_pop_type (info
);
5509 m
= ieee_get_modified_info (info
, eleindx
);
5513 for (a
= m
->arrays
; a
!= NULL
; a
= a
->next
)
5515 if (a
->low
== low
&& a
->high
== high
)
5516 return ieee_push_type (info
, a
->indx
, 0, false, false);
5520 if (! ieee_define_type (info
, 0, false, localp
)
5521 || ! ieee_write_number (info
, low
== 0 ? 'Z' : 'C')
5522 || ! ieee_write_number (info
, eleindx
))
5526 if (! ieee_write_number (info
, low
))
5530 if (! ieee_write_number (info
, high
+ 1))
5535 a
= (struct ieee_modified_array_type
*) xmalloc (sizeof *a
);
5536 memset (a
, 0, sizeof *a
);
5538 a
->indx
= info
->type_stack
->type
.indx
;
5542 a
->next
= m
->arrays
;
5549 /* Make a set type. */
5552 ieee_set_type (p
, bitstringp
)
5556 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5558 unsigned int eleindx
;
5560 localp
= info
->type_stack
->type
.localp
;
5561 eleindx
= ieee_pop_type (info
);
5563 /* FIXME: We don't know the size, so we just use 4. */
5565 return (ieee_define_type (info
, 0, true, localp
)
5566 && ieee_write_number (info
, 's')
5567 && ieee_write_number (info
, 4)
5568 && ieee_write_number (info
, eleindx
));
5571 /* Make an offset type. */
5574 ieee_offset_type (p
)
5577 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5578 unsigned int targetindx
, baseindx
;
5580 targetindx
= ieee_pop_type (info
);
5581 baseindx
= ieee_pop_type (info
);
5583 /* FIXME: The MRI C++ compiler does not appear to generate any
5584 useful type information about an offset type. It just records a
5585 pointer to member as an integer. The MRI/HP IEEE spec does
5586 describe a pmisc record which can be used for a pointer to
5587 member. Unfortunately, it does not describe the target type,
5588 which seems pretty important. I'm going to punt this for now. */
5590 return ieee_int_type (p
, 4, true);
5593 /* Make a method type. */
5596 ieee_method_type (p
, domain
, argcount
, varargs
)
5602 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5604 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
5605 method, but the definition is incomplete. We just output an 'x'
5609 ieee_pop_unused_type (info
);
5611 return ieee_function_type (p
, argcount
, varargs
);
5614 /* Make a const qualified type. */
5620 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5622 boolean unsignedp
, localp
;
5624 struct ieee_modified_type
*m
= NULL
;
5626 size
= info
->type_stack
->type
.size
;
5627 unsignedp
= info
->type_stack
->type
.unsignedp
;
5628 localp
= info
->type_stack
->type
.localp
;
5629 indx
= ieee_pop_type (info
);
5633 m
= ieee_get_modified_info (info
, indx
);
5637 if (m
->const_qualified
> 0)
5638 return ieee_push_type (info
, m
->const_qualified
, size
, unsignedp
,
5642 if (! ieee_define_type (info
, size
, unsignedp
, localp
)
5643 || ! ieee_write_number (info
, 'n')
5644 || ! ieee_write_number (info
, 1)
5645 || ! ieee_write_number (info
, indx
))
5649 m
->const_qualified
= info
->type_stack
->type
.indx
;
5654 /* Make a volatile qualified type. */
5657 ieee_volatile_type (p
)
5660 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5662 boolean unsignedp
, localp
;
5664 struct ieee_modified_type
*m
= NULL
;
5666 size
= info
->type_stack
->type
.size
;
5667 unsignedp
= info
->type_stack
->type
.unsignedp
;
5668 localp
= info
->type_stack
->type
.localp
;
5669 indx
= ieee_pop_type (info
);
5673 m
= ieee_get_modified_info (info
, indx
);
5677 if (m
->volatile_qualified
> 0)
5678 return ieee_push_type (info
, m
->volatile_qualified
, size
, unsignedp
,
5682 if (! ieee_define_type (info
, size
, unsignedp
, localp
)
5683 || ! ieee_write_number (info
, 'n')
5684 || ! ieee_write_number (info
, 2)
5685 || ! ieee_write_number (info
, indx
))
5689 m
->volatile_qualified
= info
->type_stack
->type
.indx
;
5694 /* Convert an enum debug_visibility into a CXXFLAGS value. */
5697 ieee_vis_to_flags (visibility
)
5698 enum debug_visibility visibility
;
5704 case DEBUG_VISIBILITY_PUBLIC
:
5705 return CXXFLAGS_VISIBILITY_PUBLIC
;
5706 case DEBUG_VISIBILITY_PRIVATE
:
5707 return CXXFLAGS_VISIBILITY_PRIVATE
;
5708 case DEBUG_VISIBILITY_PROTECTED
:
5709 return CXXFLAGS_VISIBILITY_PROTECTED
;
5714 /* Start defining a struct type. We build it in the strdef field on
5715 the stack, to avoid confusing type definitions required by the
5716 fields with the struct type itself. */
5719 ieee_start_struct_type (p
, tag
, id
, structp
, size
)
5726 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5727 boolean localp
, ignorep
;
5731 struct ieee_name_type_hash_entry
*h
;
5732 struct ieee_name_type
*nt
, *ntlook
;
5733 struct ieee_buflist strdef
;
5738 /* We need to create a tag for internal use even if we don't want
5739 one for external use. This will let us refer to an anonymous
5748 sprintf (ab
, "__anon%u", id
);
5753 /* If we already have references to the tag, we must use the
5754 existing type index. */
5755 h
= ieee_name_type_hash_lookup (&info
->tags
, look
, true, copy
);
5760 for (ntlook
= h
->types
; ntlook
!= NULL
; ntlook
= ntlook
->next
)
5762 if (ntlook
->id
== id
)
5764 else if (! ntlook
->type
.localp
)
5766 /* We are creating a duplicate definition of a globally
5767 defined tag. Force it to be local to avoid
5775 assert (localp
== nt
->type
.localp
);
5776 if (nt
->kind
== DEBUG_KIND_ILLEGAL
&& ! localp
)
5778 /* We've already seen a global definition of the type.
5779 Ignore this new definition. */
5785 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
5786 memset (nt
, 0, sizeof *nt
);
5788 nt
->type
.name
= h
->root
.string
;
5789 nt
->next
= h
->types
;
5791 nt
->type
.indx
= info
->type_indx
;
5795 nt
->kind
= DEBUG_KIND_ILLEGAL
;
5797 if (! ieee_init_buffer (info
, &strdef
)
5798 || ! ieee_define_named_type (info
, tag
, nt
->type
.indx
, size
, true,
5800 || ! ieee_write_number (info
, structp
? 'S' : 'U')
5801 || ! ieee_write_number (info
, size
))
5808 /* We never want nt->type.name to be NULL. We want the rest of
5809 the type to be the object set up on the type stack; it will
5810 have a NULL name if tag is NULL. */
5811 hold
= nt
->type
.name
;
5812 nt
->type
= info
->type_stack
->type
;
5813 nt
->type
.name
= hold
;
5816 info
->type_stack
->type
.name
= tag
;
5817 info
->type_stack
->type
.strdef
= strdef
;
5818 info
->type_stack
->type
.ignorep
= ignorep
;
5823 /* Add a field to a struct. */
5826 ieee_struct_field (p
, name
, bitpos
, bitsize
, visibility
)
5831 enum debug_visibility visibility
;
5833 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5841 assert (info
->type_stack
!= NULL
5842 && info
->type_stack
->next
!= NULL
5843 && ! ieee_buffer_emptyp (&info
->type_stack
->next
->type
.strdef
));
5845 /* If we are ignoring this struct definition, just pop and ignore
5847 if (info
->type_stack
->next
->type
.ignorep
)
5849 ieee_pop_unused_type (info
);
5853 size
= info
->type_stack
->type
.size
;
5854 unsignedp
= info
->type_stack
->type
.unsignedp
;
5855 referencep
= info
->type_stack
->type
.referencep
;
5856 localp
= info
->type_stack
->type
.localp
;
5857 indx
= ieee_pop_type (info
);
5860 info
->type_stack
->type
.localp
= true;
5862 if (info
->type_stack
->type
.classdef
!= NULL
)
5867 /* This is a class. We must add a description of this field to
5868 the class records we are building. */
5870 flags
= ieee_vis_to_flags (visibility
);
5871 nindx
= info
->type_stack
->type
.classdef
->indx
;
5872 if (! ieee_change_buffer (info
,
5873 &info
->type_stack
->type
.classdef
->pmiscbuf
)
5874 || ! ieee_write_asn (info
, nindx
, 'd')
5875 || ! ieee_write_asn (info
, nindx
, flags
)
5876 || ! ieee_write_atn65 (info
, nindx
, name
)
5877 || ! ieee_write_atn65 (info
, nindx
, name
))
5879 info
->type_stack
->type
.classdef
->pmisccount
+= 4;
5885 /* We need to output a record recording that this field is
5886 really of reference type. We put this on the refs field
5887 of classdef, so that it can be appended to the C++
5888 records after the class is defined. */
5890 nindx
= info
->name_indx
;
5893 if (! ieee_change_buffer (info
,
5894 &info
->type_stack
->type
.classdef
->refs
)
5895 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
5896 || ! ieee_write_number (info
, nindx
)
5897 || ! ieee_write_id (info
, "")
5898 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
5899 || ! ieee_write_number (info
, nindx
)
5900 || ! ieee_write_number (info
, 0)
5901 || ! ieee_write_number (info
, 62)
5902 || ! ieee_write_number (info
, 80)
5903 || ! ieee_write_number (info
, 4)
5904 || ! ieee_write_asn (info
, nindx
, 'R')
5905 || ! ieee_write_asn (info
, nindx
, 3)
5906 || ! ieee_write_atn65 (info
, nindx
, info
->type_stack
->type
.name
)
5907 || ! ieee_write_atn65 (info
, nindx
, name
))
5912 /* If the bitsize doesn't match the expected size, we need to output
5914 if (size
== 0 || bitsize
== 0 || bitsize
== size
* 8)
5915 offset
= bitpos
/ 8;
5918 if (! ieee_define_type (info
, 0, unsignedp
,
5919 info
->type_stack
->type
.localp
)
5920 || ! ieee_write_number (info
, 'g')
5921 || ! ieee_write_number (info
, unsignedp
? 0 : 1)
5922 || ! ieee_write_number (info
, bitsize
)
5923 || ! ieee_write_number (info
, indx
))
5925 indx
= ieee_pop_type (info
);
5929 /* Switch to the struct we are building in order to output this
5930 field definition. */
5931 return (ieee_change_buffer (info
, &info
->type_stack
->type
.strdef
)
5932 && ieee_write_id (info
, name
)
5933 && ieee_write_number (info
, indx
)
5934 && ieee_write_number (info
, offset
));
5937 /* Finish up a struct type. */
5940 ieee_end_struct_type (p
)
5943 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5944 struct ieee_buflist
*pb
;
5946 assert (info
->type_stack
!= NULL
5947 && ! ieee_buffer_emptyp (&info
->type_stack
->type
.strdef
));
5949 /* If we were ignoring this struct definition because it was a
5950 duplicate defintion, just through away whatever bytes we have
5951 accumulated. Leave the type on the stack. */
5952 if (info
->type_stack
->type
.ignorep
)
5955 /* If this is not a duplicate definition of this tag, then localp
5956 will be false, and we can put it in the global type block.
5957 FIXME: We should avoid outputting duplicate definitions which are
5959 if (! info
->type_stack
->type
.localp
)
5961 /* Make sure we have started the global type block. */
5962 if (ieee_buffer_emptyp (&info
->global_types
))
5964 if (! ieee_change_buffer (info
, &info
->global_types
)
5965 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
5966 || ! ieee_write_byte (info
, 2)
5967 || ! ieee_write_number (info
, 0)
5968 || ! ieee_write_id (info
, ""))
5971 pb
= &info
->global_types
;
5975 /* Make sure we have started the types block. */
5976 if (ieee_buffer_emptyp (&info
->types
))
5978 if (! ieee_change_buffer (info
, &info
->types
)
5979 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
5980 || ! ieee_write_byte (info
, 1)
5981 || ! ieee_write_number (info
, 0)
5982 || ! ieee_write_id (info
, info
->modname
))
5988 /* Append the struct definition to the types. */
5989 if (! ieee_append_buffer (info
, pb
, &info
->type_stack
->type
.strdef
)
5990 || ! ieee_init_buffer (info
, &info
->type_stack
->type
.strdef
))
5993 /* Leave the struct on the type stack. */
5998 /* Start a class type. */
6001 ieee_start_class_type (p
, tag
, id
, structp
, size
, vptr
, ownvptr
)
6010 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6012 struct ieee_buflist pmiscbuf
;
6014 struct ieee_type_class
*classdef
;
6016 /* A C++ class is output as a C++ struct along with a set of pmisc
6017 records describing the class. */
6019 /* We need to have a name so that we can associate the struct and
6025 t
= (char *) xmalloc (20);
6026 sprintf (t
, "__anon%u", id
);
6030 /* We can't write out the virtual table information until we have
6031 finished the class, because we don't know the virtual table size.
6032 We get the size from the largest voffset we see. */
6034 if (vptr
&& ! ownvptr
)
6036 vclass
= info
->type_stack
->type
.name
;
6037 assert (vclass
!= NULL
);
6038 /* We don't call ieee_pop_unused_type, since the class should
6040 (void) ieee_pop_type (info
);
6043 if (! ieee_start_struct_type (p
, tag
, id
, structp
, size
))
6046 indx
= info
->name_indx
;
6049 /* We write out pmisc records into the classdef field. We will
6050 write out the pmisc start after we know the number of records we
6052 if (! ieee_init_buffer (info
, &pmiscbuf
)
6053 || ! ieee_change_buffer (info
, &pmiscbuf
)
6054 || ! ieee_write_asn (info
, indx
, 'T')
6055 || ! ieee_write_asn (info
, indx
, structp
? 'o' : 'u')
6056 || ! ieee_write_atn65 (info
, indx
, tag
))
6059 classdef
= (struct ieee_type_class
*) xmalloc (sizeof *classdef
);
6060 memset (classdef
, 0, sizeof *classdef
);
6062 classdef
->indx
= indx
;
6063 classdef
->pmiscbuf
= pmiscbuf
;
6064 classdef
->pmisccount
= 3;
6065 classdef
->vclass
= vclass
;
6066 classdef
->ownvptr
= ownvptr
;
6068 info
->type_stack
->type
.classdef
= classdef
;
6073 /* Add a static member to a class. */
6076 ieee_class_static_member (p
, name
, physname
, visibility
)
6079 const char *physname
;
6080 enum debug_visibility visibility
;
6082 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6086 /* We don't care about the type. Hopefully there will be a call to
6087 ieee_variable declaring the physical name and the type, since
6088 that is where an IEEE consumer must get the type. */
6089 ieee_pop_unused_type (info
);
6091 assert (info
->type_stack
!= NULL
6092 && info
->type_stack
->type
.classdef
!= NULL
);
6094 flags
= ieee_vis_to_flags (visibility
);
6095 flags
|= CXXFLAGS_STATIC
;
6097 nindx
= info
->type_stack
->type
.classdef
->indx
;
6099 if (! ieee_change_buffer (info
, &info
->type_stack
->type
.classdef
->pmiscbuf
)
6100 || ! ieee_write_asn (info
, nindx
, 'd')
6101 || ! ieee_write_asn (info
, nindx
, flags
)
6102 || ! ieee_write_atn65 (info
, nindx
, name
)
6103 || ! ieee_write_atn65 (info
, nindx
, physname
))
6105 info
->type_stack
->type
.classdef
->pmisccount
+= 4;
6110 /* Add a base class to a class. */
6113 ieee_class_baseclass (p
, bitpos
, virtual, visibility
)
6117 enum debug_visibility visibility
;
6119 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6127 assert (info
->type_stack
!= NULL
6128 && info
->type_stack
->type
.name
!= NULL
6129 && info
->type_stack
->next
!= NULL
6130 && info
->type_stack
->next
->type
.classdef
!= NULL
6131 && ! ieee_buffer_emptyp (&info
->type_stack
->next
->type
.strdef
));
6133 bname
= info
->type_stack
->type
.name
;
6134 localp
= info
->type_stack
->type
.localp
;
6135 bindx
= ieee_pop_type (info
);
6137 /* We are currently defining both a struct and a class. We must
6138 write out a field definition in the struct which holds the base
6139 class. The stabs debugging reader will create a field named
6140 _vb$CLASS for a virtual base class, so we just use that. FIXME:
6141 we should not depend upon a detail of stabs debugging. */
6144 fname
= (char *) xmalloc (strlen (bname
) + sizeof "_vb$");
6145 sprintf (fname
, "_vb$%s", bname
);
6146 flags
= BASEFLAGS_VIRTUAL
;
6151 info
->type_stack
->type
.localp
= true;
6153 fname
= (char *) xmalloc (strlen (bname
) + sizeof "_b$");
6154 sprintf (fname
, "_b$%s", bname
);
6156 if (! ieee_change_buffer (info
, &info
->type_stack
->type
.strdef
)
6157 || ! ieee_write_id (info
, fname
)
6158 || ! ieee_write_number (info
, bindx
)
6159 || ! ieee_write_number (info
, bitpos
/ 8))
6164 if (visibility
== DEBUG_VISIBILITY_PRIVATE
)
6165 flags
|= BASEFLAGS_PRIVATE
;
6167 nindx
= info
->type_stack
->type
.classdef
->indx
;
6169 if (! ieee_change_buffer (info
, &info
->type_stack
->type
.classdef
->pmiscbuf
)
6170 || ! ieee_write_asn (info
, nindx
, 'b')
6171 || ! ieee_write_asn (info
, nindx
, flags
)
6172 || ! ieee_write_atn65 (info
, nindx
, bname
)
6173 || ! ieee_write_asn (info
, nindx
, 0)
6174 || ! ieee_write_atn65 (info
, nindx
, fname
))
6176 info
->type_stack
->type
.classdef
->pmisccount
+= 5;
6183 /* Start building a method for a class. */
6186 ieee_class_start_method (p
, name
)
6190 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6192 assert (info
->type_stack
!= NULL
6193 && info
->type_stack
->type
.classdef
!= NULL
6194 && info
->type_stack
->type
.classdef
->method
== NULL
);
6196 info
->type_stack
->type
.classdef
->method
= name
;
6201 /* Define a new method variant, either static or not. */
6204 ieee_class_method_var (info
, physname
, visibility
, staticp
, constp
,
6205 volatilep
, voffset
, context
)
6206 struct ieee_handle
*info
;
6207 const char *physname
;
6208 enum debug_visibility visibility
;
6219 /* We don't need the type of the method. An IEEE consumer which
6220 wants the type must track down the function by the physical name
6221 and get the type from that. */
6222 ieee_pop_unused_type (info
);
6224 /* We don't use the context. FIXME: We probably ought to use it to
6225 adjust the voffset somehow, but I don't really know how. */
6227 ieee_pop_unused_type (info
);
6229 assert (info
->type_stack
!= NULL
6230 && info
->type_stack
->type
.classdef
!= NULL
6231 && info
->type_stack
->type
.classdef
->method
!= NULL
);
6233 flags
= ieee_vis_to_flags (visibility
);
6235 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
6236 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
6239 flags
|= CXXFLAGS_STATIC
;
6241 flags
|= CXXFLAGS_CONST
;
6243 flags
|= CXXFLAGS_VOLATILE
;
6245 nindx
= info
->type_stack
->type
.classdef
->indx
;
6247 virtual = context
|| voffset
> 0;
6249 if (! ieee_change_buffer (info
,
6250 &info
->type_stack
->type
.classdef
->pmiscbuf
)
6251 || ! ieee_write_asn (info
, nindx
, virtual ? 'v' : 'm')
6252 || ! ieee_write_asn (info
, nindx
, flags
)
6253 || ! ieee_write_atn65 (info
, nindx
,
6254 info
->type_stack
->type
.classdef
->method
)
6255 || ! ieee_write_atn65 (info
, nindx
, physname
))
6260 if (voffset
> info
->type_stack
->type
.classdef
->voffset
)
6261 info
->type_stack
->type
.classdef
->voffset
= voffset
;
6262 if (! ieee_write_asn (info
, nindx
, voffset
))
6264 ++info
->type_stack
->type
.classdef
->pmisccount
;
6267 if (! ieee_write_asn (info
, nindx
, 0))
6270 info
->type_stack
->type
.classdef
->pmisccount
+= 5;
6275 /* Define a new method variant. */
6278 ieee_class_method_variant (p
, physname
, visibility
, constp
, volatilep
,
6281 const char *physname
;
6282 enum debug_visibility visibility
;
6288 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6290 return ieee_class_method_var (info
, physname
, visibility
, false, constp
,
6291 volatilep
, voffset
, context
);
6294 /* Define a new static method variant. */
6297 ieee_class_static_method_variant (p
, physname
, visibility
, constp
, volatilep
)
6299 const char *physname
;
6300 enum debug_visibility visibility
;
6304 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6306 return ieee_class_method_var (info
, physname
, visibility
, true, constp
,
6307 volatilep
, 0, false);
6310 /* Finish up a method. */
6313 ieee_class_end_method (p
)
6316 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6318 assert (info
->type_stack
!= NULL
6319 && info
->type_stack
->type
.classdef
!= NULL
6320 && info
->type_stack
->type
.classdef
->method
!= NULL
);
6322 info
->type_stack
->type
.classdef
->method
= NULL
;
6327 /* Finish up a class. */
6330 ieee_end_class_type (p
)
6333 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6336 assert (info
->type_stack
!= NULL
6337 && info
->type_stack
->type
.classdef
!= NULL
);
6339 /* If we were ignoring this class definition because it was a
6340 duplicate definition, just through away whatever bytes we have
6341 accumulated. Leave the type on the stack. */
6342 if (info
->type_stack
->type
.ignorep
)
6345 nindx
= info
->type_stack
->type
.classdef
->indx
;
6347 /* If we have a virtual table, we can write out the information now. */
6348 if (info
->type_stack
->type
.classdef
->vclass
!= NULL
6349 || info
->type_stack
->type
.classdef
->ownvptr
)
6351 if (! ieee_change_buffer (info
,
6352 &info
->type_stack
->type
.classdef
->pmiscbuf
)
6353 || ! ieee_write_asn (info
, nindx
, 'z')
6354 || ! ieee_write_atn65 (info
, nindx
, "")
6355 || ! ieee_write_asn (info
, nindx
,
6356 info
->type_stack
->type
.classdef
->voffset
))
6358 if (info
->type_stack
->type
.classdef
->ownvptr
)
6360 if (! ieee_write_atn65 (info
, nindx
, ""))
6365 if (! ieee_write_atn65 (info
, nindx
,
6366 info
->type_stack
->type
.classdef
->vclass
))
6369 if (! ieee_write_asn (info
, nindx
, 0))
6371 info
->type_stack
->type
.classdef
->pmisccount
+= 5;
6374 /* Now that we know the number of pmisc records, we can write out
6375 the atn62 which starts the pmisc records, and append them to the
6378 if (! ieee_change_buffer (info
, &info
->cxx
)
6379 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
6380 || ! ieee_write_number (info
, nindx
)
6381 || ! ieee_write_id (info
, "")
6382 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6383 || ! ieee_write_number (info
, nindx
)
6384 || ! ieee_write_number (info
, 0)
6385 || ! ieee_write_number (info
, 62)
6386 || ! ieee_write_number (info
, 80)
6387 || ! ieee_write_number (info
,
6388 info
->type_stack
->type
.classdef
->pmisccount
))
6391 if (! ieee_append_buffer (info
, &info
->cxx
,
6392 &info
->type_stack
->type
.classdef
->pmiscbuf
))
6394 if (! ieee_buffer_emptyp (&info
->type_stack
->type
.classdef
->refs
))
6396 if (! ieee_append_buffer (info
, &info
->cxx
,
6397 &info
->type_stack
->type
.classdef
->refs
))
6401 return ieee_end_struct_type (p
);
6404 /* Push a previously seen typedef onto the type stack. */
6407 ieee_typedef_type (p
, name
)
6411 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6412 struct ieee_name_type_hash_entry
*h
;
6413 struct ieee_name_type
*nt
;
6415 h
= ieee_name_type_hash_lookup (&info
->typedefs
, name
, false, false);
6417 /* h should never be NULL, since that would imply that the generic
6418 debugging code has asked for a typedef which it has not yet
6422 /* We always use the most recently defined type for this name, which
6423 will be the first one on the list. */
6426 if (! ieee_push_type (info
, nt
->type
.indx
, nt
->type
.size
,
6427 nt
->type
.unsignedp
, nt
->type
.localp
))
6430 /* Copy over any other type information we may have. */
6431 info
->type_stack
->type
= nt
->type
;
6436 /* Push a tagged type onto the type stack. */
6439 ieee_tag_type (p
, name
, id
, kind
)
6443 enum debug_type_kind kind
;
6445 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6449 struct ieee_name_type_hash_entry
*h
;
6450 struct ieee_name_type
*nt
;
6457 sprintf (ab
, "__anon%u", id
);
6462 h
= ieee_name_type_hash_lookup (&info
->tags
, name
, true, copy
);
6466 for (nt
= h
->types
; nt
!= NULL
; nt
= nt
->next
)
6470 if (! ieee_push_type (info
, nt
->type
.indx
, nt
->type
.size
,
6471 nt
->type
.unsignedp
, nt
->type
.localp
))
6473 /* Copy over any other type information we may have. */
6474 info
->type_stack
->type
= nt
->type
;
6478 if (! nt
->type
.localp
)
6480 /* This is a duplicate of a global type, so it must be
6486 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
6487 memset (nt
, 0, sizeof *nt
);
6490 nt
->type
.name
= h
->root
.string
;
6491 nt
->type
.indx
= info
->type_indx
;
6492 nt
->type
.localp
= localp
;
6496 nt
->next
= h
->types
;
6499 if (! ieee_push_type (info
, nt
->type
.indx
, 0, false, localp
))
6502 info
->type_stack
->type
.name
= h
->root
.string
;
6507 /* Output a typedef. */
6510 ieee_typdef (p
, name
)
6514 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6515 struct ieee_write_type type
;
6519 struct ieee_name_type_hash_entry
*h
;
6520 struct ieee_name_type
*nt
;
6522 type
= info
->type_stack
->type
;
6525 /* If this is a simple builtin type using a builtin name, we don't
6526 want to output the typedef itself. We also want to change the
6527 type index to correspond to the name being used. We recognize
6528 names used in stabs debugging output even if they don't exactly
6529 correspond to the names used for the IEEE builtin types. */
6531 if (indx
<= (unsigned int) builtin_bcd_float
)
6533 switch ((enum builtin_types
) indx
)
6539 if (strcmp (name
, "void") == 0)
6543 case builtin_signed_char
:
6545 if (strcmp (name
, "signed char") == 0)
6547 indx
= (unsigned int) builtin_signed_char
;
6550 else if (strcmp (name
, "char") == 0)
6552 indx
= (unsigned int) builtin_char
;
6557 case builtin_unsigned_char
:
6558 if (strcmp (name
, "unsigned char") == 0)
6562 case builtin_signed_short_int
:
6564 case builtin_short_int
:
6565 case builtin_signed_short
:
6566 if (strcmp (name
, "signed short int") == 0)
6568 indx
= (unsigned int) builtin_signed_short_int
;
6571 else if (strcmp (name
, "short") == 0)
6573 indx
= (unsigned int) builtin_short
;
6576 else if (strcmp (name
, "short int") == 0)
6578 indx
= (unsigned int) builtin_short_int
;
6581 else if (strcmp (name
, "signed short") == 0)
6583 indx
= (unsigned int) builtin_signed_short
;
6588 case builtin_unsigned_short_int
:
6589 case builtin_unsigned_short
:
6590 if (strcmp (name
, "unsigned short int") == 0
6591 || strcmp (name
, "short unsigned int") == 0)
6593 indx
= builtin_unsigned_short_int
;
6596 else if (strcmp (name
, "unsigned short") == 0)
6598 indx
= builtin_unsigned_short
;
6603 case builtin_signed_long
:
6604 case builtin_int
: /* FIXME: Size depends upon architecture. */
6606 if (strcmp (name
, "signed long") == 0)
6608 indx
= builtin_signed_long
;
6611 else if (strcmp (name
, "int") == 0)
6616 else if (strcmp (name
, "long") == 0
6617 || strcmp (name
, "long int") == 0)
6619 indx
= builtin_long
;
6624 case builtin_unsigned_long
:
6625 case builtin_unsigned
: /* FIXME: Size depends upon architecture. */
6626 case builtin_unsigned_int
: /* FIXME: Like builtin_unsigned. */
6627 if (strcmp (name
, "unsigned long") == 0
6628 || strcmp (name
, "long unsigned int") == 0)
6630 indx
= builtin_unsigned_long
;
6633 else if (strcmp (name
, "unsigned") == 0)
6635 indx
= builtin_unsigned
;
6638 else if (strcmp (name
, "unsigned int") == 0)
6640 indx
= builtin_unsigned_int
;
6645 case builtin_signed_long_long
:
6646 if (strcmp (name
, "signed long long") == 0
6647 || strcmp (name
, "long long int") == 0)
6651 case builtin_unsigned_long_long
:
6652 if (strcmp (name
, "unsigned long long") == 0
6653 || strcmp (name
, "long long unsigned int") == 0)
6658 if (strcmp (name
, "float") == 0)
6662 case builtin_double
:
6663 if (strcmp (name
, "double") == 0)
6667 case builtin_long_double
:
6668 if (strcmp (name
, "long double") == 0)
6672 case builtin_long_long_double
:
6673 if (strcmp (name
, "long long double") == 0)
6682 h
= ieee_name_type_hash_lookup (&info
->typedefs
, name
, true, false);
6686 /* See if we have already defined this type with this name. */
6687 localp
= type
.localp
;
6688 for (nt
= h
->types
; nt
!= NULL
; nt
= nt
->next
)
6692 /* If this is a global definition, then we don't need to
6693 do anything here. */
6694 if (! nt
->type
.localp
)
6696 ieee_pop_unused_type (info
);
6702 /* This is a duplicate definition, so make this one local. */
6707 /* We need to add a new typedef for this type. */
6709 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
6710 memset (nt
, 0, sizeof *nt
);
6713 nt
->type
.name
= name
;
6714 nt
->type
.localp
= localp
;
6715 nt
->kind
= DEBUG_KIND_ILLEGAL
;
6717 nt
->next
= h
->types
;
6722 /* This is one of the builtin typedefs, so we don't need to
6723 actually define it. */
6724 ieee_pop_unused_type (info
);
6728 indx
= ieee_pop_type (info
);
6730 if (! ieee_define_named_type (info
, name
, (unsigned int) -1, type
.size
,
6731 type
.unsignedp
, localp
,
6732 (struct ieee_buflist
*) NULL
)
6733 || ! ieee_write_number (info
, 'T')
6734 || ! ieee_write_number (info
, indx
))
6737 /* Remove the type we just added to the type stack. This should not
6738 be ieee_pop_unused_type, since the type is used, we just don't
6740 (void) ieee_pop_type (info
);
6745 /* Output a tag for a type. We don't have to do anything here. */
6752 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6754 /* This should not be ieee_pop_unused_type, since we want the type
6756 (void) ieee_pop_type (info
);
6760 /* Output an integer constant. */
6763 ieee_int_constant (p
, name
, val
)
6772 /* Output a floating point constant. */
6775 ieee_float_constant (p
, name
, val
)
6784 /* Output a typed constant. */
6787 ieee_typed_constant (p
, name
, val
)
6792 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6795 ieee_pop_unused_type (info
);
6799 /* Output a variable. */
6802 ieee_variable (p
, name
, kind
, val
)
6805 enum debug_var_kind kind
;
6808 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6809 unsigned int name_indx
;
6812 unsigned int type_indx
;
6816 size
= info
->type_stack
->type
.size
;
6817 referencep
= info
->type_stack
->type
.referencep
;
6818 type_indx
= ieee_pop_type (info
);
6820 assert (! ieee_buffer_emptyp (&info
->vars
));
6821 if (! ieee_change_buffer (info
, &info
->vars
))
6824 name_indx
= info
->name_indx
;
6827 /* Write out an NN and an ATN record for this variable. */
6828 if (! ieee_write_byte (info
, (int) ieee_nn_record
)
6829 || ! ieee_write_number (info
, name_indx
)
6830 || ! ieee_write_id (info
, name
)
6831 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6832 || ! ieee_write_number (info
, name_indx
)
6833 || ! ieee_write_number (info
, type_indx
))
6841 if (! ieee_write_number (info
, 8)
6842 || ! ieee_add_range (info
, false, val
, val
+ size
))
6848 if (! ieee_write_number (info
, 3)
6849 || ! ieee_add_range (info
, false, val
, val
+ size
))
6854 case DEBUG_LOCAL_STATIC
:
6855 if (! ieee_write_number (info
, 3)
6856 || ! ieee_add_range (info
, false, val
, val
+ size
))
6862 if (! ieee_write_number (info
, 1)
6863 || ! ieee_write_number (info
, val
))
6868 case DEBUG_REGISTER
:
6869 if (! ieee_write_number (info
, 2)
6870 || ! ieee_write_number (info
,
6871 ieee_genreg_to_regno (info
->abfd
, val
)))
6880 if (! ieee_write_asn (info
, name_indx
, val
))
6884 /* If this is really a reference type, then we just output it with
6885 pointer type, and must now output a C++ record indicating that it
6886 is really reference type. */
6891 nindx
= info
->name_indx
;
6894 /* If this is a global variable, we want to output the misc
6895 record in the C++ misc record block. Otherwise, we want to
6896 output it just after the variable definition, which is where
6897 the current buffer is. */
6900 if (! ieee_change_buffer (info
, &info
->cxx
))
6904 if (! ieee_write_byte (info
, (int) ieee_nn_record
)
6905 || ! ieee_write_number (info
, nindx
)
6906 || ! ieee_write_id (info
, "")
6907 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6908 || ! ieee_write_number (info
, nindx
)
6909 || ! ieee_write_number (info
, 0)
6910 || ! ieee_write_number (info
, 62)
6911 || ! ieee_write_number (info
, 80)
6912 || ! ieee_write_number (info
, 3)
6913 || ! ieee_write_asn (info
, nindx
, 'R')
6914 || ! ieee_write_asn (info
, nindx
, refflag
)
6915 || ! ieee_write_atn65 (info
, nindx
, name
))
6922 /* Start outputting information for a function. */
6925 ieee_start_function (p
, name
, global
)
6930 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6932 unsigned int retindx
, typeindx
;
6934 referencep
= info
->type_stack
->type
.referencep
;
6935 retindx
= ieee_pop_type (info
);
6937 /* Besides recording a BB4 or BB6 block, we record the type of the
6938 function in the BB1 typedef block. We can't write out the full
6939 type until we have seen all the parameters, so we accumulate it
6940 in info->fntype and info->fnargs. */
6941 if (! ieee_buffer_emptyp (&info
->fntype
))
6943 /* FIXME: This might happen someday if we support nested
6948 info
->fnname
= name
;
6950 /* An attribute of 0x40 means that the push mask is unknown. */
6951 if (! ieee_define_named_type (info
, name
, (unsigned int) -1, 0, false, true,
6953 || ! ieee_write_number (info
, 'x')
6954 || ! ieee_write_number (info
, 0x40)
6955 || ! ieee_write_number (info
, 0)
6956 || ! ieee_write_number (info
, 0)
6957 || ! ieee_write_number (info
, retindx
))
6960 typeindx
= ieee_pop_type (info
);
6962 if (! ieee_init_buffer (info
, &info
->fnargs
))
6964 info
->fnargcount
= 0;
6966 /* If the function return value is actually a reference type, we
6967 must add a record indicating that. */
6972 nindx
= info
->name_indx
;
6974 if (! ieee_change_buffer (info
, &info
->cxx
)
6975 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
6976 || ! ieee_write_number (info
, nindx
)
6977 || ! ieee_write_id (info
, "")
6978 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6979 || ! ieee_write_number (info
, nindx
)
6980 || ! ieee_write_number (info
, 0)
6981 || ! ieee_write_number (info
, 62)
6982 || ! ieee_write_number (info
, 80)
6983 || ! ieee_write_number (info
, 3)
6984 || ! ieee_write_asn (info
, nindx
, 'R')
6985 || ! ieee_write_asn (info
, nindx
, global
? 0 : 1)
6986 || ! ieee_write_atn65 (info
, nindx
, name
))
6990 assert (! ieee_buffer_emptyp (&info
->vars
));
6991 if (! ieee_change_buffer (info
, &info
->vars
))
6994 /* The address is written out as the first block. */
6996 ++info
->block_depth
;
6998 return (ieee_write_byte (info
, (int) ieee_bb_record_enum
)
6999 && ieee_write_byte (info
, global
? 4 : 6)
7000 && ieee_write_number (info
, 0)
7001 && ieee_write_id (info
, name
)
7002 && ieee_write_number (info
, 0)
7003 && ieee_write_number (info
, typeindx
));
7006 /* Add a function parameter. This will normally be called before the
7007 first block, so we postpone them until we see the block. */
7010 ieee_function_parameter (p
, name
, kind
, val
)
7013 enum debug_parm_kind kind
;
7016 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
7017 struct ieee_pending_parm
*m
, **pm
;
7019 assert (info
->block_depth
== 1);
7021 m
= (struct ieee_pending_parm
*) xmalloc (sizeof *m
);
7022 memset (m
, 0, sizeof *m
);
7026 m
->referencep
= info
->type_stack
->type
.referencep
;
7027 m
->type
= ieee_pop_type (info
);
7031 for (pm
= &info
->pending_parms
; *pm
!= NULL
; pm
= &(*pm
)->next
)
7035 /* Add the type to the fnargs list. */
7036 if (! ieee_change_buffer (info
, &info
->fnargs
)
7037 || ! ieee_write_number (info
, m
->type
))
7044 /* Output pending function parameters. */
7047 ieee_output_pending_parms (info
)
7048 struct ieee_handle
*info
;
7050 struct ieee_pending_parm
*m
;
7051 unsigned int refcount
;
7054 for (m
= info
->pending_parms
; m
!= NULL
; m
= m
->next
)
7056 enum debug_var_kind vkind
;
7063 case DEBUG_PARM_STACK
:
7064 case DEBUG_PARM_REFERENCE
:
7065 vkind
= DEBUG_LOCAL
;
7067 case DEBUG_PARM_REG
:
7068 case DEBUG_PARM_REF_REG
:
7069 vkind
= DEBUG_REGISTER
;
7073 if (! ieee_push_type (info
, m
->type
, 0, false, false))
7075 info
->type_stack
->type
.referencep
= m
->referencep
;
7078 if (! ieee_variable ((PTR
) info
, m
->name
, vkind
, m
->val
))
7082 /* If there are any reference parameters, we need to output a
7083 miscellaneous record indicating them. */
7086 unsigned int nindx
, varindx
;
7088 /* FIXME: The MRI compiler outputs the demangled function name
7089 here, but we are outputting the mangled name. */
7090 nindx
= info
->name_indx
;
7092 if (! ieee_change_buffer (info
, &info
->vars
)
7093 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
7094 || ! ieee_write_number (info
, nindx
)
7095 || ! ieee_write_id (info
, "")
7096 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
7097 || ! ieee_write_number (info
, nindx
)
7098 || ! ieee_write_number (info
, 0)
7099 || ! ieee_write_number (info
, 62)
7100 || ! ieee_write_number (info
, 80)
7101 || ! ieee_write_number (info
, refcount
+ 3)
7102 || ! ieee_write_asn (info
, nindx
, 'B')
7103 || ! ieee_write_atn65 (info
, nindx
, info
->fnname
)
7104 || ! ieee_write_asn (info
, nindx
, 0))
7106 for (m
= info
->pending_parms
, varindx
= 1;
7108 m
= m
->next
, varindx
++)
7112 if (! ieee_write_asn (info
, nindx
, varindx
))
7118 m
= info
->pending_parms
;
7121 struct ieee_pending_parm
*next
;
7128 info
->pending_parms
= NULL
;
7133 /* Start a block. If this is the first block, we output the address
7134 to finish the BB4 or BB6, and then output the function parameters. */
7137 ieee_start_block (p
, addr
)
7141 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
7143 if (! ieee_change_buffer (info
, &info
->vars
))
7146 if (info
->block_depth
== 1)
7148 if (! ieee_write_number (info
, addr
)
7149 || ! ieee_output_pending_parms (info
))
7154 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
7155 || ! ieee_write_byte (info
, 6)
7156 || ! ieee_write_number (info
, 0)
7157 || ! ieee_write_id (info
, "")
7158 || ! ieee_write_number (info
, 0)
7159 || ! ieee_write_number (info
, 0)
7160 || ! ieee_write_number (info
, addr
))
7164 if (! ieee_start_range (info
, addr
))
7167 ++info
->block_depth
;
7175 ieee_end_block (p
, addr
)
7179 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
7181 /* The address we are given is the end of the block, but IEEE seems
7182 to want to the address of the last byte in the block, so we
7184 if (! ieee_change_buffer (info
, &info
->vars
)
7185 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
7186 || ! ieee_write_number (info
, addr
- 1))
7189 if (! ieee_end_range (info
, addr
))
7192 --info
->block_depth
;
7194 if (addr
> info
->highaddr
)
7195 info
->highaddr
= addr
;
7200 /* End a function. */
7203 ieee_end_function (p
)
7206 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
7208 assert (info
->block_depth
== 1);
7210 --info
->block_depth
;
7212 /* Now we can finish up fntype, and add it to the typdef section.
7213 At this point, fntype is the 'x' type up to the argument count,
7214 and fnargs is the argument types. We must add the argument
7215 count, and we must add the level. FIXME: We don't record varargs
7216 functions correctly. In fact, stabs debugging does not give us
7217 enough information to do so. */
7218 if (! ieee_change_buffer (info
, &info
->fntype
)
7219 || ! ieee_write_number (info
, info
->fnargcount
)
7220 || ! ieee_change_buffer (info
, &info
->fnargs
)
7221 || ! ieee_write_number (info
, 0))
7224 /* Make sure the typdef block has been started. */
7225 if (ieee_buffer_emptyp (&info
->types
))
7227 if (! ieee_change_buffer (info
, &info
->types
)
7228 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
7229 || ! ieee_write_byte (info
, 1)
7230 || ! ieee_write_number (info
, 0)
7231 || ! ieee_write_id (info
, info
->modname
))
7235 if (! ieee_append_buffer (info
, &info
->types
, &info
->fntype
)
7236 || ! ieee_append_buffer (info
, &info
->types
, &info
->fnargs
))
7239 info
->fnname
= NULL
;
7240 if (! ieee_init_buffer (info
, &info
->fntype
)
7241 || ! ieee_init_buffer (info
, &info
->fnargs
))
7243 info
->fnargcount
= 0;
7248 /* Record line number information. */
7251 ieee_lineno (p
, filename
, lineno
, addr
)
7253 const char *filename
;
7254 unsigned long lineno
;
7257 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
7259 assert (info
->filename
!= NULL
);
7261 /* The HP simulator seems to get confused when more than one line is
7262 listed for the same address, at least if they are in different
7263 files. We handle this by always listing the last line for a
7264 given address, since that seems to be the one that gdb uses. */
7265 if (info
->pending_lineno_filename
!= NULL
7266 && addr
!= info
->pending_lineno_addr
)
7268 /* Make sure we have a line number block. */
7269 if (! ieee_buffer_emptyp (&info
->linenos
))
7271 if (! ieee_change_buffer (info
, &info
->linenos
))
7276 info
->lineno_name_indx
= info
->name_indx
;
7278 if (! ieee_change_buffer (info
, &info
->linenos
)
7279 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
7280 || ! ieee_write_byte (info
, 5)
7281 || ! ieee_write_number (info
, 0)
7282 || ! ieee_write_id (info
, info
->filename
)
7283 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
7284 || ! ieee_write_number (info
, info
->lineno_name_indx
)
7285 || ! ieee_write_id (info
, ""))
7287 info
->lineno_filename
= info
->filename
;
7290 if (strcmp (info
->pending_lineno_filename
, info
->lineno_filename
) != 0)
7292 if (strcmp (info
->filename
, info
->lineno_filename
) != 0)
7294 /* We were not in the main file. Close the block for the
7296 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
7298 if (strcmp (info
->filename
, info
->pending_lineno_filename
) == 0)
7300 /* We need a new NN record, and we aren't output to
7302 info
->lineno_name_indx
= info
->name_indx
;
7304 if (! ieee_write_byte (info
, (int) ieee_nn_record
)
7305 || ! ieee_write_number (info
, info
->lineno_name_indx
)
7306 || ! ieee_write_id (info
, ""))
7310 if (strcmp (info
->filename
, info
->pending_lineno_filename
) != 0)
7312 /* We are not changing to the main file. Open a block for
7313 the new included file. */
7314 info
->lineno_name_indx
= info
->name_indx
;
7316 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
7317 || ! ieee_write_byte (info
, 5)
7318 || ! ieee_write_number (info
, 0)
7319 || ! ieee_write_id (info
, info
->pending_lineno_filename
)
7320 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
7321 || ! ieee_write_number (info
, info
->lineno_name_indx
)
7322 || ! ieee_write_id (info
, ""))
7325 info
->lineno_filename
= info
->pending_lineno_filename
;
7328 if (! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
7329 || ! ieee_write_number (info
, info
->lineno_name_indx
)
7330 || ! ieee_write_number (info
, 0)
7331 || ! ieee_write_number (info
, 7)
7332 || ! ieee_write_number (info
, info
->pending_lineno
)
7333 || ! ieee_write_number (info
, 0)
7334 || ! ieee_write_asn (info
, info
->lineno_name_indx
,
7335 info
->pending_lineno_addr
))
7339 info
->pending_lineno_filename
= filename
;
7340 info
->pending_lineno
= lineno
;
7341 info
->pending_lineno_addr
= addr
;