1 /* ieee.c -- Write out 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. */
44 /* This structure is the block stack. */
46 #define BLOCKSTACK_SIZE (16)
48 struct ieee_blockstack
50 /* The stack pointer. */
51 struct ieee_block
*bsp
;
53 struct ieee_block stack
[BLOCKSTACK_SIZE
];
56 /* This structure holds information for a variable. */
68 /* This structure holds all the variables. */
72 /* Number of slots allocated. */
75 struct ieee_var
*vars
;
78 /* This structure holds information for a type. We need this because
79 we don't want to represent bitfields as real types. */
85 /* Slot if this is type is referenced before it is defined. */
87 /* If this is a bitfield, this is the size in bits. If this is not
88 a bitfield, this is zero. */
89 unsigned long bitsize
;
90 /* If this is a function type ('x' or 'X') this is the return type. */
91 debug_type return_type
;
94 /* This structure holds all the type information. */
98 /* Number of slots allocated. */
101 struct ieee_type
*types
;
103 #define BUILTIN_TYPE_COUNT (60)
104 debug_type builtins
[BUILTIN_TYPE_COUNT
];
107 /* Basic builtin types, not including the pointers. */
113 builtin_signed_char
= 2,
114 builtin_unsigned_char
= 3,
115 builtin_signed_short_int
= 4,
116 builtin_unsigned_short_int
= 5,
117 builtin_signed_long
= 6,
118 builtin_unsigned_long
= 7,
119 builtin_signed_long_long
= 8,
120 builtin_unsigned_long_long
= 9,
123 builtin_long_double
= 12,
124 builtin_long_long_double
= 13,
125 builtin_quoted_string
= 14,
126 builtin_instruction_address
= 15,
128 builtin_unsigned
= 17,
129 builtin_unsigned_int
= 18,
133 builtin_unsigned_short
= 22,
134 builtin_short_int
= 23,
135 builtin_signed_short
= 24,
136 builtin_bcd_float
= 25
139 static void ieee_error
140 PARAMS ((bfd
*, const bfd_byte
*, const bfd_byte
*, const char *));
141 static void ieee_eof
PARAMS ((bfd
*));
142 static char *savestring
PARAMS ((const char *, unsigned long));
143 static boolean ieee_read_number
144 PARAMS ((bfd
*, const bfd_byte
*, const bfd_byte
**, const bfd_byte
*,
146 static boolean ieee_read_optional_number
147 PARAMS ((bfd
*, const bfd_byte
*, const bfd_byte
**, const bfd_byte
*,
148 bfd_vma
*, boolean
*));
149 static boolean ieee_read_id
150 PARAMS ((bfd
*, const bfd_byte
*, const bfd_byte
**, const bfd_byte
*,
151 const char **, unsigned long *));
152 static boolean ieee_read_optional_id
153 PARAMS ((bfd
*, const bfd_byte
*, const bfd_byte
**, const bfd_byte
*,
154 const char **, unsigned long *, boolean
*));
155 static boolean ieee_read_expression
156 PARAMS ((bfd
*, const bfd_byte
*, const bfd_byte
**, const bfd_byte
*,
158 static debug_type ieee_builtin_type
159 PARAMS ((PTR
, bfd
*, struct ieee_types
*, const bfd_byte
*,
160 const bfd_byte
*, unsigned int));
161 static boolean ieee_alloc_type
162 PARAMS ((PTR
, struct ieee_types
*, unsigned int, boolean
));
163 static boolean ieee_read_type_index
164 PARAMS ((PTR
, bfd
*, struct ieee_types
*, const bfd_byte
*,
165 const bfd_byte
**, const bfd_byte
*, debug_type
*));
166 static int ieee_regno_to_genreg
PARAMS ((bfd
*, int));
167 static int ieee_genreg_to_regno
PARAMS ((bfd
*, int));
168 static boolean parse_ieee_bb
169 PARAMS ((PTR
, bfd
*, struct ieee_types
*, struct ieee_blockstack
*,
170 const bfd_byte
*, const bfd_byte
**, const bfd_byte
*));
171 static boolean parse_ieee_be
172 PARAMS ((PTR
, bfd
*, struct ieee_blockstack
*, const bfd_byte
*,
173 const bfd_byte
**, const bfd_byte
*));
174 static boolean parse_ieee_nn
175 PARAMS ((PTR
, bfd
*, struct ieee_vars
*, const bfd_byte
*,
176 const bfd_byte
**, const bfd_byte
*));
177 static boolean parse_ieee_ty
178 PARAMS ((PTR
, bfd
*, struct ieee_types
*, struct ieee_vars
*,
179 const bfd_byte
*, const bfd_byte
**, const bfd_byte
*));
180 static boolean parse_ieee_atn
181 PARAMS ((PTR
, bfd
*, struct ieee_types
*, struct ieee_vars
*, int,
182 const bfd_byte
*, const bfd_byte
**, const bfd_byte
*));
183 static boolean ieee_require_asn
184 PARAMS ((bfd
*, const bfd_byte
*, const bfd_byte
**, const bfd_byte
*,
187 /* Report an error in the IEEE debugging information. */
190 ieee_error (abfd
, bytes
, p
, s
)
192 const bfd_byte
*bytes
;
197 fprintf (stderr
, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (abfd
),
198 (unsigned long) (p
- bytes
), s
, *p
);
200 fprintf (stderr
, "%s: %s\n", bfd_get_filename (abfd
), s
);
203 /* Report an unexpected EOF in the IEEE debugging information. */
209 ieee_error (abfd
, (const bfd_byte
*) NULL
, (const bfd_byte
*) NULL
,
210 "unexpected end of debugging information");
213 /* Save a string in memory. */
216 savestring (start
, len
)
222 ret
= (char *) xmalloc (len
+ 1);
223 memcpy (ret
, start
, len
);
228 /* Read a number which must be present in an IEEE file. */
231 ieee_read_number (abfd
, bytes
, pp
, pend
, pv
)
233 const bfd_byte
*bytes
;
235 const bfd_byte
*pend
;
238 return ieee_read_optional_number (abfd
, bytes
, pp
, pend
, pv
,
242 /* Read a number in an IEEE file. If ppresent is not NULL, the number
243 need not be there. */
246 ieee_read_optional_number (abfd
, bytes
, pp
, pend
, pv
, ppresent
)
248 const bfd_byte
*bytes
;
250 const bfd_byte
*pend
;
254 ieee_record_enum_type b
;
258 if (ppresent
!= NULL
)
267 b
= (ieee_record_enum_type
) **pp
;
270 if (b
<= ieee_number_end_enum
)
273 if (ppresent
!= NULL
)
278 if (b
>= ieee_number_repeat_start_enum
&& b
<= ieee_number_repeat_end_enum
)
282 i
= (int) b
- (int) ieee_number_repeat_start_enum
;
283 if (*pp
+ i
- 1 >= pend
)
297 if (ppresent
!= NULL
)
303 if (ppresent
!= NULL
)
310 ieee_error (abfd
, bytes
, *pp
- 1, "invalid number");
314 /* Read a required string from an IEEE file. */
317 ieee_read_id (abfd
, bytes
, pp
, pend
, pname
, pnamlen
)
319 const bfd_byte
*bytes
;
321 const bfd_byte
*pend
;
323 unsigned long *pnamlen
;
325 return ieee_read_optional_id (abfd
, bytes
, pp
, pend
, pname
, pnamlen
,
329 /* Read a string from an IEEE file. If ppresent is not NULL, the
330 string is optional. */
333 ieee_read_optional_id (abfd
, bytes
, pp
, pend
, pname
, pnamlen
, ppresent
)
335 const bfd_byte
*bytes
;
337 const bfd_byte
*pend
;
339 unsigned long *pnamlen
;
356 else if ((ieee_record_enum_type
) b
== ieee_extension_length_1_enum
)
361 else if ((ieee_record_enum_type
) b
== ieee_extension_length_2_enum
)
363 len
= (**pp
<< 8) + (*pp
)[1];
368 if (ppresent
!= NULL
)
374 ieee_error (abfd
, bytes
, *pp
- 1, "invalid string length");
378 if ((unsigned long) (pend
- *pp
) < len
)
384 *pname
= (const char *) *pp
;
388 if (ppresent
!= NULL
)
394 /* Read an expression from an IEEE file. Since this code is only used
395 to parse debugging information, I haven't bothered to write a full
396 blown IEEE expression parser. I've only thrown in the things I've
397 seen in debugging information. This can be easily extended if
401 ieee_read_expression (abfd
, bytes
, pp
, pend
, pv
)
403 const bfd_byte
*bytes
;
405 const bfd_byte
*pend
;
408 const bfd_byte
*expr_start
;
409 #define EXPR_STACK_SIZE (10)
410 bfd_vma expr_stack
[EXPR_STACK_SIZE
];
419 const bfd_byte
*start
;
422 ieee_record_enum_type c
;
426 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &val
, &present
))
431 if (esp
- expr_stack
>= EXPR_STACK_SIZE
)
433 ieee_error (abfd
, bytes
, start
, "expression stack overflow");
440 c
= (ieee_record_enum_type
) **pp
;
442 if (c
>= ieee_module_beginning_enum
)
453 ieee_error (abfd
, bytes
, start
,
454 "unsupported IEEE expression operator");
457 case ieee_variable_R_enum
:
462 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &indx
))
464 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
465 if ((bfd_vma
) s
->target_index
== indx
)
469 ieee_error (abfd
, bytes
, start
, "unknown section");
473 if (esp
- expr_stack
>= EXPR_STACK_SIZE
)
475 ieee_error (abfd
, bytes
, start
, "expression stack overflow");
479 *esp
++ = bfd_get_section_vma (abfd
, s
);
483 case ieee_function_plus_enum
:
484 case ieee_function_minus_enum
:
488 if (esp
- expr_stack
< 2)
490 ieee_error (abfd
, bytes
, start
, "expression stack underflow");
502 if (esp
- 1 != expr_stack
)
504 ieee_error (abfd
, bytes
, expr_start
, "expression stack mismatch");
513 /* Return an IEEE builtin type. */
516 ieee_builtin_type (dhandle
, abfd
, types
, bytes
, p
, indx
)
519 struct ieee_types
*types
;
520 const bfd_byte
*bytes
;
527 if (indx
< BUILTIN_TYPE_COUNT
528 && types
->builtins
[indx
] != DEBUG_TYPE_NULL
)
529 return types
->builtins
[indx
];
531 if (indx
>= 32 && indx
< 64)
533 type
= debug_make_pointer_type (dhandle
,
534 ieee_builtin_type (dhandle
, abfd
,
537 assert (indx
< BUILTIN_TYPE_COUNT
);
538 types
->builtins
[indx
] = type
;
542 switch ((enum builtin_types
) indx
)
545 ieee_error (abfd
, bytes
, p
, "unknown builtin type");
548 case builtin_unknown
:
549 type
= debug_make_void_type (dhandle
);
554 type
= debug_make_void_type (dhandle
);
558 case builtin_signed_char
:
559 type
= debug_make_int_type (dhandle
, 1, false);
560 name
= "signed char";
563 case builtin_unsigned_char
:
564 type
= debug_make_int_type (dhandle
, 1, true);
565 name
= "unsigned char";
568 case builtin_signed_short_int
:
569 type
= debug_make_int_type (dhandle
, 2, false);
570 name
= "signed short int";
573 case builtin_unsigned_short_int
:
574 type
= debug_make_int_type (dhandle
, 2, true);
575 name
= "unsigned short int";
578 case builtin_signed_long
:
579 type
= debug_make_int_type (dhandle
, 4, false);
580 name
= "signed long";
583 case builtin_unsigned_long
:
584 type
= debug_make_int_type (dhandle
, 4, true);
585 name
= "unsigned long";
588 case builtin_signed_long_long
:
589 type
= debug_make_int_type (dhandle
, 8, false);
590 name
= "signed long long";
593 case builtin_unsigned_long_long
:
594 type
= debug_make_int_type (dhandle
, 8, true);
595 name
= "unsigned long long";
599 type
= debug_make_float_type (dhandle
, 4);
604 type
= debug_make_float_type (dhandle
, 8);
608 case builtin_long_double
:
609 /* FIXME: The size for this type should depend upon the
611 type
= debug_make_float_type (dhandle
, 12);
612 name
= "long double";
615 case builtin_long_long_double
:
616 type
= debug_make_float_type (dhandle
, 16);
617 name
= "long long double";
620 case builtin_quoted_string
:
621 type
= debug_make_array_type (dhandle
,
622 ieee_builtin_type (dhandle
, abfd
, types
,
626 ieee_builtin_type (dhandle
, abfd
, types
,
631 name
= "QUOTED STRING";
634 case builtin_instruction_address
:
635 /* FIXME: This should be a code address. */
636 type
= debug_make_int_type (dhandle
, 4, true);
637 name
= "instruction address";
641 /* FIXME: The size for this type should depend upon the
643 type
= debug_make_int_type (dhandle
, 4, false);
647 case builtin_unsigned
:
648 /* FIXME: The size for this type should depend upon the
650 type
= debug_make_int_type (dhandle
, 4, true);
654 case builtin_unsigned_int
:
655 /* FIXME: The size for this type should depend upon the
657 type
= debug_make_int_type (dhandle
, 4, true);
658 name
= "unsigned int";
662 type
= debug_make_int_type (dhandle
, 1, false);
667 type
= debug_make_int_type (dhandle
, 4, false);
672 type
= debug_make_int_type (dhandle
, 2, false);
676 case builtin_unsigned_short
:
677 type
= debug_make_int_type (dhandle
, 2, true);
678 name
= "unsigned short";
681 case builtin_short_int
:
682 type
= debug_make_int_type (dhandle
, 2, false);
686 case builtin_signed_short
:
687 type
= debug_make_int_type (dhandle
, 2, false);
688 name
= "signed short";
691 case builtin_bcd_float
:
692 ieee_error (abfd
, bytes
, p
, "BCD float type not supported");
697 type
= debug_name_type (dhandle
, name
, type
);
699 assert (indx
< BUILTIN_TYPE_COUNT
);
701 types
->builtins
[indx
] = type
;
706 /* Allocate more space in the type table. If ref is true, this is a
707 reference to the type; if it is not already defined, we should set
708 up an indirect type. */
711 ieee_alloc_type (dhandle
, types
, indx
, ref
)
713 struct ieee_types
*types
;
718 register struct ieee_type
*t
;
719 struct ieee_type
*tend
;
721 if (indx
>= types
->alloc
)
723 nalloc
= types
->alloc
;
726 while (indx
>= nalloc
)
729 types
->types
= ((struct ieee_type
*)
730 xrealloc (types
->types
, nalloc
* sizeof *types
->types
));
732 memset (types
->types
+ types
->alloc
, 0,
733 (nalloc
- types
->alloc
) * sizeof *types
->types
);
735 tend
= types
->types
+ nalloc
;
736 for (t
= types
->types
+ types
->alloc
; t
< tend
; t
++)
738 t
->type
= DEBUG_TYPE_NULL
;
739 t
->return_type
= DEBUG_TYPE_NULL
;
742 types
->alloc
= nalloc
;
747 t
= types
->types
+ indx
;
750 t
->pslot
= (debug_type
*) xmalloc (sizeof *t
->pslot
);
751 *t
->pslot
= DEBUG_TYPE_NULL
;
752 t
->type
= debug_make_indirect_type (dhandle
, t
->pslot
,
753 (const char *) NULL
);
762 /* Read a type index and return the corresponding type. */
765 ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
, ptype
)
768 struct ieee_types
*types
;
769 const bfd_byte
*bytes
;
771 const bfd_byte
*pend
;
774 const bfd_byte
*start
;
779 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &indx
))
784 *ptype
= ieee_builtin_type (dhandle
, abfd
, types
, bytes
, start
, indx
);
791 if (! ieee_alloc_type (dhandle
, types
, indx
, true))
794 *ptype
= types
->types
[indx
].type
;
799 /* Parse IEEE debugging information for a file. This is passed the
800 bytes which compose the Debug Information Part of an IEEE file. */
803 parse_ieee (dhandle
, abfd
, bytes
, len
)
806 const bfd_byte
*bytes
;
809 struct ieee_blockstack blockstack
;
810 struct ieee_vars vars
;
811 struct ieee_types types
;
813 const bfd_byte
*p
, *pend
;
815 blockstack
.bsp
= blockstack
.stack
;
820 for (i
= 0; i
< BUILTIN_TYPE_COUNT
; i
++)
821 types
.builtins
[i
] = DEBUG_TYPE_NULL
;
827 const bfd_byte
*record_start
;
828 ieee_record_enum_type c
;
832 c
= (ieee_record_enum_type
) *p
++;
834 if (c
== ieee_at_record_enum
)
835 c
= (ieee_record_enum_type
) (((unsigned int) c
<< 8) | *p
++);
837 if (c
<= ieee_number_repeat_end_enum
)
839 ieee_error (abfd
, bytes
, record_start
, "unexpected number");
846 ieee_error (abfd
, bytes
, record_start
, "unexpected record type");
849 case ieee_bb_record_enum
:
850 if (! parse_ieee_bb (dhandle
, abfd
, &types
, &blockstack
, bytes
,
855 case ieee_be_record_enum
:
856 if (! parse_ieee_be (dhandle
, abfd
, &blockstack
, bytes
, &p
, pend
))
861 if (! parse_ieee_nn (dhandle
, abfd
, &vars
, bytes
, &p
, pend
))
865 case ieee_ty_record_enum
:
866 if (! parse_ieee_ty (dhandle
, abfd
, &types
, &vars
, bytes
, &p
, pend
))
870 case ieee_atn_record_enum
:
871 if (! parse_ieee_atn (dhandle
, abfd
, &types
, &vars
,
872 (blockstack
.bsp
<= blockstack
.stack
874 : blockstack
.bsp
[-1].kind
),
881 if (blockstack
.bsp
!= blockstack
.stack
)
883 ieee_error (abfd
, (const bfd_byte
*) NULL
, (const bfd_byte
*) NULL
,
884 "blocks left on stack at end");
891 /* Handle an IEEE BB record. */
894 parse_ieee_bb (dhandle
, abfd
, types
, blockstack
, bytes
, pp
, pend
)
897 struct ieee_types
*types
;
898 struct ieee_blockstack
*blockstack
;
899 const bfd_byte
*bytes
;
901 const bfd_byte
*pend
;
903 const bfd_byte
*block_start
;
907 unsigned long namlen
;
915 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &size
)
916 || ! ieee_read_id (abfd
, bytes
, pp
, pend
, &name
, &namlen
))
922 /* BB1: Type definitions local to a module. */
923 namcopy
= savestring (name
, namlen
);
926 if (! debug_set_filename (dhandle
, namcopy
))
931 /* BB2: Global type definitions. The name is supposed to be
932 empty, but we don't check. */
933 if (! debug_set_filename (dhandle
, "*global*"))
938 /* BB3: High level module block begin. We don't have to do
939 anything here. The name is supposed to be the same as for
940 the BB1, but we don't check. */
944 /* BB4: Global function. */
946 bfd_vma stackspace
, typindx
, offset
;
947 debug_type return_type
;
949 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &stackspace
)
950 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &typindx
)
951 || ! ieee_read_expression (abfd
, bytes
, pp
, pend
, &offset
))
954 /* We have no way to record the stack space. FIXME. */
958 return_type
= ieee_builtin_type (dhandle
, abfd
, types
, bytes
,
959 block_start
, typindx
);
960 if (return_type
== NULL
)
966 if (! ieee_alloc_type (dhandle
, types
, typindx
, true))
968 return_type
= types
->types
[typindx
].return_type
;
969 if (return_type
== NULL
)
970 return_type
= types
->types
[typindx
].type
;
973 namcopy
= savestring (name
, namlen
);
976 if (! debug_record_function (dhandle
, namcopy
, return_type
,
983 /* BB5: File name for source line numbers. */
987 /* We ignore the date and time. FIXME. */
988 for (i
= 0; i
< 6; i
++)
993 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &ignore
,
1000 namcopy
= savestring (name
, namlen
);
1001 if (namcopy
== NULL
)
1003 if (! debug_start_source (dhandle
, namcopy
))
1009 /* BB6: Local function or block. */
1011 bfd_vma stackspace
, typindx
, offset
;
1013 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &stackspace
)
1014 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &typindx
)
1015 || ! ieee_read_expression (abfd
, bytes
, pp
, pend
, &offset
))
1018 /* We have no way to record the stack space. FIXME. */
1022 if (! debug_start_block (dhandle
, offset
))
1024 /* Change b to indicate that this is a block
1025 rather than a function. */
1030 debug_type return_type
;
1034 return_type
= ieee_builtin_type (dhandle
, abfd
, types
, bytes
,
1035 block_start
, typindx
);
1036 if (return_type
== NULL
)
1042 if (! ieee_alloc_type (dhandle
, types
, typindx
, true))
1044 return_type
= types
->types
[typindx
].return_type
;
1045 if (return_type
== NULL
)
1046 return_type
= types
->types
[typindx
].type
;
1049 namcopy
= savestring (name
, namlen
);
1050 if (namcopy
== NULL
)
1052 if (! debug_record_function (dhandle
, namcopy
, return_type
,
1060 /* BB10: Assembler module scope. We completely ignore all this
1061 information. FIXME. */
1063 const char *inam
, *vstr
;
1064 unsigned long inamlen
, vstrlen
;
1069 if (! ieee_read_id (abfd
, bytes
, pp
, pend
, &inam
, &inamlen
)
1070 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &tool_type
)
1071 || ! ieee_read_optional_id (abfd
, bytes
, pp
, pend
, &vstr
, &vstrlen
,
1074 for (i
= 0; i
< 6; i
++)
1078 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &ignore
,
1088 /* BB11: Module section. We completely ignore all this
1089 information. FIXME. */
1091 bfd_vma sectype
, secindx
, offset
, map
;
1094 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, §ype
)
1095 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &secindx
)
1096 || ! ieee_read_expression (abfd
, bytes
, pp
, pend
, &offset
)
1097 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &map
,
1104 ieee_error (abfd
, bytes
, block_start
, "unknown BB type");
1109 /* Push this block on the block stack. */
1111 if (blockstack
->bsp
>= blockstack
->stack
+ BLOCKSTACK_SIZE
)
1113 ieee_error (abfd
, (const bfd_byte
*) NULL
, (const bfd_byte
*) NULL
,
1118 blockstack
->bsp
->kind
= b
;
1120 blockstack
->bsp
->filename
= namcopy
;
1126 /* Handle an IEEE BE record. */
1129 parse_ieee_be (dhandle
, abfd
, blockstack
, bytes
, pp
, pend
)
1132 struct ieee_blockstack
*blockstack
;
1133 const bfd_byte
*bytes
;
1134 const bfd_byte
**pp
;
1135 const bfd_byte
*pend
;
1139 if (blockstack
->bsp
<= blockstack
->stack
)
1141 ieee_error (abfd
, bytes
, *pp
, "stack underflow");
1146 switch (blockstack
->bsp
->kind
)
1150 if (! ieee_read_expression (abfd
, bytes
, pp
, pend
, &offset
))
1152 if (! debug_end_function (dhandle
, offset
))
1157 /* This is BE6 when BB6 started a block rather than a local
1159 if (! ieee_read_expression (abfd
, bytes
, pp
, pend
, &offset
))
1161 if (! debug_end_block (dhandle
, offset
))
1166 /* When we end a BB5, we look up the stack for the last BB5, if
1167 there is one, so that we can call debug_start_source. */
1168 if (blockstack
->bsp
> blockstack
->stack
)
1170 struct ieee_block
*bl
;
1172 bl
= blockstack
->bsp
;
1178 if (! debug_start_source (dhandle
, bl
->filename
))
1183 while (bl
!= blockstack
->stack
);
1188 if (! ieee_read_expression (abfd
, bytes
, pp
, pend
, &offset
))
1190 /* We just ignore the module size. FIXME. */
1194 /* Other block types do not have any trailing information. */
1201 /* Parse an NN record. */
1204 parse_ieee_nn (dhandle
, abfd
, vars
, bytes
, pp
, pend
)
1207 struct ieee_vars
*vars
;
1208 const bfd_byte
*bytes
;
1209 const bfd_byte
**pp
;
1210 const bfd_byte
*pend
;
1212 const bfd_byte
*nn_start
;
1215 unsigned long namlen
;
1219 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &varindx
)
1220 || ! ieee_read_id (abfd
, bytes
, pp
, pend
, &name
, &namlen
))
1225 ieee_error (abfd
, bytes
, nn_start
, "illegal variable index");
1230 if (varindx
>= vars
->alloc
)
1234 alloc
= vars
->alloc
;
1237 while (varindx
>= alloc
)
1239 vars
->vars
= ((struct ieee_var
*)
1240 xrealloc (vars
->vars
, alloc
* sizeof *vars
->vars
));
1241 memset (vars
->vars
+ vars
->alloc
, 0,
1242 (alloc
- vars
->alloc
) * sizeof *vars
->vars
);
1243 vars
->alloc
= alloc
;
1246 vars
->vars
[varindx
].name
= name
;
1247 vars
->vars
[varindx
].namlen
= namlen
;
1252 /* Parse a TY record. */
1255 parse_ieee_ty (dhandle
, abfd
, types
, vars
, bytes
, pp
, pend
)
1258 struct ieee_types
*types
;
1259 struct ieee_vars
*vars
;
1260 const bfd_byte
*bytes
;
1261 const bfd_byte
**pp
;
1262 const bfd_byte
*pend
;
1264 const bfd_byte
*ty_start
, *ty_var_start
, *ty_code_start
;
1265 bfd_vma typeindx
, varindx
, tc
;
1267 boolean tag
, typdef
;
1268 unsigned long type_bitsize
;
1269 debug_type return_type
;
1273 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &typeindx
))
1278 ieee_error (abfd
, bytes
, ty_start
, "illegal type index");
1283 if (! ieee_alloc_type (dhandle
, types
, typeindx
, false))
1288 ieee_error (abfd
, bytes
, *pp
, "unknown TY code");
1295 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &varindx
))
1300 ieee_error (abfd
, bytes
, ty_var_start
, "illegal variable index");
1305 if (varindx
>= vars
->alloc
|| vars
->vars
[varindx
].name
== NULL
)
1307 ieee_error (abfd
, bytes
, ty_var_start
, "undefined variable in TY");
1311 ty_code_start
= *pp
;
1313 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &tc
))
1319 return_type
= DEBUG_TYPE_NULL
;
1323 ieee_error (abfd
, bytes
, ty_code_start
, "unknown TY code");
1327 /* Unknown type, with size. We treat it as int. FIXME. */
1331 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &size
))
1333 type
= debug_make_int_type (dhandle
, size
, false);
1337 case 'A': /* Array. */
1338 case 'a': /* FORTRAN array in column/row order. FIXME: Not
1339 distinguished from normal array. */
1341 debug_type ele_type
;
1342 bfd_vma lower
, upper
;
1344 if (! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1346 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &lower
)
1347 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &upper
))
1349 type
= debug_make_array_type (dhandle
, ele_type
,
1350 ieee_builtin_type (dhandle
, abfd
, types
,
1351 bytes
, ty_code_start
,
1354 (bfd_signed_vma
) lower
,
1355 (bfd_signed_vma
) upper
,
1361 /* Simple enumeration. */
1367 bfd_signed_vma
*vals
;
1370 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &size
))
1372 /* FIXME: we ignore the enumeration size. */
1375 names
= (const char **) xmalloc (alloc
* sizeof *names
);
1376 memset (names
, 0, alloc
* sizeof *names
);
1381 unsigned long namlen
;
1384 if (! ieee_read_optional_id (abfd
, bytes
, pp
, pend
, &name
,
1393 names
= ((const char **)
1394 xrealloc (names
, alloc
* sizeof *names
));
1397 names
[c
] = savestring (name
, namlen
);
1398 if (names
[c
] == NULL
)
1405 vals
= (bfd_signed_vma
*) xmalloc (c
* sizeof *vals
);
1406 for (i
= 0; i
< c
; i
++)
1409 type
= debug_make_enum_type (dhandle
, names
, vals
);
1415 /* Struct with bit fields. */
1419 debug_field
*fields
;
1422 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &size
))
1426 fields
= (debug_field
*) xmalloc (alloc
* sizeof *fields
);
1431 unsigned long namlen
;
1434 bfd_vma bitpos
, bitsize
;
1436 if (! ieee_read_optional_id (abfd
, bytes
, pp
, pend
, &name
,
1441 if (! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1443 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &bitpos
)
1444 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &bitsize
))
1450 fields
= ((debug_field
*)
1451 xrealloc (fields
, alloc
* sizeof *fields
));
1454 fields
[c
] = debug_make_field (dhandle
, savestring (name
, namlen
),
1455 ftype
, bitpos
, bitsize
,
1456 DEBUG_VISIBILITY_PUBLIC
);
1457 if (fields
[c
] == NULL
)
1464 type
= debug_make_struct_type (dhandle
, true, size
, fields
);
1474 bfd_signed_vma
*vals
;
1478 names
= (const char **) xmalloc (alloc
* sizeof *names
);
1479 vals
= (bfd_signed_vma
*) xmalloc (alloc
* sizeof *names
);
1484 unsigned long namlen
;
1488 if (! ieee_read_optional_id (abfd
, bytes
, pp
, pend
, &name
,
1493 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &val
))
1496 /* If the length of the name is zero, then the value is
1497 actually the size of the enum. We ignore this
1498 information. FIXME. */
1505 names
= ((const char **)
1506 xrealloc (names
, alloc
* sizeof *names
));
1507 vals
= ((bfd_signed_vma
*)
1508 xrealloc (vals
, alloc
* sizeof *vals
));
1511 names
[c
] = savestring (name
, namlen
);
1512 if (names
[c
] == NULL
)
1514 vals
[c
] = (bfd_signed_vma
) val
;
1520 type
= debug_make_enum_type (dhandle
, names
, vals
);
1525 case 'O': /* Small pointer. We don't distinguish small and large
1527 case 'P': /* Large pointer. */
1531 if (! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
, &t
))
1533 type
= debug_make_pointer_type (dhandle
, t
);
1540 bfd_vma low
, high
, signedp
, size
;
1542 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &low
)
1543 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &high
)
1544 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &signedp
)
1545 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &size
))
1548 type
= debug_make_range_type (dhandle
,
1549 debug_make_int_type (dhandle
, size
,
1551 (bfd_signed_vma
) low
,
1552 (bfd_signed_vma
) high
);
1556 case 'S': /* Struct. */
1557 case 'U': /* Union. */
1561 debug_field
*fields
;
1564 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &size
))
1568 fields
= (debug_field
*) xmalloc (alloc
* sizeof *fields
);
1573 unsigned long namlen
;
1580 if (! ieee_read_optional_id (abfd
, bytes
, pp
, pend
, &name
,
1585 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &tindx
)
1586 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &offset
))
1591 ftype
= ieee_builtin_type (dhandle
, abfd
, types
, bytes
,
1592 ty_code_start
, tindx
);
1598 struct ieee_type
*t
;
1601 if (! ieee_alloc_type (dhandle
, types
, tindx
, true))
1603 t
= types
->types
+ tindx
;
1605 bitsize
= t
->bitsize
;
1613 fields
= ((debug_field
*)
1614 xrealloc (fields
, alloc
* sizeof *fields
));
1617 fields
[c
] = debug_make_field (dhandle
, savestring (name
, namlen
),
1618 ftype
, offset
, bitsize
,
1619 DEBUG_VISIBILITY_PUBLIC
);
1620 if (fields
[c
] == NULL
)
1627 type
= debug_make_struct_type (dhandle
, tc
== 'S', size
, fields
);
1634 if (! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1641 /* Procedure. FIXME: This is an extern declaration, which we
1642 have no way of representing. */
1649 /* FIXME: We ignore the attribute and the argument names. */
1651 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &attr
)
1652 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1654 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &nargs
))
1659 unsigned long namlen
;
1661 if (! ieee_read_optional_id (abfd
, bytes
, pp
, pend
, &name
,
1667 type
= debug_make_function_type (dhandle
, rtype
, (debug_type
*) NULL
,
1669 return_type
= rtype
;
1674 /* Array with 0 lower bound. */
1679 if (! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1681 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &high
))
1684 type
= debug_make_array_type (dhandle
, etype
,
1685 ieee_builtin_type (dhandle
, abfd
, types
,
1686 bytes
, ty_code_start
,
1689 0, (bfd_signed_vma
) high
, false);
1693 case 'c': /* Complex. */
1694 case 'd': /* Double complex. */
1697 unsigned long namlen
;
1699 /* FIXME: I don't know what the name means. */
1701 if (! ieee_read_id (abfd
, bytes
, pp
, pend
, &name
, &namlen
))
1704 type
= debug_make_complex_type (dhandle
, tc
== 'c' ? 4 : 8);
1709 /* Pascal file name. FIXME. */
1710 ieee_error (abfd
, bytes
, ty_code_start
,
1711 "Pascal file name not supported");
1715 /* Bitfield type. */
1717 bfd_vma signedp
, bitsize
;
1719 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &signedp
)
1720 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &bitsize
)
1721 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1725 /* FIXME: This is just a guess. */
1727 type
= debug_make_int_type (dhandle
, 4, true);
1728 type_bitsize
= bitsize
;
1738 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &kind
)
1739 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1746 ieee_error (abfd
, bytes
, ty_start
, "unsupported qualifer");
1750 type
= debug_make_const_type (dhandle
, t
);
1754 type
= debug_make_volatile_type (dhandle
, t
);
1766 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &size
)
1767 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1771 /* FIXME: We ignore the size. */
1773 type
= debug_make_set_type (dhandle
, etype
, false);
1778 /* Procedure with compiler dependencies. FIXME: This is an
1779 extern declaration, which we have no way of representing. */
1781 bfd_vma attr
, frame_type
, push_mask
, nargs
, level
, father
;
1783 debug_type
*arg_types
;
1787 /* FIXME: We ignore almost all this information. */
1789 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &attr
)
1790 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &frame_type
)
1791 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &push_mask
)
1792 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1794 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &nargs
))
1796 if (nargs
== (bfd_vma
) -1)
1805 arg_types
= ((debug_type
*)
1806 xmalloc ((nargs
+ 1) * sizeof *arg_types
));
1807 for (i
= 0; i
< nargs
; i
++)
1808 if (! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
,
1809 pend
, arg_types
+ i
))
1812 /* If the last type is pointer to void, this is really a
1813 varargs function. */
1819 last
= arg_types
[nargs
- 1];
1820 if (debug_get_type_kind (dhandle
, last
) == DEBUG_KIND_POINTER
1821 && (debug_get_type_kind (dhandle
,
1822 debug_get_target_type (dhandle
,
1824 == DEBUG_KIND_VOID
))
1831 arg_types
[nargs
] = DEBUG_TYPE_NULL
;
1833 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &level
)
1834 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &father
,
1838 type
= debug_make_function_type (dhandle
, rtype
, arg_types
, varargs
);
1839 return_type
= rtype
;
1844 /* Record the type in the table. If the corresponding NN record has
1845 a name, name it. FIXME: Is this always correct? */
1851 && vars
->vars
[varindx
].namlen
> 0)
1855 name
= savestring (vars
->vars
[varindx
].name
,
1856 vars
->vars
[varindx
].namlen
);
1858 type
= debug_tag_type (dhandle
, name
, type
);
1860 type
= debug_name_type (dhandle
, name
, type
);
1865 types
->types
[typeindx
].type
= type
;
1866 types
->types
[typeindx
].bitsize
= type_bitsize
;
1867 types
->types
[typeindx
].return_type
= return_type
;
1869 /* We may have already allocated type as an indirect type pointing
1870 to slot. It does no harm to replace the indirect type with the
1871 real type. Filling in slot as well handles the indirect types
1872 which are already hanging around. */
1873 if (types
->types
[typeindx
].pslot
!= NULL
)
1874 *types
->types
[typeindx
].pslot
= type
;
1879 /* Parse an ATN record. */
1882 parse_ieee_atn (dhandle
, abfd
, types
, vars
, blocktype
, bytes
, pp
, pend
)
1885 struct ieee_types
*types
;
1886 struct ieee_vars
*vars
;
1888 const bfd_byte
*bytes
;
1889 const bfd_byte
**pp
;
1890 const bfd_byte
*pend
;
1892 const bfd_byte
*atn_start
, *atn_code_start
;
1897 bfd_vma v
, v2
, v3
, v4
, v5
;
1899 unsigned long namlen
;
1905 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &varindx
)
1906 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
, &type
))
1909 atn_code_start
= *pp
;
1911 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &atn_code
))
1920 else if (varindx
< 32)
1922 ieee_error (abfd
, bytes
, atn_start
, "illegal variable index");
1929 if (varindx
>= vars
->alloc
|| vars
->vars
[varindx
].name
== NULL
)
1931 ieee_error (abfd
, bytes
, atn_start
, "undefined variable in ATN");
1935 vars
->vars
[varindx
].type
= type
;
1937 name
= vars
->vars
[varindx
].name
;
1938 namlen
= vars
->vars
[varindx
].namlen
;
1944 ieee_error (abfd
, bytes
, atn_code_start
, "unknown ATN type");
1948 /* Automatic variable. */
1949 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
))
1951 namcopy
= savestring (name
, namlen
);
1953 type
= debug_make_void_type (dhandle
);
1954 return debug_record_variable (dhandle
, namcopy
, type
, DEBUG_LOCAL
, v
);
1957 /* Register variable. */
1958 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
))
1960 namcopy
= savestring (name
, namlen
);
1962 type
= debug_make_void_type (dhandle
);
1963 return debug_record_variable (dhandle
, namcopy
, type
, DEBUG_REGISTER
,
1964 ieee_regno_to_genreg (abfd
, v
));
1967 /* Static variable. */
1968 if (! ieee_require_asn (abfd
, bytes
, pp
, pend
, &v
))
1970 namcopy
= savestring (name
, namlen
);
1972 type
= debug_make_void_type (dhandle
);
1973 return debug_record_variable (dhandle
, namcopy
, type
,
1974 (blocktype
== 4 || blocktype
== 6
1975 ? DEBUG_LOCAL_STATIC
1980 /* External function. We don't currently record these. FIXME. */
1984 /* External variable. We don't currently record these. FIXME. */
1988 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
1989 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &v2
)
1990 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v3
,
1995 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v4
,
2000 /* We just ignore the two optional fields in v3 and v4, since
2001 they are not defined. */
2003 if (! ieee_require_asn (abfd
, bytes
, pp
, pend
, &v3
))
2006 /* We have no way to record the column number. FIXME. */
2008 return debug_record_line (dhandle
, v
, v3
);
2011 /* Global variable. */
2012 if (! ieee_require_asn (abfd
, bytes
, pp
, pend
, &v
))
2014 namcopy
= savestring (name
, namlen
);
2016 type
= debug_make_void_type (dhandle
);
2017 return debug_record_variable (dhandle
, namcopy
, type
, DEBUG_GLOBAL
, v
);
2020 /* Variable lifetime information. */
2021 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
))
2024 /* We have no way to record this information. FIXME. */
2028 /* Locked register. */
2029 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
2030 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &v2
))
2033 /* I think this means a variable that is both in a register and
2034 a frame slot. We ignore the frame slot. FIXME. */
2036 namcopy
= savestring (name
, namlen
);
2038 type
= debug_make_void_type (dhandle
);
2039 return debug_record_variable (dhandle
, namcopy
, type
, DEBUG_REGISTER
, v
);
2042 /* Reserved for FORTRAN common. */
2043 ieee_error (abfd
, bytes
, atn_code_start
, "unsupported ATN11");
2045 /* Return true to keep going. */
2049 /* Based variable. */
2053 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
2054 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &v2
)
2055 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v3
,
2060 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v4
,
2065 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v5
,
2071 /* We have no way to record this information. FIXME. */
2073 ieee_error (abfd
, bytes
, atn_code_start
, "unsupported ATN12");
2075 /* Return true to keep going. */
2079 /* Constant. The description of this that I have is ambiguous,
2080 so I'm not going to try to implement it. */
2081 ieee_error (abfd
, bytes
, atn_code_start
, "unsupported ATN16");
2085 /* Static variable from assembler. */
2087 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
2088 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v2
,
2090 || ! ieee_require_asn (abfd
, bytes
, pp
, pend
, &v3
))
2092 namcopy
= savestring (name
, namlen
);
2093 /* We don't really handle this correctly. FIXME. */
2094 return debug_record_variable (dhandle
, namcopy
,
2095 debug_make_void_type (dhandle
),
2096 v2
!= 0 ? DEBUG_GLOBAL
: DEBUG_STATIC
,
2100 /* Procedure miscellaneous information. */
2102 /* Variable miscellaneous information. */
2104 /* Module miscellaneous information. */
2105 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
2106 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &v2
)
2107 || ! ieee_read_optional_id (abfd
, bytes
, pp
, pend
, &name
, &namlen
,
2111 /* We just ignore all of this stuff. FIXME. */
2113 for (; v2
> 0; --v2
)
2115 ieee_record_enum_type c
;
2118 unsigned long strlen
;
2120 c
= (ieee_record_enum_type
) **pp
;
2122 if (c
!= ieee_at_record_enum
2123 && c
!= ieee_e2_first_byte_enum
)
2125 ieee_error (abfd
, bytes
, *pp
- 1, "bad misc record");
2129 c
= (ieee_record_enum_type
) (((unsigned int) c
<< 8) | **pp
);
2134 ieee_error (abfd
, bytes
, *pp
- 2, "bad misc record");
2137 case ieee_atn_record_enum
:
2138 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &vindx
))
2140 if ((*pp
)[0] != 0 || (*pp
)[1] != 65)
2142 ieee_error (abfd
, bytes
, *pp
, "bad atn in misc");
2146 if (! ieee_read_id (abfd
, bytes
, pp
, pend
, &str
, &strlen
))
2150 case ieee_asn_record_enum
:
2151 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &vindx
)
2152 || ! ieee_read_expression (abfd
, bytes
, pp
, pend
, &v3
))
2164 /* Require an ASN record. */
2167 ieee_require_asn (abfd
, bytes
, pp
, pend
, pv
)
2169 const bfd_byte
*bytes
;
2170 const bfd_byte
**pp
;
2171 const bfd_byte
*pend
;
2174 const bfd_byte
*start
;
2175 ieee_record_enum_type c
;
2180 c
= (ieee_record_enum_type
) **pp
;
2181 if (c
!= ieee_e2_first_byte_enum
)
2183 ieee_error (abfd
, bytes
, start
, "missing required ASN");
2188 c
= (ieee_record_enum_type
) (((unsigned int) c
<< 8) | **pp
);
2189 if (c
!= ieee_asn_record_enum
)
2191 ieee_error (abfd
, bytes
, start
, "missing required ASN");
2196 /* Just ignore the variable index. */
2197 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &varindx
))
2200 return ieee_read_expression (abfd
, bytes
, pp
, pend
, pv
);
2203 /* Convert a register number in IEEE debugging information into a
2204 generic register number. */
2207 ieee_regno_to_genreg (abfd
, r
)
2214 /* Convert a generic register number to an IEEE specific one. */
2217 ieee_genreg_to_regno (abfd
, r
)
2224 /* These routines build IEEE debugging information out of the generic
2225 debugging information. */
2227 /* We build the IEEE debugging information byte by byte. Rather than
2228 waste time copying data around, we use a linked list of buffers to
2231 #define IEEE_BUFSIZE (490)
2236 struct ieee_buf
*next
;
2237 /* Number of data bytes in this buffer. */
2240 bfd_byte buf
[IEEE_BUFSIZE
];
2243 /* In order to generate the BB11 blocks required by the HP emulator,
2244 we keep track of ranges of addresses which correspond to a given
2245 compilation unit. */
2250 struct ieee_range
*next
;
2257 /* This is how we store types for the writing routines. Most types
2258 are simply represented by a type index. */
2260 struct ieee_write_type
2264 /* The size of the type, if known. */
2266 /* If this is a struct, this is where the struct definition is
2268 struct ieee_buf
*strdef
;
2269 /* Whether the type is unsigned. */
2270 unsigned int unsignedp
: 1;
2271 /* Whether this is a reference type. */
2272 unsigned int referencep
: 1;
2275 /* This is the type stack used by the debug writing routines. FIXME:
2276 We could generate more efficient output if we remembered when we
2277 have output a particular type before. */
2279 struct ieee_type_stack
2281 /* Next entry on stack. */
2282 struct ieee_type_stack
*next
;
2283 /* Type information. */
2284 struct ieee_write_type type
;
2287 /* This is a list of associations between names and types. This could
2288 be more efficiently implemented as a hash table. */
2290 struct ieee_name_type
2292 /* Next name/type assocation. */
2293 struct ieee_name_type
*next
;
2297 struct ieee_write_type type
;
2298 /* If this is a tag which has not yet been defined, this is the
2299 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
2300 enum debug_type_kind kind
;
2303 /* This is a list of pending function parameter information. We don't
2304 output them until we see the first block. */
2306 struct ieee_pending_parm
2308 /* Next pending parameter. */
2309 struct ieee_pending_parm
*next
;
2315 enum debug_parm_kind kind
;
2320 /* This is the handle passed down by debug_write. */
2324 /* BFD we are writing to. */
2326 /* Current data buffer. */
2327 struct ieee_buf
*current
;
2328 /* Filename of current compilation unit. */
2329 const char *filename
;
2330 /* Module name of current compilation unit. */
2331 const char *modname
;
2332 /* List of finished data buffers. */
2333 struct ieee_buf
*data
;
2334 /* List of buffers for typedefs in the current compilation unit. */
2335 struct ieee_buf
*types
;
2336 /* List of buffers for variables and functions in the current
2337 compilation unit. */
2338 struct ieee_buf
*vars
;
2339 /* List of buffers for line numbers in the current compilation unit. */
2340 struct ieee_buf
*linenos
;
2341 /* Ranges for the current compilation unit. */
2342 struct ieee_range
*ranges
;
2343 /* Nested pending ranges. */
2344 struct ieee_range
*pending_ranges
;
2346 struct ieee_type_stack
*type_stack
;
2347 /* Next unallocated type index. */
2348 unsigned int type_indx
;
2349 /* Next unallocated name index. */
2350 unsigned int name_indx
;
2352 struct ieee_name_type
*typedefs
;
2354 struct ieee_name_type
*tags
;
2355 /* The depth of block nesting. This is 0 outside a function, and 1
2356 just after start_function is called. */
2357 unsigned int block_depth
;
2358 /* Pending function parameters. */
2359 struct ieee_pending_parm
*pending_parms
;
2360 /* Current line number filename. */
2361 const char *lineno_filename
;
2362 /* Line number name index. */
2363 unsigned int lineno_name_indx
;
2366 static boolean ieee_change_buffer
2367 PARAMS ((struct ieee_handle
*, struct ieee_buf
**));
2368 static boolean ieee_push_type
2369 PARAMS ((struct ieee_handle
*, unsigned int, unsigned int, boolean
));
2370 static unsigned int ieee_pop_type
PARAMS ((struct ieee_handle
*));
2371 static boolean ieee_add_range
2372 PARAMS ((struct ieee_handle
*, bfd_vma
, bfd_vma
));
2373 static boolean ieee_start_range
PARAMS ((struct ieee_handle
*, bfd_vma
));
2374 static boolean ieee_end_range
PARAMS ((struct ieee_handle
*, bfd_vma
));
2375 static boolean ieee_real_write_byte
PARAMS ((struct ieee_handle
*, int));
2376 static boolean ieee_write_2bytes
PARAMS ((struct ieee_handle
*, int));
2377 static boolean ieee_write_number
PARAMS ((struct ieee_handle
*, bfd_vma
));
2378 static boolean ieee_write_id
PARAMS ((struct ieee_handle
*, const char *));
2379 static boolean ieee_define_type
2380 PARAMS ((struct ieee_handle
*, unsigned int, boolean
));
2381 static boolean ieee_define_named_type
2382 PARAMS ((struct ieee_handle
*, const char *, boolean
, unsigned int, boolean
,
2383 struct ieee_buf
**));
2384 static boolean ieee_finish_compilation_unit
PARAMS ((struct ieee_handle
*));
2385 static boolean ieee_output_pending_parms
PARAMS ((struct ieee_handle
*));
2387 static boolean ieee_start_compilation_unit
PARAMS ((PTR
, const char *));
2388 static boolean ieee_start_source
PARAMS ((PTR
, const char *));
2389 static boolean ieee_empty_type
PARAMS ((PTR
));
2390 static boolean ieee_void_type
PARAMS ((PTR
));
2391 static boolean ieee_int_type
PARAMS ((PTR
, unsigned int, boolean
));
2392 static boolean ieee_float_type
PARAMS ((PTR
, unsigned int));
2393 static boolean ieee_complex_type
PARAMS ((PTR
, unsigned int));
2394 static boolean ieee_bool_type
PARAMS ((PTR
, unsigned int));
2395 static boolean ieee_enum_type
2396 PARAMS ((PTR
, const char *, const char **, bfd_signed_vma
*));
2397 static boolean ieee_pointer_type
PARAMS ((PTR
));
2398 static boolean ieee_function_type
PARAMS ((PTR
, int, boolean
));
2399 static boolean ieee_reference_type
PARAMS ((PTR
));
2400 static boolean ieee_range_type
PARAMS ((PTR
, bfd_signed_vma
, bfd_signed_vma
));
2401 static boolean ieee_array_type
2402 PARAMS ((PTR
, bfd_signed_vma
, bfd_signed_vma
, boolean
));
2403 static boolean ieee_set_type
PARAMS ((PTR
, boolean
));
2404 static boolean ieee_offset_type
PARAMS ((PTR
));
2405 static boolean ieee_method_type
PARAMS ((PTR
, boolean
, int, boolean
));
2406 static boolean ieee_const_type
PARAMS ((PTR
));
2407 static boolean ieee_volatile_type
PARAMS ((PTR
));
2408 static boolean ieee_start_struct_type
2409 PARAMS ((PTR
, const char *, unsigned int, boolean
, unsigned int));
2410 static boolean ieee_struct_field
2411 PARAMS ((PTR
, const char *, bfd_vma
, bfd_vma
, enum debug_visibility
));
2412 static boolean ieee_end_struct_type
PARAMS ((PTR
));
2413 static boolean ieee_start_class_type
2414 PARAMS ((PTR
, const char *, unsigned int, boolean
, unsigned int, boolean
,
2416 static boolean ieee_class_static_member
2417 PARAMS ((PTR
, const char *, const char *, enum debug_visibility
));
2418 static boolean ieee_class_baseclass
2419 PARAMS ((PTR
, bfd_vma
, boolean
, enum debug_visibility
));
2420 static boolean ieee_class_start_method
PARAMS ((PTR
, const char *));
2421 static boolean ieee_class_method_variant
2422 PARAMS ((PTR
, const char *, enum debug_visibility
, boolean
, boolean
,
2424 static boolean ieee_class_static_method_variant
2425 PARAMS ((PTR
, const char *, enum debug_visibility
, boolean
, boolean
));
2426 static boolean ieee_class_end_method
PARAMS ((PTR
));
2427 static boolean ieee_end_class_type
PARAMS ((PTR
));
2428 static boolean ieee_typedef_type
PARAMS ((PTR
, const char *));
2429 static boolean ieee_tag_type
2430 PARAMS ((PTR
, const char *, unsigned int, enum debug_type_kind
));
2431 static boolean ieee_typdef
PARAMS ((PTR
, const char *));
2432 static boolean ieee_tag
PARAMS ((PTR
, const char *));
2433 static boolean ieee_int_constant
PARAMS ((PTR
, const char *, bfd_vma
));
2434 static boolean ieee_float_constant
PARAMS ((PTR
, const char *, double));
2435 static boolean ieee_typed_constant
PARAMS ((PTR
, const char *, bfd_vma
));
2436 static boolean ieee_variable
2437 PARAMS ((PTR
, const char *, enum debug_var_kind
, bfd_vma
));
2438 static boolean ieee_start_function
PARAMS ((PTR
, const char *, boolean
));
2439 static boolean ieee_function_parameter
2440 PARAMS ((PTR
, const char *, enum debug_parm_kind
, bfd_vma
));
2441 static boolean ieee_start_block
PARAMS ((PTR
, bfd_vma
));
2442 static boolean ieee_end_block
PARAMS ((PTR
, bfd_vma
));
2443 static boolean ieee_end_function
PARAMS ((PTR
));
2444 static boolean ieee_lineno
2445 PARAMS ((PTR
, const char *, unsigned long, bfd_vma
));
2447 static const struct debug_write_fns ieee_fns
=
2449 ieee_start_compilation_unit
,
2460 ieee_reference_type
,
2468 ieee_start_struct_type
,
2470 ieee_end_struct_type
,
2471 ieee_start_class_type
,
2472 ieee_class_static_member
,
2473 ieee_class_baseclass
,
2474 ieee_class_start_method
,
2475 ieee_class_method_variant
,
2476 ieee_class_static_method_variant
,
2477 ieee_class_end_method
,
2478 ieee_end_class_type
,
2484 ieee_float_constant
,
2485 ieee_typed_constant
,
2487 ieee_start_function
,
2488 ieee_function_parameter
,
2495 /* Change the current buffer to a specified buffer chain. */
2498 ieee_change_buffer (info
, ppbuf
)
2499 struct ieee_handle
*info
;
2500 struct ieee_buf
**ppbuf
;
2502 struct ieee_buf
*buf
;
2506 for (buf
= *ppbuf
; buf
->next
!= NULL
; buf
= buf
->next
)
2511 buf
= (struct ieee_buf
*) xmalloc (sizeof *buf
);
2517 info
->current
= buf
;
2521 /* Push a type index onto the type stack. */
2524 ieee_push_type (info
, indx
, size
, unsignedp
)
2525 struct ieee_handle
*info
;
2530 struct ieee_type_stack
*ts
;
2532 ts
= (struct ieee_type_stack
*) xmalloc (sizeof *ts
);
2533 memset (ts
, 0, sizeof *ts
);
2535 ts
->type
.indx
= indx
;
2536 ts
->type
.size
= size
;
2537 ts
->type
.unsignedp
= unsignedp
;
2539 ts
->next
= info
->type_stack
;
2540 info
->type_stack
= ts
;
2545 /* Pop a type index off the type stack. */
2548 ieee_pop_type (info
)
2549 struct ieee_handle
*info
;
2551 struct ieee_type_stack
*ts
;
2554 ts
= info
->type_stack
;
2555 assert (ts
!= NULL
);
2556 ret
= ts
->type
.indx
;
2557 info
->type_stack
= ts
->next
;
2562 /* Add a range of bytes included in the current compilation unit. */
2565 ieee_add_range (info
, low
, high
)
2566 struct ieee_handle
*info
;
2570 struct ieee_range
*r
, **pr
;
2572 if (low
== (bfd_vma
) -1 || high
== (bfd_vma
) -1)
2575 for (r
= info
->ranges
; r
!= NULL
; r
= r
->next
)
2577 if (high
>= r
->low
&& low
<= r
->high
)
2579 /* The new range overlaps r. */
2585 while (*pr
!= NULL
&& (*pr
)->low
<= r
->high
)
2587 struct ieee_range
*n
;
2589 if ((*pr
)->high
> r
->high
)
2590 r
->high
= (*pr
)->high
;
2599 r
= (struct ieee_range
*) xmalloc (sizeof *r
);
2600 memset (r
, 0, sizeof *r
);
2605 /* Store the ranges sorted by address. */
2606 for (pr
= &info
->ranges
; *pr
!= NULL
; pr
= &(*pr
)->next
)
2607 if ((*pr
)->next
!= NULL
&& (*pr
)->next
->low
> high
)
2615 /* Start a new range for which we only have the low address. */
2618 ieee_start_range (info
, low
)
2619 struct ieee_handle
*info
;
2622 struct ieee_range
*r
;
2624 r
= (struct ieee_range
*) xmalloc (sizeof *r
);
2625 memset (r
, 0, sizeof *r
);
2627 r
->next
= info
->pending_ranges
;
2628 info
->pending_ranges
= r
;
2632 /* Finish a range started by ieee_start_range. */
2635 ieee_end_range (info
, high
)
2636 struct ieee_handle
*info
;
2639 struct ieee_range
*r
;
2642 assert (info
->pending_ranges
!= NULL
);
2643 r
= info
->pending_ranges
;
2645 info
->pending_ranges
= r
->next
;
2647 return ieee_add_range (info
, low
, high
);
2650 /* Write a byte into the buffer. We use a macro for speed and a
2651 function for the complex cases. */
2653 #define ieee_write_byte(info, b) \
2654 ((info)->current->c < IEEE_BUFSIZE \
2655 ? ((info)->current->buf[(info)->current->c++] = (b), true) \
2656 : ieee_real_write_byte ((info), (b)))
2659 ieee_real_write_byte (info
, b
)
2660 struct ieee_handle
*info
;
2663 if (info
->current
->c
>= IEEE_BUFSIZE
)
2667 n
= (struct ieee_buf
*) xmalloc (sizeof *n
);
2670 info
->current
->next
= n
;
2674 info
->current
->buf
[info
->current
->c
] = b
;
2680 /* Write out two bytes. */
2683 ieee_write_2bytes (info
, i
)
2684 struct ieee_handle
*info
;
2687 return (ieee_write_byte (info
, i
>> 8)
2688 && ieee_write_byte (info
, i
& 0xff));
2691 /* Write out an integer. */
2694 ieee_write_number (info
, v
)
2695 struct ieee_handle
*info
;
2703 if (v
<= (bfd_vma
) ieee_number_end_enum
)
2704 return ieee_write_byte (info
, (int) v
);
2715 if (c
> (unsigned int) (ieee_number_repeat_end_enum
2716 - ieee_number_repeat_start_enum
))
2718 fprintf (stderr
, "IEEE numeric overflow: 0x");
2719 fprintf_vma (stderr
, v
);
2720 fprintf (stderr
, "\n");
2724 if (! ieee_write_byte (info
, (int) ieee_number_repeat_start_enum
+ c
))
2726 for (; c
> 0; --c
, ++p
)
2728 if (! ieee_write_byte (info
, *p
))
2735 /* Write out a string. */
2738 ieee_write_id (info
, s
)
2739 struct ieee_handle
*info
;
2747 if (! ieee_write_byte (info
, len
))
2750 else if (len
<= 0xff)
2752 if (! ieee_write_byte (info
, (int) ieee_extension_length_1_enum
)
2753 || ! ieee_write_byte (info
, len
))
2756 else if (len
<= 0xffff)
2758 if (! ieee_write_byte (info
, (int) ieee_extension_length_2_enum
)
2759 || ! ieee_write_2bytes (info
, len
))
2764 fprintf (stderr
, "IEEE string length overflow: %u\n", len
);
2768 for (; *s
!= '\0'; s
++)
2769 if (! ieee_write_byte (info
, *s
))
2775 /* Start defining a type. */
2778 ieee_define_type (info
, size
, unsignedp
)
2779 struct ieee_handle
*info
;
2783 return ieee_define_named_type (info
, (const char *) NULL
, false, size
,
2784 unsignedp
, (struct ieee_buf
**) NULL
);
2787 /* Start defining a named type. */
2790 ieee_define_named_type (info
, name
, tagp
, size
, unsignedp
, ppbuf
)
2791 struct ieee_handle
*info
;
2796 struct ieee_buf
**ppbuf
;
2798 unsigned int type_indx
;
2799 unsigned int name_indx
;
2801 if (! tagp
|| name
== NULL
|| *name
== '\0')
2803 type_indx
= info
->type_indx
;
2808 struct ieee_name_type
*nt
;
2810 /* The name is a tag. If we have already defined the tag, we
2811 must use the existing type index. */
2812 for (nt
= info
->tags
; nt
!= NULL
; nt
= nt
->next
)
2813 if (nt
->name
[0] == name
[0]
2814 && strcmp (nt
->name
, name
) == 0)
2819 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
2820 memset (nt
, 0, sizeof *nt
);
2822 nt
->next
= info
->tags
;
2824 nt
->type
.indx
= info
->type_indx
;
2828 nt
->type
.size
= size
;
2829 nt
->type
.unsignedp
= unsignedp
;
2830 nt
->kind
= DEBUG_KIND_ILLEGAL
;
2832 type_indx
= nt
->type
.indx
;
2835 name_indx
= info
->name_indx
;
2841 /* If we were given a buffer, use it; otherwise, use the general
2842 type information, and make sure that the type block is started. */
2845 if (! ieee_change_buffer (info
, ppbuf
))
2848 else if (info
->types
!= NULL
)
2850 if (! ieee_change_buffer (info
, &info
->types
))
2855 if (! ieee_change_buffer (info
, &info
->types
)
2856 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
2857 || ! ieee_write_byte (info
, 1)
2858 || ! ieee_write_number (info
, 0)
2859 || ! ieee_write_id (info
, info
->modname
))
2863 /* Push the new type on the type stack, write out an NN record, and
2864 write out the start of a TY record. The caller will then finish
2866 return (ieee_push_type (info
, type_indx
, size
, unsignedp
)
2867 && ieee_write_byte (info
, (int) ieee_nn_record
)
2868 && ieee_write_number (info
, name_indx
)
2869 && ieee_write_id (info
, name
)
2870 && ieee_write_byte (info
, (int) ieee_ty_record_enum
)
2871 && ieee_write_number (info
, type_indx
)
2872 && ieee_write_byte (info
, 0xce)
2873 && ieee_write_number (info
, name_indx
));
2876 /* The general routine to write out IEEE debugging information. */
2879 write_ieee_debugging_info (abfd
, dhandle
)
2883 struct ieee_handle info
;
2884 struct ieee_buf
*tags
;
2885 struct ieee_name_type
*nt
;
2890 memset (&info
, 0, sizeof info
);
2892 info
.type_indx
= 256;
2893 info
.name_indx
= 32;
2895 if (! debug_write (dhandle
, &ieee_fns
, (PTR
) &info
))
2898 if (info
.filename
!= NULL
)
2900 if (! ieee_finish_compilation_unit (&info
))
2904 /* Put any undefined tags in the global typedef information. */
2906 for (nt
= info
.tags
; nt
!= NULL
; nt
= nt
->next
)
2908 unsigned int name_indx
;
2911 if (nt
->kind
== DEBUG_KIND_ILLEGAL
)
2915 if (! ieee_change_buffer (&info
, &tags
)
2916 || ! ieee_write_byte (&info
, (int) ieee_bb_record_enum
)
2917 || ! ieee_write_byte (&info
, 2)
2918 || ! ieee_write_number (&info
, 0)
2919 || ! ieee_write_id (&info
, ""))
2922 name_indx
= info
.name_indx
;
2924 if (! ieee_write_byte (&info
, (int) ieee_nn_record
)
2925 || ! ieee_write_number (&info
, name_indx
)
2926 || ! ieee_write_id (&info
, nt
->name
)
2927 || ! ieee_write_byte (&info
, (int) ieee_ty_record_enum
)
2928 || ! ieee_write_number (&info
, nt
->type
.indx
)
2929 || ! ieee_write_byte (&info
, 0xce)
2930 || ! ieee_write_number (&info
, name_indx
))
2937 case DEBUG_KIND_STRUCT
:
2938 case DEBUG_KIND_CLASS
:
2941 case DEBUG_KIND_UNION
:
2942 case DEBUG_KIND_UNION_CLASS
:
2945 case DEBUG_KIND_ENUM
:
2949 if (! ieee_write_number (&info
, code
)
2950 || ! ieee_write_number (&info
, 0))
2955 struct ieee_buf
**pb
;
2957 if (! ieee_write_byte (&info
, (int) ieee_be_record_enum
))
2960 for (pb
= &tags
; *pb
!= NULL
; pb
= &(*pb
)->next
)
2966 /* Now all the data is in info.data. Write it out to the BFD. We
2967 normally would need to worry about whether all the other sections
2968 are set up yet, but the IEEE backend will handle this particular
2969 case correctly regardless. */
2970 if (info
.data
== NULL
)
2972 /* There is no debugging information. */
2976 s
= bfd_make_section (abfd
, ".debug");
2978 err
= "bfd_make_section";
2981 if (! bfd_set_section_flags (abfd
, s
, SEC_DEBUGGING
| SEC_HAS_CONTENTS
))
2982 err
= "bfd_set_section_flags";
2989 for (b
= info
.data
; b
!= NULL
; b
= b
->next
)
2991 if (! bfd_set_section_size (abfd
, s
, size
))
2992 err
= "bfd_set_section_size";
2999 for (b
= info
.data
; b
!= NULL
; b
= b
->next
)
3001 if (! bfd_set_section_contents (abfd
, s
, b
->buf
, offset
, b
->c
))
3003 err
= "bfd_set_section_contents";
3012 fprintf (stderr
, "%s: %s: %s\n", bfd_get_filename (abfd
), err
,
3013 bfd_errmsg (bfd_get_error ()));
3020 /* Start writing out information for a compilation unit. */
3023 ieee_start_compilation_unit (p
, filename
)
3025 const char *filename
;
3027 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3028 const char *modname
;
3031 if (info
->filename
!= NULL
)
3033 if (! ieee_finish_compilation_unit (info
))
3037 info
->filename
= filename
;
3038 modname
= strrchr (filename
, '/');
3039 if (modname
!= NULL
)
3043 modname
= strrchr (filename
, '\\');
3044 if (modname
!= NULL
)
3049 c
= xstrdup (modname
);
3050 s
= strrchr (c
, '.');
3057 info
->linenos
= NULL
;
3058 info
->ranges
= NULL
;
3063 /* Finish up a compilation unit. */
3066 ieee_finish_compilation_unit (info
)
3067 struct ieee_handle
*info
;
3069 struct ieee_buf
**pp
;
3070 struct ieee_range
*r
;
3072 if (info
->types
!= NULL
)
3074 if (! ieee_change_buffer (info
, &info
->types
)
3075 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
3079 if (info
->vars
!= NULL
)
3081 if (! ieee_change_buffer (info
, &info
->vars
)
3082 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
3086 if (info
->linenos
!= NULL
)
3088 if (! ieee_change_buffer (info
, &info
->linenos
)
3089 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
3093 for (pp
= &info
->data
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3096 for (; *pp
!= NULL
; pp
= &(*pp
)->next
)
3099 for (; *pp
!= NULL
; pp
= &(*pp
)->next
)
3101 *pp
= info
->linenos
;
3103 /* Build BB10/BB11 blocks based on the ranges we recorded. */
3104 if (! ieee_change_buffer (info
, &info
->data
))
3107 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
3108 || ! ieee_write_byte (info
, 10)
3109 || ! ieee_write_number (info
, 0)
3110 || ! ieee_write_id (info
, info
->modname
)
3111 || ! ieee_write_id (info
, "")
3112 || ! ieee_write_number (info
, 0)
3113 || ! ieee_write_id (info
, "GNU objcopy"))
3116 for (r
= info
->ranges
; r
!= NULL
; r
= r
->next
)
3125 /* Find the section corresponding to this range. */
3126 for (s
= info
->abfd
->sections
; s
!= NULL
; s
= s
->next
)
3128 if (bfd_get_section_vma (info
->abfd
, s
) <= low
3129 && high
<= (bfd_get_section_vma (info
->abfd
, s
)
3130 + bfd_section_size (info
->abfd
, s
)))
3136 /* Just ignore this range. */
3140 /* Coalesce ranges if it seems reasonable. */
3141 while (r
->next
!= NULL
3142 && high
+ 64 >= r
->next
->low
3144 <= (bfd_get_section_vma (info
->abfd
, s
)
3145 + bfd_section_size (info
->abfd
, s
))))
3148 high
= r
->next
->high
;
3151 if ((s
->flags
& SEC_CODE
) != 0)
3153 else if ((s
->flags
& SEC_READONLY
) != 0)
3158 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
3159 || ! ieee_write_byte (info
, 11)
3160 || ! ieee_write_number (info
, 0)
3161 || ! ieee_write_id (info
, "")
3162 || ! ieee_write_number (info
, kind
)
3163 || ! ieee_write_number (info
, s
->index
)
3164 || ! ieee_write_number (info
, low
)
3165 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
3166 || ! ieee_write_number (info
, high
- low
))
3170 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
3176 /* Start recording information from a particular source file. This is
3177 used to record which file defined which types, variables, etc. It
3178 is not used for line numbers, since the lineno entry point passes
3179 down the file name anyhow. IEEE debugging information doesn't seem
3180 to store this information anywhere. */
3184 ieee_start_source (p
, filename
)
3186 const char *filename
;
3191 /* Make an empty type. */
3197 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3199 return ieee_push_type (info
, 0, 0, false);
3202 /* Make a void type. */
3208 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3210 return ieee_push_type (info
, 1, 0, false);
3213 /* Make an integer type. */
3216 ieee_int_type (p
, size
, unsignedp
)
3221 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3227 indx
= (int) builtin_signed_char
;
3230 indx
= (int) builtin_signed_short_int
;
3233 indx
= (int) builtin_signed_long
;
3236 indx
= (int) builtin_signed_long_long
;
3239 fprintf (stderr
, "IEEE unsupported integer type size %u\n", size
);
3246 return ieee_push_type (info
, indx
, size
, unsignedp
);
3249 /* Make a floating point type. */
3252 ieee_float_type (p
, size
)
3256 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3262 indx
= (int) builtin_float
;
3265 indx
= (int) builtin_double
;
3268 /* FIXME: This size really depends upon the processor. */
3269 indx
= (int) builtin_long_double
;
3272 indx
= (int) builtin_long_long_double
;
3275 fprintf (stderr
, "IEEE unsupported float type size %u\n", size
);
3279 return ieee_push_type (info
, indx
, size
, false);
3282 /* Make a complex type. */
3285 ieee_complex_type (p
, size
)
3289 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3301 fprintf (stderr
, "IEEE unsupported complex type size %u\n", size
);
3305 /* FIXME: I don't know what the string is for. */
3306 return (ieee_define_type (info
, size
, false)
3307 && ieee_write_number (info
, code
)
3308 && ieee_write_id (info
, ""));
3311 /* Make a boolean type. IEEE doesn't support these, so we just make
3312 an integer type instead. */
3315 ieee_bool_type (p
, size
)
3319 return ieee_int_type (p
, size
, true);
3322 /* Make an enumeration. */
3325 ieee_enum_type (p
, tag
, names
, vals
)
3329 bfd_signed_vma
*vals
;
3331 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3335 /* If this is a simple enumeration, in which the values start at 0
3336 and always increment by 1, we can use type E. Otherwise we must
3342 for (i
= 0; names
[i
] != NULL
; i
++)
3352 if (! ieee_define_named_type (info
, tag
, true, 0, true,
3353 (struct ieee_buf
**) NULL
)
3354 || ! ieee_write_number (info
, simple
? 'E' : 'N'))
3358 /* FIXME: This is supposed to be the enumeration size, but we
3359 don't store that. */
3360 if (! ieee_write_number (info
, 4))
3365 for (i
= 0; names
[i
] != NULL
; i
++)
3367 if (! ieee_write_id (info
, names
[i
]))
3371 if (! ieee_write_number (info
, vals
[i
]))
3380 /* Make a pointer type. */
3383 ieee_pointer_type (p
)
3386 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3389 indx
= ieee_pop_type (info
);
3391 /* A pointer to a simple builtin type can be obtained by adding 32. */
3393 return ieee_push_type (info
, indx
+ 32, 0, true);
3395 return (ieee_define_type (info
, 0, true)
3396 && ieee_write_number (info
, 'P')
3397 && ieee_write_number (info
, indx
));
3400 /* Make a function type. */
3403 ieee_function_type (p
, argcount
, varargs
)
3408 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3409 unsigned int *args
= NULL
;
3411 unsigned int retindx
;
3415 args
= (unsigned int *) xmalloc (argcount
* sizeof *args
);
3416 for (i
= argcount
- 1; i
>= 0; i
--)
3417 args
[i
] = ieee_pop_type (info
);
3419 else if (argcount
< 0)
3422 retindx
= ieee_pop_type (info
);
3424 /* An attribute of 0x41 means that the frame and push mask are
3426 if (! ieee_define_type (info
, 0, true)
3427 || ! ieee_write_number (info
, 'x')
3428 || ! ieee_write_number (info
, 0x41)
3429 || ! ieee_write_number (info
, 0)
3430 || ! ieee_write_number (info
, 0)
3431 || ! ieee_write_number (info
, retindx
)
3432 || ! ieee_write_number (info
, (bfd_vma
) argcount
+ (varargs
? 1 : 0)))
3436 for (i
= 0; i
< argcount
; i
++)
3437 if (! ieee_write_number (info
, args
[i
]))
3443 /* A varargs function is represented by writing out the last
3444 argument as type void *, although this makes little sense. */
3445 if (! ieee_write_number (info
, (bfd_vma
) builtin_void
+ 32))
3449 return ieee_write_number (info
, 0);
3452 /* Make a reference type. */
3455 ieee_reference_type (p
)
3458 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3460 /* IEEE appears to record a normal pointer type, and then use a
3461 pmisc record to indicate that it is really a reference. */
3463 if (! ieee_pointer_type (p
))
3465 info
->type_stack
->type
.referencep
= true;
3469 /* Make a range type. */
3472 ieee_range_type (p
, low
, high
)
3475 bfd_signed_vma high
;
3477 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3481 size
= info
->type_stack
->type
.size
;
3482 unsignedp
= info
->type_stack
->type
.unsignedp
;
3483 (void) ieee_pop_type (info
);
3484 return (ieee_define_type (info
, size
, unsignedp
)
3485 && ieee_write_number (info
, 'R')
3486 && ieee_write_number (info
, (bfd_vma
) low
)
3487 && ieee_write_number (info
, (bfd_vma
) high
)
3488 && ieee_write_number (info
, unsignedp
? 0 : 1)
3489 && ieee_write_number (info
, size
));
3492 /* Make an array type. */
3496 ieee_array_type (p
, low
, high
, stringp
)
3499 bfd_signed_vma high
;
3502 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3503 unsigned int eleindx
;
3505 /* IEEE does not store the range, so we just ignore it. */
3506 (void) ieee_pop_type (info
);
3507 eleindx
= ieee_pop_type (info
);
3509 if (! ieee_define_type (info
, 0, false)
3510 || ! ieee_write_number (info
, low
== 0 ? 'Z' : 'C')
3511 || ! ieee_write_number (info
, eleindx
))
3515 if (! ieee_write_number (info
, low
))
3519 return ieee_write_number (info
, high
);
3522 /* Make a set type. */
3525 ieee_set_type (p
, bitstringp
)
3529 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3530 unsigned int eleindx
;
3532 eleindx
= ieee_pop_type (info
);
3534 /* FIXME: We don't know the size, so we just use 4. */
3536 return (ieee_define_type (info
, 0, true)
3537 && ieee_write_number (info
, 's')
3538 && ieee_write_number (info
, 4)
3539 && ieee_write_number (info
, eleindx
));
3542 /* Make an offset type. */
3545 ieee_offset_type (p
)
3548 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3549 unsigned int targetindx
, baseindx
;
3551 targetindx
= ieee_pop_type (info
);
3552 baseindx
= ieee_pop_type (info
);
3554 /* FIXME: The MRI C++ compiler does not appear to generate any
3555 useful type information about an offset type. It just records a
3556 pointer to member as an integer. The MRI/HP IEEE spec does
3557 describe a pmisc record which can be used for a pointer to
3558 member. Unfortunately, it does not describe the target type,
3559 which seems pretty important. I'm going to punt this for now. */
3561 return ieee_int_type (p
, 4, true);
3564 /* Make a method type. */
3567 ieee_method_type (p
, domain
, argcount
, varargs
)
3573 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3575 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
3576 method, but the definition is incomplete. We just output an 'x'
3580 (void) ieee_pop_type (info
);
3582 return ieee_function_type (p
, argcount
, varargs
);
3585 /* Make a const qualified type. */
3591 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3596 size
= info
->type_stack
->type
.size
;
3597 unsignedp
= info
->type_stack
->type
.unsignedp
;
3598 indx
= ieee_pop_type (info
);
3599 return (ieee_define_type (info
, size
, unsignedp
)
3600 && ieee_write_number (info
, 'n')
3601 && ieee_write_number (info
, 1)
3602 && ieee_write_number (info
, indx
));
3605 /* Make a volatile qualified type. */
3608 ieee_volatile_type (p
)
3611 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3616 size
= info
->type_stack
->type
.size
;
3617 unsignedp
= info
->type_stack
->type
.unsignedp
;
3618 indx
= ieee_pop_type (info
);
3619 return (ieee_define_type (info
, size
, unsignedp
)
3620 && ieee_write_number (info
, 'n')
3621 && ieee_write_number (info
, 2)
3622 && ieee_write_number (info
, indx
));
3625 /* Start defining a struct type. We build it in the strdef field on
3626 the stack, to avoid confusing type definitions required by the
3627 fields with the struct type itself. */
3630 ieee_start_struct_type (p
, tag
, id
, structp
, size
)
3637 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3638 struct ieee_buf
*strdef
;
3641 if (! ieee_define_named_type (info
, tag
, true, size
, true, &strdef
)
3642 || ! ieee_write_number (info
, structp
? 'S' : 'U')
3643 || ! ieee_write_number (info
, size
))
3646 info
->type_stack
->type
.strdef
= strdef
;
3651 /* Add a field to a struct. */
3654 ieee_struct_field (p
, name
, bitpos
, bitsize
, visibility
)
3659 enum debug_visibility visibility
;
3661 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3667 size
= info
->type_stack
->type
.size
;
3668 unsignedp
= info
->type_stack
->type
.unsignedp
;
3669 indx
= ieee_pop_type (info
);
3671 assert (info
->type_stack
!= NULL
&& info
->type_stack
->type
.strdef
!= NULL
);
3673 /* If the bitsize doesn't match the expected size, we need to output
3675 if (size
== 0 || bitsize
== size
* 8)
3676 offset
= bitpos
/ 8;
3679 if (! ieee_define_type (info
, 0, unsignedp
)
3680 || ! ieee_write_number (info
, 'g')
3681 || ! ieee_write_number (info
, unsignedp
? 0 : 1)
3682 || ! ieee_write_number (info
, indx
))
3684 indx
= ieee_pop_type (info
);
3688 /* Switch to the struct we are building in order to output this
3689 field definition. */
3690 return (ieee_change_buffer (info
, &info
->type_stack
->type
.strdef
)
3691 && ieee_write_id (info
, name
)
3692 && ieee_write_number (info
, indx
)
3693 && ieee_write_number (info
, offset
));
3696 /* Finish up a struct type. */
3699 ieee_end_struct_type (p
)
3702 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3703 struct ieee_buf
**pb
;
3705 assert (info
->type_stack
!= NULL
&& info
->type_stack
->type
.strdef
!= NULL
);
3707 /* Make sure we have started the types block. */
3708 if (info
->types
== NULL
)
3710 if (! ieee_change_buffer (info
, &info
->types
)
3711 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
3712 || ! ieee_write_byte (info
, 1)
3713 || ! ieee_write_number (info
, 0)
3714 || ! ieee_write_id (info
, info
->modname
))
3718 /* Append the struct definition to the types. */
3719 for (pb
= &info
->types
; *pb
!= NULL
; pb
= &(*pb
)->next
)
3721 *pb
= info
->type_stack
->type
.strdef
;
3722 info
->type_stack
->type
.strdef
= NULL
;
3724 /* Leave the struct on the type stack. */
3729 /* Start a class type. */
3732 ieee_start_class_type (p
, tag
, id
, structp
, size
, vptr
, ownvptr
)
3741 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3744 if (vptr
&& ! ownvptr
)
3745 (void) ieee_pop_type (info
);
3746 return ieee_start_struct_type (p
, tag
, id
, structp
, size
);
3749 /* Add a static member to a class. */
3752 ieee_class_static_member (p
, name
, physname
, visibility
)
3755 const char *physname
;
3756 enum debug_visibility visibility
;
3758 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3761 (void) ieee_pop_type (info
);
3765 /* Add a base class to a class. */
3768 ieee_class_baseclass (p
, bitpos
, virtual, visibility
)
3772 enum debug_visibility visibility
;
3774 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3777 (void) ieee_pop_type (info
);
3781 /* Start building a method for a class. */
3784 ieee_class_start_method (p
, name
)
3792 /* Define a new method variant. */
3795 ieee_class_method_variant (p
, physname
, visibility
, constp
, volatilep
,
3798 const char *physname
;
3799 enum debug_visibility visibility
;
3805 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3808 (void) ieee_pop_type (info
);
3810 (void) ieee_pop_type (info
);
3814 /* Define a new static method variant. */
3817 ieee_class_static_method_variant (p
, physname
, visibility
, constp
, volatilep
)
3819 const char *physname
;
3820 enum debug_visibility visibility
;
3824 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3827 (void) ieee_pop_type (info
);
3831 /* Finish up a method. */
3834 ieee_class_end_method (p
)
3841 /* Finish up a class. */
3844 ieee_end_class_type (p
)
3847 return ieee_end_struct_type (p
);
3850 /* Push a previously seen typedef onto the type stack. */
3853 ieee_typedef_type (p
, name
)
3857 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3858 register struct ieee_name_type
*nt
;
3860 for (nt
= info
->typedefs
; nt
!= NULL
; nt
= nt
->next
)
3862 if (nt
->name
[0] == name
[0]
3863 && strcmp (nt
->name
, name
) == 0)
3865 if (! ieee_push_type (info
, nt
->type
.indx
, nt
->type
.size
,
3866 nt
->type
.unsignedp
))
3868 /* Copy over any other type information we may have. */
3869 info
->type_stack
->type
= nt
->type
;
3877 /* Push a tagged type onto the type stack. */
3880 ieee_tag_type (p
, name
, id
, kind
)
3884 enum debug_type_kind kind
;
3886 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3887 register struct ieee_name_type
*nt
;
3892 for (nt
= info
->tags
; nt
!= NULL
; nt
= nt
->next
)
3894 if (nt
->name
[0] == name
[0]
3895 && strcmp (nt
->name
, name
) == 0)
3897 if (! ieee_push_type (info
, nt
->type
.indx
, nt
->type
.size
,
3898 nt
->type
.unsignedp
))
3900 /* Copy over any other type information we may have. */
3901 info
->type_stack
->type
= nt
->type
;
3906 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
3907 memset (nt
, 0, sizeof *nt
);
3910 nt
->type
.indx
= info
->type_indx
;
3914 nt
->next
= info
->tags
;
3917 return ieee_push_type (info
, nt
->type
.indx
, 0, false);
3920 /* Output a typedef. */
3923 ieee_typdef (p
, name
)
3927 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3928 struct ieee_name_type
*nt
;
3933 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
3934 memset (nt
, 0, sizeof *nt
);
3936 nt
->type
= info
->type_stack
->type
;
3937 nt
->kind
= DEBUG_KIND_ILLEGAL
;
3939 nt
->next
= info
->typedefs
;
3940 info
->typedefs
= nt
;
3942 size
= info
->type_stack
->type
.size
;
3943 unsignedp
= info
->type_stack
->type
.unsignedp
;
3944 indx
= ieee_pop_type (info
);
3946 /* If this is a simple builtin type using a builtin name, we don't
3947 want to output the typedef itself. We also want to change the
3948 type index to correspond to the name being used. We recognize
3949 names used in stabs debugging output even if they don't exactly
3950 correspond to the names used for the IEEE builtin types. */
3951 if (indx
<= (unsigned int) builtin_bcd_float
)
3956 switch ((enum builtin_types
) indx
)
3962 if (strcmp (name
, "void") == 0)
3966 case builtin_signed_char
:
3968 if (strcmp (name
, "signed char") == 0)
3970 indx
= (unsigned int) builtin_signed_char
;
3973 else if (strcmp (name
, "char") == 0)
3975 indx
= (unsigned int) builtin_char
;
3980 case builtin_unsigned_char
:
3981 if (strcmp (name
, "unsigned char") == 0)
3985 case builtin_signed_short_int
:
3987 case builtin_short_int
:
3988 case builtin_signed_short
:
3989 if (strcmp (name
, "signed short int") == 0)
3991 indx
= (unsigned int) builtin_signed_short_int
;
3994 else if (strcmp (name
, "short") == 0)
3996 indx
= (unsigned int) builtin_short
;
3999 else if (strcmp (name
, "short int") == 0)
4001 indx
= (unsigned int) builtin_short_int
;
4004 else if (strcmp (name
, "signed short") == 0)
4006 indx
= (unsigned int) builtin_signed_short
;
4011 case builtin_unsigned_short_int
:
4012 case builtin_unsigned_short
:
4013 if (strcmp (name
, "unsigned short int") == 0
4014 || strcmp (name
, "short unsigned int") == 0)
4016 indx
= builtin_unsigned_short_int
;
4019 else if (strcmp (name
, "unsigned short") == 0)
4021 indx
= builtin_unsigned_short
;
4026 case builtin_signed_long
:
4027 case builtin_int
: /* FIXME: Size depends upon architecture. */
4029 if (strcmp (name
, "signed long") == 0)
4031 indx
= builtin_signed_long
;
4034 else if (strcmp (name
, "int") == 0)
4039 else if (strcmp (name
, "long") == 0
4040 || strcmp (name
, "long int") == 0)
4042 indx
= builtin_long
;
4047 case builtin_unsigned_long
:
4048 case builtin_unsigned
: /* FIXME: Size depends upon architecture. */
4049 case builtin_unsigned_int
: /* FIXME: Like builtin_unsigned. */
4050 if (strcmp (name
, "unsigned long") == 0
4051 || strcmp (name
, "long unsigned int") == 0)
4053 indx
= builtin_unsigned_long
;
4056 else if (strcmp (name
, "unsigned") == 0)
4058 indx
= builtin_unsigned
;
4061 else if (strcmp (name
, "unsigned int") == 0)
4063 indx
= builtin_unsigned_int
;
4068 case builtin_signed_long_long
:
4069 if (strcmp (name
, "signed long long") == 0
4070 || strcmp (name
, "long long int") == 0)
4074 case builtin_unsigned_long_long
:
4075 if (strcmp (name
, "unsigned long long") == 0
4076 || strcmp (name
, "long long unsigned int") == 0)
4081 if (strcmp (name
, "float") == 0)
4085 case builtin_double
:
4086 if (strcmp (name
, "double") == 0)
4090 case builtin_long_double
:
4091 if (strcmp (name
, "long double") == 0)
4095 case builtin_long_long_double
:
4096 if (strcmp (name
, "long long double") == 0)
4103 nt
->type
.indx
= indx
;
4108 if (! ieee_define_named_type (info
, name
, false, size
, unsignedp
,
4109 (struct ieee_buf
**) NULL
)
4110 || ! ieee_write_number (info
, 'T')
4111 || ! ieee_write_number (info
, indx
))
4114 /* Remove the type we just added to the type stack. */
4115 (void) ieee_pop_type (info
);
4120 /* Output a tag for a type. We don't have to do anything here. */
4127 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4129 (void) ieee_pop_type (info
);
4133 /* Output an integer constant. */
4136 ieee_int_constant (p
, name
, val
)
4145 /* Output a floating point constant. */
4148 ieee_float_constant (p
, name
, val
)
4157 /* Output a typed constant. */
4160 ieee_typed_constant (p
, name
, val
)
4165 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4168 (void) ieee_pop_type (info
);
4172 /* Output a variable. */
4175 ieee_variable (p
, name
, kind
, val
)
4178 enum debug_var_kind kind
;
4181 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4182 unsigned int name_indx
;
4184 unsigned int type_indx
;
4187 /* Make sure the variable section is started. */
4188 if (info
->vars
!= NULL
)
4190 if (! ieee_change_buffer (info
, &info
->vars
))
4195 if (! ieee_change_buffer (info
, &info
->vars
)
4196 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4197 || ! ieee_write_byte (info
, 3)
4198 || ! ieee_write_number (info
, 0)
4199 || ! ieee_write_id (info
, info
->modname
))
4203 name_indx
= info
->name_indx
;
4206 size
= info
->type_stack
->type
.size
;
4207 type_indx
= ieee_pop_type (info
);
4209 /* Write out an NN and an ATN record for this variable. */
4210 if (! ieee_write_byte (info
, (int) ieee_nn_record
)
4211 || ! ieee_write_number (info
, name_indx
)
4212 || ! ieee_write_id (info
, name
)
4213 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
4214 || ! ieee_write_number (info
, name_indx
)
4215 || ! ieee_write_number (info
, type_indx
))
4223 if (! ieee_write_number (info
, 8)
4224 || ! ieee_add_range (info
, val
, val
+ size
))
4229 case DEBUG_LOCAL_STATIC
:
4230 if (! ieee_write_number (info
, 3)
4231 || ! ieee_add_range (info
, val
, val
+ size
))
4236 if (! ieee_write_number (info
, 1)
4237 || ! ieee_write_number (info
, val
))
4241 case DEBUG_REGISTER
:
4242 if (! ieee_write_number (info
, 2)
4243 || ! ieee_write_number (info
,
4244 ieee_genreg_to_regno (info
->abfd
, val
)))
4252 if (! ieee_write_2bytes (info
, (int) ieee_asn_record_enum
)
4253 || ! ieee_write_number (info
, name_indx
)
4254 || ! ieee_write_number (info
, val
))
4261 /* Start outputting information for a function. */
4264 ieee_start_function (p
, name
, global
)
4269 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4272 /* Make sure the variable section is started. */
4273 if (info
->vars
!= NULL
)
4275 if (! ieee_change_buffer (info
, &info
->vars
))
4280 if (! ieee_change_buffer (info
, &info
->vars
)
4281 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4282 || ! ieee_write_byte (info
, 3)
4283 || ! ieee_write_number (info
, 0)
4284 || ! ieee_write_id (info
, info
->modname
))
4288 indx
= ieee_pop_type (info
);
4290 /* The address is written out as the first block. */
4292 ++info
->block_depth
;
4294 return (ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4295 && ieee_write_byte (info
, global
? 4 : 6)
4296 && ieee_write_number (info
, 0)
4297 && ieee_write_id (info
, name
)
4298 && ieee_write_number (info
, 0)
4299 && ieee_write_number (info
, indx
));
4302 /* Add a function parameter. This will normally be called before the
4303 first block, so we postpone them until we see the block. */
4306 ieee_function_parameter (p
, name
, kind
, val
)
4309 enum debug_parm_kind kind
;
4312 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4313 struct ieee_pending_parm
*m
, **pm
;
4315 assert (info
->block_depth
== 1);
4317 m
= (struct ieee_pending_parm
*) xmalloc (sizeof *m
);
4318 memset (m
, 0, sizeof *m
);
4322 m
->type
= ieee_pop_type (info
);
4326 for (pm
= &info
->pending_parms
; *pm
!= NULL
; pm
= &(*pm
)->next
)
4333 /* Output pending function parameters. */
4336 ieee_output_pending_parms (info
)
4337 struct ieee_handle
*info
;
4339 struct ieee_pending_parm
*m
;
4341 m
= info
->pending_parms
;
4344 struct ieee_pending_parm
*next
;
4345 enum debug_var_kind vkind
;
4352 case DEBUG_PARM_STACK
:
4353 case DEBUG_PARM_REFERENCE
:
4354 vkind
= DEBUG_LOCAL
;
4356 case DEBUG_PARM_REG
:
4357 case DEBUG_PARM_REF_REG
:
4358 vkind
= DEBUG_REGISTER
;
4362 if (! ieee_push_type (info
, m
->type
, 0, false)
4363 || ! ieee_variable ((PTR
) info
, m
->name
, vkind
, m
->val
))
4366 /* FIXME: We should output a pmisc note here for reference
4373 info
->pending_parms
= NULL
;
4378 /* Start a block. If this is the first block, we output the address
4379 to finish the BB4 or BB6, and then output the function parameters. */
4382 ieee_start_block (p
, addr
)
4386 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4388 if (! ieee_change_buffer (info
, &info
->vars
))
4391 if (info
->block_depth
== 1)
4393 if (! ieee_write_number (info
, addr
)
4394 || ! ieee_output_pending_parms (info
))
4399 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4400 || ! ieee_write_byte (info
, 6)
4401 || ! ieee_write_byte (info
, 0)
4402 || ! ieee_write_id (info
, "")
4403 || ! ieee_write_number (info
, 0)
4404 || ! ieee_write_number (info
, 0)
4405 || ! ieee_write_number (info
, addr
))
4409 if (! ieee_start_range (info
, addr
))
4412 ++info
->block_depth
;
4420 ieee_end_block (p
, addr
)
4424 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4426 if (! ieee_change_buffer (info
, &info
->vars
)
4427 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
4428 || ! ieee_write_number (info
, addr
))
4431 if (! ieee_end_range (info
, addr
))
4434 --info
->block_depth
;
4439 /* End a function. */
4442 ieee_end_function (p
)
4445 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4447 assert (info
->block_depth
== 1);
4449 --info
->block_depth
;
4454 /* Record line number information. */
4457 ieee_lineno (p
, filename
, lineno
, addr
)
4459 const char *filename
;
4460 unsigned long lineno
;
4463 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4465 assert (info
->filename
!= NULL
);
4467 /* Make sure we have a line number block. */
4468 if (info
->linenos
!= NULL
)
4470 if (! ieee_change_buffer (info
, &info
->linenos
))
4475 info
->lineno_name_indx
= info
->name_indx
;
4477 if (! ieee_change_buffer (info
, &info
->linenos
)
4478 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4479 || ! ieee_write_byte (info
, 5)
4480 || ! ieee_write_number (info
, 0)
4481 || ! ieee_write_id (info
, info
->filename
)
4482 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
4483 || ! ieee_write_number (info
, info
->lineno_name_indx
)
4484 || ! ieee_write_id (info
, ""))
4486 info
->lineno_filename
= info
->filename
;
4489 if (strcmp (filename
, info
->lineno_filename
) != 0)
4491 if (strcmp (info
->filename
, info
->lineno_filename
) != 0)
4493 /* We were not in the main file. Close the block for the
4495 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4498 if (strcmp (info
->filename
, filename
) != 0)
4500 /* We are not changing to the main file. Open a block for
4501 the new included file. */
4502 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4503 || ! ieee_write_byte (info
, 5)
4504 || ! ieee_write_number (info
, 0)
4505 || ! ieee_write_id (info
, filename
))
4508 info
->lineno_filename
= filename
;
4511 return (ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
4512 && ieee_write_number (info
, info
->lineno_name_indx
)
4513 && ieee_write_number (info
, 0)
4514 && ieee_write_number (info
, 7)
4515 && ieee_write_number (info
, lineno
)
4516 && ieee_write_number (info
, 0)
4517 && ieee_write_2bytes (info
, (int) ieee_asn_record_enum
)
4518 && ieee_write_number (info
, info
->lineno_name_indx
)
4519 && ieee_write_number (info
, addr
));