X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fstabs.c;h=72e312cc5201f2874cf16fa40647bc253d08a485;hb=6bba1048d63e0476b94b9934527defd81c590a13;hp=04b91f6800452d1be31c4738adaba37ad196e265;hpb=66a695f0b67c43e00b49bb4b97f7a183557c2b5f;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/stabs.c b/bfd/stabs.c index 04b91f6800..72e312cc52 100644 --- a/bfd/stabs.c +++ b/bfd/stabs.c @@ -1,13 +1,13 @@ /* Stabs in sections linking support. - Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 - Free Software Foundation, Inc. + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, + 2006, 2007 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 +17,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,19 +43,12 @@ 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 a unique identifier for a particular BINCL...EINCL @@ -80,12 +75,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. */ @@ -124,50 +113,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 = 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; } @@ -176,16 +146,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; @@ -194,67 +162,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); @@ -264,25 +220,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 @@ -291,7 +239,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) @@ -301,10 +249,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]; @@ -327,13 +273,11 @@ _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)); + (_("%B(%A+0x%lx): Stabs entry has invalid string index."), + abfd, stabsec, (long) (sym - stabbuf)); bfd_set_error (bfd_error_bad_value); goto error_return; } @@ -393,7 +337,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of if (num_chars >= buf_len) { buf_len += 32 * 1024; - symb = bfd_realloc (symb, buf_len); + symb = bfd_realloc_or_free (symb, buf_len); if (symb == NULL) goto error_return; symb_rover = symb + num_chars; @@ -417,8 +361,8 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of /* 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; @@ -431,7 +375,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of /* Record this symbol, so that we can set the value correctly. */ amt = sizeof *ne; - ne = (struct stab_excl_list *) bfd_alloc (abfd, amt); + ne = bfd_alloc (abfd, amt); if (ne == NULL) goto error_return; ne->offset = sym - stabbuf; @@ -444,13 +388,12 @@ _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 = bfd_hash_allocate (&sinfo->includes, sizeof *t); if (t == NULL) goto error_return; t->sum_chars = sum_chars; t->num_chars = num_chars; - t->symb = bfd_realloc (symb, num_chars); /* Trim data down. */ + t->symb = symb = bfd_realloc_or_free (symb, num_chars); /* Trim data down. */ t->next = incl_entry->totals; incl_entry->totals = t; } @@ -490,7 +433,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; @@ -513,11 +456,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. */ @@ -528,7 +471,7 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of bfd_size_type *pskips; amt = count * sizeof (bfd_size_type); - secinfo->cumulative_skips = (bfd_size_type *) bfd_alloc (abfd, amt); + secinfo->cumulative_skips = bfd_alloc (abfd, amt); if (secinfo->cumulative_skips == NULL) goto error_return; @@ -555,7 +498,6 @@ _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo, pstring_of free (stabstrbuf); return FALSE; } - /* This function is called for each input file before the stab section is relocated. It discards stab entries for discarded @@ -564,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; @@ -580,26 +520,20 @@ _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. If there was some bizarre error reading the string sections, though, @@ -607,26 +541,19 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo, 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) @@ -634,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]; @@ -684,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. */ @@ -699,7 +624,7 @@ _bfd_discard_section_stabs (abfd, stabsec, psecinfo, if (secinfo->cumulative_skips == NULL) { amt = count * sizeof (bfd_size_type); - secinfo->cumulative_skips = (bfd_size_type *) bfd_alloc (abfd, amt); + secinfo->cumulative_skips = bfd_alloc (abfd, amt); if (secinfo->cumulative_skips == NULL) goto error_return; } @@ -730,34 +655,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; @@ -766,7 +687,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) @@ -787,7 +708,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); } @@ -795,36 +716,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 @@ -837,7 +747,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; } @@ -847,22 +757,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) {