* stabs.c (_bfd_link_section_stabs): Copy over the first header
[external/binutils.git] / bfd / stabs.c
1 /* Stabs in sections linking support.
2    Copyright 1996, 1997 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
21 /* This file contains support for linking stabs in sections, as used
22    on COFF and ELF.  */
23
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "libbfd.h"
27 #include "aout/stab_gnu.h"
28
29 #include <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   /* This is an array of string indices.  For each stab symbol, we
105      store the string index here.  If a stab symbol should not be
106      included in the final output, the string index is -1.  */
107   bfd_size_type stridxs[1];
108 };
109
110 /* This structure is used to keep track of stabs in sections
111    information while linking.  */
112
113 struct stab_info
114 {
115   /* A hash table used to hold stabs strings.  */
116   struct bfd_strtab_hash *strings;
117   /* The header file hash table.  */
118   struct stab_link_includes_table includes;
119   /* The first .stabstr section.  */
120   asection *stabstr;
121 };
122
123 static struct bfd_hash_entry *stab_link_includes_newfunc
124   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
125 \f
126 /* The function to create a new entry in the header file hash table.  */
127
128 static struct bfd_hash_entry *
129 stab_link_includes_newfunc (entry, table, string)
130      struct bfd_hash_entry *entry;
131      struct bfd_hash_table *table;
132      const char *string;
133 {
134   struct stab_link_includes_entry *ret =
135     (struct stab_link_includes_entry *) entry;
136
137   /* Allocate the structure if it has not already been allocated by a
138      subclass.  */
139   if (ret == (struct stab_link_includes_entry *) NULL)
140     ret = ((struct stab_link_includes_entry *)
141            bfd_hash_allocate (table,
142                               sizeof (struct stab_link_includes_entry)));
143   if (ret == (struct stab_link_includes_entry *) NULL)
144     return (struct bfd_hash_entry *) ret;
145
146   /* Call the allocation method of the superclass.  */
147   ret = ((struct stab_link_includes_entry *)
148          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
149   if (ret)
150     {
151       /* Set local fields.  */
152       ret->totals = NULL;
153     }
154
155   return (struct bfd_hash_entry *) ret;
156 }
157 \f
158 /* This function is called for each input file from the add_symbols
159    pass of the linker.  */
160
161 boolean
162 _bfd_link_section_stabs (abfd, psinfo, stabsec, stabstrsec, psecinfo)
163      bfd *abfd;
164      PTR *psinfo;
165      asection *stabsec;
166      asection *stabstrsec;
167      PTR *psecinfo;
168 {
169   boolean first;
170   struct stab_info *sinfo;
171   bfd_size_type count;
172   struct stab_section_info *secinfo;
173   bfd_byte *stabbuf = NULL;
174   bfd_byte *stabstrbuf = NULL;
175   bfd_byte *sym, *symend;
176   bfd_size_type stroff, next_stroff, skip;
177   bfd_size_type *pstridx;
178
179   if (stabsec->_raw_size == 0
180       || stabstrsec->_raw_size == 0)
181     {
182       /* This file does not contain stabs debugging information.  */
183       return true;
184     }
185
186   if (stabsec->_raw_size % STABSIZE != 0)
187     {
188       /* Something is wrong with the format of these stab symbols.
189          Don't try to optimize them.  */
190       return true;
191     }
192
193   if ((stabstrsec->flags & SEC_RELOC) != 0)
194     {
195       /* We shouldn't see relocations in the strings, and we aren't
196          prepared to handle them.  */
197       return true;
198     }
199
200   if ((stabsec->output_section != NULL
201        && bfd_is_abs_section (stabsec->output_section))
202       || (stabstrsec->output_section != NULL
203           && bfd_is_abs_section (stabstrsec->output_section)))
204     {
205       /* At least one of the sections is being discarded from the
206          link, so we should just ignore them.  */
207       return true;
208     }
209
210   first = false;
211
212   if (*psinfo == NULL)
213     {
214       /* Initialize the stabs information we need to keep track of.  */
215       first = true;
216       *psinfo = (PTR) bfd_alloc (abfd, sizeof (struct stab_info));
217       if (*psinfo == NULL)
218         goto error_return;
219       sinfo = (struct stab_info *) *psinfo;
220       sinfo->strings = _bfd_stringtab_init ();
221       if (sinfo->strings == NULL)
222         goto error_return;
223       if (! bfd_hash_table_init_n (&sinfo->includes.root,
224                                    stab_link_includes_newfunc,
225                                    251))
226         goto error_return;
227       sinfo->stabstr = bfd_make_section_anyway (abfd, ".stabstr");
228       sinfo->stabstr->flags |= SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
229     }
230
231   sinfo = (struct stab_info *) *psinfo;
232
233   /* Initialize the information we are going to store for this .stab
234      section.  */
235
236   count = stabsec->_raw_size / STABSIZE;
237
238   *psecinfo = bfd_alloc (abfd,
239                          (sizeof (struct stab_section_info)
240                           + (count - 1) * sizeof (bfd_size_type)));
241   if (*psecinfo == NULL)
242     goto error_return;
243
244   secinfo = (struct stab_section_info *) *psecinfo;
245   secinfo->excls = NULL;
246   memset (secinfo->stridxs, 0, count * sizeof (bfd_size_type));
247
248   /* Read the stabs information from abfd.  */
249
250   stabbuf = (bfd_byte *) bfd_malloc (stabsec->_raw_size);
251   stabstrbuf = (bfd_byte *) bfd_malloc (stabstrsec->_raw_size);
252   if (stabbuf == NULL || stabstrbuf == NULL)
253     goto error_return;
254
255   if (! bfd_get_section_contents (abfd, stabsec, stabbuf, 0,
256                                   stabsec->_raw_size)
257       || ! bfd_get_section_contents (abfd, stabstrsec, stabstrbuf, 0,
258                                      stabstrsec->_raw_size))
259     goto error_return;
260
261   /* Look through the stabs symbols, work out the new string indices,
262      and identify N_BINCL symbols which can be eliminated.  */
263
264   stroff = 0;
265   next_stroff = 0;
266   skip = 0;
267
268   symend = stabbuf + stabsec->_raw_size;
269   for (sym = stabbuf, pstridx = secinfo->stridxs;
270        sym < symend;
271        sym += STABSIZE, ++pstridx)
272     {
273       int type;
274       const char *string;
275
276       if (*pstridx != 0)
277         {
278           /* This symbol has already been handled by an N_BINCL pass.  */
279           continue;
280         }
281
282       type = sym[TYPEOFF];
283
284       if (type == 0)
285         {
286           /* Special type 0 stabs indicate the offset to the next
287              string table.  We only copy the very first one.  */
288           stroff = next_stroff;
289           next_stroff += bfd_get_32 (abfd, sym + 8);
290           if (! first)
291             {
292               *pstridx = (bfd_size_type) -1;
293               ++skip;
294               continue;
295             }
296           first = false;
297         }
298
299       /* Store the string in the hash table, and record the index.  */
300       string = ((char *) stabstrbuf
301                 + stroff
302                 + bfd_get_32 (abfd, sym + STRDXOFF));
303       *pstridx = _bfd_stringtab_add (sinfo->strings, string, true, true);
304
305       /* An N_BINCL symbol indicates the start of the stabs entries
306          for a header file.  We need to scan ahead to the next N_EINCL
307          symbol, ignoring nesting, adding up all the characters in the
308          symbol names, not including the file numbers in types (the
309          first number after an open parenthesis).  */
310       if (type == N_BINCL)
311         {
312           bfd_vma val;
313           int nest;
314           bfd_byte *incl_sym;
315           struct stab_link_includes_entry *incl_entry;
316           struct stab_link_includes_totals *t;
317           struct stab_excl_list *ne;
318
319           val = 0;
320           nest = 0;
321           for (incl_sym = sym + STABSIZE;
322                incl_sym < symend;
323                incl_sym += STABSIZE)
324             {
325               int incl_type;
326
327               incl_type = incl_sym[TYPEOFF];
328               if (incl_type == 0)
329                 break;
330               else if (incl_type == N_EINCL)
331                 {
332                   if (nest == 0)
333                     break;
334                   --nest;
335                 }
336               else if (incl_type == N_BINCL)
337                 ++nest;
338               else if (nest == 0)
339                 {
340                   const char *str;
341
342                   str = ((char *) stabstrbuf
343                          + stroff
344                          + bfd_get_32 (abfd, incl_sym + STRDXOFF));
345                   for (; *str != '\0'; str++)
346                     {
347                       val += *str;
348                       if (*str == '(')
349                         {
350                           /* Skip the file number.  */
351                           ++str;
352                           while (isdigit ((unsigned char) *str))
353                             ++str;
354                           --str;
355                         }
356                     }
357                 }
358             }
359
360           /* If we have already included a header file with the same
361              value, then replaced this one with an N_EXCL symbol.  */
362           incl_entry = stab_link_includes_lookup (&sinfo->includes, string,
363                                                   true, true);
364           if (incl_entry == NULL)
365             goto error_return;
366
367           for (t = incl_entry->totals; t != NULL; t = t->next)
368             if (t->total == val)
369               break;
370
371           /* Record this symbol, so that we can set the value
372              correctly.  */
373           ne = (struct stab_excl_list *) bfd_alloc (abfd, sizeof *ne);
374           ne->offset = sym - stabbuf;
375           ne->val = val;
376           ne->type = N_BINCL;
377           ne->next = secinfo->excls;
378           secinfo->excls = ne;
379
380           if (t == NULL)
381             {
382               /* This is the first time we have seen this header file
383                  with this set of stabs strings.  */
384               t = ((struct stab_link_includes_totals *)
385                    bfd_hash_allocate (&sinfo->includes.root, sizeof *t));
386               if (t == NULL)
387                 goto error_return;
388               t->total = val;
389               t->next = incl_entry->totals;
390               incl_entry->totals = t;
391             }
392           else
393             {
394               bfd_size_type *incl_pstridx;
395
396               /* We have seen this header file before.  Tell the final
397                  pass to change the type to N_EXCL.  */
398               ne->type = N_EXCL;
399
400               /* Mark the skipped symbols.  */
401
402               nest = 0;
403               for (incl_sym = sym + STABSIZE, incl_pstridx = pstridx + 1;
404                    incl_sym < symend;
405                    incl_sym += STABSIZE, ++incl_pstridx)
406                 {
407                   int incl_type;
408
409                   incl_type = incl_sym[TYPEOFF];
410
411                   if (incl_type == N_EINCL)
412                     {
413                       if (nest == 0)
414                         {
415                           *incl_pstridx = (bfd_size_type) -1;
416                           ++skip;
417                           break;
418                         }
419                       --nest;
420                     }
421                   else if (incl_type == N_BINCL)
422                     ++nest;
423                   else if (nest == 0)
424                     {
425                       *incl_pstridx = (bfd_size_type) -1;
426                       ++skip;
427                     }
428                 }
429             }
430         }
431     }
432
433   free (stabbuf);
434   free (stabstrbuf);
435
436   /* We need to set the section sizes such that the linker will
437      compute the output section sizes correctly.  We set the .stab
438      size to not include the entries we don't want.  We set
439      SEC_EXCLUDE for the .stabstr section, so that it will be dropped
440      from the link.  We record the size of the strtab in the first
441      .stabstr section we saw, and make sure we don't set SEC_EXCLUDE
442      for that section.  */
443   stabsec->_cooked_size = (count - skip) * STABSIZE;
444   if (stabsec->_cooked_size == 0)
445     stabsec->flags |= SEC_EXCLUDE;
446   stabstrsec->flags |= SEC_EXCLUDE;
447   sinfo->stabstr->_cooked_size = _bfd_stringtab_size (sinfo->strings);
448
449   return true;
450
451  error_return:
452   if (stabbuf != NULL)
453     free (stabbuf);
454   if (stabstrbuf != NULL)
455     free (stabstrbuf);
456   return false;
457 }
458
459 /* Write out the stab section.  This is called with the relocated
460    contents.  */
461
462 boolean
463 _bfd_write_section_stabs (output_bfd, psinfo, stabsec, psecinfo, contents)
464      bfd *output_bfd;
465      PTR *psinfo;
466      asection *stabsec;
467      PTR *psecinfo;
468      bfd_byte *contents;
469 {
470   struct stab_info *sinfo;
471   struct stab_section_info *secinfo;
472   struct stab_excl_list *e;
473   bfd_byte *sym, *tosym, *symend;
474   bfd_size_type *pstridx;
475
476   sinfo = (struct stab_info *) *psinfo;
477   secinfo = (struct stab_section_info *) *psecinfo;
478
479   if (secinfo == NULL)
480     return bfd_set_section_contents (output_bfd, stabsec->output_section,
481                                      contents, stabsec->output_offset,
482                                      stabsec->_raw_size);
483
484   /* Handle each N_BINCL entry.  */
485   for (e = secinfo->excls; e != NULL; e = e->next)
486     {
487       bfd_byte *excl_sym;
488
489       BFD_ASSERT (e->offset < stabsec->_raw_size);
490       excl_sym = contents + e->offset;
491       bfd_put_32 (output_bfd, e->val, excl_sym + VALOFF);
492       excl_sym[TYPEOFF] = e->type;
493     }
494
495   /* Copy over all the stabs symbols, omitting the ones we don't want,
496      and correcting the string indices for those we do want.  */
497   tosym = contents;
498   symend = contents + stabsec->_raw_size;
499   for (sym = contents, pstridx = secinfo->stridxs;
500        sym < symend;
501        sym += STABSIZE, ++pstridx)
502     {
503       if (*pstridx != (bfd_size_type) -1)
504         {
505           if (tosym != sym)
506             memcpy (tosym, sym, STABSIZE);
507           bfd_put_32 (output_bfd, *pstridx, tosym + STRDXOFF);
508
509           if (sym[TYPEOFF] == 0)
510             {
511               /* This is the header symbol for the stabs section.  We
512                  don't really need one, since we have merged all the
513                  input stabs sections into one, but we generate one
514                  for the benefit of readers which expect to see one.  */
515               BFD_ASSERT (sym == contents);
516               bfd_put_32 (output_bfd, _bfd_stringtab_size (sinfo->strings),
517                           tosym + VALOFF);
518               bfd_put_16 (output_bfd,
519                           stabsec->output_section->_raw_size / STABSIZE - 1,
520                           tosym + DESCOFF);
521             }
522
523           tosym += STABSIZE;
524         }
525     }
526
527   BFD_ASSERT (tosym - contents == stabsec->_cooked_size);
528
529   return bfd_set_section_contents (output_bfd, stabsec->output_section,
530                                    contents, stabsec->output_offset,
531                                    stabsec->_cooked_size);
532 }
533
534 /* Write out the .stabstr section.  */
535
536 boolean
537 _bfd_write_stab_strings (output_bfd, psinfo)
538      bfd *output_bfd;
539      PTR *psinfo;
540 {
541   struct stab_info *sinfo;
542
543   sinfo = (struct stab_info *) *psinfo;
544
545   if (sinfo == NULL)
546     return true;
547
548   BFD_ASSERT ((sinfo->stabstr->output_offset
549                + _bfd_stringtab_size (sinfo->strings))
550               <= sinfo->stabstr->output_section->_raw_size);
551
552   if (bfd_seek (output_bfd,
553                 (sinfo->stabstr->output_section->filepos
554                  + sinfo->stabstr->output_offset),
555                 SEEK_SET) != 0)
556     return false;
557
558   if (! _bfd_stringtab_emit (output_bfd, sinfo->strings))
559     return false;
560
561   /* We no longer need the stabs information.  */
562   _bfd_stringtab_free (sinfo->strings);
563   bfd_hash_table_free (&sinfo->includes.root);
564
565   return true;
566 }