1 /* Stabs in sections linking support.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
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 02111-1307, 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 hash table used for header files with N_BINCL entries. */
53 struct stab_link_includes_table
55 struct bfd_hash_table root;
58 /* A linked list of totals that we have found for a particular header
61 struct stab_link_includes_totals
63 struct stab_link_includes_totals *next;
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 /* Look up an entry in an the header file hash table. */
78 #define stab_link_includes_lookup(table, string, create, copy) \
79 ((struct stab_link_includes_entry *) \
80 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
82 /* This structure is used to hold a list of N_BINCL symbols, some of
83 which might be converted into N_EXCL symbols. */
87 /* The next symbol to convert. */
88 struct stab_excl_list *next;
89 /* The offset to this symbol in the section contents. */
91 /* The value to use for the symbol. */
93 /* The type of this symbol (N_BINCL or N_EXCL). */
97 /* This structure is stored with each .stab section. */
99 struct stab_section_info
101 /* This is a linked list of N_BINCL symbols which should be
102 converted into N_EXCL symbols. */
103 struct stab_excl_list *excls;
105 /* This is used to map input stab offsets within their sections
106 to output stab offsets, to take into account stabs that have
107 been deleted. If it is NULL, the output offsets are the same
108 as the input offsets, because no stabs have been deleted from
109 this section. Otherwise the i'th entry is the number of
110 bytes of stabs that have been deleted prior to the i'th
112 bfd_size_type *cumulative_skips;
114 /* This is an array of string indices. For each stab symbol, we
115 store the string index here. If a stab symbol should not be
116 included in the final output, the string index is -1. */
117 bfd_size_type stridxs[1];
120 /* This structure is used to keep track of stabs in sections
121 information while linking. */
125 /* A hash table used to hold stabs strings. */
126 struct bfd_strtab_hash *strings;
127 /* The header file hash table. */
128 struct stab_link_includes_table includes;
129 /* The first .stabstr section. */
133 static struct bfd_hash_entry *stab_link_includes_newfunc
134 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
136 /* The function to create a new entry in the header file hash table. */
138 static struct bfd_hash_entry *
139 stab_link_includes_newfunc (entry, table, string)
140 struct bfd_hash_entry *entry;
141 struct bfd_hash_table *table;
144 struct stab_link_includes_entry *ret =
145 (struct stab_link_includes_entry *) entry;
147 /* Allocate the structure if it has not already been allocated by a
149 if (ret == (struct stab_link_includes_entry *) NULL)
150 ret = ((struct stab_link_includes_entry *)
151 bfd_hash_allocate (table,
152 sizeof (struct stab_link_includes_entry)));
153 if (ret == (struct stab_link_includes_entry *) NULL)
154 return (struct bfd_hash_entry *) ret;
156 /* Call the allocation method of the superclass. */
157 ret = ((struct stab_link_includes_entry *)
158 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
161 /* Set local fields. */
165 return (struct bfd_hash_entry *) ret;
168 /* This function is called for each input file from the add_symbols
169 pass of the linker. */
172 _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_offset)
176 asection *stabstrsec;
178 bfd_size_type *pstring_offset;
181 struct stab_info *sinfo;
182 bfd_size_type count, amt;
183 struct stab_section_info *secinfo;
184 bfd_byte *stabbuf = NULL;
185 bfd_byte *stabstrbuf = NULL;
186 bfd_byte *sym, *symend;
187 bfd_size_type stroff, next_stroff, skip;
188 bfd_size_type *pstridx;
190 if (stabsec->_raw_size == 0
191 || stabstrsec->_raw_size == 0)
193 /* This file does not contain stabs debugging information. */
197 if (stabsec->_raw_size % STABSIZE != 0)
199 /* Something is wrong with the format of these stab symbols.
200 Don't try to optimize them. */
204 if ((stabstrsec->flags & SEC_RELOC) != 0)
206 /* We shouldn't see relocations in the strings, and we aren't
207 prepared to handle them. */
211 if ((stabsec->output_section != NULL
212 && bfd_is_abs_section (stabsec->output_section))
213 || (stabstrsec->output_section != NULL
214 && bfd_is_abs_section (stabstrsec->output_section)))
216 /* At least one of the sections is being discarded from the
217 link, so we should just ignore them. */
225 /* Initialize the stabs information we need to keep track of. */
227 amt = sizeof (struct stab_info);
228 *psinfo = (PTR) bfd_alloc (abfd, amt);
231 sinfo = (struct stab_info *) *psinfo;
232 sinfo->strings = _bfd_stringtab_init ();
233 if (sinfo->strings == NULL)
235 /* Make sure the first byte is zero. */
236 (void) _bfd_stringtab_add (sinfo->strings, "", TRUE, TRUE);
237 if (! bfd_hash_table_init_n (&sinfo->includes.root,
238 stab_link_includes_newfunc,
241 sinfo->stabstr = bfd_make_section_anyway (abfd, ".stabstr");
242 sinfo->stabstr->flags |= SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
245 sinfo = (struct stab_info *) *psinfo;
247 /* Initialize the information we are going to store for this .stab
250 count = stabsec->_raw_size / STABSIZE;
252 amt = sizeof (struct stab_section_info);
253 amt += (count - 1) * sizeof (bfd_size_type);
254 *psecinfo = bfd_alloc (abfd, amt);
255 if (*psecinfo == NULL)
258 secinfo = (struct stab_section_info *) *psecinfo;
259 secinfo->excls = NULL;
260 secinfo->cumulative_skips = NULL;
261 memset (secinfo->stridxs, 0, (size_t) count * sizeof (bfd_size_type));
263 /* Read the stabs information from abfd. */
265 stabbuf = (bfd_byte *) bfd_malloc (stabsec->_raw_size);
266 stabstrbuf = (bfd_byte *) bfd_malloc (stabstrsec->_raw_size);
267 if (stabbuf == NULL || stabstrbuf == NULL)
270 if (! bfd_get_section_contents (abfd, stabsec, stabbuf, (bfd_vma) 0,
272 || ! bfd_get_section_contents (abfd, stabstrsec, stabstrbuf, (bfd_vma) 0,
273 stabstrsec->_raw_size))
276 /* Look through the stabs symbols, work out the new string indices,
277 and identify N_BINCL symbols which can be eliminated. */
280 /* The stabs sections can be split when
281 -split-by-reloc/-split-by-file is used. We must keep track of
282 each stab section's place in the single concatenated string
284 next_stroff = pstring_offset ? *pstring_offset : 0;
287 symend = stabbuf + stabsec->_raw_size;
288 for (sym = stabbuf, pstridx = secinfo->stridxs;
290 sym += STABSIZE, ++pstridx)
292 bfd_size_type symstroff;
298 /* This symbol has already been handled by an N_BINCL pass. */
306 /* Special type 0 stabs indicate the offset to the next
307 string table. We only copy the very first one. */
308 stroff = next_stroff;
309 next_stroff += bfd_get_32 (abfd, sym + 8);
311 *pstring_offset = next_stroff;
314 *pstridx = (bfd_size_type) -1;
321 /* Store the string in the hash table, and record the index. */
322 symstroff = stroff + bfd_get_32 (abfd, sym + STRDXOFF);
323 if (symstroff >= stabstrsec->_raw_size)
325 (*_bfd_error_handler)
326 (_("%s(%s+0x%lx): Stabs entry has invalid string index."),
327 bfd_archive_filename (abfd),
328 bfd_get_section_name (abfd, stabsec),
329 (long) (sym - stabbuf));
330 bfd_set_error (bfd_error_bad_value);
333 string = (char *) stabstrbuf + symstroff;
334 *pstridx = _bfd_stringtab_add (sinfo->strings, string, TRUE, TRUE);
336 /* An N_BINCL symbol indicates the start of the stabs entries
337 for a header file. We need to scan ahead to the next N_EINCL
338 symbol, ignoring nesting, adding up all the characters in the
339 symbol names, not including the file numbers in types (the
340 first number after an open parenthesis). */
341 if (type == (int) N_BINCL)
346 struct stab_link_includes_entry *incl_entry;
347 struct stab_link_includes_totals *t;
348 struct stab_excl_list *ne;
352 for (incl_sym = sym + STABSIZE;
354 incl_sym += STABSIZE)
358 incl_type = incl_sym[TYPEOFF];
361 else if (incl_type == (int) N_EXCL)
363 else if (incl_type == (int) N_EINCL)
369 else if (incl_type == (int) N_BINCL)
375 str = ((char *) stabstrbuf
377 + bfd_get_32 (abfd, incl_sym + STRDXOFF));
378 for (; *str != '\0'; str++)
383 /* Skip the file number. */
385 while (ISDIGIT (*str))
393 /* If we have already included a header file with the same
394 value, then replaced this one with an N_EXCL symbol. */
395 incl_entry = stab_link_includes_lookup (&sinfo->includes, string,
397 if (incl_entry == NULL)
400 for (t = incl_entry->totals; t != NULL; t = t->next)
404 /* Record this symbol, so that we can set the value
407 ne = (struct stab_excl_list *) bfd_alloc (abfd, amt);
410 ne->offset = sym - stabbuf;
412 ne->type = (int) N_BINCL;
413 ne->next = secinfo->excls;
418 /* This is the first time we have seen this header file
419 with this set of stabs strings. */
420 t = ((struct stab_link_includes_totals *)
421 bfd_hash_allocate (&sinfo->includes.root, sizeof *t));
425 t->next = incl_entry->totals;
426 incl_entry->totals = t;
430 bfd_size_type *incl_pstridx;
432 /* We have seen this header file before. Tell the final
433 pass to change the type to N_EXCL. */
434 ne->type = (int) N_EXCL;
436 /* Mark the skipped symbols. */
439 for (incl_sym = sym + STABSIZE, incl_pstridx = pstridx + 1;
441 incl_sym += STABSIZE, ++incl_pstridx)
445 incl_type = incl_sym[TYPEOFF];
447 if (incl_type == (int) N_EINCL)
451 *incl_pstridx = (bfd_size_type) -1;
457 else if (incl_type == (int) N_BINCL)
459 else if (incl_type == (int) N_EXCL)
460 /* Keep existing exclusion marks. */
464 *incl_pstridx = (bfd_size_type) -1;
477 /* We need to set the section sizes such that the linker will
478 compute the output section sizes correctly. We set the .stab
479 size to not include the entries we don't want. We set
480 SEC_EXCLUDE for the .stabstr section, so that it will be dropped
481 from the link. We record the size of the strtab in the first
482 .stabstr section we saw, and make sure we don't set SEC_EXCLUDE
484 stabsec->_cooked_size = (count - skip) * STABSIZE;
485 if (stabsec->_cooked_size == 0)
486 stabsec->flags |= SEC_EXCLUDE;
487 stabstrsec->flags |= SEC_EXCLUDE;
488 sinfo->stabstr->_cooked_size = _bfd_stringtab_size (sinfo->strings);
490 /* Calculate the `cumulative_skips' array now that stabs have been
491 deleted for this section. */
495 bfd_size_type i, offset;
496 bfd_size_type *pskips;
498 amt = count * sizeof (bfd_size_type);
499 secinfo->cumulative_skips = (bfd_size_type *) bfd_alloc (abfd, amt);
500 if (secinfo->cumulative_skips == NULL)
503 pskips = secinfo->cumulative_skips;
504 pstridx = secinfo->stridxs;
507 for (i = 0; i < count; i++, pskips++, pstridx++)
510 if (*pstridx == (bfd_size_type) -1)
514 BFD_ASSERT (offset != 0);
522 if (stabstrbuf != NULL)
528 /* This function is called for each input file before the stab
529 section is relocated. It discards stab entries for discarded
530 functions and variables. The function returns TRUE iff
531 any entries have been deleted.
535 _bfd_discard_section_stabs (abfd, stabsec, psecinfo,
536 reloc_symbol_deleted_p, cookie)
540 bfd_boolean (*reloc_symbol_deleted_p) PARAMS ((bfd_vma, PTR));
543 bfd_size_type count, amt;
544 struct stab_section_info *secinfo;
545 bfd_byte *stabbuf = NULL;
546 bfd_byte *sym, *symend;
548 bfd_size_type *pstridx;
551 if (stabsec->_raw_size == 0)
553 /* This file does not contain stabs debugging information. */
557 if (stabsec->_raw_size % STABSIZE != 0)
559 /* Something is wrong with the format of these stab symbols.
560 Don't try to optimize them. */
564 if ((stabsec->output_section != NULL
565 && bfd_is_abs_section (stabsec->output_section)))
567 /* At least one of the sections is being discarded from the
568 link, so we should just ignore them. */
572 /* We should have initialized our data in _bfd_link_stab_sections.
573 If there was some bizarre error reading the string sections, though,
574 we might not have. Bail rather than asserting. */
575 if (psecinfo == NULL)
578 count = stabsec->_raw_size / STABSIZE;
579 secinfo = (struct stab_section_info *) psecinfo;
581 /* Read the stabs information from abfd. */
583 stabbuf = (bfd_byte *) bfd_malloc (stabsec->_raw_size);
587 if (! bfd_get_section_contents (abfd, stabsec, stabbuf, (bfd_vma) 0,
591 /* Look through the stabs symbols and discard any information for
592 discarded functions. */
597 symend = stabbuf + stabsec->_raw_size;
598 for (sym = stabbuf, pstridx = secinfo->stridxs;
600 sym += STABSIZE, ++pstridx)
604 if (*pstridx == (bfd_size_type) -1)
606 /* This stab was deleted in a previous pass. */
612 if (type == (int) N_FUN)
614 int strx = bfd_get_32 (abfd, sym + STRDXOFF);
627 if ((*reloc_symbol_deleted_p) (sym + VALOFF - stabbuf, cookie))
636 else if (deleting == -1)
638 /* Outside of a function. Check for deleted variables. */
639 if (type == (int) N_STSYM || type == (int) N_LCSYM)
640 if ((*reloc_symbol_deleted_p) (sym + VALOFF - stabbuf, cookie))
645 /* We should also check for N_GSYM entries which reference a
646 deleted global, but those are less harmful to debuggers
647 and would require parsing the stab strings. */
654 /* Shrink the stabsec as needed. */
655 stabsec->_cooked_size -= skip * STABSIZE;
656 if (stabsec->_cooked_size == 0)
657 stabsec->flags |= SEC_EXCLUDE;
659 /* Recalculate the `cumulative_skips' array now that stabs have been
660 deleted for this section. */
664 bfd_size_type i, offset;
665 bfd_size_type *pskips;
667 if (secinfo->cumulative_skips == NULL)
669 amt = count * sizeof (bfd_size_type);
670 secinfo->cumulative_skips = (bfd_size_type *) bfd_alloc (abfd, amt);
671 if (secinfo->cumulative_skips == NULL)
675 pskips = secinfo->cumulative_skips;
676 pstridx = secinfo->stridxs;
679 for (i = 0; i < count; i++, pskips++, pstridx++)
682 if (*pstridx == (bfd_size_type) -1)
686 BFD_ASSERT (offset != 0);
697 /* Write out the stab section. This is called with the relocated
701 _bfd_write_section_stabs (output_bfd, psinfo, stabsec, psecinfo, contents)
708 struct stab_info *sinfo;
709 struct stab_section_info *secinfo;
710 struct stab_excl_list *e;
711 bfd_byte *sym, *tosym, *symend;
712 bfd_size_type *pstridx;
714 sinfo = (struct stab_info *) *psinfo;
715 secinfo = (struct stab_section_info *) *psecinfo;
718 return bfd_set_section_contents (output_bfd, stabsec->output_section,
720 (file_ptr) stabsec->output_offset,
723 /* Handle each N_BINCL entry. */
724 for (e = secinfo->excls; e != NULL; e = e->next)
728 BFD_ASSERT (e->offset < stabsec->_raw_size);
729 excl_sym = contents + e->offset;
730 bfd_put_32 (output_bfd, e->val, excl_sym + VALOFF);
731 excl_sym[TYPEOFF] = e->type;
734 /* Copy over all the stabs symbols, omitting the ones we don't want,
735 and correcting the string indices for those we do want. */
737 symend = contents + stabsec->_raw_size;
738 for (sym = contents, pstridx = secinfo->stridxs;
740 sym += STABSIZE, ++pstridx)
742 if (*pstridx != (bfd_size_type) -1)
745 memcpy (tosym, sym, STABSIZE);
746 bfd_put_32 (output_bfd, *pstridx, tosym + STRDXOFF);
748 if (sym[TYPEOFF] == 0)
750 /* This is the header symbol for the stabs section. We
751 don't really need one, since we have merged all the
752 input stabs sections into one, but we generate one
753 for the benefit of readers which expect to see one. */
754 BFD_ASSERT (sym == contents);
755 bfd_put_32 (output_bfd, _bfd_stringtab_size (sinfo->strings),
757 bfd_put_16 (output_bfd,
758 stabsec->output_section->_raw_size / STABSIZE - 1,
766 BFD_ASSERT ((bfd_size_type) (tosym - contents) == stabsec->_cooked_size);
768 return bfd_set_section_contents (output_bfd, stabsec->output_section,
769 contents, (file_ptr) stabsec->output_offset,
770 stabsec->_cooked_size);
773 /* Write out the .stabstr section. */
776 _bfd_write_stab_strings (output_bfd, psinfo)
780 struct stab_info *sinfo;
782 sinfo = (struct stab_info *) *psinfo;
787 if (bfd_is_abs_section (sinfo->stabstr->output_section))
789 /* The section was discarded from the link. */
793 BFD_ASSERT ((sinfo->stabstr->output_offset
794 + _bfd_stringtab_size (sinfo->strings))
795 <= sinfo->stabstr->output_section->_raw_size);
797 if (bfd_seek (output_bfd,
798 (file_ptr) (sinfo->stabstr->output_section->filepos
799 + sinfo->stabstr->output_offset),
803 if (! _bfd_stringtab_emit (output_bfd, sinfo->strings))
806 /* We no longer need the stabs information. */
807 _bfd_stringtab_free (sinfo->strings);
808 bfd_hash_table_free (&sinfo->includes.root);
813 /* Adjust an address in the .stab section. Given OFFSET within
814 STABSEC, this returns the new offset in the adjusted stab section,
815 or -1 if the address refers to a stab which has been removed. */
818 _bfd_stab_section_offset (output_bfd, psinfo, stabsec, psecinfo, offset)
819 bfd *output_bfd ATTRIBUTE_UNUSED;
820 PTR *psinfo ATTRIBUTE_UNUSED;
825 struct stab_section_info *secinfo;
827 secinfo = (struct stab_section_info *) *psecinfo;
832 if (offset >= stabsec->_raw_size)
833 return offset - (stabsec->_cooked_size - stabsec->_raw_size);
835 if (secinfo->cumulative_skips)
839 i = offset / STABSIZE;
841 if (secinfo->stridxs [i] == (bfd_size_type) -1)
844 return offset - secinfo->cumulative_skips [i];