OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [stabs.c] - Blame information for rev 846

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* 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
 
116
 
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
}
144
 
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
}
503
 
504
/* This function is called for each input file before the stab
505
   section is relocated.  It discards stab entries for discarded
506
   functions and variables.  The function returns TRUE iff
507
   any entries have been deleted.
508
*/
509
 
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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.