1/* Stabs in sections linking support. 2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 3 2006, 2007, 2008 Free Software Foundation, Inc. 4 Written by Ian Lance Taylor, Cygnus Support. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 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 3 of the License, or 11 (at your option) any later version. 12 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. 17 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., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 24/* This file contains support for linking stabs in sections, as used 25 on COFF and ELF. */ 26 27#include "sysdep.h" 28#include "bfd.h" 29#include "libbfd.h" 30#include "aout/stab_gnu.h" 31#include "safe-ctype.h" 32 33/* Stabs entries use a 12 byte format: 34 4 byte string table index 35 1 byte stab type 36 1 byte stab other field 37 2 byte stab desc field 38 4 byte stab value 39 FIXME: This will have to change for a 64 bit object format. 40 41 The stabs symbols are divided into compilation units. For the 42 first entry in each unit, the type of 0, the value is the length of 43 the string table for this unit, and the desc field is the number of 44 stabs symbols for this unit. */ 45 46#define STRDXOFF 0 47#define TYPEOFF 4 48#define OTHEROFF 5 49#define DESCOFF 6 50#define VALOFF 8 51#define STABSIZE 12 52 53/* A linked list of totals that we have found for a particular header 54 file. A total is a unique identifier for a particular BINCL...EINCL 55 sequence of STABs that can be used to identify duplicate sequences. 56 It consists of three fields, 'sum_chars' which is the sum of all the 57 STABS characters; 'num_chars' which is the number of these charactes 58 and 'symb' which is a buffer of all the symbols in the sequence. This 59 buffer is only checked as a last resort. */ 60 61struct stab_link_includes_totals 62{ 63 struct stab_link_includes_totals *next; 64 bfd_vma sum_chars; /* Accumulated sum of STABS characters. */ 65 bfd_vma num_chars; /* Number of STABS characters. */ 66 const char* symb; /* The STABS characters themselves. */ 67}; 68 69/* An entry in the header file hash table. */ 70 71struct stab_link_includes_entry 72{ 73 struct bfd_hash_entry root; 74 /* List of totals we have found for this file. */ 75 struct stab_link_includes_totals *totals; 76}; 77 78/* This structure is used to hold a list of N_BINCL symbols, some of 79 which might be converted into N_EXCL symbols. */ 80 81struct stab_excl_list 82{ 83 /* The next symbol to convert. */ 84 struct stab_excl_list *next; 85 /* The offset to this symbol in the section contents. */ 86 bfd_size_type offset; 87 /* The value to use for the symbol. */ 88 bfd_vma val; 89 /* The type of this symbol (N_BINCL or N_EXCL). */ 90 int type; 91}; 92 93/* This structure is stored with each .stab section. */ 94 95struct stab_section_info 96{ 97 /* This is a linked list of N_BINCL symbols which should be 98 converted into N_EXCL symbols. */ 99 struct stab_excl_list *excls; 100 101 /* This is used to map input stab offsets within their sections 102 to output stab offsets, to take into account stabs that have 103 been deleted. If it is NULL, the output offsets are the same 104 as the input offsets, because no stabs have been deleted from 105 this section. Otherwise the i'th entry is the number of 106 bytes of stabs that have been deleted prior to the i'th 107 stab. */ 108 bfd_size_type *cumulative_skips; 109 110 /* This is an array of string indices. For each stab symbol, we 111 store the string index here. If a stab symbol should not be 112 included in the final output, the string index is -1. */ 113 bfd_size_type stridxs[1]; 114}; 115 116 117/* The function to create a new entry in the header file hash table. */ 118 119static struct bfd_hash_entry * 120stab_link_includes_newfunc (struct bfd_hash_entry *entry, 121 struct bfd_hash_table *table, 122 const char *string) 123{ 124 struct stab_link_includes_entry *ret = 125 (struct stab_link_includes_entry *) entry; 126 127 /* Allocate the structure if it has not already been allocated by a 128 subclass. */ 129 if (ret == NULL) 130 ret = (struct stab_link_includes_entry *) 131 bfd_hash_allocate (table, sizeof (struct stab_link_includes_entry)); 132 if (ret == NULL) 133 return NULL; 134 135 /* Call the allocation method of the superclass. */ 136 ret = ((struct stab_link_includes_entry *) 137 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 138 if (ret) 139 /* Set local fields. */ 140 ret->totals = NULL; 141 142 return (struct bfd_hash_entry *) ret; 143} 144 145/* This function is called for each input file from the add_symbols 146 pass of the linker. */ 147 148bfd_boolean 149_bfd_link_section_stabs (bfd *abfd, 150 struct stab_info *sinfo, 151 asection *stabsec, 152 asection *stabstrsec, 153 void * *psecinfo, 154 bfd_size_type *pstring_offset) 155{ 156 bfd_boolean first; 157 bfd_size_type count, amt; 158 struct stab_section_info *secinfo; 159 bfd_byte *stabbuf = NULL; 160 bfd_byte *stabstrbuf = NULL; 161 bfd_byte *sym, *symend; 162 bfd_size_type stroff, next_stroff, skip; 163 bfd_size_type *pstridx; 164 165 if (stabsec->size == 0 166 || stabstrsec->size == 0) 167 /* This file does not contain stabs debugging information. */ 168 return TRUE; 169 170 if (stabsec->size % STABSIZE != 0) 171 /* Something is wrong with the format of these stab symbols. 172 Don't try to optimize them. */ 173 return TRUE; 174 175 if ((stabstrsec->flags & SEC_RELOC) != 0) 176 /* We shouldn't see relocations in the strings, and we aren't 177 prepared to handle them. */ 178 return TRUE; 179 180 if (bfd_is_abs_section (stabsec->output_section) 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. */ 184 return TRUE; 185 186 first = FALSE; 187 188 if (sinfo->stabstr == NULL) 189 { 190 flagword flags; 191 192 /* Initialize the stabs information we need to keep track of. */ 193 first = TRUE; 194 sinfo->strings = _bfd_stringtab_init (); 195 if (sinfo->strings == NULL) 196 goto error_return; 197 /* Make sure the first byte is zero. */ 198 (void) _bfd_stringtab_add (sinfo->strings, "", TRUE, TRUE); 199 if (! bfd_hash_table_init (&sinfo->includes, 200 stab_link_includes_newfunc, 201 sizeof (struct stab_link_includes_entry))) 202 goto error_return; 203 flags = (SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING 204 | SEC_LINKER_CREATED); 205 sinfo->stabstr = bfd_make_section_anyway_with_flags (abfd, ".stabstr", 206 flags); 207 if (sinfo->stabstr == NULL) 208 goto error_return; 209 } 210 211 /* Initialize the information we are going to store for this .stab 212 section. */ 213 count = stabsec->size / STABSIZE; 214 215 amt = sizeof (struct stab_section_info); 216 amt += (count - 1) * sizeof (bfd_size_type); 217 *psecinfo = bfd_alloc (abfd, amt); 218 if (*psecinfo == NULL) 219 goto error_return; 220 221 secinfo = (struct stab_section_info *) *psecinfo; 222 secinfo->excls = NULL; 223 stabsec->rawsize = stabsec->size; 224 secinfo->cumulative_skips = NULL; 225 memset (secinfo->stridxs, 0, (size_t) count * sizeof (bfd_size_type)); 226 227 /* Read the stabs information from abfd. */ 228 if (!bfd_malloc_and_get_section (abfd, stabsec, &stabbuf) 229 || !bfd_malloc_and_get_section (abfd, stabstrsec, &stabstrbuf)) 230 goto error_return; 231 232 /* Look through the stabs symbols, work out the new string indices, 233 and identify N_BINCL symbols which can be eliminated. */ 234 stroff = 0; 235 /* The stabs sections can be split when 236 -split-by-reloc/-split-by-file is used. We must keep track of 237 each stab section's place in the single concatenated string 238 table. */ 239 next_stroff = pstring_offset ? *pstring_offset : 0; 240 skip = 0; 241 242 symend = stabbuf + stabsec->size; 243 for (sym = stabbuf, pstridx = secinfo->stridxs; 244 sym < symend; 245 sym += STABSIZE, ++pstridx) 246 { 247 bfd_size_type symstroff; 248 int type; 249 const char *string; 250 251 if (*pstridx != 0) 252 /* This symbol has already been handled by an N_BINCL pass. */ 253 continue; 254 255 type = sym[TYPEOFF]; 256 257 if (type == 0) 258 { 259 /* Special type 0 stabs indicate the offset to the next 260 string table. We only copy the very first one. */ 261 stroff = next_stroff; 262 next_stroff += bfd_get_32 (abfd, sym + 8); 263 if (pstring_offset) 264 *pstring_offset = next_stroff; 265 if (! first) 266 { 267 *pstridx = (bfd_size_type) -1; 268 ++skip; 269 continue; 270 } 271 first = FALSE; 272 } 273 274 /* Store the string in the hash table, and record the index. */ 275 symstroff = stroff + bfd_get_32 (abfd, sym + STRDXOFF); 276 if (symstroff >= stabstrsec->size) 277 { 278 (*_bfd_error_handler) 279 (_("%B(%A+0x%lx): Stabs entry has invalid string index."), 280 abfd, stabsec, (long) (sym - stabbuf)); 281 bfd_set_error (bfd_error_bad_value); 282 goto error_return; 283 } 284 string = (char *) stabstrbuf + symstroff; 285 *pstridx = _bfd_stringtab_add (sinfo->strings, string, TRUE, TRUE); 286 287 /* An N_BINCL symbol indicates the start of the stabs entries 288 for a header file. We need to scan ahead to the next N_EINCL 289 symbol, ignoring nesting, adding up all the characters in the 290 symbol names, not including the file numbers in types (the 291 first number after an open parenthesis). */ 292 if (type == (int) N_BINCL) 293 { 294 bfd_vma sum_chars; 295 bfd_vma num_chars; 296 bfd_vma buf_len = 0; 297 char * symb; 298 char * symb_rover; 299 int nest; 300 bfd_byte * incl_sym; 301 struct stab_link_includes_entry * incl_entry; 302 struct stab_link_includes_totals * t; 303 struct stab_excl_list * ne; 304 305 symb = symb_rover = NULL; 306 sum_chars = num_chars = 0; 307 nest = 0; 308 309 for (incl_sym = sym + STABSIZE; 310 incl_sym < symend; 311 incl_sym += STABSIZE) 312 { 313 int incl_type; 314 315 incl_type = incl_sym[TYPEOFF]; 316 if (incl_type == 0) 317 break; 318 else if (incl_type == (int) N_EXCL) 319 continue; 320 else if (incl_type == (int) N_EINCL) 321 { 322 if (nest == 0) 323 break; 324 --nest; 325 } 326 else if (incl_type == (int) N_BINCL) 327 ++nest; 328 else if (nest == 0) 329 { 330 const char *str; 331 332 str = ((char *) stabstrbuf 333 + stroff 334 + bfd_get_32 (abfd, incl_sym + STRDXOFF)); 335 for (; *str != '\0'; str++) 336 { 337 if (num_chars >= buf_len) 338 { 339 buf_len += 32 * 1024; 340 symb = (char *) bfd_realloc_or_free (symb, buf_len); 341 if (symb == NULL) 342 goto error_return; 343 symb_rover = symb + num_chars; 344 } 345 * symb_rover ++ = * str; 346 sum_chars += *str; 347 num_chars ++; 348 if (*str == '(') 349 { 350 /* Skip the file number. */ 351 ++str; 352 while (ISDIGIT (*str)) 353 ++str; 354 --str; 355 } 356 } 357 } 358 } 359 360 BFD_ASSERT (num_chars == (bfd_vma) (symb_rover - symb)); 361 362 /* If we have already included a header file with the same 363 value, then replaced this one with an N_EXCL symbol. */ 364 incl_entry = (struct stab_link_includes_entry * ) 365 bfd_hash_lookup (&sinfo->includes, string, TRUE, TRUE); 366 if (incl_entry == NULL) 367 goto error_return; 368 369 for (t = incl_entry->totals; t != NULL; t = t->next) 370 if (t->sum_chars == sum_chars 371 && t->num_chars == num_chars 372 && memcmp (t->symb, symb, num_chars) == 0) 373 break; 374 375 /* Record this symbol, so that we can set the value 376 correctly. */ 377 amt = sizeof *ne; 378 ne = (struct stab_excl_list *) bfd_alloc (abfd, amt); 379 if (ne == NULL) 380 goto error_return; 381 ne->offset = sym - stabbuf; 382 ne->val = sum_chars; 383 ne->type = (int) N_BINCL; 384 ne->next = secinfo->excls; 385 secinfo->excls = ne; 386 387 if (t == NULL) 388 { 389 /* This is the first time we have seen this header file 390 with this set of stabs strings. */ 391 t = (struct stab_link_includes_totals *) 392 bfd_hash_allocate (&sinfo->includes, sizeof *t); 393 if (t == NULL) 394 goto error_return; 395 t->sum_chars = sum_chars; 396 t->num_chars = num_chars; 397 /* Trim data down. */ 398 t->symb = symb = (char *) bfd_realloc_or_free (symb, num_chars); 399 t->next = incl_entry->totals; 400 incl_entry->totals = t; 401 } 402 else 403 { 404 bfd_size_type *incl_pstridx; 405 406 /* We have seen this header file before. Tell the final 407 pass to change the type to N_EXCL. */ 408 ne->type = (int) N_EXCL; 409 410 /* Free off superfluous symbols. */ 411 free (symb); 412 413 /* Mark the skipped symbols. */ 414 415 nest = 0; 416 for (incl_sym = sym + STABSIZE, incl_pstridx = pstridx + 1; 417 incl_sym < symend; 418 incl_sym += STABSIZE, ++incl_pstridx) 419 { 420 int incl_type; 421 422 incl_type = incl_sym[TYPEOFF]; 423 424 if (incl_type == (int) N_EINCL) 425 { 426 if (nest == 0) 427 { 428 *incl_pstridx = (bfd_size_type) -1; 429 ++skip; 430 break; 431 } 432 --nest; 433 } 434 else if (incl_type == (int) N_BINCL) 435 ++nest; 436 else if (incl_type == (int) N_EXCL) 437 /* Keep existing exclusion marks. */ 438 continue; 439 else if (nest == 0) 440 { 441 *incl_pstridx = (bfd_size_type) -1; 442 ++skip; 443 } 444 } 445 } 446 } 447 } 448 449 free (stabbuf); 450 stabbuf = NULL; 451 free (stabstrbuf); 452 stabstrbuf = NULL; 453 454 /* We need to set the section sizes such that the linker will 455 compute the output section sizes correctly. We set the .stab 456 size to not include the entries we don't want. We set 457 SEC_EXCLUDE for the .stabstr section, so that it will be dropped 458 from the link. We record the size of the strtab in the first 459 .stabstr section we saw, and make sure we don't set SEC_EXCLUDE 460 for that section. */ 461 stabsec->size = (count - skip) * STABSIZE; 462 if (stabsec->size == 0) 463 stabsec->flags |= SEC_EXCLUDE | SEC_KEEP; 464 stabstrsec->flags |= SEC_EXCLUDE | SEC_KEEP; 465 sinfo->stabstr->size = _bfd_stringtab_size (sinfo->strings); 466 467 /* Calculate the `cumulative_skips' array now that stabs have been 468 deleted for this section. */ 469 470 if (skip != 0) 471 { 472 bfd_size_type i, offset; 473 bfd_size_type *pskips; 474 475 amt = count * sizeof (bfd_size_type); 476 secinfo->cumulative_skips = (bfd_size_type *) bfd_alloc (abfd, amt); 477 if (secinfo->cumulative_skips == NULL) 478 goto error_return; 479 480 pskips = secinfo->cumulative_skips; 481 pstridx = secinfo->stridxs; 482 offset = 0; 483 484 for (i = 0; i < count; i++, pskips++, pstridx++) 485 { 486 *pskips = offset; 487 if (*pstridx == (bfd_size_type) -1) 488 offset += STABSIZE; 489 } 490 491 BFD_ASSERT (offset != 0); 492 } 493 494 return TRUE; 495 496 error_return: 497 if (stabbuf != NULL) 498 free (stabbuf); 499 if (stabstrbuf != NULL) 500 free (stabstrbuf); 501 return FALSE; 502} 503 504/* This function is called for each input file before the stab 505 section is relocated. It discards stab entries for discarded 506 functions and variables. The function returns TRUE iff 507 any entries have been deleted. 508*/ 509 510bfd_boolean 511_bfd_discard_section_stabs (bfd *abfd, 512 asection *stabsec, 513 void * psecinfo, 514 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *), 515 void * cookie) 516{ 517 bfd_size_type count, amt; 518 struct stab_section_info *secinfo; 519 bfd_byte *stabbuf = NULL; 520 bfd_byte *sym, *symend; 521 bfd_size_type skip; 522 bfd_size_type *pstridx; 523 int deleting; 524 525 if (stabsec->size == 0) 526 /* This file does not contain stabs debugging information. */ 527 return FALSE; 528 529 if (stabsec->size % STABSIZE != 0) 530 /* Something is wrong with the format of these stab symbols. 531 Don't try to optimize them. */ 532 return FALSE; 533 534 if ((stabsec->output_section != NULL 535 && bfd_is_abs_section (stabsec->output_section))) 536 /* At least one of the sections is being discarded from the 537 link, so we should just ignore them. */ 538 return FALSE; 539 540 /* We should have initialized our data in _bfd_link_stab_sections. 541 If there was some bizarre error reading the string sections, though, 542 we might not have. Bail rather than asserting. */ 543 if (psecinfo == NULL) 544 return FALSE; 545 546 count = stabsec->rawsize / STABSIZE; 547 secinfo = (struct stab_section_info *) psecinfo; 548 549 /* Read the stabs information from abfd. */ 550 if (!bfd_malloc_and_get_section (abfd, stabsec, &stabbuf)) 551 goto error_return; 552 553 /* Look through the stabs symbols and discard any information for 554 discarded functions. */ 555 skip = 0; 556 deleting = -1; 557 558 symend = stabbuf + stabsec->rawsize; 559 for (sym = stabbuf, pstridx = secinfo->stridxs; 560 sym < symend; 561 sym += STABSIZE, ++pstridx) 562 { 563 int type; 564 565 if (*pstridx == (bfd_size_type) -1) 566 /* This stab was deleted in a previous pass. */ 567 continue; 568 569 type = sym[TYPEOFF]; 570 571 if (type == (int) N_FUN) 572 { 573 int strx = bfd_get_32 (abfd, sym + STRDXOFF); 574 575 if (strx == 0) 576 { 577 if (deleting) 578 { 579 skip++; 580 *pstridx = -1; 581 } 582 deleting = -1; 583 continue; 584 } 585 deleting = 0; 586 if ((*reloc_symbol_deleted_p) (sym + VALOFF - stabbuf, cookie)) 587 deleting = 1; 588 } 589 590 if (deleting == 1) 591 { 592 *pstridx = -1; 593 skip++; 594 } 595 else if (deleting == -1) 596 { 597 /* Outside of a function. Check for deleted variables. */ 598 if (type == (int) N_STSYM || type == (int) N_LCSYM) 599 if ((*reloc_symbol_deleted_p) (sym + VALOFF - stabbuf, cookie)) 600 { 601 *pstridx = -1; 602 skip ++; 603 } 604 /* We should also check for N_GSYM entries which reference a 605 deleted global, but those are less harmful to debuggers 606 and would require parsing the stab strings. */ 607 } 608 } 609 610 free (stabbuf); 611 stabbuf = NULL; 612 613 /* Shrink the stabsec as needed. */ 614 stabsec->size -= skip * STABSIZE; 615 if (stabsec->size == 0) 616 stabsec->flags |= SEC_EXCLUDE | SEC_KEEP; 617 618 /* Recalculate the `cumulative_skips' array now that stabs have been 619 deleted for this section. */ 620 621 if (skip != 0) 622 { 623 bfd_size_type i, offset; 624 bfd_size_type *pskips; 625 626 if (secinfo->cumulative_skips == NULL) 627 { 628 amt = count * sizeof (bfd_size_type); 629 secinfo->cumulative_skips = (bfd_size_type *) bfd_alloc (abfd, amt); 630 if (secinfo->cumulative_skips == NULL) 631 goto error_return; 632 } 633 634 pskips = secinfo->cumulative_skips; 635 pstridx = secinfo->stridxs; 636 offset = 0; 637 638 for (i = 0; i < count; i++, pskips++, pstridx++) 639 { 640 *pskips = offset; 641 if (*pstridx == (bfd_size_type) -1) 642 offset += STABSIZE; 643 } 644 645 BFD_ASSERT (offset != 0); 646 } 647 648 return skip > 0; 649 650 error_return: 651 if (stabbuf != NULL) 652 free (stabbuf); 653 return FALSE; 654} 655 656/* Write out the stab section. This is called with the relocated 657 contents. */ 658 659bfd_boolean 660_bfd_write_section_stabs (bfd *output_bfd, 661 struct stab_info *sinfo, 662 asection *stabsec, 663 void * *psecinfo, 664 bfd_byte *contents) 665{ 666 struct stab_section_info *secinfo; 667 struct stab_excl_list *e; 668 bfd_byte *sym, *tosym, *symend; 669 bfd_size_type *pstridx; 670 671 secinfo = (struct stab_section_info *) *psecinfo; 672 673 if (secinfo == NULL) 674 return bfd_set_section_contents (output_bfd, stabsec->output_section, 675 contents, stabsec->output_offset, 676 stabsec->size); 677 678 /* Handle each N_BINCL entry. */ 679 for (e = secinfo->excls; e != NULL; e = e->next) 680 { 681 bfd_byte *excl_sym; 682 683 BFD_ASSERT (e->offset < stabsec->rawsize); 684 excl_sym = contents + e->offset; 685 bfd_put_32 (output_bfd, e->val, excl_sym + VALOFF); 686 excl_sym[TYPEOFF] = e->type; 687 } 688 689 /* Copy over all the stabs symbols, omitting the ones we don't want, 690 and correcting the string indices for those we do want. */ 691 tosym = contents; 692 symend = contents + stabsec->rawsize; 693 for (sym = contents, pstridx = secinfo->stridxs; 694 sym < symend; 695 sym += STABSIZE, ++pstridx) 696 { 697 if (*pstridx != (bfd_size_type) -1) 698 { 699 if (tosym != sym) 700 memcpy (tosym, sym, STABSIZE); 701 bfd_put_32 (output_bfd, *pstridx, tosym + STRDXOFF); 702 703 if (sym[TYPEOFF] == 0) 704 { 705 /* This is the header symbol for the stabs section. We 706 don't really need one, since we have merged all the 707 input stabs sections into one, but we generate one 708 for the benefit of readers which expect to see one. */ 709 BFD_ASSERT (sym == contents); 710 bfd_put_32 (output_bfd, _bfd_stringtab_size (sinfo->strings), 711 tosym + VALOFF); 712 bfd_put_16 (output_bfd, 713 stabsec->output_section->size / STABSIZE - 1, 714 tosym + DESCOFF); 715 } 716 717 tosym += STABSIZE; 718 } 719 } 720 721 BFD_ASSERT ((bfd_size_type) (tosym - contents) == stabsec->size); 722 723 return bfd_set_section_contents (output_bfd, stabsec->output_section, 724 contents, (file_ptr) stabsec->output_offset, 725 stabsec->size); 726} 727 728/* Write out the .stabstr section. */ 729 730bfd_boolean 731_bfd_write_stab_strings (bfd *output_bfd, struct stab_info *sinfo) 732{ 733 if (bfd_is_abs_section (sinfo->stabstr->output_section)) 734 /* The section was discarded from the link. */ 735 return TRUE; 736 737 BFD_ASSERT ((sinfo->stabstr->output_offset 738 + _bfd_stringtab_size (sinfo->strings)) 739 <= sinfo->stabstr->output_section->size); 740 741 if (bfd_seek (output_bfd, 742 (file_ptr) (sinfo->stabstr->output_section->filepos 743 + sinfo->stabstr->output_offset), 744 SEEK_SET) != 0) 745 return FALSE; 746 747 if (! _bfd_stringtab_emit (output_bfd, sinfo->strings)) 748 return FALSE; 749 750 /* We no longer need the stabs information. */ 751 _bfd_stringtab_free (sinfo->strings); 752 bfd_hash_table_free (&sinfo->includes); 753 754 return TRUE; 755} 756 757/* Adjust an address in the .stab section. Given OFFSET within 758 STABSEC, this returns the new offset in the adjusted stab section, 759 or -1 if the address refers to a stab which has been removed. */ 760 761bfd_vma 762_bfd_stab_section_offset (asection *stabsec, 763 void * psecinfo, 764 bfd_vma offset) 765{ 766 struct stab_section_info *secinfo; 767 768 secinfo = (struct stab_section_info *) psecinfo; 769 770 if (secinfo == NULL) 771 return offset; 772 773 if (offset >= stabsec->rawsize) 774 return offset - stabsec->rawsize + stabsec->size; 775 776 if (secinfo->cumulative_skips) 777 { 778 bfd_vma i; 779 780 i = offset / STABSIZE; 781 782 if (secinfo->stridxs [i] == (bfd_size_type) -1) 783 return (bfd_vma) -1; 784 785 return offset - secinfo->cumulative_skips [i]; 786 } 787 788 return offset; 789} 790