1 /* Stabs in sections linking support.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02110-1301, USA. */
22 /* This file contains support for linking stabs in sections, as used
28 #include "aout/stab_gnu.h"
29 #include "safe-ctype.h"
31 /* Stabs entries use a 12 byte format:
32 4 byte string table index
34 1 byte stab other field
35 2 byte stab desc field
37 FIXME: This will have to change for a 64 bit object format.
39 The stabs symbols are divided into compilation units. For the
40 first entry in each unit, the type of 0, the value is the length of
41 the string table for this unit, and the desc field is the number of
42 stabs symbols for this unit. */
51 /* A linked list of totals that we have found for a particular header
52 file. A total is a unique identifier for a particular BINCL...EINCL
53 sequence of STABs that can be used to identify duplicate sequences.
54 It consists of three fields, 'sum_chars' which is the sum of all the
55 STABS characters; 'num_chars' which is the number of these charactes
56 and 'symb' which is a buffer of all the symbols in the sequence. This
57 buffer is only checked as a last resort. */
59 struct stab_link_includes_totals
61 struct stab_link_includes_totals *next;
62 bfd_vma sum_chars; /* Accumulated sum of STABS characters. */
63 bfd_vma num_chars; /* Number of STABS characters. */
64 const char* symb; /* The STABS characters themselves. */
67 /* An entry in the header file hash table. */
69 struct stab_link_includes_entry
71 struct bfd_hash_entry root;
72 /* List of totals we have found for this file. */
73 struct stab_link_includes_totals *totals;
76 /* This structure is used to hold a list of N_BINCL symbols, some of
77 which might be converted into N_EXCL symbols. */
81 /* The next symbol to convert. */
82 struct stab_excl_list *next;
83 /* The offset to this symbol in the section contents. */
85 /* The value to use for the symbol. */
87 /* The type of this symbol (N_BINCL or N_EXCL). */
91 /* This structure is stored with each .stab section. */
93 struct stab_section_info
95 /* This is a linked list of N_BINCL symbols which should be
96 converted into N_EXCL symbols. */
97 struct stab_excl_list *excls;
99 /* This is used to map input stab offsets within their sections
100 to output stab offsets, to take into account stabs that have
101 been deleted. If it is NULL, the output offsets are the same
102 as the input offsets, because no stabs have been deleted from
103 this section. Otherwise the i'th entry is the number of
104 bytes of stabs that have been deleted prior to the i'th
106 bfd_size_type *cumulative_skips;
108 /* This is an array of string indices. For each stab symbol, we
109 store the string index here. If a stab symbol should not be
110 included in the final output, the string index is -1. */
111 bfd_size_type stridxs[1];
115 /* The function to create a new entry in the header file hash table. */
117 static struct bfd_hash_entry *
118 stab_link_includes_newfunc (struct bfd_hash_entry *entry,
119 struct bfd_hash_table *table,
122 struct stab_link_includes_entry *ret =
123 (struct stab_link_includes_entry *) entry;
125 /* Allocate the structure if it has not already been allocated by a
128 ret = bfd_hash_allocate (table,
129 sizeof (struct stab_link_includes_entry));
133 /* Call the allocation method of the superclass. */
134 ret = ((struct stab_link_includes_entry *)
135 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
137 /* Set local fields. */
140 return (struct bfd_hash_entry *) ret;
143 /* This function is called for each input file from the add_symbols
144 pass of the linker. */
147 _bfd_link_section_stabs (bfd *abfd,
148 struct stab_info *sinfo,
150 asection *stabstrsec,
152 bfd_size_type *pstring_offset)
155 bfd_size_type count, amt;
156 struct stab_section_info *secinfo;
157 bfd_byte *stabbuf = NULL;
158 bfd_byte *stabstrbuf = NULL;
159 bfd_byte *sym, *symend;
160 bfd_size_type stroff, next_stroff, skip;
161 bfd_size_type *pstridx;
163 if (stabsec->size == 0
164 || stabstrsec->size == 0)
165 /* This file does not contain stabs debugging information. */
168 if (stabsec->size % STABSIZE != 0)
169 /* Something is wrong with the format of these stab symbols.
170 Don't try to optimize them. */
173 if ((stabstrsec->flags & SEC_RELOC) != 0)
174 /* We shouldn't see relocations in the strings, and we aren't
175 prepared to handle them. */
178 if ((stabsec->output_section != NULL
179 && bfd_is_abs_section (stabsec->output_section))
180 || (stabstrsec->output_section != NULL
181 && bfd_is_abs_section (stabstrsec->output_section)))
182 /* At least one of the sections is being discarded from the
183 link, so we should just ignore them. */
188 if (sinfo->stabstr == NULL)
190 /* Initialize the stabs information we need to keep track of. */
192 sinfo->strings = _bfd_stringtab_init ();
193 if (sinfo->strings == NULL)
195 /* Make sure the first byte is zero. */
196 (void) _bfd_stringtab_add (sinfo->strings, "", TRUE, TRUE);
197 if (! bfd_hash_table_init_n (&sinfo->includes,
198 stab_link_includes_newfunc,
201 sinfo->stabstr = bfd_make_section_anyway (abfd, ".stabstr");
202 if (sinfo->stabstr == NULL)
204 sinfo->stabstr->flags |= (SEC_HAS_CONTENTS | SEC_READONLY
205 | SEC_DEBUGGING | SEC_LINKER_CREATED);
208 /* Initialize the information we are going to store for this .stab
210 count = stabsec->size / STABSIZE;
212 amt = sizeof (struct stab_section_info);
213 amt += (count - 1) * sizeof (bfd_size_type);
214 *psecinfo = bfd_alloc (abfd, amt);
215 if (*psecinfo == NULL)
218 secinfo = (struct stab_section_info *) *psecinfo;
219 secinfo->excls = NULL;
220 stabsec->rawsize = stabsec->size;
221 secinfo->cumulative_skips = NULL;
222 memset (secinfo->stridxs, 0, (size_t) count * sizeof (bfd_size_type));
224 /* Read the stabs information from abfd. */
225 if (!bfd_malloc_and_get_section (abfd, stabsec, &stabbuf)
226 || !bfd_malloc_and_get_section (abfd, stabstrsec, &stabstrbuf))
229 /* Look through the stabs symbols, work out the new string indices,
230 and identify N_BINCL symbols which can be eliminated. */
232 /* The stabs sections can be split when
233 -split-by-reloc/-split-by-file is used. We must keep track of
234 each stab section's place in the single concatenated string
236 next_stroff = pstring_offset ? *pstring_offset : 0;
239 symend = stabbuf + stabsec->size;
240 for (sym = stabbuf, pstridx = secinfo->stridxs;
242 sym += STABSIZE, ++pstridx)
244 bfd_size_type symstroff;
249 /* This symbol has already been handled by an N_BINCL pass. */
256 /* Special type 0 stabs indicate the offset to the next
257 string table. We only copy the very first one. */
258 stroff = next_stroff;
259 next_stroff += bfd_get_32 (abfd, sym + 8);
261 *pstring_offset = next_stroff;
264 *pstridx = (bfd_size_type) -1;
271 /* Store the string in the hash table, and record the index. */
272 symstroff = stroff + bfd_get_32 (abfd, sym + STRDXOFF);
273 if (symstroff >= stabstrsec->size)
275 (*_bfd_error_handler)
276 (_("%B(%A+0x%lx): Stabs entry has invalid string index."),
277 abfd, stabsec, (long) (sym - stabbuf));
278 bfd_set_error (bfd_error_bad_value);
281 string = (char *) stabstrbuf + symstroff;
282 *pstridx = _bfd_stringtab_add (sinfo->strings, string, TRUE, TRUE);
284 /* An N_BINCL symbol indicates the start of the stabs entries
285 for a header file. We need to scan ahead to the next N_EINCL
286 symbol, ignoring nesting, adding up all the characters in the
287 symbol names, not including the file numbers in types (the
288 first number after an open parenthesis). */
289 if (type == (int) N_BINCL)
298 struct stab_link_includes_entry * incl_entry;
299 struct stab_link_includes_totals * t;
300 struct stab_excl_list * ne;
302 symb = symb_rover = NULL;
303 sum_chars = num_chars = 0;
306 for (incl_sym = sym + STABSIZE;
308 incl_sym += STABSIZE)
312 incl_type = incl_sym[TYPEOFF];
315 else if (incl_type == (int) N_EXCL)
317 else if (incl_type == (int) N_EINCL)
323 else if (incl_type == (int) N_BINCL)
329 str = ((char *) stabstrbuf
331 + bfd_get_32 (abfd, incl_sym + STRDXOFF));
332 for (; *str != '\0'; str++)
334 if (num_chars >= buf_len)
336 buf_len += 32 * 1024;
337 symb = bfd_realloc (symb, buf_len);
340 symb_rover = symb + num_chars;
342 * symb_rover ++ = * str;
347 /* Skip the file number. */
349 while (ISDIGIT (*str))
357 BFD_ASSERT (num_chars == (bfd_vma) (symb_rover - symb));
359 /* If we have already included a header file with the same
360 value, then replaced this one with an N_EXCL symbol. */
361 incl_entry = (struct stab_link_includes_entry * )
362 bfd_hash_lookup (&sinfo->includes, string, TRUE, TRUE);
363 if (incl_entry == NULL)
366 for (t = incl_entry->totals; t != NULL; t = t->next)
367 if (t->sum_chars == sum_chars
368 && t->num_chars == num_chars
369 && memcmp (t->symb, symb, num_chars) == 0)
372 /* Record this symbol, so that we can set the value
375 ne = bfd_alloc (abfd, amt);
378 ne->offset = sym - stabbuf;
380 ne->type = (int) N_BINCL;
381 ne->next = secinfo->excls;
386 /* This is the first time we have seen this header file
387 with this set of stabs strings. */
388 t = bfd_hash_allocate (&sinfo->includes, sizeof *t);
391 t->sum_chars = sum_chars;
392 t->num_chars = num_chars;
393 t->symb = bfd_realloc (symb, num_chars); /* Trim data down. */
394 t->next = incl_entry->totals;
395 incl_entry->totals = t;
399 bfd_size_type *incl_pstridx;
401 /* We have seen this header file before. Tell the final
402 pass to change the type to N_EXCL. */
403 ne->type = (int) N_EXCL;
405 /* Free off superfluous symbols. */
408 /* Mark the skipped symbols. */
411 for (incl_sym = sym + STABSIZE, incl_pstridx = pstridx + 1;
413 incl_sym += STABSIZE, ++incl_pstridx)
417 incl_type = incl_sym[TYPEOFF];
419 if (incl_type == (int) N_EINCL)
423 *incl_pstridx = (bfd_size_type) -1;
429 else if (incl_type == (int) N_BINCL)
431 else if (incl_type == (int) N_EXCL)
432 /* Keep existing exclusion marks. */
436 *incl_pstridx = (bfd_size_type) -1;
449 /* We need to set the section sizes such that the linker will
450 compute the output section sizes correctly. We set the .stab
451 size to not include the entries we don't want. We set
452 SEC_EXCLUDE for the .stabstr section, so that it will be dropped
453 from the link. We record the size of the strtab in the first
454 .stabstr section we saw, and make sure we don't set SEC_EXCLUDE
456 stabsec->size = (count - skip) * STABSIZE;
457 if (stabsec->size == 0)
458 stabsec->flags |= SEC_EXCLUDE;
459 stabstrsec->flags |= SEC_EXCLUDE;
460 sinfo->stabstr->size = _bfd_stringtab_size (sinfo->strings);
462 /* Calculate the `cumulative_skips' array now that stabs have been
463 deleted for this section. */
467 bfd_size_type i, offset;
468 bfd_size_type *pskips;
470 amt = count * sizeof (bfd_size_type);
471 secinfo->cumulative_skips = bfd_alloc (abfd, amt);
472 if (secinfo->cumulative_skips == NULL)
475 pskips = secinfo->cumulative_skips;
476 pstridx = secinfo->stridxs;
479 for (i = 0; i < count; i++, pskips++, pstridx++)
482 if (*pstridx == (bfd_size_type) -1)
486 BFD_ASSERT (offset != 0);
494 if (stabstrbuf != NULL)
499 /* This function is called for each input file before the stab
500 section is relocated. It discards stab entries for discarded
501 functions and variables. The function returns TRUE iff
502 any entries have been deleted.
506 _bfd_discard_section_stabs (bfd *abfd,
509 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
512 bfd_size_type count, amt;
513 struct stab_section_info *secinfo;
514 bfd_byte *stabbuf = NULL;
515 bfd_byte *sym, *symend;
517 bfd_size_type *pstridx;
520 if (stabsec->size == 0)
521 /* This file does not contain stabs debugging information. */
524 if (stabsec->size % STABSIZE != 0)
525 /* Something is wrong with the format of these stab symbols.
526 Don't try to optimize them. */
529 if ((stabsec->output_section != NULL
530 && bfd_is_abs_section (stabsec->output_section)))
531 /* At least one of the sections is being discarded from the
532 link, so we should just ignore them. */
535 /* We should have initialized our data in _bfd_link_stab_sections.
536 If there was some bizarre error reading the string sections, though,
537 we might not have. Bail rather than asserting. */
538 if (psecinfo == NULL)
541 count = stabsec->rawsize / STABSIZE;
542 secinfo = (struct stab_section_info *) psecinfo;
544 /* Read the stabs information from abfd. */
545 if (!bfd_malloc_and_get_section (abfd, stabsec, &stabbuf))
548 /* Look through the stabs symbols and discard any information for
549 discarded functions. */
553 symend = stabbuf + stabsec->rawsize;
554 for (sym = stabbuf, pstridx = secinfo->stridxs;
556 sym += STABSIZE, ++pstridx)
560 if (*pstridx == (bfd_size_type) -1)
561 /* This stab was deleted in a previous pass. */
566 if (type == (int) N_FUN)
568 int strx = bfd_get_32 (abfd, sym + STRDXOFF);
581 if ((*reloc_symbol_deleted_p) (sym + VALOFF - stabbuf, cookie))
590 else if (deleting == -1)
592 /* Outside of a function. Check for deleted variables. */
593 if (type == (int) N_STSYM || type == (int) N_LCSYM)
594 if ((*reloc_symbol_deleted_p) (sym + VALOFF - stabbuf, cookie))
599 /* We should also check for N_GSYM entries which reference a
600 deleted global, but those are less harmful to debuggers
601 and would require parsing the stab strings. */
608 /* Shrink the stabsec as needed. */
609 stabsec->size -= skip * STABSIZE;
610 if (stabsec->size == 0)
611 stabsec->flags |= SEC_EXCLUDE;
613 /* Recalculate the `cumulative_skips' array now that stabs have been
614 deleted for this section. */
618 bfd_size_type i, offset;
619 bfd_size_type *pskips;
621 if (secinfo->cumulative_skips == NULL)
623 amt = count * sizeof (bfd_size_type);
624 secinfo->cumulative_skips = bfd_alloc (abfd, amt);
625 if (secinfo->cumulative_skips == NULL)
629 pskips = secinfo->cumulative_skips;
630 pstridx = secinfo->stridxs;
633 for (i = 0; i < count; i++, pskips++, pstridx++)
636 if (*pstridx == (bfd_size_type) -1)
640 BFD_ASSERT (offset != 0);
651 /* Write out the stab section. This is called with the relocated
655 _bfd_write_section_stabs (bfd *output_bfd,
656 struct stab_info *sinfo,
661 struct stab_section_info *secinfo;
662 struct stab_excl_list *e;
663 bfd_byte *sym, *tosym, *symend;
664 bfd_size_type *pstridx;
666 secinfo = (struct stab_section_info *) *psecinfo;
669 return bfd_set_section_contents (output_bfd, stabsec->output_section,
670 contents, stabsec->output_offset,
673 /* Handle each N_BINCL entry. */
674 for (e = secinfo->excls; e != NULL; e = e->next)
678 BFD_ASSERT (e->offset < stabsec->rawsize);
679 excl_sym = contents + e->offset;
680 bfd_put_32 (output_bfd, e->val, excl_sym + VALOFF);
681 excl_sym[TYPEOFF] = e->type;
684 /* Copy over all the stabs symbols, omitting the ones we don't want,
685 and correcting the string indices for those we do want. */
687 symend = contents + stabsec->rawsize;
688 for (sym = contents, pstridx = secinfo->stridxs;
690 sym += STABSIZE, ++pstridx)
692 if (*pstridx != (bfd_size_type) -1)
695 memcpy (tosym, sym, STABSIZE);
696 bfd_put_32 (output_bfd, *pstridx, tosym + STRDXOFF);
698 if (sym[TYPEOFF] == 0)
700 /* This is the header symbol for the stabs section. We
701 don't really need one, since we have merged all the
702 input stabs sections into one, but we generate one
703 for the benefit of readers which expect to see one. */
704 BFD_ASSERT (sym == contents);
705 bfd_put_32 (output_bfd, _bfd_stringtab_size (sinfo->strings),
707 bfd_put_16 (output_bfd,
708 stabsec->output_section->size / STABSIZE - 1,
716 BFD_ASSERT ((bfd_size_type) (tosym - contents) == stabsec->size);
718 return bfd_set_section_contents (output_bfd, stabsec->output_section,
719 contents, (file_ptr) stabsec->output_offset,
723 /* Write out the .stabstr section. */
726 _bfd_write_stab_strings (bfd *output_bfd, struct stab_info *sinfo)
728 if (bfd_is_abs_section (sinfo->stabstr->output_section))
729 /* The section was discarded from the link. */
732 BFD_ASSERT ((sinfo->stabstr->output_offset
733 + _bfd_stringtab_size (sinfo->strings))
734 <= sinfo->stabstr->output_section->size);
736 if (bfd_seek (output_bfd,
737 (file_ptr) (sinfo->stabstr->output_section->filepos
738 + sinfo->stabstr->output_offset),
742 if (! _bfd_stringtab_emit (output_bfd, sinfo->strings))
745 /* We no longer need the stabs information. */
746 _bfd_stringtab_free (sinfo->strings);
747 bfd_hash_table_free (&sinfo->includes);
752 /* Adjust an address in the .stab section. Given OFFSET within
753 STABSEC, this returns the new offset in the adjusted stab section,
754 or -1 if the address refers to a stab which has been removed. */
757 _bfd_stab_section_offset (asection *stabsec,
761 struct stab_section_info *secinfo;
763 secinfo = (struct stab_section_info *) psecinfo;
768 if (offset >= stabsec->rawsize)
769 return offset - stabsec->rawsize + stabsec->size;
771 if (secinfo->cumulative_skips)
775 i = offset / STABSIZE;
777 if (secinfo->stridxs [i] == (bfd_size_type) -1)
780 return offset - secinfo->cumulative_skips [i];