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
);
1668 return_type
= rtype
;
1673 /* Array with 0 lower bound. */
1678 if (! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1680 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &high
))
1683 type
= debug_make_array_type (dhandle
, etype
,
1684 ieee_builtin_type (dhandle
, abfd
, types
,
1685 bytes
, ty_code_start
,
1688 0, (bfd_signed_vma
) high
, false);
1692 case 'c': /* Complex. */
1693 case 'd': /* Double complex. */
1696 unsigned long namlen
;
1698 /* FIXME: I don't know what the name means. */
1700 if (! ieee_read_id (abfd
, bytes
, pp
, pend
, &name
, &namlen
))
1703 type
= debug_make_complex_type (dhandle
, tc
== 'c' ? 4 : 8);
1708 /* Pascal file name. FIXME. */
1709 ieee_error (abfd
, bytes
, ty_code_start
,
1710 "Pascal file name not supported");
1714 /* Bitfield type. */
1716 bfd_vma signedp
, bitsize
;
1718 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &signedp
)
1719 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &bitsize
)
1720 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1724 /* FIXME: This is just a guess. */
1726 type
= debug_make_int_type (dhandle
, 4, true);
1727 type_bitsize
= bitsize
;
1737 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &kind
)
1738 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1745 ieee_error (abfd
, bytes
, ty_start
, "unsupported qualifer");
1749 type
= debug_make_const_type (dhandle
, t
);
1753 type
= debug_make_volatile_type (dhandle
, t
);
1765 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &size
)
1766 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1770 /* FIXME: We ignore the size. */
1772 type
= debug_make_set_type (dhandle
, etype
, false);
1777 /* Procedure with compiler dependencies. FIXME: This is an
1778 extern declaration, which we have no way of representing. */
1780 bfd_vma attr
, frame_type
, push_mask
, nargs
, level
, father
;
1784 /* FIXME: We ignore almost all this information. */
1786 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &attr
)
1787 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &frame_type
)
1788 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &push_mask
)
1789 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
,
1791 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &nargs
))
1793 if (nargs
!= (bfd_vma
) -1)
1795 for (; nargs
> 0; nargs
--)
1799 if (! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
,
1804 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &level
)
1805 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &father
,
1809 type
= debug_make_function_type (dhandle
, rtype
);
1810 return_type
= rtype
;
1815 /* Record the type in the table. If the corresponding NN record has
1816 a name, name it. FIXME: Is this always correct? */
1822 && vars
->vars
[varindx
].namlen
> 0)
1826 name
= savestring (vars
->vars
[varindx
].name
,
1827 vars
->vars
[varindx
].namlen
);
1829 type
= debug_tag_type (dhandle
, name
, type
);
1831 type
= debug_name_type (dhandle
, name
, type
);
1836 types
->types
[typeindx
].type
= type
;
1837 types
->types
[typeindx
].bitsize
= type_bitsize
;
1838 types
->types
[typeindx
].return_type
= return_type
;
1840 /* We may have already allocated type as an indirect type pointing
1841 to slot. It does no harm to replace the indirect type with the
1842 real type. Filling in slot as well handles the indirect types
1843 which are already hanging around. */
1844 if (types
->types
[typeindx
].pslot
!= NULL
)
1845 *types
->types
[typeindx
].pslot
= type
;
1850 /* Parse an ATN record. */
1853 parse_ieee_atn (dhandle
, abfd
, types
, vars
, blocktype
, bytes
, pp
, pend
)
1856 struct ieee_types
*types
;
1857 struct ieee_vars
*vars
;
1859 const bfd_byte
*bytes
;
1860 const bfd_byte
**pp
;
1861 const bfd_byte
*pend
;
1863 const bfd_byte
*atn_start
, *atn_code_start
;
1868 bfd_vma v
, v2
, v3
, v4
, v5
;
1870 unsigned long namlen
;
1876 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &varindx
)
1877 || ! ieee_read_type_index (dhandle
, abfd
, types
, bytes
, pp
, pend
, &type
))
1880 atn_code_start
= *pp
;
1882 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &atn_code
))
1891 else if (varindx
< 32)
1893 ieee_error (abfd
, bytes
, atn_start
, "illegal variable index");
1900 if (varindx
>= vars
->alloc
|| vars
->vars
[varindx
].name
== NULL
)
1902 ieee_error (abfd
, bytes
, atn_start
, "undefined variable in ATN");
1906 vars
->vars
[varindx
].type
= type
;
1908 name
= vars
->vars
[varindx
].name
;
1909 namlen
= vars
->vars
[varindx
].namlen
;
1915 ieee_error (abfd
, bytes
, atn_code_start
, "unknown ATN type");
1919 /* Automatic variable. */
1920 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
))
1922 namcopy
= savestring (name
, namlen
);
1924 type
= debug_make_void_type (dhandle
);
1925 return debug_record_variable (dhandle
, namcopy
, type
, DEBUG_LOCAL
, v
);
1928 /* Register variable. */
1929 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
))
1931 namcopy
= savestring (name
, namlen
);
1933 type
= debug_make_void_type (dhandle
);
1934 return debug_record_variable (dhandle
, namcopy
, type
, DEBUG_REGISTER
,
1935 ieee_regno_to_genreg (abfd
, v
));
1938 /* Static variable. */
1939 if (! ieee_require_asn (abfd
, bytes
, pp
, pend
, &v
))
1941 namcopy
= savestring (name
, namlen
);
1943 type
= debug_make_void_type (dhandle
);
1944 return debug_record_variable (dhandle
, namcopy
, type
,
1945 (blocktype
== 4 || blocktype
== 6
1946 ? DEBUG_LOCAL_STATIC
1951 /* External function. We don't currently record these. FIXME. */
1955 /* External variable. We don't currently record these. FIXME. */
1959 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
1960 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &v2
)
1961 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v3
,
1966 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v4
,
1971 /* We just ignore the two optional fields in v3 and v4, since
1972 they are not defined. */
1974 if (! ieee_require_asn (abfd
, bytes
, pp
, pend
, &v3
))
1977 /* We have no way to record the column number. FIXME. */
1979 return debug_record_line (dhandle
, v
, v3
);
1982 /* Global variable. */
1983 if (! ieee_require_asn (abfd
, bytes
, pp
, pend
, &v
))
1985 namcopy
= savestring (name
, namlen
);
1987 type
= debug_make_void_type (dhandle
);
1988 return debug_record_variable (dhandle
, namcopy
, type
, DEBUG_GLOBAL
, v
);
1991 /* Variable lifetime information. */
1992 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
))
1995 /* We have no way to record this information. FIXME. */
1999 /* Locked register. */
2000 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
2001 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &v2
))
2004 /* I think this means a variable that is both in a register and
2005 a frame slot. We ignore the frame slot. FIXME. */
2007 namcopy
= savestring (name
, namlen
);
2009 type
= debug_make_void_type (dhandle
);
2010 return debug_record_variable (dhandle
, namcopy
, type
, DEBUG_REGISTER
, v
);
2013 /* Reserved for FORTRAN common. */
2014 ieee_error (abfd
, bytes
, atn_code_start
, "unsupported ATN11");
2016 /* Return true to keep going. */
2020 /* Based variable. */
2024 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
2025 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &v2
)
2026 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v3
,
2031 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v4
,
2036 if (! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v5
,
2042 /* We have no way to record this information. FIXME. */
2044 ieee_error (abfd
, bytes
, atn_code_start
, "unsupported ATN12");
2046 /* Return true to keep going. */
2050 /* Constant. The description of this that I have is ambiguous,
2051 so I'm not going to try to implement it. */
2052 ieee_error (abfd
, bytes
, atn_code_start
, "unsupported ATN16");
2056 /* Static variable from assembler. */
2058 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
2059 || ! ieee_read_optional_number (abfd
, bytes
, pp
, pend
, &v2
,
2061 || ! ieee_require_asn (abfd
, bytes
, pp
, pend
, &v3
))
2063 namcopy
= savestring (name
, namlen
);
2064 /* We don't really handle this correctly. FIXME. */
2065 return debug_record_variable (dhandle
, namcopy
,
2066 debug_make_void_type (dhandle
),
2067 v2
!= 0 ? DEBUG_GLOBAL
: DEBUG_STATIC
,
2071 /* Procedure miscellaneous information. */
2073 /* Variable miscellaneous information. */
2075 /* Module miscellaneous information. */
2076 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &v
)
2077 || ! ieee_read_number (abfd
, bytes
, pp
, pend
, &v2
)
2078 || ! ieee_read_optional_id (abfd
, bytes
, pp
, pend
, &name
, &namlen
,
2082 /* We just ignore all of this stuff. FIXME. */
2084 for (; v2
> 0; --v2
)
2086 ieee_record_enum_type c
;
2089 unsigned long strlen
;
2091 c
= (ieee_record_enum_type
) **pp
;
2093 if (c
!= ieee_at_record_enum
2094 && c
!= ieee_e2_first_byte_enum
)
2096 ieee_error (abfd
, bytes
, *pp
- 1, "bad misc record");
2100 c
= (ieee_record_enum_type
) (((unsigned int) c
<< 8) | **pp
);
2105 ieee_error (abfd
, bytes
, *pp
- 2, "bad misc record");
2108 case ieee_atn_record_enum
:
2109 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &vindx
))
2111 if ((*pp
)[0] != 0 || (*pp
)[1] != 65)
2113 ieee_error (abfd
, bytes
, *pp
, "bad atn in misc");
2117 if (! ieee_read_id (abfd
, bytes
, pp
, pend
, &str
, &strlen
))
2121 case ieee_asn_record_enum
:
2122 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &vindx
)
2123 || ! ieee_read_expression (abfd
, bytes
, pp
, pend
, &v3
))
2135 /* Require an ASN record. */
2138 ieee_require_asn (abfd
, bytes
, pp
, pend
, pv
)
2140 const bfd_byte
*bytes
;
2141 const bfd_byte
**pp
;
2142 const bfd_byte
*pend
;
2145 const bfd_byte
*start
;
2146 ieee_record_enum_type c
;
2151 c
= (ieee_record_enum_type
) **pp
;
2152 if (c
!= ieee_e2_first_byte_enum
)
2154 ieee_error (abfd
, bytes
, start
, "missing required ASN");
2159 c
= (ieee_record_enum_type
) (((unsigned int) c
<< 8) | **pp
);
2160 if (c
!= ieee_asn_record_enum
)
2162 ieee_error (abfd
, bytes
, start
, "missing required ASN");
2167 /* Just ignore the variable index. */
2168 if (! ieee_read_number (abfd
, bytes
, pp
, pend
, &varindx
))
2171 return ieee_read_expression (abfd
, bytes
, pp
, pend
, pv
);
2174 /* Convert a register number in IEEE debugging information into a
2175 generic register number. */
2178 ieee_regno_to_genreg (abfd
, r
)
2185 /* Convert a generic register number to an IEEE specific one. */
2188 ieee_genreg_to_regno (abfd
, r
)
2195 /* These routines build IEEE debugging information out of the generic
2196 debugging information. */
2198 /* We build the IEEE debugging information byte by byte. Rather than
2199 waste time copying data around, we use a linked list of buffers to
2202 #define IEEE_BUFSIZE (490)
2207 struct ieee_buf
*next
;
2208 /* Number of data bytes in this buffer. */
2211 bfd_byte buf
[IEEE_BUFSIZE
];
2214 /* In order to generate the BB11 blocks required by the HP emulator,
2215 we keep track of ranges of addresses which correspond to a given
2216 compilation unit. */
2221 struct ieee_range
*next
;
2228 /* This is how we store types for the writing routines. Most types
2229 are simply represented by a type index. */
2231 struct ieee_write_type
2235 /* The size of the type, if known. */
2237 /* If this is a struct, this is where the struct definition is
2239 struct ieee_buf
*strdef
;
2240 /* Whether the type is unsigned. */
2241 unsigned int unsignedp
: 1;
2242 /* Whether this is a reference type. */
2243 unsigned int referencep
: 1;
2246 /* This is the type stack used by the debug writing routines. FIXME:
2247 We could generate more efficient output if we remembered when we
2248 have output a particular type before. */
2250 struct ieee_type_stack
2252 /* Next entry on stack. */
2253 struct ieee_type_stack
*next
;
2254 /* Type information. */
2255 struct ieee_write_type type
;
2258 /* This is a list of associations between names and types. This could
2259 be more efficiently implemented as a hash table. */
2261 struct ieee_name_type
2263 /* Next name/type assocation. */
2264 struct ieee_name_type
*next
;
2268 struct ieee_write_type type
;
2269 /* If this is a tag which has not yet been defined, this is the
2270 kind. If the tag has been defined, this is DEBUG_KIND_VOID. */
2271 enum debug_type_kind kind
;
2274 /* This is a list of pending function parameter information. We don't
2275 output them until we see the first block. */
2277 struct ieee_pending_parm
2279 /* Next pending parameter. */
2280 struct ieee_pending_parm
*next
;
2286 enum debug_parm_kind kind
;
2291 /* This is the handle passed down by debug_write. */
2295 /* BFD we are writing to. */
2297 /* Current data buffer. */
2298 struct ieee_buf
*current
;
2299 /* Filename of current compilation unit. */
2300 const char *filename
;
2301 /* Module name of current compilation unit. */
2302 const char *modname
;
2303 /* List of finished data buffers. */
2304 struct ieee_buf
*data
;
2305 /* List of buffers for typedefs in the current compilation unit. */
2306 struct ieee_buf
*types
;
2307 /* List of buffers for variables and functions in the current
2308 compilation unit. */
2309 struct ieee_buf
*vars
;
2310 /* List of buffers for line numbers in the current compilation unit. */
2311 struct ieee_buf
*linenos
;
2312 /* Ranges for the current compilation unit. */
2313 struct ieee_range
*ranges
;
2314 /* Nested pending ranges. */
2315 struct ieee_range
*pending_ranges
;
2317 struct ieee_type_stack
*type_stack
;
2318 /* Next unallocated type index. */
2319 unsigned int type_indx
;
2320 /* Next unallocated name index. */
2321 unsigned int name_indx
;
2323 struct ieee_name_type
*typedefs
;
2325 struct ieee_name_type
*tags
;
2326 /* The depth of block nesting. This is 0 outside a function, and 1
2327 just after start_function is called. */
2328 unsigned int block_depth
;
2329 /* Pending function parameters. */
2330 struct ieee_pending_parm
*pending_parms
;
2331 /* Current line number filename. */
2332 const char *lineno_filename
;
2333 /* Line number name index. */
2334 unsigned int lineno_name_indx
;
2337 static boolean ieee_change_buffer
2338 PARAMS ((struct ieee_handle
*, struct ieee_buf
**));
2339 static boolean ieee_push_type
2340 PARAMS ((struct ieee_handle
*, unsigned int, unsigned int, boolean
));
2341 static unsigned int ieee_pop_type
PARAMS ((struct ieee_handle
*));
2342 static boolean ieee_add_range
2343 PARAMS ((struct ieee_handle
*, bfd_vma
, bfd_vma
));
2344 static boolean ieee_start_range
PARAMS ((struct ieee_handle
*, bfd_vma
));
2345 static boolean ieee_end_range
PARAMS ((struct ieee_handle
*, bfd_vma
));
2346 static boolean ieee_real_write_byte
PARAMS ((struct ieee_handle
*, int));
2347 static boolean ieee_write_2bytes
PARAMS ((struct ieee_handle
*, int));
2348 static boolean ieee_write_number
PARAMS ((struct ieee_handle
*, bfd_vma
));
2349 static boolean ieee_write_id
PARAMS ((struct ieee_handle
*, const char *));
2350 static boolean ieee_define_type
2351 PARAMS ((struct ieee_handle
*, unsigned int, boolean
));
2352 static boolean ieee_define_named_type
2353 PARAMS ((struct ieee_handle
*, const char *, boolean
, unsigned int, boolean
,
2354 struct ieee_buf
**));
2355 static boolean ieee_finish_compilation_unit
PARAMS ((struct ieee_handle
*));
2356 static boolean ieee_output_pending_parms
PARAMS ((struct ieee_handle
*));
2358 static boolean ieee_start_compilation_unit
PARAMS ((PTR
, const char *));
2359 static boolean ieee_start_source
PARAMS ((PTR
, const char *));
2360 static boolean ieee_empty_type
PARAMS ((PTR
));
2361 static boolean ieee_void_type
PARAMS ((PTR
));
2362 static boolean ieee_int_type
PARAMS ((PTR
, unsigned int, boolean
));
2363 static boolean ieee_float_type
PARAMS ((PTR
, unsigned int));
2364 static boolean ieee_complex_type
PARAMS ((PTR
, unsigned int));
2365 static boolean ieee_bool_type
PARAMS ((PTR
, unsigned int));
2366 static boolean ieee_enum_type
2367 PARAMS ((PTR
, const char *, const char **, bfd_signed_vma
*));
2368 static boolean ieee_pointer_type
PARAMS ((PTR
));
2369 static boolean ieee_function_type
PARAMS ((PTR
));
2370 static boolean ieee_reference_type
PARAMS ((PTR
));
2371 static boolean ieee_range_type
PARAMS ((PTR
, bfd_signed_vma
, bfd_signed_vma
));
2372 static boolean ieee_array_type
2373 PARAMS ((PTR
, bfd_signed_vma
, bfd_signed_vma
, boolean
));
2374 static boolean ieee_set_type
PARAMS ((PTR
, boolean
));
2375 static boolean ieee_offset_type
PARAMS ((PTR
));
2376 static boolean ieee_method_type
PARAMS ((PTR
, boolean
, int));
2377 static boolean ieee_const_type
PARAMS ((PTR
));
2378 static boolean ieee_volatile_type
PARAMS ((PTR
));
2379 static boolean ieee_start_struct_type
2380 PARAMS ((PTR
, const char *, boolean
, unsigned int));
2381 static boolean ieee_struct_field
2382 PARAMS ((PTR
, const char *, bfd_vma
, bfd_vma
, enum debug_visibility
));
2383 static boolean ieee_end_struct_type
PARAMS ((PTR
));
2384 static boolean ieee_start_class_type
2385 PARAMS ((PTR
, const char *, boolean
, unsigned int, boolean
, boolean
));
2386 static boolean ieee_class_static_member
2387 PARAMS ((PTR
, const char *, const char *, enum debug_visibility
));
2388 static boolean ieee_class_baseclass
2389 PARAMS ((PTR
, bfd_vma
, boolean
, enum debug_visibility
));
2390 static boolean ieee_class_start_method
PARAMS ((PTR
, const char *));
2391 static boolean ieee_class_method_variant
2392 PARAMS ((PTR
, const char *, enum debug_visibility
, boolean
, boolean
,
2394 static boolean ieee_class_static_method_variant
2395 PARAMS ((PTR
, const char *, enum debug_visibility
, boolean
, boolean
));
2396 static boolean ieee_class_end_method
PARAMS ((PTR
));
2397 static boolean ieee_end_class_type
PARAMS ((PTR
));
2398 static boolean ieee_typedef_type
PARAMS ((PTR
, const char *));
2399 static boolean ieee_tag_type
2400 PARAMS ((PTR
, const char *, enum debug_type_kind
));
2401 static boolean ieee_typdef
PARAMS ((PTR
, const char *));
2402 static boolean ieee_tag
PARAMS ((PTR
, const char *));
2403 static boolean ieee_int_constant
PARAMS ((PTR
, const char *, bfd_vma
));
2404 static boolean ieee_float_constant
PARAMS ((PTR
, const char *, double));
2405 static boolean ieee_typed_constant
PARAMS ((PTR
, const char *, bfd_vma
));
2406 static boolean ieee_variable
2407 PARAMS ((PTR
, const char *, enum debug_var_kind
, bfd_vma
));
2408 static boolean ieee_start_function
PARAMS ((PTR
, const char *, boolean
));
2409 static boolean ieee_function_parameter
2410 PARAMS ((PTR
, const char *, enum debug_parm_kind
, bfd_vma
));
2411 static boolean ieee_start_block
PARAMS ((PTR
, bfd_vma
));
2412 static boolean ieee_end_block
PARAMS ((PTR
, bfd_vma
));
2413 static boolean ieee_end_function
PARAMS ((PTR
));
2414 static boolean ieee_lineno
2415 PARAMS ((PTR
, const char *, unsigned long, bfd_vma
));
2417 static const struct debug_write_fns ieee_fns
=
2419 ieee_start_compilation_unit
,
2430 ieee_reference_type
,
2438 ieee_start_struct_type
,
2440 ieee_end_struct_type
,
2441 ieee_start_class_type
,
2442 ieee_class_static_member
,
2443 ieee_class_baseclass
,
2444 ieee_class_start_method
,
2445 ieee_class_method_variant
,
2446 ieee_class_static_method_variant
,
2447 ieee_class_end_method
,
2448 ieee_end_class_type
,
2454 ieee_float_constant
,
2455 ieee_typed_constant
,
2457 ieee_start_function
,
2458 ieee_function_parameter
,
2465 /* Change the current buffer to a specified buffer chain. */
2468 ieee_change_buffer (info
, ppbuf
)
2469 struct ieee_handle
*info
;
2470 struct ieee_buf
**ppbuf
;
2472 struct ieee_buf
*buf
;
2476 for (buf
= *ppbuf
; buf
->next
!= NULL
; buf
= buf
->next
)
2481 buf
= (struct ieee_buf
*) xmalloc (sizeof *buf
);
2487 info
->current
= buf
;
2491 /* Push a type index onto the type stack. */
2494 ieee_push_type (info
, indx
, size
, unsignedp
)
2495 struct ieee_handle
*info
;
2500 struct ieee_type_stack
*ts
;
2502 ts
= (struct ieee_type_stack
*) xmalloc (sizeof *ts
);
2503 memset (ts
, 0, sizeof *ts
);
2505 ts
->type
.indx
= indx
;
2506 ts
->type
.size
= size
;
2507 ts
->type
.unsignedp
= unsignedp
;
2509 ts
->next
= info
->type_stack
;
2510 info
->type_stack
= ts
;
2515 /* Pop a type index off the type stack. */
2518 ieee_pop_type (info
)
2519 struct ieee_handle
*info
;
2521 struct ieee_type_stack
*ts
;
2524 ts
= info
->type_stack
;
2525 assert (ts
!= NULL
);
2526 ret
= ts
->type
.indx
;
2527 info
->type_stack
= ts
->next
;
2532 /* Add a range of bytes included in the current compilation unit. */
2535 ieee_add_range (info
, low
, high
)
2536 struct ieee_handle
*info
;
2540 struct ieee_range
*r
, **pr
;
2542 if (low
== (bfd_vma
) -1 || high
== (bfd_vma
) -1)
2545 for (r
= info
->ranges
; r
!= NULL
; r
= r
->next
)
2547 if (high
>= r
->low
&& low
<= r
->high
)
2549 /* The new range overlaps r. */
2555 while (*pr
!= NULL
&& (*pr
)->low
<= r
->high
)
2557 struct ieee_range
*n
;
2559 if ((*pr
)->high
> r
->high
)
2560 r
->high
= (*pr
)->high
;
2569 r
= (struct ieee_range
*) xmalloc (sizeof *r
);
2570 memset (r
, 0, sizeof *r
);
2575 /* Store the ranges sorted by address. */
2576 for (pr
= &info
->ranges
; *pr
!= NULL
; pr
= &(*pr
)->next
)
2577 if ((*pr
)->next
!= NULL
&& (*pr
)->next
->low
> high
)
2585 /* Start a new range for which we only have the low address. */
2588 ieee_start_range (info
, low
)
2589 struct ieee_handle
*info
;
2592 struct ieee_range
*r
;
2594 r
= (struct ieee_range
*) xmalloc (sizeof *r
);
2595 memset (r
, 0, sizeof *r
);
2597 r
->next
= info
->pending_ranges
;
2598 info
->pending_ranges
= r
;
2602 /* Finish a range started by ieee_start_range. */
2605 ieee_end_range (info
, high
)
2606 struct ieee_handle
*info
;
2609 struct ieee_range
*r
;
2612 assert (info
->pending_ranges
!= NULL
);
2613 r
= info
->pending_ranges
;
2615 info
->pending_ranges
= r
->next
;
2617 return ieee_add_range (info
, low
, high
);
2620 /* Write a byte into the buffer. We use a macro for speed and a
2621 function for the complex cases. */
2623 #define ieee_write_byte(info, b) \
2624 ((info)->current->c < IEEE_BUFSIZE \
2625 ? ((info)->current->buf[(info)->current->c++] = (b), true) \
2626 : ieee_real_write_byte ((info), (b)))
2629 ieee_real_write_byte (info
, b
)
2630 struct ieee_handle
*info
;
2633 if (info
->current
->c
>= IEEE_BUFSIZE
)
2637 n
= (struct ieee_buf
*) xmalloc (sizeof *n
);
2640 info
->current
->next
= n
;
2644 info
->current
->buf
[info
->current
->c
] = b
;
2650 /* Write out two bytes. */
2653 ieee_write_2bytes (info
, i
)
2654 struct ieee_handle
*info
;
2657 return (ieee_write_byte (info
, i
>> 8)
2658 && ieee_write_byte (info
, i
& 0xff));
2661 /* Write out an integer. */
2664 ieee_write_number (info
, v
)
2665 struct ieee_handle
*info
;
2673 if (v
<= (bfd_vma
) ieee_number_end_enum
)
2674 return ieee_write_byte (info
, (int) v
);
2685 if (c
> (unsigned int) (ieee_number_repeat_end_enum
2686 - ieee_number_repeat_start_enum
))
2688 fprintf (stderr
, "IEEE numeric overflow: 0x");
2689 fprintf_vma (stderr
, v
);
2690 fprintf (stderr
, "\n");
2694 if (! ieee_write_byte (info
, (int) ieee_number_repeat_start_enum
+ c
))
2696 for (; c
> 0; --c
, ++p
)
2698 if (! ieee_write_byte (info
, *p
))
2705 /* Write out a string. */
2708 ieee_write_id (info
, s
)
2709 struct ieee_handle
*info
;
2717 if (! ieee_write_byte (info
, len
))
2720 else if (len
<= 0xff)
2722 if (! ieee_write_byte (info
, (int) ieee_extension_length_1_enum
)
2723 || ! ieee_write_byte (info
, len
))
2726 else if (len
<= 0xffff)
2728 if (! ieee_write_byte (info
, (int) ieee_extension_length_2_enum
)
2729 || ! ieee_write_2bytes (info
, len
))
2734 fprintf (stderr
, "IEEE string length overflow: %u\n", len
);
2738 for (; *s
!= '\0'; s
++)
2739 if (! ieee_write_byte (info
, *s
))
2745 /* Start defining a type. */
2748 ieee_define_type (info
, size
, unsignedp
)
2749 struct ieee_handle
*info
;
2753 return ieee_define_named_type (info
, (const char *) NULL
, false, size
,
2754 unsignedp
, (struct ieee_buf
**) NULL
);
2757 /* Start defining a named type. */
2760 ieee_define_named_type (info
, name
, tagp
, size
, unsignedp
, ppbuf
)
2761 struct ieee_handle
*info
;
2766 struct ieee_buf
**ppbuf
;
2768 unsigned int type_indx
;
2769 unsigned int name_indx
;
2771 if (! tagp
|| name
== NULL
|| *name
== '\0')
2773 type_indx
= info
->type_indx
;
2778 struct ieee_name_type
*nt
;
2780 /* The name is a tag. If we have already defined the tag, we
2781 must use the existing type index. */
2782 for (nt
= info
->tags
; nt
!= NULL
; nt
= nt
->next
)
2783 if (nt
->name
[0] == name
[0]
2784 && strcmp (nt
->name
, name
) == 0)
2789 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
2790 memset (nt
, 0, sizeof *nt
);
2792 nt
->next
= info
->tags
;
2794 nt
->type
.indx
= info
->type_indx
;
2798 nt
->type
.size
= size
;
2799 nt
->type
.unsignedp
= unsignedp
;
2800 nt
->kind
= DEBUG_KIND_VOID
;
2802 type_indx
= nt
->type
.indx
;
2805 name_indx
= info
->name_indx
;
2811 /* If we were given a buffer, use it; otherwise, use the general
2812 type information, and make sure that the type block is started. */
2815 if (! ieee_change_buffer (info
, ppbuf
))
2818 else if (info
->types
!= NULL
)
2820 if (! ieee_change_buffer (info
, &info
->types
))
2825 if (! ieee_change_buffer (info
, &info
->types
)
2826 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
2827 || ! ieee_write_byte (info
, 1)
2828 || ! ieee_write_number (info
, 0)
2829 || ! ieee_write_id (info
, info
->modname
))
2833 /* Push the new type on the type stack, write out an NN record, and
2834 write out the start of a TY record. The caller will then finish
2836 return (ieee_push_type (info
, type_indx
, size
, unsignedp
)
2837 && ieee_write_byte (info
, (int) ieee_nn_record
)
2838 && ieee_write_number (info
, name_indx
)
2839 && ieee_write_id (info
, name
)
2840 && ieee_write_byte (info
, (int) ieee_ty_record_enum
)
2841 && ieee_write_number (info
, type_indx
)
2842 && ieee_write_byte (info
, 0xce)
2843 && ieee_write_number (info
, name_indx
));
2846 /* The general routine to write out IEEE debugging information. */
2849 write_ieee_debugging_info (abfd
, dhandle
)
2853 struct ieee_handle info
;
2854 struct ieee_buf
*tags
;
2855 struct ieee_name_type
*nt
;
2860 memset (&info
, 0, sizeof info
);
2862 info
.type_indx
= 256;
2863 info
.name_indx
= 32;
2865 if (! debug_write (dhandle
, &ieee_fns
, (PTR
) &info
))
2868 if (info
.filename
!= NULL
)
2870 if (! ieee_finish_compilation_unit (&info
))
2874 /* Put any undefined tags in the global typedef information. */
2876 for (nt
= info
.tags
; nt
!= NULL
; nt
= nt
->next
)
2878 unsigned int name_indx
;
2881 if (nt
->kind
== DEBUG_KIND_VOID
)
2885 if (! ieee_change_buffer (&info
, &tags
)
2886 || ! ieee_write_byte (&info
, (int) ieee_bb_record_enum
)
2887 || ! ieee_write_byte (&info
, 2)
2888 || ! ieee_write_number (&info
, 0)
2889 || ! ieee_write_id (&info
, ""))
2892 name_indx
= info
.name_indx
;
2894 if (! ieee_write_byte (&info
, (int) ieee_nn_record
)
2895 || ! ieee_write_number (&info
, name_indx
)
2896 || ! ieee_write_id (&info
, nt
->name
)
2897 || ! ieee_write_byte (&info
, (int) ieee_ty_record_enum
)
2898 || ! ieee_write_number (&info
, nt
->type
.indx
)
2899 || ! ieee_write_byte (&info
, 0xce)
2900 || ! ieee_write_number (&info
, name_indx
))
2907 case DEBUG_KIND_STRUCT
:
2908 case DEBUG_KIND_CLASS
:
2911 case DEBUG_KIND_UNION
:
2912 case DEBUG_KIND_UNION_CLASS
:
2915 case DEBUG_KIND_ENUM
:
2919 if (! ieee_write_number (&info
, code
)
2920 || ! ieee_write_number (&info
, 0))
2925 struct ieee_buf
**pb
;
2927 if (! ieee_write_byte (&info
, (int) ieee_be_record_enum
))
2930 for (pb
= &tags
; *pb
!= NULL
; pb
= &(*pb
)->next
)
2936 /* Now all the data is in info.data. Write it out to the BFD. We
2937 normally would need to worry about whether all the other sections
2938 are set up yet, but the IEEE backend will handle this particular
2939 case correctly regardless. */
2940 if (info
.data
== NULL
)
2942 /* There is no debugging information. */
2946 s
= bfd_make_section (abfd
, ".debug");
2948 err
= "bfd_make_section";
2951 if (! bfd_set_section_flags (abfd
, s
, SEC_DEBUGGING
| SEC_HAS_CONTENTS
))
2952 err
= "bfd_set_section_flags";
2959 for (b
= info
.data
; b
!= NULL
; b
= b
->next
)
2961 if (! bfd_set_section_size (abfd
, s
, size
))
2962 err
= "bfd_set_section_size";
2969 for (b
= info
.data
; b
!= NULL
; b
= b
->next
)
2971 if (! bfd_set_section_contents (abfd
, s
, b
->buf
, offset
, b
->c
))
2973 err
= "bfd_set_section_contents";
2982 fprintf (stderr
, "%s: %s: %s\n", bfd_get_filename (abfd
), err
,
2983 bfd_errmsg (bfd_get_error ()));
2990 /* Start writing out information for a compilation unit. */
2993 ieee_start_compilation_unit (p
, filename
)
2995 const char *filename
;
2997 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
2998 const char *modname
;
3001 if (info
->filename
!= NULL
)
3003 if (! ieee_finish_compilation_unit (info
))
3007 info
->filename
= filename
;
3008 modname
= strrchr (filename
, '/');
3009 if (modname
!= NULL
)
3013 modname
= strrchr (filename
, '\\');
3014 if (modname
!= NULL
)
3019 c
= xstrdup (modname
);
3020 s
= strrchr (c
, '.');
3027 info
->linenos
= NULL
;
3028 info
->ranges
= NULL
;
3033 /* Finish up a compilation unit. */
3036 ieee_finish_compilation_unit (info
)
3037 struct ieee_handle
*info
;
3039 struct ieee_buf
**pp
;
3040 struct ieee_range
*r
;
3042 if (info
->types
!= NULL
)
3044 if (! ieee_change_buffer (info
, &info
->types
)
3045 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
3049 if (info
->vars
!= NULL
)
3051 if (! ieee_change_buffer (info
, &info
->vars
)
3052 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
3056 if (info
->linenos
!= NULL
)
3058 if (! ieee_change_buffer (info
, &info
->linenos
)
3059 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
3063 for (pp
= &info
->data
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3066 for (; *pp
!= NULL
; pp
= &(*pp
)->next
)
3069 for (; *pp
!= NULL
; pp
= &(*pp
)->next
)
3071 *pp
= info
->linenos
;
3073 /* Build BB10/BB11 blocks based on the ranges we recorded. */
3074 if (! ieee_change_buffer (info
, &info
->data
))
3077 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
3078 || ! ieee_write_byte (info
, 10)
3079 || ! ieee_write_number (info
, 0)
3080 || ! ieee_write_id (info
, info
->modname
)
3081 || ! ieee_write_id (info
, "")
3082 || ! ieee_write_number (info
, 0)
3083 || ! ieee_write_id (info
, "GNU objcopy"))
3086 for (r
= info
->ranges
; r
!= NULL
; r
= r
->next
)
3095 /* Find the section corresponding to this range. */
3096 for (s
= info
->abfd
->sections
; s
!= NULL
; s
= s
->next
)
3098 if (bfd_get_section_vma (info
->abfd
, s
) <= low
3099 && high
<= (bfd_get_section_vma (info
->abfd
, s
)
3100 + bfd_section_size (info
->abfd
, s
)))
3106 /* Just ignore this range. */
3110 /* Coalesce ranges if it seems reasonable. */
3111 while (r
->next
!= NULL
3112 && high
+ 64 >= r
->next
->low
3114 <= (bfd_get_section_vma (info
->abfd
, s
)
3115 + bfd_section_size (info
->abfd
, s
))))
3118 high
= r
->next
->high
;
3121 if ((s
->flags
& SEC_CODE
) != 0)
3123 else if ((s
->flags
& SEC_READONLY
) != 0)
3128 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
3129 || ! ieee_write_byte (info
, 11)
3130 || ! ieee_write_number (info
, 0)
3131 || ! ieee_write_id (info
, "")
3132 || ! ieee_write_number (info
, kind
)
3133 || ! ieee_write_number (info
, s
->index
)
3134 || ! ieee_write_number (info
, low
)
3135 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
3136 || ! ieee_write_number (info
, high
- low
))
3140 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
3146 /* Start recording information from a particular source file. This is
3147 used to record which file defined which types, variables, etc. It
3148 is not used for line numbers, since the lineno entry point passes
3149 down the file name anyhow. IEEE debugging information doesn't seem
3150 to store this information anywhere. */
3154 ieee_start_source (p
, filename
)
3156 const char *filename
;
3161 /* Make an empty type. */
3167 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3169 return ieee_push_type (info
, 0, 0, false);
3172 /* Make a void type. */
3178 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3180 return ieee_push_type (info
, 1, 0, false);
3183 /* Make an integer type. */
3186 ieee_int_type (p
, size
, unsignedp
)
3191 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3197 indx
= (int) builtin_signed_char
;
3200 indx
= (int) builtin_signed_short_int
;
3203 indx
= (int) builtin_signed_long
;
3206 indx
= (int) builtin_signed_long_long
;
3209 fprintf (stderr
, "IEEE unsupported integer type size %u\n", size
);
3216 return ieee_push_type (info
, indx
, size
, unsignedp
);
3219 /* Make a floating point type. */
3222 ieee_float_type (p
, size
)
3226 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3232 indx
= (int) builtin_float
;
3235 indx
= (int) builtin_double
;
3238 /* FIXME: This size really depends upon the processor. */
3239 indx
= (int) builtin_long_double
;
3242 indx
= (int) builtin_long_long_double
;
3245 fprintf (stderr
, "IEEE unsupported float type size %u\n", size
);
3249 return ieee_push_type (info
, indx
, size
, false);
3252 /* Make a complex type. */
3255 ieee_complex_type (p
, size
)
3259 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3271 fprintf (stderr
, "IEEE unsupported complex type size %u\n", size
);
3275 /* FIXME: I don't know what the string is for. */
3276 return (ieee_define_type (info
, size
, false)
3277 && ieee_write_number (info
, code
)
3278 && ieee_write_id (info
, ""));
3281 /* Make a boolean type. IEEE doesn't support these, so we just make
3282 an integer type instead. */
3285 ieee_bool_type (p
, size
)
3289 return ieee_int_type (p
, size
, true);
3292 /* Make an enumeration. */
3295 ieee_enum_type (p
, tag
, names
, vals
)
3299 bfd_signed_vma
*vals
;
3301 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3305 /* If this is a simple enumeration, in which the values start at 0
3306 and always increment by 1, we can use type E. Otherwise we must
3310 for (i
= 0; names
[i
] != NULL
; i
++)
3319 if (! ieee_define_named_type (info
, tag
, true, 0, true,
3320 (struct ieee_buf
**) NULL
)
3321 || ! ieee_write_number (info
, simple
? 'E' : 'N'))
3325 /* FIXME: This is supposed to be the enumeration size, but we
3326 don't store that. */
3327 if (! ieee_write_number (info
, 4))
3330 for (i
= 0; names
[i
] != NULL
; i
++)
3332 if (! ieee_write_id (info
, names
[i
]))
3336 if (! ieee_write_number (info
, vals
[i
]))
3344 /* Make a pointer type. */
3347 ieee_pointer_type (p
)
3350 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3353 indx
= ieee_pop_type (info
);
3355 /* A pointer to a simple builtin type can be obtained by adding 32. */
3357 return ieee_push_type (info
, indx
+ 32, 0, true);
3359 return (ieee_define_type (info
, 0, true)
3360 && ieee_write_number (info
, 'P')
3361 && ieee_write_number (info
, indx
));
3364 /* Make a function type. */
3367 ieee_function_type (p
)
3370 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3373 indx
= ieee_pop_type (info
);
3375 /* FIXME: IEEE can represent the argument types for the function,
3376 but we didn't store them. */
3378 /* An attribute of 0x41 means that the frame and push mask are
3380 return (ieee_define_type (info
, 0, true)
3381 && ieee_write_number (info
, 'x')
3382 && ieee_write_number (info
, 0x41)
3383 && ieee_write_number (info
, 0)
3384 && ieee_write_number (info
, 0)
3385 && ieee_write_number (info
, indx
)
3386 && ieee_write_number (info
, (bfd_vma
) -1)
3387 && ieee_write_number (info
, 0));
3390 /* Make a reference type. */
3393 ieee_reference_type (p
)
3396 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3398 /* IEEE appears to record a normal pointer type, and then use a
3399 pmisc record to indicate that it is really a reference. */
3401 if (! ieee_pointer_type (p
))
3403 info
->type_stack
->type
.referencep
= true;
3407 /* Make a range type. */
3410 ieee_range_type (p
, low
, high
)
3413 bfd_signed_vma high
;
3415 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3419 size
= info
->type_stack
->type
.size
;
3420 unsignedp
= info
->type_stack
->type
.unsignedp
;
3421 (void) ieee_pop_type (info
);
3422 return (ieee_define_type (info
, size
, unsignedp
)
3423 && ieee_write_number (info
, 'R')
3424 && ieee_write_number (info
, (bfd_vma
) low
)
3425 && ieee_write_number (info
, (bfd_vma
) high
)
3426 && ieee_write_number (info
, unsignedp
? 0 : 1)
3427 && ieee_write_number (info
, size
));
3430 /* Make an array type. */
3434 ieee_array_type (p
, low
, high
, stringp
)
3437 bfd_signed_vma high
;
3440 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3441 unsigned int eleindx
;
3443 /* IEEE does not store the range, so we just ignore it. */
3444 (void) ieee_pop_type (info
);
3445 eleindx
= ieee_pop_type (info
);
3447 if (! ieee_define_type (info
, 0, false)
3448 || ! ieee_write_number (info
, low
== 0 ? 'Z' : 'C')
3449 || ! ieee_write_number (info
, eleindx
))
3453 if (! ieee_write_number (info
, low
))
3457 return ieee_write_number (info
, high
);
3460 /* Make a set type. */
3463 ieee_set_type (p
, bitstringp
)
3467 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3468 unsigned int eleindx
;
3470 eleindx
= ieee_pop_type (info
);
3472 /* FIXME: We don't know the size, so we just use 4. */
3474 return (ieee_define_type (info
, 0, true)
3475 && ieee_write_number (info
, 's')
3476 && ieee_write_number (info
, 4)
3477 && ieee_write_number (info
, eleindx
));
3480 /* Make an offset type. */
3483 ieee_offset_type (p
)
3486 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3487 unsigned int targetindx
, baseindx
;
3489 targetindx
= ieee_pop_type (info
);
3490 baseindx
= ieee_pop_type (info
);
3492 /* FIXME: The MRI C++ compiler does not appear to generate any
3493 useful type information about an offset type. It just records a
3494 pointer to member as an integer. The MRI/HP IEEE spec does
3495 describe a pmisc record which can be used for a pointer to
3496 member. Unfortunately, it does not describe the target type,
3497 which seems pretty important. I'm going to punt this for now. */
3499 return ieee_int_type (p
, 4, true);
3502 /* Make a method type. */
3505 ieee_method_type (p
, domain
, argcount
)
3510 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3511 unsigned int *args
= NULL
;
3513 unsigned int retindx
;
3515 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
3516 method, but the definition is incomplete. We just output an 'x'
3520 (void) ieee_pop_type (info
);
3524 args
= (unsigned int *) xmalloc (argcount
* sizeof *args
);
3525 for (i
= argcount
- 1; i
>= 0; i
--)
3526 args
[i
] = ieee_pop_type (info
);
3529 retindx
= ieee_pop_type (info
);
3531 if (! ieee_define_type (info
, 0, true)
3532 || ! ieee_write_number (info
, 'x')
3533 || ! ieee_write_number (info
, 0x41)
3534 || ! ieee_write_number (info
, 0)
3535 || ! ieee_write_number (info
, 0)
3536 || ! ieee_write_number (info
, retindx
)
3537 || ! ieee_write_number (info
, (bfd_vma
) argcount
))
3541 for (i
= 0; i
< argcount
; i
++)
3542 if (! ieee_write_number (info
, args
[i
]))
3547 return ieee_write_number (info
, 0);
3550 /* Make a const qualified type. */
3556 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3561 size
= info
->type_stack
->type
.size
;
3562 unsignedp
= info
->type_stack
->type
.unsignedp
;
3563 indx
= ieee_pop_type (info
);
3564 return (ieee_define_type (info
, size
, unsignedp
)
3565 && ieee_write_number (info
, 'n')
3566 && ieee_write_number (info
, 1)
3567 && ieee_write_number (info
, indx
));
3570 /* Make a volatile qualified type. */
3573 ieee_volatile_type (p
)
3576 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3581 size
= info
->type_stack
->type
.size
;
3582 unsignedp
= info
->type_stack
->type
.unsignedp
;
3583 indx
= ieee_pop_type (info
);
3584 return (ieee_define_type (info
, size
, unsignedp
)
3585 && ieee_write_number (info
, 'n')
3586 && ieee_write_number (info
, 2)
3587 && ieee_write_number (info
, indx
));
3590 /* Start defining a struct type. We build it in the strdef field on
3591 the stack, to avoid confusing type definitions required by the
3592 fields with the struct type itself. */
3595 ieee_start_struct_type (p
, tag
, structp
, size
)
3601 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3602 struct ieee_buf
*strdef
;
3605 if (! ieee_define_named_type (info
, tag
, true, size
, true, &strdef
)
3606 || ! ieee_write_number (info
, structp
? 'S' : 'U')
3607 || ! ieee_write_number (info
, size
))
3610 info
->type_stack
->type
.strdef
= strdef
;
3615 /* Add a field to a struct. */
3618 ieee_struct_field (p
, name
, bitpos
, bitsize
, visibility
)
3623 enum debug_visibility visibility
;
3625 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3631 size
= info
->type_stack
->type
.size
;
3632 unsignedp
= info
->type_stack
->type
.unsignedp
;
3633 indx
= ieee_pop_type (info
);
3635 assert (info
->type_stack
!= NULL
&& info
->type_stack
->type
.strdef
!= NULL
);
3637 /* If the bitsize doesn't match the expected size, we need to output
3639 if (size
== 0 || bitsize
== size
* 8)
3640 offset
= bitpos
/ 8;
3643 if (! ieee_define_type (info
, 0, unsignedp
)
3644 || ! ieee_write_number (info
, 'g')
3645 || ! ieee_write_number (info
, unsignedp
? 0 : 1)
3646 || ! ieee_write_number (info
, indx
))
3648 indx
= ieee_pop_type (info
);
3652 /* Switch to the struct we are building in order to output this
3653 field definition. */
3654 return (ieee_change_buffer (info
, &info
->type_stack
->type
.strdef
)
3655 && ieee_write_id (info
, name
)
3656 && ieee_write_number (info
, indx
)
3657 && ieee_write_number (info
, offset
));
3660 /* Finish up a struct type. */
3663 ieee_end_struct_type (p
)
3666 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3667 struct ieee_buf
**pb
;
3669 assert (info
->type_stack
!= NULL
&& info
->type_stack
->type
.strdef
!= NULL
);
3671 /* Make sure we have started the types block. */
3672 if (info
->types
== NULL
)
3674 if (! ieee_change_buffer (info
, &info
->types
)
3675 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
3676 || ! ieee_write_byte (info
, 1)
3677 || ! ieee_write_number (info
, 0)
3678 || ! ieee_write_id (info
, info
->modname
))
3682 /* Append the struct definition to the types. */
3683 for (pb
= &info
->types
; *pb
!= NULL
; pb
= &(*pb
)->next
)
3685 *pb
= info
->type_stack
->type
.strdef
;
3686 info
->type_stack
->type
.strdef
= NULL
;
3688 /* Leave the struct on the type stack. */
3693 /* Start a class type. */
3696 ieee_start_class_type (p
, tag
, structp
, size
, vptr
, ownvptr
)
3704 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3707 if (vptr
&& ! ownvptr
)
3708 (void) ieee_pop_type (info
);
3709 return ieee_start_struct_type (p
, tag
, structp
, size
);
3712 /* Add a static member to a class. */
3715 ieee_class_static_member (p
, name
, physname
, visibility
)
3718 const char *physname
;
3719 enum debug_visibility visibility
;
3721 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3724 (void) ieee_pop_type (info
);
3728 /* Add a base class to a class. */
3731 ieee_class_baseclass (p
, bitpos
, virtual, visibility
)
3735 enum debug_visibility visibility
;
3737 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3740 (void) ieee_pop_type (info
);
3744 /* Start building a method for a class. */
3747 ieee_class_start_method (p
, name
)
3755 /* Define a new method variant. */
3758 ieee_class_method_variant (p
, name
, visibility
, constp
, volatilep
,
3762 enum debug_visibility visibility
;
3768 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3771 (void) ieee_pop_type (info
);
3773 (void) ieee_pop_type (info
);
3777 /* Define a new static method variant. */
3780 ieee_class_static_method_variant (p
, name
, visibility
, constp
, volatilep
)
3783 enum debug_visibility visibility
;
3787 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3790 (void) ieee_pop_type (info
);
3794 /* Finish up a method. */
3797 ieee_class_end_method (p
)
3804 /* Finish up a class. */
3807 ieee_end_class_type (p
)
3810 return ieee_end_struct_type (p
);
3813 /* Push a previously seen typedef onto the type stack. */
3816 ieee_typedef_type (p
, name
)
3820 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3821 register struct ieee_name_type
*nt
;
3823 for (nt
= info
->typedefs
; nt
!= NULL
; nt
= nt
->next
)
3825 if (nt
->name
[0] == name
[0]
3826 && strcmp (nt
->name
, name
) == 0)
3828 if (! ieee_push_type (info
, nt
->type
.indx
, nt
->type
.size
,
3829 nt
->type
.unsignedp
))
3831 /* Copy over any other type information we may have. */
3832 info
->type_stack
->type
= nt
->type
;
3840 /* Push a tagged type onto the type stack. */
3843 ieee_tag_type (p
, name
, kind
)
3846 enum debug_type_kind kind
;
3848 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3849 register struct ieee_name_type
*nt
;
3851 for (nt
= info
->tags
; nt
!= NULL
; nt
= nt
->next
)
3853 if (nt
->name
[0] == name
[0]
3854 && strcmp (nt
->name
, name
) == 0)
3856 if (! ieee_push_type (info
, nt
->type
.indx
, nt
->type
.size
,
3857 nt
->type
.unsignedp
))
3859 /* Copy over any other type information we may have. */
3860 info
->type_stack
->type
= nt
->type
;
3865 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
3866 memset (nt
, 0, sizeof *nt
);
3869 nt
->type
.indx
= info
->type_indx
;
3873 nt
->next
= info
->tags
;
3876 return ieee_push_type (info
, nt
->type
.indx
, 0, false);
3879 /* Output a typedef. */
3882 ieee_typdef (p
, name
)
3886 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
3887 struct ieee_name_type
*nt
;
3892 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
3893 memset (nt
, 0, sizeof *nt
);
3895 nt
->type
= info
->type_stack
->type
;
3896 nt
->kind
= DEBUG_KIND_VOID
;
3898 nt
->next
= info
->typedefs
;
3899 info
->typedefs
= nt
;
3901 size
= info
->type_stack
->type
.size
;
3902 unsignedp
= info
->type_stack
->type
.unsignedp
;
3903 indx
= ieee_pop_type (info
);
3905 /* If this is a simple builtin type using a builtin name, we don't
3906 want to output the typedef itself. We also want to change the
3907 type index to correspond to the name being used. We recognize
3908 names used in stabs debugging output even if they don't exactly
3909 correspond to the names used for the IEEE builtin types. */
3910 if (indx
<= (unsigned int) builtin_bcd_float
)
3915 switch ((enum builtin_types
) indx
)
3921 if (strcmp (name
, "void") == 0)
3925 case builtin_signed_char
:
3927 if (strcmp (name
, "signed char") == 0)
3929 indx
= (unsigned int) builtin_signed_char
;
3932 else if (strcmp (name
, "char") == 0)
3934 indx
= (unsigned int) builtin_char
;
3939 case builtin_unsigned_char
:
3940 if (strcmp (name
, "unsigned char") == 0)
3944 case builtin_signed_short_int
:
3946 case builtin_short_int
:
3947 case builtin_signed_short
:
3948 if (strcmp (name
, "signed short int") == 0)
3950 indx
= (unsigned int) builtin_signed_short_int
;
3953 else if (strcmp (name
, "short") == 0)
3955 indx
= (unsigned int) builtin_short
;
3958 else if (strcmp (name
, "short int") == 0)
3960 indx
= (unsigned int) builtin_short_int
;
3963 else if (strcmp (name
, "signed short") == 0)
3965 indx
= (unsigned int) builtin_signed_short
;
3970 case builtin_unsigned_short_int
:
3971 case builtin_unsigned_short
:
3972 if (strcmp (name
, "unsigned short int") == 0
3973 || strcmp (name
, "short unsigned int") == 0)
3975 indx
= builtin_unsigned_short_int
;
3978 else if (strcmp (name
, "unsigned short") == 0)
3980 indx
= builtin_unsigned_short
;
3985 case builtin_signed_long
:
3986 case builtin_int
: /* FIXME: Size depends upon architecture. */
3988 if (strcmp (name
, "signed long") == 0)
3990 indx
= builtin_signed_long
;
3993 else if (strcmp (name
, "int") == 0)
3998 else if (strcmp (name
, "long") == 0
3999 || strcmp (name
, "long int") == 0)
4001 indx
= builtin_long
;
4006 case builtin_unsigned_long
:
4007 case builtin_unsigned
: /* FIXME: Size depends upon architecture. */
4008 case builtin_unsigned_int
: /* FIXME: Like builtin_unsigned. */
4009 if (strcmp (name
, "unsigned long") == 0
4010 || strcmp (name
, "long unsigned int") == 0)
4012 indx
= builtin_unsigned_long
;
4015 else if (strcmp (name
, "unsigned") == 0)
4017 indx
= builtin_unsigned
;
4020 else if (strcmp (name
, "unsigned int") == 0)
4022 indx
= builtin_unsigned_int
;
4027 case builtin_signed_long_long
:
4028 if (strcmp (name
, "signed long long") == 0
4029 || strcmp (name
, "long long int") == 0)
4033 case builtin_unsigned_long_long
:
4034 if (strcmp (name
, "unsigned long long") == 0
4035 || strcmp (name
, "long long unsigned int") == 0)
4040 if (strcmp (name
, "float") == 0)
4044 case builtin_double
:
4045 if (strcmp (name
, "double") == 0)
4049 case builtin_long_double
:
4050 if (strcmp (name
, "long double") == 0)
4054 case builtin_long_long_double
:
4055 if (strcmp (name
, "long long double") == 0)
4062 nt
->type
.indx
= indx
;
4067 if (! ieee_define_named_type (info
, name
, false, size
, unsignedp
,
4068 (struct ieee_buf
**) NULL
)
4069 || ! ieee_write_number (info
, 'T')
4070 || ! ieee_write_number (info
, indx
))
4073 /* Remove the type we just added to the type stack. */
4074 (void) ieee_pop_type (info
);
4079 /* Output a tag for a type. We don't have to do anything here. */
4086 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4088 (void) ieee_pop_type (info
);
4092 /* Output an integer constant. */
4095 ieee_int_constant (p
, name
, val
)
4104 /* Output a floating point constant. */
4107 ieee_float_constant (p
, name
, val
)
4116 /* Output a typed constant. */
4119 ieee_typed_constant (p
, name
, val
)
4124 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4127 (void) ieee_pop_type (info
);
4131 /* Output a variable. */
4134 ieee_variable (p
, name
, kind
, val
)
4137 enum debug_var_kind kind
;
4140 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4141 unsigned int name_indx
;
4143 unsigned int type_indx
;
4146 /* Make sure the variable section is started. */
4147 if (info
->vars
!= NULL
)
4149 if (! ieee_change_buffer (info
, &info
->vars
))
4154 if (! ieee_change_buffer (info
, &info
->vars
)
4155 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4156 || ! ieee_write_byte (info
, 3)
4157 || ! ieee_write_number (info
, 0)
4158 || ! ieee_write_id (info
, info
->modname
))
4162 name_indx
= info
->name_indx
;
4165 size
= info
->type_stack
->type
.size
;
4166 type_indx
= ieee_pop_type (info
);
4168 /* Write out an NN and an ATN record for this variable. */
4169 if (! ieee_write_byte (info
, (int) ieee_nn_record
)
4170 || ! ieee_write_number (info
, name_indx
)
4171 || ! ieee_write_id (info
, name
)
4172 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
4173 || ! ieee_write_number (info
, name_indx
)
4174 || ! ieee_write_number (info
, type_indx
))
4182 if (! ieee_write_number (info
, 8)
4183 || ! ieee_add_range (info
, val
, val
+ size
))
4188 case DEBUG_LOCAL_STATIC
:
4189 if (! ieee_write_number (info
, 3)
4190 || ! ieee_add_range (info
, val
, val
+ size
))
4195 if (! ieee_write_number (info
, 1)
4196 || ! ieee_write_number (info
, val
))
4200 case DEBUG_REGISTER
:
4201 if (! ieee_write_number (info
, 2)
4202 || ! ieee_write_number (info
,
4203 ieee_genreg_to_regno (info
->abfd
, val
)))
4211 if (! ieee_write_2bytes (info
, (int) ieee_asn_record_enum
)
4212 || ! ieee_write_number (info
, name_indx
)
4213 || ! ieee_write_number (info
, val
))
4220 /* Start outputting information for a function. */
4223 ieee_start_function (p
, name
, global
)
4228 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4231 /* Make sure the variable section is started. */
4232 if (info
->vars
!= NULL
)
4234 if (! ieee_change_buffer (info
, &info
->vars
))
4239 if (! ieee_change_buffer (info
, &info
->vars
)
4240 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4241 || ! ieee_write_byte (info
, 3)
4242 || ! ieee_write_number (info
, 0)
4243 || ! ieee_write_id (info
, info
->modname
))
4247 indx
= ieee_pop_type (info
);
4249 /* The address is written out as the first block. */
4251 ++info
->block_depth
;
4253 return (ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4254 && ieee_write_byte (info
, global
? 4 : 6)
4255 && ieee_write_number (info
, 0)
4256 && ieee_write_id (info
, name
)
4257 && ieee_write_number (info
, 0)
4258 && ieee_write_number (info
, indx
));
4261 /* Add a function parameter. This will normally be called before the
4262 first block, so we postpone them until we see the block. */
4265 ieee_function_parameter (p
, name
, kind
, val
)
4268 enum debug_parm_kind kind
;
4271 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4272 struct ieee_pending_parm
*m
, **pm
;
4274 assert (info
->block_depth
== 1);
4276 m
= (struct ieee_pending_parm
*) xmalloc (sizeof *m
);
4277 memset (m
, 0, sizeof *m
);
4281 m
->type
= ieee_pop_type (info
);
4285 for (pm
= &info
->pending_parms
; *pm
!= NULL
; pm
= &(*pm
)->next
)
4292 /* Output pending function parameters. */
4295 ieee_output_pending_parms (info
)
4296 struct ieee_handle
*info
;
4298 struct ieee_pending_parm
*m
;
4300 m
= info
->pending_parms
;
4303 struct ieee_pending_parm
*next
;
4304 enum debug_var_kind vkind
;
4311 case DEBUG_PARM_STACK
:
4312 case DEBUG_PARM_REFERENCE
:
4313 vkind
= DEBUG_LOCAL
;
4315 case DEBUG_PARM_REG
:
4316 case DEBUG_PARM_REF_REG
:
4317 vkind
= DEBUG_REGISTER
;
4321 if (! ieee_push_type (info
, m
->type
, 0, false)
4322 || ! ieee_variable ((PTR
) info
, m
->name
, vkind
, m
->val
))
4325 /* FIXME: We should output a pmisc note here for reference
4332 info
->pending_parms
= NULL
;
4337 /* Start a block. If this is the first block, we output the address
4338 to finish the BB4 or BB6, and then output the function parameters. */
4341 ieee_start_block (p
, addr
)
4345 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4347 if (! ieee_change_buffer (info
, &info
->vars
))
4350 if (info
->block_depth
== 1)
4352 if (! ieee_write_number (info
, addr
)
4353 || ! ieee_output_pending_parms (info
))
4358 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4359 || ! ieee_write_byte (info
, 6)
4360 || ! ieee_write_byte (info
, 0)
4361 || ! ieee_write_id (info
, "")
4362 || ! ieee_write_number (info
, 0)
4363 || ! ieee_write_number (info
, 0)
4364 || ! ieee_write_number (info
, addr
))
4368 if (! ieee_start_range (info
, addr
))
4371 ++info
->block_depth
;
4379 ieee_end_block (p
, addr
)
4383 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4385 if (! ieee_change_buffer (info
, &info
->vars
)
4386 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
4387 || ! ieee_write_number (info
, addr
))
4390 if (! ieee_end_range (info
, addr
))
4393 --info
->block_depth
;
4398 /* End a function. */
4401 ieee_end_function (p
)
4404 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4406 assert (info
->block_depth
== 1);
4408 --info
->block_depth
;
4413 /* Record line number information. */
4416 ieee_lineno (p
, filename
, lineno
, addr
)
4418 const char *filename
;
4419 unsigned long lineno
;
4422 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4424 assert (info
->filename
!= NULL
);
4426 /* Make sure we have a line number block. */
4427 if (info
->linenos
!= NULL
)
4429 if (! ieee_change_buffer (info
, &info
->linenos
))
4434 info
->lineno_name_indx
= info
->name_indx
;
4436 if (! ieee_change_buffer (info
, &info
->linenos
)
4437 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4438 || ! ieee_write_byte (info
, 5)
4439 || ! ieee_write_number (info
, 0)
4440 || ! ieee_write_id (info
, info
->filename
)
4441 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
4442 || ! ieee_write_number (info
, info
->lineno_name_indx
)
4443 || ! ieee_write_id (info
, ""))
4445 info
->lineno_filename
= info
->filename
;
4448 if (strcmp (filename
, info
->lineno_filename
) != 0)
4450 if (strcmp (info
->filename
, info
->lineno_filename
) != 0)
4452 /* We were not in the main file. Close the block for the
4454 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4457 if (strcmp (info
->filename
, filename
) != 0)
4459 /* We are not changing to the main file. Open a block for
4460 the new included file. */
4461 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4462 || ! ieee_write_byte (info
, 5)
4463 || ! ieee_write_number (info
, 0)
4464 || ! ieee_write_id (info
, filename
))
4467 info
->lineno_filename
= filename
;
4470 return (ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
4471 && ieee_write_number (info
, info
->lineno_name_indx
)
4472 && ieee_write_number (info
, 0)
4473 && ieee_write_number (info
, 7)
4474 && ieee_write_number (info
, lineno
)
4475 && ieee_write_number (info
, 0)
4476 && ieee_write_2bytes (info
, (int) ieee_asn_record_enum
)
4477 && ieee_write_number (info
, info
->lineno_name_indx
)
4478 && ieee_write_number (info
, addr
));