X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fstabs.c;h=81ef1deb4a6ad589f0b38e4bacef31a7f955af65;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=23cb24ac89c1e9dac6e74ee590938c90c2d10ea5;hpb=a56b48eb0fa6568864c2e3adc4dd70ab23b84611;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/stabs.c b/bfd/stabs.c index 23cb24ac89..81ef1deb4a 100644 --- a/bfd/stabs.c +++ b/bfd/stabs.c @@ -1,13 +1,12 @@ /* Stabs in sections linking support. - Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 - Free Software Foundation, Inc. + Copyright (C) 1996-2020 Free Software Foundation, Inc. Written by Ian Lance Taylor, Cygnus Support. This file is part of BFD, the Binary File Descriptor library. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,13 +16,15 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + /* This file contains support for linking stabs in sections, as used on COFF and ELF. */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "libbfd.h" #include "aout/stab_gnu.h" #include "safe-ctype.h" @@ -41,32 +42,27 @@ the string table for this unit, and the desc field is the number of stabs symbols for this unit. */ -#define STRDXOFF (0) -#define TYPEOFF (4) -#define OTHEROFF (5) -#define DESCOFF (6) -#define VALOFF (8) -#define STABSIZE (12) - -/* A hash table used for header files with N_BINCL entries. */ - -struct stab_link_includes_table -{ - struct bfd_hash_table root; -}; +#define STRDXOFF 0 +#define TYPEOFF 4 +#define OTHEROFF 5 +#define DESCOFF 6 +#define VALOFF 8 +#define STABSIZE 12 /* A linked list of totals that we have found for a particular header - file. A total is the sum of all the STABS characters for a particular - file and the number of these charactes. It is used to identify - duplicate files which can be excluded. XXX: A better method would be to - compute an MD5 checksum, but that is coding left for another day. - The bfd_vma type is used because it is a very large unsigned type. */ + file. A total is a unique identifier for a particular BINCL...EINCL + sequence of STABs that can be used to identify duplicate sequences. + It consists of three fields, 'sum_chars' which is the sum of all the + STABS characters; 'num_chars' which is the number of these charactes + and 'symb' which is a buffer of all the symbols in the sequence. This + buffer is only checked as a last resort. */ struct stab_link_includes_totals { struct stab_link_includes_totals *next; bfd_vma sum_chars; /* Accumulated sum of STABS characters. */ bfd_vma num_chars; /* Number of STABS characters. */ + const char* symb; /* The STABS characters themselves. */ }; /* An entry in the header file hash table. */ @@ -78,12 +74,6 @@ struct stab_link_includes_entry struct stab_link_includes_totals *totals; }; -/* Look up an entry in an the header file hash table. */ - -#define stab_link_includes_lookup(table, string, create, copy) \ - ((struct stab_link_includes_entry *) \ - bfd_hash_lookup (&(table)->root, (string), (create), (copy))) - /* This structure is used to hold a list of N_BINCL symbols, some of which might be converted into N_EXCL symbols. */ @@ -122,50 +112,31 @@ struct stab_section_info bfd_size_type stridxs[1]; }; -/* This structure is used to keep track of stabs in sections - information while linking. */ - -struct stab_info -{ - /* A hash table used to hold stabs strings. */ - struct bfd_strtab_hash *strings; - /* The header file hash table. */ - struct stab_link_includes_table includes; - /* The first .stabstr section. */ - asection *stabstr; -}; - -static struct bfd_hash_entry *stab_link_includes_newfunc - PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); /* The function to create a new entry in the header file hash table. */ static struct bfd_hash_entry * -stab_link_includes_newfunc (entry, table, string) - struct bfd_hash_entry *entry; - struct bfd_hash_table *table; - const char *string; +stab_link_includes_newfunc (struct bfd_hash_entry *entry, + struct bfd_hash_table *table, + const char *string) { struct stab_link_includes_entry *ret = (struct stab_link_includes_entry *) entry; /* Allocate the structure if it has not already been allocated by a subclass. */ - if (ret == (struct stab_link_includes_entry *) NULL) - ret = ((struct stab_link_includes_entry *) - bfd_hash_allocate (table, - sizeof (struct stab_link_includes_entry))); - if (ret == (struct stab_link_includes_entry *) NULL) - return (struct bfd_hash_entry *) ret; + if (ret == NULL) + ret = (struct stab_link_includes_entry *) + bfd_hash_allocate (table, sizeof (struct stab_link_includes_entry)); + if (ret == NULL) + return NULL; /* Call the allocation method of the superclass. */ ret = ((struct stab_link_includes_entry *) bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); if (ret) - { - /* Set local fields. */ - ret->totals = NULL; - } + /* Set local fields. */ + ret->totals = NULL; return (struct bfd_hash_entry *) ret; } @@ -174,16 +145,14 @@ stab_link_includes_newfunc (entry, table, string) pass of the linker. */ bfd_boolean -_bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_offset) - bfd *abfd; - PTR *psinfo; - asection *stabsec; - asection *stabstrsec; - PTR *psecinfo; - bfd_size_type *pstring_offset; +_bfd_link_section_stabs (bfd *abfd, + struct stab_info *sinfo, + asection *stabsec, + asection *stabstrsec, + void * *psecinfo, + bfd_size_type *pstring_offset) { bfd_boolean first; - struct stab_info *sinfo; bfd_size_type count, amt; struct stab_section_info *secinfo; bfd_byte *stabbuf = NULL; @@ -192,67 +161,55 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of bfd_size_type stroff, next_stroff, skip; bfd_size_type *pstridx; - if (stabsec->_raw_size == 0 - || stabstrsec->_raw_size == 0) - { - /* This file does not contain stabs debugging information. */ - return TRUE; - } + if (stabsec->size == 0 + || stabstrsec->size == 0) + /* This file does not contain stabs debugging information. */ + return TRUE; - if (stabsec->_raw_size % STABSIZE != 0) - { - /* Something is wrong with the format of these stab symbols. - Don't try to optimize them. */ - return TRUE; - } + if (stabsec->size % STABSIZE != 0) + /* Something is wrong with the format of these stab symbols. + Don't try to optimize them. */ + return TRUE; if ((stabstrsec->flags & SEC_RELOC) != 0) - { - /* We shouldn't see relocations in the strings, and we aren't - prepared to handle them. */ - return TRUE; - } + /* We shouldn't see relocations in the strings, and we aren't + prepared to handle them. */ + return TRUE; - if ((stabsec->output_section != NULL - && bfd_is_abs_section (stabsec->output_section)) - || (stabstrsec->output_section != NULL - && bfd_is_abs_section (stabstrsec->output_section))) - { - /* At least one of the sections is being discarded from the - link, so we should just ignore them. */ - return TRUE; - } + if (bfd_is_abs_section (stabsec->output_section) + || bfd_is_abs_section (stabstrsec->output_section)) + /* At least one of the sections is being discarded from the + link, so we should just ignore them. */ + return TRUE; first = FALSE; - if (*psinfo == NULL) + if (sinfo->stabstr == NULL) { + flagword flags; + /* Initialize the stabs information we need to keep track of. */ first = TRUE; - amt = sizeof (struct stab_info); - *psinfo = (PTR) bfd_alloc (abfd, amt); - if (*psinfo == NULL) - goto error_return; - sinfo = (struct stab_info *) *psinfo; sinfo->strings = _bfd_stringtab_init (); if (sinfo->strings == NULL) goto error_return; /* Make sure the first byte is zero. */ (void) _bfd_stringtab_add (sinfo->strings, "", TRUE, TRUE); - if (! bfd_hash_table_init_n (&sinfo->includes.root, - stab_link_includes_newfunc, - 251)) + if (! bfd_hash_table_init (&sinfo->includes, + stab_link_includes_newfunc, + sizeof (struct stab_link_includes_entry))) + goto error_return; + flags = (SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING + | SEC_LINKER_CREATED); + sinfo->stabstr = bfd_make_section_anyway_with_flags (abfd, ".stabstr", + flags); + if (sinfo->stabstr == NULL) goto error_return; - sinfo->stabstr = bfd_make_section_anyway (abfd, ".stabstr"); - sinfo->stabstr->flags |= SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING; } - sinfo = (struct stab_info *) *psinfo; - /* Initialize the information we are going to store for this .stab section. */ - - count = stabsec->_raw_size / STABSIZE; + count = stabsec->size / STABSIZE; amt = sizeof (struct stab_section_info); amt += (count - 1) * sizeof (bfd_size_type); @@ -262,25 +219,17 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of secinfo = (struct stab_section_info *) *psecinfo; secinfo->excls = NULL; + stabsec->rawsize = stabsec->size; secinfo->cumulative_skips = NULL; memset (secinfo->stridxs, 0, (size_t) count * sizeof (bfd_size_type)); /* Read the stabs information from abfd. */ - - stabbuf = (bfd_byte *) bfd_malloc (stabsec->_raw_size); - stabstrbuf = (bfd_byte *) bfd_malloc (stabstrsec->_raw_size); - if (stabbuf == NULL || stabstrbuf == NULL) - goto error_return; - - if (! bfd_get_section_contents (abfd, stabsec, stabbuf, (bfd_vma) 0, - stabsec->_raw_size) - || ! bfd_get_section_contents (abfd, stabstrsec, stabstrbuf, (bfd_vma) 0, - stabstrsec->_raw_size)) + if (!bfd_malloc_and_get_section (abfd, stabsec, &stabbuf) + || !bfd_malloc_and_get_section (abfd, stabstrsec, &stabstrbuf)) goto error_return; /* Look through the stabs symbols, work out the new string indices, and identify N_BINCL symbols which can be eliminated. */ - stroff = 0; /* The stabs sections can be split when -split-by-reloc/-split-by-file is used. We must keep track of @@ -289,7 +238,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of next_stroff = pstring_offset ? *pstring_offset : 0; skip = 0; - symend = stabbuf + stabsec->_raw_size; + symend = stabbuf + stabsec->size; for (sym = stabbuf, pstridx = secinfo->stridxs; sym < symend; sym += STABSIZE, ++pstridx) @@ -299,10 +248,8 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of const char *string; if (*pstridx != 0) - { - /* This symbol has already been handled by an N_BINCL pass. */ - continue; - } + /* This symbol has already been handled by an N_BINCL pass. */ + continue; type = sym[TYPEOFF]; @@ -325,13 +272,12 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of /* Store the string in the hash table, and record the index. */ symstroff = stroff + bfd_get_32 (abfd, sym + STRDXOFF); - if (symstroff >= stabstrsec->_raw_size) + if (symstroff >= stabstrsec->size) { - (*_bfd_error_handler) - (_("%s(%s+0x%lx): Stabs entry has invalid string index."), - bfd_archive_filename (abfd), - bfd_get_section_name (abfd, stabsec), - (long) (sym - stabbuf)); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB(%pA+%#lx): stabs entry has invalid string index"), + abfd, stabsec, (long) (sym - stabbuf)); bfd_set_error (bfd_error_bad_value); goto error_return; } @@ -347,14 +293,19 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of { bfd_vma sum_chars; bfd_vma num_chars; + bfd_vma buf_len = 0; + char * symb; + char * symb_rover; int nest; - bfd_byte *incl_sym; - struct stab_link_includes_entry *incl_entry; - struct stab_link_includes_totals *t; - struct stab_excl_list *ne; + bfd_byte * incl_sym; + struct stab_link_includes_entry * incl_entry; + struct stab_link_includes_totals * t; + struct stab_excl_list * ne; + symb = symb_rover = NULL; sum_chars = num_chars = 0; nest = 0; + for (incl_sym = sym + STABSIZE; incl_sym < symend; incl_sym += STABSIZE) @@ -383,6 +334,15 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of + bfd_get_32 (abfd, incl_sym + STRDXOFF)); for (; *str != '\0'; str++) { + if (num_chars >= buf_len) + { + buf_len += 32 * 1024; + symb = (char *) bfd_realloc_or_free (symb, buf_len); + if (symb == NULL) + goto error_return; + symb_rover = symb + num_chars; + } + * symb_rover ++ = * str; sum_chars += *str; num_chars ++; if (*str == '(') @@ -397,15 +357,19 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of } } + BFD_ASSERT (num_chars == (bfd_vma) (symb_rover - symb)); + /* If we have already included a header file with the same value, then replaced this one with an N_EXCL symbol. */ - incl_entry = stab_link_includes_lookup (&sinfo->includes, string, - TRUE, TRUE); + incl_entry = (struct stab_link_includes_entry * ) + bfd_hash_lookup (&sinfo->includes, string, TRUE, TRUE); if (incl_entry == NULL) goto error_return; for (t = incl_entry->totals; t != NULL; t = t->next) - if (t->sum_chars == sum_chars && t->num_chars == num_chars) + if (t->sum_chars == sum_chars + && t->num_chars == num_chars + && memcmp (t->symb, symb, num_chars) == 0) break; /* Record this symbol, so that we can set the value @@ -424,12 +388,14 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of { /* This is the first time we have seen this header file with this set of stabs strings. */ - t = ((struct stab_link_includes_totals *) - bfd_hash_allocate (&sinfo->includes.root, sizeof *t)); + t = (struct stab_link_includes_totals *) + bfd_hash_allocate (&sinfo->includes, sizeof *t); if (t == NULL) goto error_return; t->sum_chars = sum_chars; t->num_chars = num_chars; + /* Trim data down. */ + t->symb = symb = (char *) bfd_realloc_or_free (symb, num_chars); t->next = incl_entry->totals; incl_entry->totals = t; } @@ -441,6 +407,9 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of pass to change the type to N_EXCL. */ ne->type = (int) N_EXCL; + /* Free off superfluous symbols. */ + free (symb); + /* Mark the skipped symbols. */ nest = 0; @@ -466,7 +435,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of ++nest; else if (incl_type == (int) N_EXCL) /* Keep existing exclusion marks. */ - continue; + continue; else if (nest == 0) { *incl_pstridx = (bfd_size_type) -1; @@ -489,11 +458,11 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of from the link. We record the size of the strtab in the first .stabstr section we saw, and make sure we don't set SEC_EXCLUDE for that section. */ - stabsec->_cooked_size = (count - skip) * STABSIZE; - if (stabsec->_cooked_size == 0) - stabsec->flags |= SEC_EXCLUDE; - stabstrsec->flags |= SEC_EXCLUDE; - sinfo->stabstr->_cooked_size = _bfd_stringtab_size (sinfo->strings); + stabsec->size = (count - skip) * STABSIZE; + if (stabsec->size == 0) + stabsec->flags |= SEC_EXCLUDE | SEC_KEEP; + stabstrsec->flags |= SEC_EXCLUDE | SEC_KEEP; + sinfo->stabstr->size = _bfd_stringtab_size (sinfo->strings); /* Calculate the `cumulative_skips' array now that stabs have been deleted for this section. */ @@ -525,13 +494,10 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of return TRUE; error_return: - if (stabbuf != NULL) - free (stabbuf); - if (stabstrbuf != NULL) - free (stabstrbuf); + free (stabbuf); + free (stabstrbuf); return FALSE; } - /* This function is called for each input file before the stab section is relocated. It discards stab entries for discarded @@ -540,13 +506,11 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of */ bfd_boolean -_bfd_discard_section_stabs (abfd, stabsec, psecinfo, - reloc_symbol_deleted_p, cookie) - bfd *abfd; - asection *stabsec; - PTR psecinfo; - bfd_boolean (*reloc_symbol_deleted_p) PARAMS ((bfd_vma, PTR)); - PTR cookie; +_bfd_discard_section_stabs (bfd *abfd, + asection *stabsec, + void * psecinfo, + bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *), + void * cookie) { bfd_size_type count, amt; struct stab_section_info *secinfo; @@ -556,53 +520,40 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo, bfd_size_type *pstridx; int deleting; - if (stabsec->_raw_size == 0) - { - /* This file does not contain stabs debugging information. */ - return FALSE; - } + if (stabsec->size == 0) + /* This file does not contain stabs debugging information. */ + return FALSE; - if (stabsec->_raw_size % STABSIZE != 0) - { - /* Something is wrong with the format of these stab symbols. - Don't try to optimize them. */ - return FALSE; - } + if (stabsec->size % STABSIZE != 0) + /* Something is wrong with the format of these stab symbols. + Don't try to optimize them. */ + return FALSE; if ((stabsec->output_section != NULL && bfd_is_abs_section (stabsec->output_section))) - { - /* At least one of the sections is being discarded from the - link, so we should just ignore them. */ - return FALSE; - } + /* At least one of the sections is being discarded from the + link, so we should just ignore them. */ + return FALSE; - /* We should have initialized our data in _bfd_link_stab_sections. + /* We should have initialized our data in _bfd_link_section_stabs. If there was some bizarre error reading the string sections, though, we might not have. Bail rather than asserting. */ if (psecinfo == NULL) return FALSE; - count = stabsec->_raw_size / STABSIZE; + count = stabsec->rawsize / STABSIZE; secinfo = (struct stab_section_info *) psecinfo; /* Read the stabs information from abfd. */ - - stabbuf = (bfd_byte *) bfd_malloc (stabsec->_raw_size); - if (stabbuf == NULL) - goto error_return; - - if (! bfd_get_section_contents (abfd, stabsec, stabbuf, (bfd_vma) 0, - stabsec->_raw_size)) + if (!bfd_malloc_and_get_section (abfd, stabsec, &stabbuf)) goto error_return; /* Look through the stabs symbols and discard any information for discarded functions. */ - skip = 0; deleting = -1; - symend = stabbuf + stabsec->_raw_size; + symend = stabbuf + stabsec->rawsize; for (sym = stabbuf, pstridx = secinfo->stridxs; sym < symend; sym += STABSIZE, ++pstridx) @@ -610,10 +561,8 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo, int type; if (*pstridx == (bfd_size_type) -1) - { - /* This stab was deleted in a previous pass. */ - continue; - } + /* This stab was deleted in a previous pass. */ + continue; type = sym[TYPEOFF]; @@ -660,9 +609,9 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo, stabbuf = NULL; /* Shrink the stabsec as needed. */ - stabsec->_cooked_size -= skip * STABSIZE; - if (stabsec->_cooked_size == 0) - stabsec->flags |= SEC_EXCLUDE; + stabsec->size -= skip * STABSIZE; + if (stabsec->size == 0) + stabsec->flags |= SEC_EXCLUDE | SEC_KEEP; /* Recalculate the `cumulative_skips' array now that stabs have been deleted for this section. */ @@ -697,8 +646,7 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo, return skip > 0; error_return: - if (stabbuf != NULL) - free (stabbuf); + free (stabbuf); return FALSE; } @@ -706,34 +654,30 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo, contents. */ bfd_boolean -_bfd_write_section_stabs (output_bfd, psinfo, stabsec, psecinfo, contents) - bfd *output_bfd; - PTR *psinfo; - asection *stabsec; - PTR *psecinfo; - bfd_byte *contents; +_bfd_write_section_stabs (bfd *output_bfd, + struct stab_info *sinfo, + asection *stabsec, + void * *psecinfo, + bfd_byte *contents) { - struct stab_info *sinfo; struct stab_section_info *secinfo; struct stab_excl_list *e; bfd_byte *sym, *tosym, *symend; bfd_size_type *pstridx; - sinfo = (struct stab_info *) *psinfo; secinfo = (struct stab_section_info *) *psecinfo; if (secinfo == NULL) return bfd_set_section_contents (output_bfd, stabsec->output_section, - contents, - (file_ptr) stabsec->output_offset, - stabsec->_raw_size); + contents, stabsec->output_offset, + stabsec->size); /* Handle each N_BINCL entry. */ for (e = secinfo->excls; e != NULL; e = e->next) { bfd_byte *excl_sym; - BFD_ASSERT (e->offset < stabsec->_raw_size); + BFD_ASSERT (e->offset < stabsec->rawsize); excl_sym = contents + e->offset; bfd_put_32 (output_bfd, e->val, excl_sym + VALOFF); excl_sym[TYPEOFF] = e->type; @@ -742,7 +686,7 @@ _bfd_write_section_stabs (output_bfd, psinfo, stabsec, psecinfo, contents) /* Copy over all the stabs symbols, omitting the ones we don't want, and correcting the string indices for those we do want. */ tosym = contents; - symend = contents + stabsec->_raw_size; + symend = contents + stabsec->rawsize; for (sym = contents, pstridx = secinfo->stridxs; sym < symend; sym += STABSIZE, ++pstridx) @@ -763,7 +707,7 @@ _bfd_write_section_stabs (output_bfd, psinfo, stabsec, psecinfo, contents) bfd_put_32 (output_bfd, _bfd_stringtab_size (sinfo->strings), tosym + VALOFF); bfd_put_16 (output_bfd, - stabsec->output_section->_raw_size / STABSIZE - 1, + stabsec->output_section->size / STABSIZE - 1, tosym + DESCOFF); } @@ -771,36 +715,25 @@ _bfd_write_section_stabs (output_bfd, psinfo, stabsec, psecinfo, contents) } } - BFD_ASSERT ((bfd_size_type) (tosym - contents) == stabsec->_cooked_size); + BFD_ASSERT ((bfd_size_type) (tosym - contents) == stabsec->size); return bfd_set_section_contents (output_bfd, stabsec->output_section, contents, (file_ptr) stabsec->output_offset, - stabsec->_cooked_size); + stabsec->size); } /* Write out the .stabstr section. */ bfd_boolean -_bfd_write_stab_strings (output_bfd, psinfo) - bfd *output_bfd; - PTR *psinfo; +_bfd_write_stab_strings (bfd *output_bfd, struct stab_info *sinfo) { - struct stab_info *sinfo; - - sinfo = (struct stab_info *) *psinfo; - - if (sinfo == NULL) - return TRUE; - if (bfd_is_abs_section (sinfo->stabstr->output_section)) - { - /* The section was discarded from the link. */ - return TRUE; - } + /* The section was discarded from the link. */ + return TRUE; BFD_ASSERT ((sinfo->stabstr->output_offset + _bfd_stringtab_size (sinfo->strings)) - <= sinfo->stabstr->output_section->_raw_size); + <= sinfo->stabstr->output_section->size); if (bfd_seek (output_bfd, (file_ptr) (sinfo->stabstr->output_section->filepos @@ -813,7 +746,7 @@ _bfd_write_stab_strings (output_bfd, psinfo) /* We no longer need the stabs information. */ _bfd_stringtab_free (sinfo->strings); - bfd_hash_table_free (&sinfo->includes.root); + bfd_hash_table_free (&sinfo->includes); return TRUE; } @@ -823,22 +756,19 @@ _bfd_write_stab_strings (output_bfd, psinfo) or -1 if the address refers to a stab which has been removed. */ bfd_vma -_bfd_stab_section_offset (output_bfd, psinfo, stabsec, psecinfo, offset) - bfd *output_bfd ATTRIBUTE_UNUSED; - PTR *psinfo ATTRIBUTE_UNUSED; - asection *stabsec; - PTR *psecinfo; - bfd_vma offset; +_bfd_stab_section_offset (asection *stabsec, + void * psecinfo, + bfd_vma offset) { struct stab_section_info *secinfo; - secinfo = (struct stab_section_info *) *psecinfo; + secinfo = (struct stab_section_info *) psecinfo; if (secinfo == NULL) return offset; - if (offset >= stabsec->_raw_size) - return offset - (stabsec->_cooked_size - stabsec->_raw_size); + if (offset >= stabsec->rawsize) + return offset - stabsec->rawsize + stabsec->size; if (secinfo->cumulative_skips) {