1 /* stabs.c -- Parse COFF debugging information
2 Copyright (C) 1996-2017 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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA
22 /* This file contains code which parses COFF debugging information. */
26 #include "coff/internal.h"
27 #include "libiberty.h"
32 /* FIXME: We should not need this BFD internal file. We need it for
33 the N_BTMASK, etc., values. */
36 /* These macros extract the right mask and shifts for this BFD. They
37 assume that there is a local variable named ABFD. This is so that
38 macros like ISFCN and DECREF, from coff/internal.h, will work
39 without modification. */
40 #define N_BTMASK (coff_data (abfd)->local_n_btmask)
41 #define N_BTSHFT (coff_data (abfd)->local_n_btshft)
42 #define N_TMASK (coff_data (abfd)->local_n_tmask)
43 #define N_TSHIFT (coff_data (abfd)->local_n_tshift)
45 /* This structure is used to hold the symbols, as well as the current
46 location within the symbols. */
52 /* The number of symbols. */
54 /* The index of the current symbol. */
56 /* The index of the current symbol in the COFF symbol table (where
57 each auxent counts as a symbol). */
61 /* The largest basic type we are prepared to handle. */
63 #define T_MAX (T_LNGDBL)
65 /* This structure is used to hold slots. */
69 /* Next set of slots. */
70 struct coff_slots
*next
;
72 #define COFF_SLOTS (16)
73 debug_type slots
[COFF_SLOTS
];
76 /* This structure is used to map symbol indices to types. */
81 struct coff_slots
*slots
;
83 debug_type basic
[T_MAX
+ 1];
86 static debug_type
*coff_get_slot (struct coff_types
*, long);
87 static debug_type parse_coff_type
88 (bfd
*, struct coff_symbols
*, struct coff_types
*, long, int,
89 union internal_auxent
*, bfd_boolean
, void *);
90 static debug_type parse_coff_base_type
91 (bfd
*, struct coff_symbols
*, struct coff_types
*, long, int,
92 union internal_auxent
*, void *);
93 static debug_type parse_coff_struct_type
94 (bfd
*, struct coff_symbols
*, struct coff_types
*, int,
95 union internal_auxent
*, void *);
96 static debug_type parse_coff_enum_type
97 (bfd
*, struct coff_symbols
*, struct coff_types
*,
98 union internal_auxent
*, void *);
99 static bfd_boolean parse_coff_symbol
100 (bfd
*, struct coff_types
*, asymbol
*, long, struct internal_syment
*,
101 void *, debug_type
, bfd_boolean
);
102 static bfd_boolean
external_coff_symbol_p (int sym_class
);
104 /* Return the slot for a type. */
107 coff_get_slot (struct coff_types
*types
, long indx
)
109 struct coff_slots
**pps
;
113 /* PR 17512: file: 078-18333-0.001:0.1.
114 FIXME: The value of 1000 is a guess. Maybe a better heuristic is needed. */
115 if (indx
/ COFF_SLOTS
> 1000)
116 fatal (_("Excessively large slot index: %lx"), indx
);
118 while (indx
>= COFF_SLOTS
)
122 *pps
= (struct coff_slots
*) xmalloc (sizeof **pps
);
123 memset (*pps
, 0, sizeof **pps
);
131 *pps
= (struct coff_slots
*) xmalloc (sizeof **pps
);
132 memset (*pps
, 0, sizeof **pps
);
135 return (*pps
)->slots
+ indx
;
138 /* Parse a COFF type code in NTYPE. */
141 parse_coff_type (bfd
*abfd
, struct coff_symbols
*symbols
,
142 struct coff_types
*types
, long coff_symno
, int ntype
,
143 union internal_auxent
*pauxent
, bfd_boolean useaux
,
148 if ((ntype
& ~N_BTMASK
) != 0)
152 newtype
= DECREF (ntype
);
156 type
= parse_coff_type (abfd
, symbols
, types
, coff_symno
, newtype
,
157 pauxent
, useaux
, dhandle
);
158 type
= debug_make_pointer_type (dhandle
, type
);
160 else if (ISFCN (ntype
))
162 type
= parse_coff_type (abfd
, symbols
, types
, coff_symno
, newtype
,
163 pauxent
, useaux
, dhandle
);
164 type
= debug_make_function_type (dhandle
, type
, (debug_type
*) NULL
,
167 else if (ISARY (ntype
))
178 /* FIXME: If pauxent->x_sym.x_tagndx.l == 0, gdb sets
179 the c_naux field of the syment to 0. */
181 /* Move the dimensions down, so that the next array
182 picks up the next one. */
183 dim
= pauxent
->x_sym
.x_fcnary
.x_ary
.x_dimen
;
185 for (i
= 0; *dim
!= 0 && i
< DIMNUM
- 1; i
++, dim
++)
190 type
= parse_coff_type (abfd
, symbols
, types
, coff_symno
, newtype
,
191 pauxent
, FALSE
, dhandle
);
192 type
= debug_make_array_type (dhandle
, type
,
193 parse_coff_base_type (abfd
, symbols
,
202 non_fatal (_("parse_coff_type: Bad type code 0x%x"), ntype
);
203 return DEBUG_TYPE_NULL
;
209 if (pauxent
!= NULL
&& pauxent
->x_sym
.x_tagndx
.l
> 0)
213 /* This is a reference to an existing type. FIXME: gdb checks
214 that the class is not C_STRTAG, nor C_UNTAG, nor C_ENTAG. */
215 slot
= coff_get_slot (types
, pauxent
->x_sym
.x_tagndx
.l
);
216 if (*slot
!= DEBUG_TYPE_NULL
)
219 return debug_make_indirect_type (dhandle
, slot
, (const char *) NULL
);
222 /* If the aux entry has already been used for something, useaux will
223 have been set to false, indicating that parse_coff_base_type
224 should not use it. We need to do it this way, rather than simply
225 passing pauxent as NULL, because we need to be able handle
226 multiple array dimensions while still discarding pauxent after
227 having handled all of them. */
231 return parse_coff_base_type (abfd
, symbols
, types
, coff_symno
, ntype
,
235 /* Parse a basic COFF type in NTYPE. */
238 parse_coff_base_type (bfd
*abfd
, struct coff_symbols
*symbols
,
239 struct coff_types
*types
, long coff_symno
, int ntype
,
240 union internal_auxent
*pauxent
, void *dhandle
)
243 bfd_boolean set_basic
;
249 && types
->basic
[ntype
] != DEBUG_TYPE_NULL
)
250 return types
->basic
[ntype
];
258 ret
= debug_make_void_type (dhandle
);
263 ret
= debug_make_void_type (dhandle
);
268 ret
= debug_make_int_type (dhandle
, 1, FALSE
);
273 ret
= debug_make_int_type (dhandle
, 2, FALSE
);
278 /* FIXME: Perhaps the size should depend upon the architecture. */
279 ret
= debug_make_int_type (dhandle
, 4, FALSE
);
284 ret
= debug_make_int_type (dhandle
, 4, FALSE
);
289 ret
= debug_make_float_type (dhandle
, 4);
294 ret
= debug_make_float_type (dhandle
, 8);
299 ret
= debug_make_float_type (dhandle
, 12);
300 name
= "long double";
304 ret
= debug_make_int_type (dhandle
, 1, TRUE
);
305 name
= "unsigned char";
309 ret
= debug_make_int_type (dhandle
, 2, TRUE
);
310 name
= "unsigned short";
314 ret
= debug_make_int_type (dhandle
, 4, TRUE
);
315 name
= "unsigned int";
319 ret
= debug_make_int_type (dhandle
, 4, TRUE
);
320 name
= "unsigned long";
325 ret
= debug_make_struct_type (dhandle
, TRUE
, 0,
326 (debug_field
*) NULL
);
328 ret
= parse_coff_struct_type (abfd
, symbols
, types
, ntype
, pauxent
,
331 slot
= coff_get_slot (types
, coff_symno
);
339 ret
= debug_make_struct_type (dhandle
, FALSE
, 0, (debug_field
*) NULL
);
341 ret
= parse_coff_struct_type (abfd
, symbols
, types
, ntype
, pauxent
,
344 slot
= coff_get_slot (types
, coff_symno
);
352 ret
= debug_make_enum_type (dhandle
, (const char **) NULL
,
353 (bfd_signed_vma
*) NULL
);
355 ret
= parse_coff_enum_type (abfd
, symbols
, types
, pauxent
, dhandle
);
357 slot
= coff_get_slot (types
, coff_symno
);
365 ret
= debug_name_type (dhandle
, name
, ret
);
370 types
->basic
[ntype
] = ret
;
375 /* Parse a struct type. */
378 parse_coff_struct_type (bfd
*abfd
, struct coff_symbols
*symbols
,
379 struct coff_types
*types
, int ntype
,
380 union internal_auxent
*pauxent
, void *dhandle
)
388 symend
= pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
391 fields
= (debug_field
*) xmalloc (alloc
* sizeof *fields
);
396 && symbols
->coff_symno
< symend
397 && symbols
->symno
< symbols
->symcount
)
400 long this_coff_symno
;
401 struct internal_syment syment
;
402 union internal_auxent auxent
;
403 union internal_auxent
*psubaux
;
404 bfd_vma bitpos
= 0, bitsize
= 0;
406 sym
= symbols
->syms
[symbols
->symno
];
408 if (! bfd_coff_get_syment (abfd
, sym
, &syment
))
410 non_fatal (_("bfd_coff_get_syment failed: %s"),
411 bfd_errmsg (bfd_get_error ()));
412 return DEBUG_TYPE_NULL
;
415 this_coff_symno
= symbols
->coff_symno
;
418 symbols
->coff_symno
+= 1 + syment
.n_numaux
;
420 if (syment
.n_numaux
== 0)
424 if (! bfd_coff_get_auxent (abfd
, sym
, 0, &auxent
))
426 non_fatal (_("bfd_coff_get_auxent failed: %s"),
427 bfd_errmsg (bfd_get_error ()));
428 return DEBUG_TYPE_NULL
;
433 switch (syment
.n_sclass
)
437 bitpos
= 8 * bfd_asymbol_value (sym
);
442 bitpos
= bfd_asymbol_value (sym
);
443 bitsize
= auxent
.x_sym
.x_misc
.x_lnsz
.x_size
;
456 ftype
= parse_coff_type (abfd
, symbols
, types
, this_coff_symno
,
457 syment
.n_type
, psubaux
, TRUE
, dhandle
);
458 f
= debug_make_field (dhandle
, bfd_asymbol_name (sym
), ftype
,
459 bitpos
, bitsize
, DEBUG_VISIBILITY_PUBLIC
);
460 if (f
== DEBUG_FIELD_NULL
)
461 return DEBUG_TYPE_NULL
;
463 if (count
+ 1 >= alloc
)
466 fields
= ((debug_field
*)
467 xrealloc (fields
, alloc
* sizeof *fields
));
475 fields
[count
] = DEBUG_FIELD_NULL
;
477 return debug_make_struct_type (dhandle
, ntype
== T_STRUCT
,
478 pauxent
->x_sym
.x_misc
.x_lnsz
.x_size
,
482 /* Parse an enum type. */
485 parse_coff_enum_type (bfd
*abfd
, struct coff_symbols
*symbols
,
486 struct coff_types
*types ATTRIBUTE_UNUSED
,
487 union internal_auxent
*pauxent
, void *dhandle
)
492 bfd_signed_vma
*vals
;
496 symend
= pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
499 names
= (const char **) xmalloc (alloc
* sizeof *names
);
500 vals
= (bfd_signed_vma
*) xmalloc (alloc
* sizeof *vals
);
505 && symbols
->coff_symno
< symend
506 && symbols
->symno
< symbols
->symcount
)
509 struct internal_syment syment
;
511 sym
= symbols
->syms
[symbols
->symno
];
513 if (! bfd_coff_get_syment (abfd
, sym
, &syment
))
515 non_fatal (_("bfd_coff_get_syment failed: %s"),
516 bfd_errmsg (bfd_get_error ()));
517 return DEBUG_TYPE_NULL
;
521 symbols
->coff_symno
+= 1 + syment
.n_numaux
;
523 switch (syment
.n_sclass
)
526 if (count
+ 1 >= alloc
)
529 names
= ((const char **)
530 xrealloc (names
, alloc
* sizeof *names
));
531 vals
= ((bfd_signed_vma
*)
532 xrealloc (vals
, alloc
* sizeof *vals
));
535 names
[count
] = bfd_asymbol_name (sym
);
536 vals
[count
] = bfd_asymbol_value (sym
);
548 return debug_make_enum_type (dhandle
, names
, vals
);
551 /* Handle a single COFF symbol. */
554 parse_coff_symbol (bfd
*abfd ATTRIBUTE_UNUSED
, struct coff_types
*types
,
555 asymbol
*sym
, long coff_symno
,
556 struct internal_syment
*psyment
, void *dhandle
,
557 debug_type type
, bfd_boolean within_function
)
559 switch (psyment
->n_sclass
)
565 if (! debug_record_variable (dhandle
, bfd_asymbol_name (sym
), type
,
566 DEBUG_LOCAL
, bfd_asymbol_value (sym
)))
572 if (! debug_record_variable (dhandle
, bfd_asymbol_name (sym
), type
,
573 DEBUG_GLOBAL
, bfd_asymbol_value (sym
)))
578 if (! debug_record_variable (dhandle
, bfd_asymbol_name (sym
), type
,
582 bfd_asymbol_value (sym
)))
587 /* FIXME: We may need to convert the register number. */
588 if (! debug_record_variable (dhandle
, bfd_asymbol_name (sym
), type
,
589 DEBUG_REGISTER
, bfd_asymbol_value (sym
)))
597 if (! debug_record_parameter (dhandle
, bfd_asymbol_name (sym
), type
,
598 DEBUG_PARM_STACK
, bfd_asymbol_value (sym
)))
603 /* FIXME: We may need to convert the register number. */
604 if (! debug_record_parameter (dhandle
, bfd_asymbol_name (sym
), type
,
605 DEBUG_PARM_REG
, bfd_asymbol_value (sym
)))
610 type
= debug_name_type (dhandle
, bfd_asymbol_name (sym
), type
);
611 if (type
== DEBUG_TYPE_NULL
)
621 type
= debug_tag_type (dhandle
, bfd_asymbol_name (sym
), type
);
622 if (type
== DEBUG_TYPE_NULL
)
625 /* Store the named type into the slot, so that references get
627 slot
= coff_get_slot (types
, coff_symno
);
639 /* Determine if a symbol has external visibility. */
642 external_coff_symbol_p (int sym_class
)
655 /* This is the main routine. It looks through all the symbols and
659 parse_coff (bfd
*abfd
, asymbol
**syms
, long symcount
, void *dhandle
)
661 struct coff_symbols symbols
;
662 struct coff_types types
;
670 bfd_boolean within_function
;
671 long this_coff_symno
;
674 symbols
.symcount
= symcount
;
676 symbols
.coff_symno
= 0;
679 for (i
= 0; i
<= T_MAX
; i
++)
680 types
.basic
[i
] = DEBUG_TYPE_NULL
;
688 within_function
= FALSE
;
690 while (symbols
.symno
< symcount
)
694 struct internal_syment syment
;
695 union internal_auxent auxent
;
696 union internal_auxent
*paux
;
699 sym
= syms
[symbols
.symno
];
701 if (! bfd_coff_get_syment (abfd
, sym
, &syment
))
703 non_fatal (_("bfd_coff_get_syment failed: %s"),
704 bfd_errmsg (bfd_get_error ()));
708 name
= bfd_asymbol_name (sym
);
710 this_coff_symno
= symbols
.coff_symno
;
713 symbols
.coff_symno
+= 1 + syment
.n_numaux
;
715 /* We only worry about the first auxent, because that is the
716 only one which is relevant for debugging information. */
717 if (syment
.n_numaux
== 0)
721 if (! bfd_coff_get_auxent (abfd
, sym
, 0, &auxent
))
723 non_fatal (_("bfd_coff_get_auxent failed: %s"),
724 bfd_errmsg (bfd_get_error ()));
730 if (this_coff_symno
== next_c_file
&& syment
.n_sclass
!= C_FILE
)
732 /* The last C_FILE symbol points to the first external
734 if (! debug_set_filename (dhandle
, "*globals*"))
738 switch (syment
.n_sclass
)
747 /* Just ignore these classes. */
751 next_c_file
= syment
.n_value
;
752 if (! debug_set_filename (dhandle
, name
))
757 /* Ignore static symbols with a type of T_NULL. These
758 represent section entries. */
759 if (syment
.n_type
== T_NULL
)
764 if (ISFCN (syment
.n_type
))
767 fnclass
= syment
.n_sclass
;
768 fntype
= syment
.n_type
;
769 if (syment
.n_numaux
> 0)
770 fnend
= bfd_asymbol_value (sym
) + auxent
.x_sym
.x_misc
.x_fsize
;
773 linenos
= BFD_SEND (abfd
, _get_lineno
, (abfd
, sym
));
776 type
= parse_coff_type (abfd
, &symbols
, &types
, this_coff_symno
,
777 syment
.n_type
, paux
, TRUE
, dhandle
);
778 if (type
== DEBUG_TYPE_NULL
)
780 if (! parse_coff_symbol (abfd
, &types
, sym
, this_coff_symno
, &syment
,
781 dhandle
, type
, within_function
))
786 if (strcmp (name
, ".bf") == 0)
790 non_fatal (_("%ld: .bf without preceding function"),
795 type
= parse_coff_type (abfd
, &symbols
, &types
, this_coff_symno
,
796 DECREF (fntype
), paux
, FALSE
, dhandle
);
797 if (type
== DEBUG_TYPE_NULL
)
800 if (! debug_record_function (dhandle
, fnname
, type
,
801 external_coff_symbol_p (fnclass
),
802 bfd_asymbol_value (sym
)))
810 if (syment
.n_numaux
== 0)
813 base
= auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
- 1;
815 addr
= bfd_get_section_vma (abfd
, bfd_get_section (sym
));
819 while (linenos
->line_number
!= 0)
821 if (! debug_record_line (dhandle
,
822 linenos
->line_number
+ base
,
823 linenos
->u
.offset
+ addr
))
834 within_function
= TRUE
;
836 else if (strcmp (name
, ".ef") == 0)
838 if (! within_function
)
840 non_fatal (_("%ld: unexpected .ef\n"), this_coff_symno
);
844 if (bfd_asymbol_value (sym
) > fnend
)
845 fnend
= bfd_asymbol_value (sym
);
846 if (! debug_end_function (dhandle
, fnend
))
850 within_function
= FALSE
;
855 if (strcmp (name
, ".bb") == 0)
857 if (! debug_start_block (dhandle
, bfd_asymbol_value (sym
)))
860 else if (strcmp (name
, ".eb") == 0)
862 if (! debug_end_block (dhandle
, bfd_asymbol_value (sym
)))
868 type
= parse_coff_type (abfd
, &symbols
, &types
, this_coff_symno
,
869 syment
.n_type
, paux
, TRUE
, dhandle
);
870 if (type
== DEBUG_TYPE_NULL
)
872 if (! parse_coff_symbol (abfd
, &types
, sym
, this_coff_symno
, &syment
,
873 dhandle
, type
, within_function
))