Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  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.  
  61. struct 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.  
  71. struct 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.  
  81. struct 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.  
  95. struct 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.  
  117. /* The function to create a new entry in the header file hash table.  */
  118.  
  119. static struct bfd_hash_entry *
  120. stab_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. }
  145. /* This function is called for each input file from the add_symbols
  146.    pass of the linker.  */
  147.  
  148. bfd_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. }
  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.  
  510. bfd_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.  
  659. bfd_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.  
  730. bfd_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.  
  761. bfd_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.