bfd/stabs.c

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