contrib/binutils-2.25/bfd/stabs.c

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