testsuite, threads: fix LD_LIBRARY_PATH in 'tls-sepdebug.exp'
[binutils-gdb.git] / binutils / rdcoff.c
blob404a658b7cd91ce65a83d483c5a2571dd9d5eca6
1 /* stabs.c -- Parse COFF debugging information
2 Copyright (C) 1996-2024 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
20 02110-1301, USA. */
22 /* This file contains code which parses COFF debugging information. */
24 #include "sysdep.h"
25 #include "bfd.h"
26 #include "coff/internal.h"
27 #include "libiberty.h"
28 #include "bucomm.h"
29 #include "debug.h"
30 #include "budbg.h"
32 /* FIXME: We should not need this BFD internal file. We need it for
33 the N_BTMASK, etc., values. */
34 #include "libcoff.h"
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. */
48 struct coff_symbols
50 /* The symbols. */
51 asymbol **syms;
52 /* The number of symbols. */
53 long symcount;
54 /* The index of the current symbol. */
55 long symno;
56 /* The index of the current symbol in the COFF symbol table (where
57 each auxent counts as a symbol). */
58 long coff_symno;
61 /* This structure is used to map symbol indices to types. */
63 struct coff_types
65 /* Next set of slots. */
66 struct coff_types *next;
67 /* Where the TYPES array starts. */
68 unsigned int base_index;
69 /* Slots. */
70 #define COFF_SLOTS (16)
71 debug_type types[COFF_SLOTS];
74 static debug_type parse_coff_base_type
75 (bfd *, struct coff_symbols *, struct coff_types **, long, int,
76 union internal_auxent *, void *);
77 static debug_type parse_coff_struct_type
78 (bfd *, struct coff_symbols *, struct coff_types **, int,
79 union internal_auxent *, void *);
80 static debug_type parse_coff_enum_type
81 (bfd *, struct coff_symbols *, struct coff_types **,
82 union internal_auxent *, void *);
84 /* Return the slot for a type. */
86 static debug_type *
87 coff_get_slot (void *dhandle, struct coff_types **types, long indx)
89 unsigned int base_index;
91 base_index = indx / COFF_SLOTS * COFF_SLOTS;
92 indx -= base_index;
94 while (*types && (*types)->base_index < base_index)
95 types = &(*types)->next;
97 if (*types == NULL || (*types)->base_index != base_index)
99 struct coff_types *n = debug_xzalloc (dhandle, sizeof (*n));
100 n->next = *types;
101 n->base_index = base_index;
102 *types = n;
105 return (*types)->types + indx;
108 /* Parse a COFF type code in NTYPE. */
110 static debug_type
111 parse_coff_type (bfd *abfd, struct coff_symbols *symbols,
112 struct coff_types **types, long coff_symno, int ntype,
113 union internal_auxent *pauxent, bool useaux,
114 void *dhandle)
116 debug_type type;
118 if ((ntype & ~N_BTMASK) != 0)
120 int newtype;
122 newtype = DECREF (ntype);
124 if (ISPTR (ntype))
126 type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
127 pauxent, useaux, dhandle);
128 type = debug_make_pointer_type (dhandle, type);
130 else if (ISFCN (ntype))
132 type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
133 pauxent, useaux, dhandle);
134 type = debug_make_function_type (dhandle, type, (debug_type *) NULL,
135 false);
137 else if (ISARY (ntype))
139 int n;
141 if (pauxent == NULL)
142 n = 0;
143 else
145 unsigned short *dim;
146 int i;
148 /* FIXME: If pauxent->x_sym.x_tagndx.l == 0, gdb sets
149 the c_naux field of the syment to 0. */
151 /* Move the dimensions down, so that the next array
152 picks up the next one. */
153 dim = pauxent->x_sym.x_fcnary.x_ary.x_dimen;
154 n = dim[0];
155 for (i = 0; *dim != 0 && i < DIMNUM - 1; i++, dim++)
156 *dim = *(dim + 1);
157 *dim = 0;
160 type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
161 pauxent, false, dhandle);
162 type = debug_make_array_type (dhandle, type,
163 parse_coff_base_type (abfd, symbols,
164 types,
165 coff_symno,
166 T_INT,
167 NULL, dhandle),
168 0, n - 1, false);
170 else
172 non_fatal (_("parse_coff_type: Bad type code 0x%x"), ntype);
173 return DEBUG_TYPE_NULL;
176 return type;
179 if (pauxent != NULL && (int32_t) pauxent->x_sym.x_tagndx.u32 > 0)
181 debug_type *slot;
183 /* This is a reference to an existing type. FIXME: gdb checks
184 that the class is not C_STRTAG, nor C_UNTAG, nor C_ENTAG. */
185 slot = coff_get_slot (dhandle, types, pauxent->x_sym.x_tagndx.u32);
186 if (*slot != DEBUG_TYPE_NULL)
187 return *slot;
188 else
189 return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
192 /* If the aux entry has already been used for something, useaux will
193 have been set to false, indicating that parse_coff_base_type
194 should not use it. We need to do it this way, rather than simply
195 passing pauxent as NULL, because we need to be able handle
196 multiple array dimensions while still discarding pauxent after
197 having handled all of them. */
198 if (! useaux)
199 pauxent = NULL;
201 return parse_coff_base_type (abfd, symbols, types, coff_symno, ntype,
202 pauxent, dhandle);
205 /* Parse a basic COFF type in NTYPE. */
207 static debug_type
208 parse_coff_base_type (bfd *abfd, struct coff_symbols *symbols,
209 struct coff_types **types, long coff_symno, int ntype,
210 union internal_auxent *pauxent, void *dhandle)
212 debug_type ret;
213 const char *name = NULL;
215 switch (ntype)
217 default:
218 ret = debug_make_void_type (dhandle);
219 break;
221 case T_NULL:
222 case T_VOID:
223 ret = debug_make_void_type (dhandle);
224 name = "void";
225 break;
227 case T_CHAR:
228 ret = debug_make_int_type (dhandle, 1, false);
229 name = "char";
230 break;
232 case T_SHORT:
233 ret = debug_make_int_type (dhandle, 2, false);
234 name = "short";
235 break;
237 case T_INT:
238 /* FIXME: Perhaps the size should depend upon the architecture. */
239 ret = debug_make_int_type (dhandle, 4, false);
240 name = "int";
241 break;
243 case T_LONG:
244 ret = debug_make_int_type (dhandle, 4, false);
245 name = "long";
246 break;
248 case T_FLOAT:
249 ret = debug_make_float_type (dhandle, 4);
250 name = "float";
251 break;
253 case T_DOUBLE:
254 ret = debug_make_float_type (dhandle, 8);
255 name = "double";
256 break;
258 case T_LNGDBL:
259 ret = debug_make_float_type (dhandle, 12);
260 name = "long double";
261 break;
263 case T_UCHAR:
264 ret = debug_make_int_type (dhandle, 1, true);
265 name = "unsigned char";
266 break;
268 case T_USHORT:
269 ret = debug_make_int_type (dhandle, 2, true);
270 name = "unsigned short";
271 break;
273 case T_UINT:
274 ret = debug_make_int_type (dhandle, 4, true);
275 name = "unsigned int";
276 break;
278 case T_ULONG:
279 ret = debug_make_int_type (dhandle, 4, true);
280 name = "unsigned long";
281 break;
283 case T_STRUCT:
284 if (pauxent == NULL)
285 ret = debug_make_struct_type (dhandle, true, 0,
286 (debug_field *) NULL);
287 else
288 ret = parse_coff_struct_type (abfd, symbols, types, ntype, pauxent,
289 dhandle);
290 break;
292 case T_UNION:
293 if (pauxent == NULL)
294 ret = debug_make_struct_type (dhandle, false, 0, (debug_field *) NULL);
295 else
296 ret = parse_coff_struct_type (abfd, symbols, types, ntype, pauxent,
297 dhandle);
298 break;
300 case T_ENUM:
301 if (pauxent == NULL)
302 ret = debug_make_enum_type (dhandle, (const char **) NULL,
303 (bfd_signed_vma *) NULL);
304 else
305 ret = parse_coff_enum_type (abfd, symbols, types, pauxent, dhandle);
306 break;
309 if (name != NULL)
310 ret = debug_name_type (dhandle, name, ret);
312 debug_type *slot = coff_get_slot (dhandle, types, coff_symno);
313 *slot = ret;
315 return ret;
318 /* Parse a struct type. */
320 static debug_type
321 parse_coff_struct_type (bfd *abfd, struct coff_symbols *symbols,
322 struct coff_types **types, int ntype,
323 union internal_auxent *pauxent, void *dhandle)
325 long symend;
326 int alloc;
327 debug_field *fields, *xfields;
328 int count;
329 bool done;
331 symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.u32;
333 alloc = 10;
334 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
335 count = 0;
337 done = false;
338 while (! done
339 && symbols->coff_symno < symend
340 && symbols->symno < symbols->symcount)
342 asymbol *sym;
343 long this_coff_symno;
344 struct internal_syment syment;
345 union internal_auxent auxent;
346 union internal_auxent *psubaux;
347 bfd_vma bitpos = 0, bitsize = 0;
349 sym = symbols->syms[symbols->symno];
351 if (! bfd_coff_get_syment (abfd, sym, &syment))
353 non_fatal (_("bfd_coff_get_syment failed: %s"),
354 bfd_errmsg (bfd_get_error ()));
355 free (fields);
356 return DEBUG_TYPE_NULL;
359 this_coff_symno = symbols->coff_symno;
361 ++symbols->symno;
362 symbols->coff_symno += 1 + syment.n_numaux;
364 if (syment.n_numaux == 0)
365 psubaux = NULL;
366 else
368 if (! bfd_coff_get_auxent (abfd, sym, 0, &auxent))
370 non_fatal (_("bfd_coff_get_auxent failed: %s"),
371 bfd_errmsg (bfd_get_error ()));
372 free (fields);
373 return DEBUG_TYPE_NULL;
375 psubaux = &auxent;
378 switch (syment.n_sclass)
380 case C_MOS:
381 case C_MOU:
382 bitpos = 8 * bfd_asymbol_value (sym);
383 bitsize = 0;
384 break;
386 case C_FIELD:
387 bitpos = bfd_asymbol_value (sym);
388 if (psubaux != NULL)
389 bitsize = psubaux->x_sym.x_misc.x_lnsz.x_size;
390 break;
392 case C_EOS:
393 done = true;
394 break;
397 if (! done)
399 debug_type ftype;
400 debug_field f;
402 ftype = parse_coff_type (abfd, symbols, types, this_coff_symno,
403 syment.n_type, psubaux, true, dhandle);
404 f = debug_make_field (dhandle, bfd_asymbol_name (sym), ftype,
405 bitpos, bitsize, DEBUG_VISIBILITY_PUBLIC);
406 if (f == DEBUG_FIELD_NULL)
408 free (fields);
409 return DEBUG_TYPE_NULL;
412 if (count + 1 >= alloc)
414 alloc += 10;
415 fields = ((debug_field *)
416 xrealloc (fields, alloc * sizeof *fields));
419 fields[count] = f;
420 ++count;
424 fields[count] = DEBUG_FIELD_NULL;
425 xfields = debug_xalloc (dhandle, (count + 1) * sizeof (*fields));
426 memcpy (xfields, fields, (count + 1) * sizeof (*fields));
427 free (fields);
429 return debug_make_struct_type (dhandle, ntype == T_STRUCT,
430 pauxent->x_sym.x_misc.x_lnsz.x_size,
431 xfields);
434 /* Parse an enum type. */
436 static debug_type
437 parse_coff_enum_type (bfd *abfd, struct coff_symbols *symbols,
438 struct coff_types **types ATTRIBUTE_UNUSED,
439 union internal_auxent *pauxent, void *dhandle)
441 long symend;
442 int alloc;
443 const char **names, **xnames;
444 bfd_signed_vma *vals, *xvals;
445 int count;
446 bool done;
448 symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.u32;
450 alloc = 10;
451 names = (const char **) xmalloc (alloc * sizeof *names);
452 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *vals);
453 count = 0;
455 done = false;
456 while (! done
457 && symbols->coff_symno < symend
458 && symbols->symno < symbols->symcount)
460 asymbol *sym;
461 struct internal_syment syment;
463 sym = symbols->syms[symbols->symno];
465 if (! bfd_coff_get_syment (abfd, sym, &syment))
467 non_fatal (_("bfd_coff_get_syment failed: %s"),
468 bfd_errmsg (bfd_get_error ()));
469 free (names);
470 free (vals);
471 return DEBUG_TYPE_NULL;
474 ++symbols->symno;
475 symbols->coff_symno += 1 + syment.n_numaux;
477 switch (syment.n_sclass)
479 case C_MOE:
480 if (count + 1 >= alloc)
482 alloc += 10;
483 names = ((const char **)
484 xrealloc (names, alloc * sizeof *names));
485 vals = ((bfd_signed_vma *)
486 xrealloc (vals, alloc * sizeof *vals));
489 names[count] = bfd_asymbol_name (sym);
490 vals[count] = bfd_asymbol_value (sym);
491 ++count;
492 break;
494 case C_EOS:
495 done = true;
496 break;
500 names[count] = NULL;
501 vals[count] = 0;
502 xnames = debug_xalloc (dhandle, (count + 1) * sizeof (*names));
503 memcpy (xnames, names, (count + 1) * sizeof (*names));
504 free (names);
505 xvals = debug_xalloc (dhandle, (count + 1) * sizeof (*vals));
506 memcpy (xvals, vals, (count + 1) * sizeof (*vals));
507 free (vals);
509 return debug_make_enum_type (dhandle, xnames, xvals);
512 /* Handle a single COFF symbol. */
514 static bool
515 parse_coff_symbol (bfd *abfd ATTRIBUTE_UNUSED, struct coff_types **types,
516 asymbol *sym, long coff_symno,
517 struct internal_syment *psyment, void *dhandle,
518 debug_type type, bool within_function)
520 switch (psyment->n_sclass)
522 case C_NULL:
523 break;
525 case C_AUTO:
526 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
527 DEBUG_LOCAL, bfd_asymbol_value (sym)))
528 return false;
529 break;
531 case C_WEAKEXT:
532 case C_EXT:
533 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
534 DEBUG_GLOBAL, bfd_asymbol_value (sym)))
535 return false;
536 break;
538 case C_STAT:
539 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
540 (within_function
541 ? DEBUG_LOCAL_STATIC
542 : DEBUG_STATIC),
543 bfd_asymbol_value (sym)))
544 return false;
545 break;
547 case C_REG:
548 /* FIXME: We may need to convert the register number. */
549 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
550 DEBUG_REGISTER, bfd_asymbol_value (sym)))
551 return false;
552 break;
554 case C_LABEL:
555 break;
557 case C_ARG:
558 if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
559 DEBUG_PARM_STACK, bfd_asymbol_value (sym)))
560 return false;
561 break;
563 case C_REGPARM:
564 /* FIXME: We may need to convert the register number. */
565 if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
566 DEBUG_PARM_REG, bfd_asymbol_value (sym)))
567 return false;
568 break;
570 case C_TPDEF:
571 type = debug_name_type (dhandle, bfd_asymbol_name (sym), type);
572 if (type == DEBUG_TYPE_NULL)
573 return false;
574 break;
576 case C_STRTAG:
577 case C_UNTAG:
578 case C_ENTAG:
580 debug_type *slot;
582 type = debug_tag_type (dhandle, bfd_asymbol_name (sym), type);
583 if (type == DEBUG_TYPE_NULL)
584 return false;
586 /* Store the named type into the slot, so that references get
587 the name. */
588 slot = coff_get_slot (dhandle, types, coff_symno);
589 *slot = type;
591 break;
593 default:
594 break;
597 return true;
600 /* Determine if a symbol has external visibility. */
602 static bool
603 external_coff_symbol_p (int sym_class)
605 switch (sym_class)
607 case C_EXT:
608 case C_WEAKEXT:
609 return true;
610 default:
611 break;
613 return false;
616 /* This is the main routine. It looks through all the symbols and
617 handles them. */
619 bool
620 parse_coff (bfd *abfd, asymbol **syms, long symcount, void *dhandle)
622 struct coff_symbols symbols;
623 struct coff_types *types;
624 long next_c_file;
625 const char *fnname;
626 int fnclass;
627 int fntype;
628 bfd_vma fnend;
629 alent *linenos;
630 bool within_function;
631 long this_coff_symno;
633 symbols.syms = syms;
634 symbols.symcount = symcount;
635 symbols.symno = 0;
636 symbols.coff_symno = 0;
638 types= NULL;
640 next_c_file = -1;
641 fnname = NULL;
642 fnclass = 0;
643 fntype = 0;
644 fnend = 0;
645 linenos = NULL;
646 within_function = false;
648 while (symbols.symno < symcount)
650 asymbol *sym;
651 const char *name;
652 struct internal_syment syment;
653 union internal_auxent auxent;
654 union internal_auxent *paux;
655 debug_type type;
657 sym = syms[symbols.symno];
659 if (! bfd_coff_get_syment (abfd, sym, &syment))
661 non_fatal (_("bfd_coff_get_syment failed: %s"),
662 bfd_errmsg (bfd_get_error ()));
663 return false;
666 name = bfd_asymbol_name (sym);
668 this_coff_symno = symbols.coff_symno;
670 ++symbols.symno;
671 symbols.coff_symno += 1 + syment.n_numaux;
673 /* We only worry about the first auxent, because that is the
674 only one which is relevant for debugging information. */
675 if (syment.n_numaux == 0)
676 paux = NULL;
677 else
679 if (! bfd_coff_get_auxent (abfd, sym, 0, &auxent))
681 non_fatal (_("bfd_coff_get_auxent failed: %s"),
682 bfd_errmsg (bfd_get_error ()));
683 return false;
685 paux = &auxent;
688 if (this_coff_symno == next_c_file && syment.n_sclass != C_FILE)
690 /* The last C_FILE symbol points to the first external
691 symbol. */
692 if (! debug_set_filename (dhandle, "*globals*"))
693 return false;
696 switch (syment.n_sclass)
698 case C_EFCN:
699 case C_EXTDEF:
700 case C_ULABEL:
701 case C_USTATIC:
702 case C_LINE:
703 case C_ALIAS:
704 case C_HIDDEN:
705 /* Just ignore these classes. */
706 break;
708 case C_FILE:
709 next_c_file = syment.n_value;
710 if (! debug_set_filename (dhandle, name))
711 return false;
712 break;
714 case C_STAT:
715 /* Ignore static symbols with a type of T_NULL. These
716 represent section entries. */
717 if (syment.n_type == T_NULL)
718 break;
719 /* Fall through. */
720 case C_WEAKEXT:
721 case C_EXT:
722 if (ISFCN (syment.n_type))
724 fnname = name;
725 fnclass = syment.n_sclass;
726 fntype = syment.n_type;
727 if (syment.n_numaux > 0)
728 fnend = bfd_asymbol_value (sym) + auxent.x_sym.x_misc.x_fsize;
729 else
730 fnend = 0;
731 linenos = BFD_SEND (abfd, _get_lineno, (abfd, sym));
732 break;
734 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
735 syment.n_type, paux, true, dhandle);
736 if (type == DEBUG_TYPE_NULL)
737 return false;
738 if (! parse_coff_symbol (abfd, &types, sym, this_coff_symno, &syment,
739 dhandle, type, within_function))
740 return false;
741 break;
743 case C_FCN:
744 if (strcmp (name, ".bf") == 0)
746 if (fnname == NULL)
748 non_fatal (_("%ld: .bf without preceding function"),
749 this_coff_symno);
750 return false;
753 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
754 DECREF (fntype), paux, false, dhandle);
755 if (type == DEBUG_TYPE_NULL)
756 return false;
758 if (! debug_record_function (dhandle, fnname, type,
759 external_coff_symbol_p (fnclass),
760 bfd_asymbol_value (sym)))
761 return false;
763 if (linenos != NULL)
765 int base;
766 bfd_vma addr;
768 if (syment.n_numaux == 0)
769 base = 0;
770 else
771 base = auxent.x_sym.x_misc.x_lnsz.x_lnno - 1;
773 addr = bfd_section_vma (bfd_asymbol_section (sym));
775 ++linenos;
777 while (linenos->line_number != 0)
779 if (! debug_record_line (dhandle,
780 linenos->line_number + base,
781 linenos->u.offset + addr))
782 return false;
783 ++linenos;
787 fnname = NULL;
788 linenos = NULL;
789 fnclass = 0;
790 fntype = 0;
792 within_function = true;
794 else if (strcmp (name, ".ef") == 0)
796 if (! within_function)
798 non_fatal (_("%ld: unexpected .ef\n"), this_coff_symno);
799 return false;
802 if (bfd_asymbol_value (sym) > fnend)
803 fnend = bfd_asymbol_value (sym);
804 if (! debug_end_function (dhandle, fnend))
805 return false;
807 fnend = 0;
808 within_function = false;
810 break;
812 case C_BLOCK:
813 if (strcmp (name, ".bb") == 0)
815 if (! debug_start_block (dhandle, bfd_asymbol_value (sym)))
816 return false;
818 else if (strcmp (name, ".eb") == 0)
820 if (! debug_end_block (dhandle, bfd_asymbol_value (sym)))
821 return false;
823 break;
825 default:
826 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
827 syment.n_type, paux, true, dhandle);
828 if (type == DEBUG_TYPE_NULL)
829 return false;
830 if (! parse_coff_symbol (abfd, &types, sym, this_coff_symno, &syment,
831 dhandle, type, within_function))
832 return false;
833 break;
837 return true;