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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [cofflink.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* COFF specific linker code.
2
   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3
   2004, 2005, 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
/* This file contains the COFF backend linker code.  */
24
 
25
#include "sysdep.h"
26
#include "bfd.h"
27
#include "bfdlink.h"
28
#include "libbfd.h"
29
#include "coff/internal.h"
30
#include "libcoff.h"
31
#include "safe-ctype.h"
32
 
33
static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info);
34
static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded);
35
static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info);
36
 
37
/* Return TRUE if SYM is a weak, external symbol.  */
38
#define IS_WEAK_EXTERNAL(abfd, sym)                     \
39
  ((sym).n_sclass == C_WEAKEXT                          \
40
   || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
41
 
42
/* Return TRUE if SYM is an external symbol.  */
43
#define IS_EXTERNAL(abfd, sym)                          \
44
  ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
45
 
46
/* Define macros so that the ISFCN, et. al., macros work correctly.
47
   These macros are defined in include/coff/internal.h in terms of
48
   N_TMASK, etc.  These definitions require a user to define local
49
   variables with the appropriate names, and with values from the
50
   coff_data (abfd) structure.  */
51
 
52
#define N_TMASK n_tmask
53
#define N_BTSHFT n_btshft
54
#define N_BTMASK n_btmask
55
 
56
/* Create an entry in a COFF linker hash table.  */
57
 
58
struct bfd_hash_entry *
59
_bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
60
                             struct bfd_hash_table *table,
61
                             const char *string)
62
{
63
  struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
64
 
65
  /* Allocate the structure if it has not already been allocated by a
66
     subclass.  */
67
  if (ret == (struct coff_link_hash_entry *) NULL)
68
    ret = ((struct coff_link_hash_entry *)
69
           bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
70
  if (ret == (struct coff_link_hash_entry *) NULL)
71
    return (struct bfd_hash_entry *) ret;
72
 
73
  /* Call the allocation method of the superclass.  */
74
  ret = ((struct coff_link_hash_entry *)
75
         _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
76
                                 table, string));
77
  if (ret != (struct coff_link_hash_entry *) NULL)
78
    {
79
      /* Set local fields.  */
80
      ret->indx = -1;
81
      ret->type = T_NULL;
82
      ret->class = C_NULL;
83
      ret->numaux = 0;
84
      ret->auxbfd = NULL;
85
      ret->aux = NULL;
86
    }
87
 
88
  return (struct bfd_hash_entry *) ret;
89
}
90
 
91
/* Initialize a COFF linker hash table.  */
92
 
93
bfd_boolean
94
_bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
95
                                bfd *abfd,
96
                                struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
97
                                                                   struct bfd_hash_table *,
98
                                                                   const char *),
99
                                unsigned int entsize)
100
{
101
  memset (&table->stab_info, 0, sizeof (table->stab_info));
102
  return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
103
}
104
 
105
/* Create a COFF linker hash table.  */
106
 
107
struct bfd_link_hash_table *
108
_bfd_coff_link_hash_table_create (bfd *abfd)
109
{
110
  struct coff_link_hash_table *ret;
111
  bfd_size_type amt = sizeof (struct coff_link_hash_table);
112
 
113
  ret = bfd_malloc (amt);
114
  if (ret == NULL)
115
    return NULL;
116
 
117
  if (! _bfd_coff_link_hash_table_init (ret, abfd,
118
                                        _bfd_coff_link_hash_newfunc,
119
                                        sizeof (struct coff_link_hash_entry)))
120
    {
121
      free (ret);
122
      return (struct bfd_link_hash_table *) NULL;
123
    }
124
  return &ret->root;
125
}
126
 
127
/* Create an entry in a COFF debug merge hash table.  */
128
 
129
struct bfd_hash_entry *
130
_bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,
131
                                    struct bfd_hash_table *table,
132
                                    const char *string)
133
{
134
  struct coff_debug_merge_hash_entry *ret =
135
    (struct coff_debug_merge_hash_entry *) entry;
136
 
137
  /* Allocate the structure if it has not already been allocated by a
138
     subclass.  */
139
  if (ret == (struct coff_debug_merge_hash_entry *) NULL)
140
    ret = ((struct coff_debug_merge_hash_entry *)
141
           bfd_hash_allocate (table,
142
                              sizeof (struct coff_debug_merge_hash_entry)));
143
  if (ret == (struct coff_debug_merge_hash_entry *) NULL)
144
    return (struct bfd_hash_entry *) ret;
145
 
146
  /* Call the allocation method of the superclass.  */
147
  ret = ((struct coff_debug_merge_hash_entry *)
148
         bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
149
  if (ret != (struct coff_debug_merge_hash_entry *) NULL)
150
    {
151
      /* Set local fields.  */
152
      ret->types = NULL;
153
    }
154
 
155
  return (struct bfd_hash_entry *) ret;
156
}
157
 
158
/* Given a COFF BFD, add symbols to the global hash table as
159
   appropriate.  */
160
 
161
bfd_boolean
162
_bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
163
{
164
  switch (bfd_get_format (abfd))
165
    {
166
    case bfd_object:
167
      return coff_link_add_object_symbols (abfd, info);
168
    case bfd_archive:
169
      return _bfd_generic_link_add_archive_symbols
170
        (abfd, info, coff_link_check_archive_element);
171
    default:
172
      bfd_set_error (bfd_error_wrong_format);
173
      return FALSE;
174
    }
175
}
176
 
177
/* Add symbols from a COFF object file.  */
178
 
179
static bfd_boolean
180
coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
181
{
182
  if (! _bfd_coff_get_external_symbols (abfd))
183
    return FALSE;
184
  if (! coff_link_add_symbols (abfd, info))
185
    return FALSE;
186
 
187
  if (! info->keep_memory
188
      && ! _bfd_coff_free_symbols (abfd))
189
    return FALSE;
190
 
191
  return TRUE;
192
}
193
 
194
/* Look through the symbols to see if this object file should be
195
   included in the link.  */
196
 
197
static bfd_boolean
198
coff_link_check_ar_symbols (bfd *abfd,
199
                            struct bfd_link_info *info,
200
                            bfd_boolean *pneeded)
201
{
202
  bfd_size_type symesz;
203
  bfd_byte *esym;
204
  bfd_byte *esym_end;
205
 
206
  *pneeded = FALSE;
207
 
208
  symesz = bfd_coff_symesz (abfd);
209
  esym = (bfd_byte *) obj_coff_external_syms (abfd);
210
  esym_end = esym + obj_raw_syment_count (abfd) * symesz;
211
  while (esym < esym_end)
212
    {
213
      struct internal_syment sym;
214
      enum coff_symbol_classification classification;
215
 
216
      bfd_coff_swap_sym_in (abfd, esym, &sym);
217
 
218
      classification = bfd_coff_classify_symbol (abfd, &sym);
219
      if (classification == COFF_SYMBOL_GLOBAL
220
          || classification == COFF_SYMBOL_COMMON)
221
        {
222
          const char *name;
223
          char buf[SYMNMLEN + 1];
224
          struct bfd_link_hash_entry *h;
225
 
226
          /* This symbol is externally visible, and is defined by this
227
             object file.  */
228
          name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
229
          if (name == NULL)
230
            return FALSE;
231
          h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
232
 
233
          /* Auto import.  */
234
          if (!h
235
              && info->pei386_auto_import
236
              && CONST_STRNEQ (name, "__imp_"))
237
            h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
238
 
239
          /* We are only interested in symbols that are currently
240
             undefined.  If a symbol is currently known to be common,
241
             COFF linkers do not bring in an object file which defines
242
             it.  */
243
          if (h != (struct bfd_link_hash_entry *) NULL
244
              && h->type == bfd_link_hash_undefined)
245
            {
246
              if (! (*info->callbacks->add_archive_element) (info, abfd, name))
247
                return FALSE;
248
              *pneeded = TRUE;
249
              return TRUE;
250
            }
251
        }
252
 
253
      esym += (sym.n_numaux + 1) * symesz;
254
    }
255
 
256
  /* We do not need this object file.  */
257
  return TRUE;
258
}
259
 
260
/* Check a single archive element to see if we need to include it in
261
   the link.  *PNEEDED is set according to whether this element is
262
   needed in the link or not.  This is called via
263
   _bfd_generic_link_add_archive_symbols.  */
264
 
265
static bfd_boolean
266
coff_link_check_archive_element (bfd *abfd,
267
                                 struct bfd_link_info *info,
268
                                 bfd_boolean *pneeded)
269
{
270
  if (! _bfd_coff_get_external_symbols (abfd))
271
    return FALSE;
272
 
273
  if (! coff_link_check_ar_symbols (abfd, info, pneeded))
274
    return FALSE;
275
 
276
  if (*pneeded
277
      && ! coff_link_add_symbols (abfd, info))
278
    return FALSE;
279
 
280
  if ((! info->keep_memory || ! *pneeded)
281
      && ! _bfd_coff_free_symbols (abfd))
282
    return FALSE;
283
 
284
  return TRUE;
285
}
286
 
287
/* Add all the symbols from an object file to the hash table.  */
288
 
289
static bfd_boolean
290
coff_link_add_symbols (bfd *abfd,
291
                       struct bfd_link_info *info)
292
{
293
  unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
294
  unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
295
  unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
296
  bfd_boolean keep_syms;
297
  bfd_boolean default_copy;
298
  bfd_size_type symcount;
299
  struct coff_link_hash_entry **sym_hash;
300
  bfd_size_type symesz;
301
  bfd_byte *esym;
302
  bfd_byte *esym_end;
303
  bfd_size_type amt;
304
 
305
  symcount = obj_raw_syment_count (abfd);
306
 
307
  if (symcount == 0)
308
    return TRUE;                /* Nothing to do.  */
309
 
310
  /* Keep the symbols during this function, in case the linker needs
311
     to read the generic symbols in order to report an error message.  */
312
  keep_syms = obj_coff_keep_syms (abfd);
313
  obj_coff_keep_syms (abfd) = TRUE;
314
 
315
  if (info->keep_memory)
316
    default_copy = FALSE;
317
  else
318
    default_copy = TRUE;
319
 
320
  /* We keep a list of the linker hash table entries that correspond
321
     to particular symbols.  */
322
  amt = symcount * sizeof (struct coff_link_hash_entry *);
323
  sym_hash = bfd_zalloc (abfd, amt);
324
  if (sym_hash == NULL)
325
    goto error_return;
326
  obj_coff_sym_hashes (abfd) = sym_hash;
327
 
328
  symesz = bfd_coff_symesz (abfd);
329
  BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
330
  esym = (bfd_byte *) obj_coff_external_syms (abfd);
331
  esym_end = esym + symcount * symesz;
332
  while (esym < esym_end)
333
    {
334
      struct internal_syment sym;
335
      enum coff_symbol_classification classification;
336
      bfd_boolean copy;
337
 
338
      bfd_coff_swap_sym_in (abfd, esym, &sym);
339
 
340
      classification = bfd_coff_classify_symbol (abfd, &sym);
341
      if (classification != COFF_SYMBOL_LOCAL)
342
        {
343
          const char *name;
344
          char buf[SYMNMLEN + 1];
345
          flagword flags;
346
          asection *section;
347
          bfd_vma value;
348
          bfd_boolean addit;
349
 
350
          /* This symbol is externally visible.  */
351
 
352
          name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
353
          if (name == NULL)
354
            goto error_return;
355
 
356
          /* We must copy the name into memory if we got it from the
357
             syment itself, rather than the string table.  */
358
          copy = default_copy;
359
          if (sym._n._n_n._n_zeroes != 0
360
              || sym._n._n_n._n_offset == 0)
361
            copy = TRUE;
362
 
363
          value = sym.n_value;
364
 
365
          switch (classification)
366
            {
367
            default:
368
              abort ();
369
 
370
            case COFF_SYMBOL_GLOBAL:
371
              flags = BSF_EXPORT | BSF_GLOBAL;
372
              section = coff_section_from_bfd_index (abfd, sym.n_scnum);
373
              if (! obj_pe (abfd))
374
                value -= section->vma;
375
              break;
376
 
377
            case COFF_SYMBOL_UNDEFINED:
378
              flags = 0;
379
              section = bfd_und_section_ptr;
380
              break;
381
 
382
            case COFF_SYMBOL_COMMON:
383
              flags = BSF_GLOBAL;
384
              section = bfd_com_section_ptr;
385
              break;
386
 
387
            case COFF_SYMBOL_PE_SECTION:
388
              flags = BSF_SECTION_SYM | BSF_GLOBAL;
389
              section = coff_section_from_bfd_index (abfd, sym.n_scnum);
390
              break;
391
            }
392
 
393
          if (IS_WEAK_EXTERNAL (abfd, sym))
394
            flags = BSF_WEAK;
395
 
396
          addit = TRUE;
397
 
398
          /* In the PE format, section symbols actually refer to the
399
             start of the output section.  We handle them specially
400
             here.  */
401
          if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
402
            {
403
              *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
404
                                                 name, FALSE, copy, FALSE);
405
              if (*sym_hash != NULL)
406
                {
407
                  if (((*sym_hash)->coff_link_hash_flags
408
                       & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
409
                      && (*sym_hash)->root.type != bfd_link_hash_undefined
410
                      && (*sym_hash)->root.type != bfd_link_hash_undefweak)
411
                    (*_bfd_error_handler)
412
                      ("Warning: symbol `%s' is both section and non-section",
413
                       name);
414
 
415
                  addit = FALSE;
416
                }
417
            }
418
 
419
          /* The Microsoft Visual C compiler does string pooling by
420
             hashing the constants to an internal symbol name, and
421
             relying on the linker comdat support to discard
422
             duplicate names.  However, if one string is a literal and
423
             one is a data initializer, one will end up in the .data
424
             section and one will end up in the .rdata section.  The
425
             Microsoft linker will combine them into the .data
426
             section, which seems to be wrong since it might cause the
427
             literal to change.
428
 
429
             As long as there are no external references to the
430
             symbols, which there shouldn't be, we can treat the .data
431
             and .rdata instances as separate symbols.  The comdat
432
             code in the linker will do the appropriate merging.  Here
433
             we avoid getting a multiple definition error for one of
434
             these special symbols.
435
 
436
             FIXME: I don't think this will work in the case where
437
             there are two object files which use the constants as a
438
             literal and two object files which use it as a data
439
             initializer.  One or the other of the second object files
440
             is going to wind up with an inappropriate reference.  */
441
          if (obj_pe (abfd)
442
              && (classification == COFF_SYMBOL_GLOBAL
443
                  || classification == COFF_SYMBOL_PE_SECTION)
444
              && coff_section_data (abfd, section) != NULL
445
              && coff_section_data (abfd, section)->comdat != NULL
446
              && CONST_STRNEQ (name, "??_")
447
              && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
448
            {
449
              if (*sym_hash == NULL)
450
                *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
451
                                                   name, FALSE, copy, FALSE);
452
              if (*sym_hash != NULL
453
                  && (*sym_hash)->root.type == bfd_link_hash_defined
454
                  && coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL
455
                  && strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,
456
                             coff_section_data (abfd, section)->comdat->name) == 0)
457
                addit = FALSE;
458
            }
459
 
460
          if (addit)
461
            {
462
              if (! (bfd_coff_link_add_one_symbol
463
                     (info, abfd, name, flags, section, value,
464
                      (const char *) NULL, copy, FALSE,
465
                      (struct bfd_link_hash_entry **) sym_hash)))
466
                goto error_return;
467
            }
468
 
469
          if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
470
            (*sym_hash)->coff_link_hash_flags |=
471
              COFF_LINK_HASH_PE_SECTION_SYMBOL;
472
 
473
          /* Limit the alignment of a common symbol to the possible
474
             alignment of a section.  There is no point to permitting
475
             a higher alignment for a common symbol: we can not
476
             guarantee it, and it may cause us to allocate extra space
477
             in the common section.  */
478
          if (section == bfd_com_section_ptr
479
              && (*sym_hash)->root.type == bfd_link_hash_common
480
              && ((*sym_hash)->root.u.c.p->alignment_power
481
                  > bfd_coff_default_section_alignment_power (abfd)))
482
            (*sym_hash)->root.u.c.p->alignment_power
483
              = bfd_coff_default_section_alignment_power (abfd);
484
 
485
          if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
486
            {
487
              /* If we don't have any symbol information currently in
488
                 the hash table, or if we are looking at a symbol
489
                 definition, then update the symbol class and type in
490
                 the hash table.  */
491
              if (((*sym_hash)->class == C_NULL
492
                   && (*sym_hash)->type == T_NULL)
493
                  || sym.n_scnum != 0
494
                  || (sym.n_value != 0
495
                      && (*sym_hash)->root.type != bfd_link_hash_defined
496
                      && (*sym_hash)->root.type != bfd_link_hash_defweak))
497
                {
498
                  (*sym_hash)->class = sym.n_sclass;
499
                  if (sym.n_type != T_NULL)
500
                    {
501
                      /* We want to warn if the type changed, but not
502
                         if it changed from an unspecified type.
503
                         Testing the whole type byte may work, but the
504
                         change from (e.g.) a function of unspecified
505
                         type to function of known type also wants to
506
                         skip the warning.  */
507
                      if ((*sym_hash)->type != T_NULL
508
                          && (*sym_hash)->type != sym.n_type
509
                          && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
510
                               && (BTYPE ((*sym_hash)->type) == T_NULL
511
                                   || BTYPE (sym.n_type) == T_NULL)))
512
                        (*_bfd_error_handler)
513
                          (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
514
                           abfd, name, (*sym_hash)->type, sym.n_type);
515
 
516
                      /* We don't want to change from a meaningful
517
                         base type to a null one, but if we know
518
                         nothing, take what little we might now know.  */
519
                      if (BTYPE (sym.n_type) != T_NULL
520
                          || (*sym_hash)->type == T_NULL)
521
                        (*sym_hash)->type = sym.n_type;
522
                    }
523
                  (*sym_hash)->auxbfd = abfd;
524
                  if (sym.n_numaux != 0)
525
                    {
526
                      union internal_auxent *alloc;
527
                      unsigned int i;
528
                      bfd_byte *eaux;
529
                      union internal_auxent *iaux;
530
 
531
                      (*sym_hash)->numaux = sym.n_numaux;
532
                      alloc = ((union internal_auxent *)
533
                               bfd_hash_allocate (&info->hash->table,
534
                                                  (sym.n_numaux
535
                                                   * sizeof (*alloc))));
536
                      if (alloc == NULL)
537
                        goto error_return;
538
                      for (i = 0, eaux = esym + symesz, iaux = alloc;
539
                           i < sym.n_numaux;
540
                           i++, eaux += symesz, iaux++)
541
                        bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
542
                                              sym.n_sclass, (int) i,
543
                                              sym.n_numaux, iaux);
544
                      (*sym_hash)->aux = alloc;
545
                    }
546
                }
547
            }
548
 
549
          if (classification == COFF_SYMBOL_PE_SECTION
550
              && (*sym_hash)->numaux != 0)
551
            {
552
              /* Some PE sections (such as .bss) have a zero size in
553
                 the section header, but a non-zero size in the AUX
554
                 record.  Correct that here.
555
 
556
                 FIXME: This is not at all the right place to do this.
557
                 For example, it won't help objdump.  This needs to be
558
                 done when we swap in the section header.  */
559
              BFD_ASSERT ((*sym_hash)->numaux == 1);
560
              if (section->size == 0)
561
                section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;
562
 
563
              /* FIXME: We could test whether the section sizes
564
                 matches the size in the aux entry, but apparently
565
                 that sometimes fails unexpectedly.  */
566
            }
567
        }
568
 
569
      esym += (sym.n_numaux + 1) * symesz;
570
      sym_hash += sym.n_numaux + 1;
571
    }
572
 
573
  /* If this is a non-traditional, non-relocatable link, try to
574
     optimize the handling of any .stab/.stabstr sections.  */
575
  if (! info->relocatable
576
      && ! info->traditional_format
577
      && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)
578
      && (info->strip != strip_all && info->strip != strip_debugger))
579
    {
580
      asection *stabstr;
581
 
582
      stabstr = bfd_get_section_by_name (abfd, ".stabstr");
583
 
584
      if (stabstr != NULL)
585
        {
586
          bfd_size_type string_offset = 0;
587
          asection *stab;
588
 
589
          for (stab = abfd->sections; stab; stab = stab->next)
590
            if (CONST_STRNEQ (stab->name, ".stab")
591
                && (!stab->name[5]
592
                    || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
593
            {
594
              struct coff_link_hash_table *table;
595
              struct coff_section_tdata *secdata
596
                = coff_section_data (abfd, stab);
597
 
598
              if (secdata == NULL)
599
                {
600
                  amt = sizeof (struct coff_section_tdata);
601
                  stab->used_by_bfd = bfd_zalloc (abfd, amt);
602
                  if (stab->used_by_bfd == NULL)
603
                    goto error_return;
604
                  secdata = coff_section_data (abfd, stab);
605
                }
606
 
607
              table = coff_hash_table (info);
608
 
609
              if (! _bfd_link_section_stabs (abfd, &table->stab_info,
610
                                             stab, stabstr,
611
                                             &secdata->stab_info,
612
                                             &string_offset))
613
                goto error_return;
614
            }
615
        }
616
    }
617
 
618
  obj_coff_keep_syms (abfd) = keep_syms;
619
 
620
  return TRUE;
621
 
622
 error_return:
623
  obj_coff_keep_syms (abfd) = keep_syms;
624
  return FALSE;
625
}
626
 
627
/* Do the final link step.  */
628
 
629
bfd_boolean
630
_bfd_coff_final_link (bfd *abfd,
631
                      struct bfd_link_info *info)
632
{
633
  bfd_size_type symesz;
634
  struct coff_final_link_info finfo;
635
  bfd_boolean debug_merge_allocated;
636
  bfd_boolean long_section_names;
637
  asection *o;
638
  struct bfd_link_order *p;
639
  bfd_size_type max_sym_count;
640
  bfd_size_type max_lineno_count;
641
  bfd_size_type max_reloc_count;
642
  bfd_size_type max_output_reloc_count;
643
  bfd_size_type max_contents_size;
644
  file_ptr rel_filepos;
645
  unsigned int relsz;
646
  file_ptr line_filepos;
647
  unsigned int linesz;
648
  bfd *sub;
649
  bfd_byte *external_relocs = NULL;
650
  char strbuf[STRING_SIZE_SIZE];
651
  bfd_size_type amt;
652
 
653
  symesz = bfd_coff_symesz (abfd);
654
 
655
  finfo.info = info;
656
  finfo.output_bfd = abfd;
657
  finfo.strtab = NULL;
658
  finfo.section_info = NULL;
659
  finfo.last_file_index = -1;
660
  finfo.last_bf_index = -1;
661
  finfo.internal_syms = NULL;
662
  finfo.sec_ptrs = NULL;
663
  finfo.sym_indices = NULL;
664
  finfo.outsyms = NULL;
665
  finfo.linenos = NULL;
666
  finfo.contents = NULL;
667
  finfo.external_relocs = NULL;
668
  finfo.internal_relocs = NULL;
669
  finfo.global_to_static = FALSE;
670
  debug_merge_allocated = FALSE;
671
 
672
  coff_data (abfd)->link_info = info;
673
 
674
  finfo.strtab = _bfd_stringtab_init ();
675
  if (finfo.strtab == NULL)
676
    goto error_return;
677
 
678
  if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
679
    goto error_return;
680
  debug_merge_allocated = TRUE;
681
 
682
  /* Compute the file positions for all the sections.  */
683
  if (! abfd->output_has_begun)
684
    {
685
      if (! bfd_coff_compute_section_file_positions (abfd))
686
        goto error_return;
687
    }
688
 
689
  /* Count the line numbers and relocation entries required for the
690
     output file.  Set the file positions for the relocs.  */
691
  rel_filepos = obj_relocbase (abfd);
692
  relsz = bfd_coff_relsz (abfd);
693
  max_contents_size = 0;
694
  max_lineno_count = 0;
695
  max_reloc_count = 0;
696
 
697
  long_section_names = FALSE;
698
  for (o = abfd->sections; o != NULL; o = o->next)
699
    {
700
      o->reloc_count = 0;
701
      o->lineno_count = 0;
702
      for (p = o->map_head.link_order; p != NULL; p = p->next)
703
        {
704
          if (p->type == bfd_indirect_link_order)
705
            {
706
              asection *sec;
707
 
708
              sec = p->u.indirect.section;
709
 
710
              /* Mark all sections which are to be included in the
711
                 link.  This will normally be every section.  We need
712
                 to do this so that we can identify any sections which
713
                 the linker has decided to not include.  */
714
              sec->linker_mark = TRUE;
715
 
716
              if (info->strip == strip_none
717
                  || info->strip == strip_some)
718
                o->lineno_count += sec->lineno_count;
719
 
720
              if (info->relocatable)
721
                o->reloc_count += sec->reloc_count;
722
 
723
              if (sec->rawsize > max_contents_size)
724
                max_contents_size = sec->rawsize;
725
              if (sec->size > max_contents_size)
726
                max_contents_size = sec->size;
727
              if (sec->lineno_count > max_lineno_count)
728
                max_lineno_count = sec->lineno_count;
729
              if (sec->reloc_count > max_reloc_count)
730
                max_reloc_count = sec->reloc_count;
731
            }
732
          else if (info->relocatable
733
                   && (p->type == bfd_section_reloc_link_order
734
                       || p->type == bfd_symbol_reloc_link_order))
735
            ++o->reloc_count;
736
        }
737
      if (o->reloc_count == 0)
738
        o->rel_filepos = 0;
739
      else
740
        {
741
          o->flags |= SEC_RELOC;
742
          o->rel_filepos = rel_filepos;
743
          rel_filepos += o->reloc_count * relsz;
744
          /* In PE COFF, if there are at least 0xffff relocations an
745
             extra relocation will be written out to encode the count.  */
746
          if (obj_pe (abfd) && o->reloc_count >= 0xffff)
747
            rel_filepos += relsz;
748
        }
749
 
750
      if (bfd_coff_long_section_names (abfd)
751
          && strlen (o->name) > SCNNMLEN)
752
        {
753
          /* This section has a long name which must go in the string
754
             table.  This must correspond to the code in
755
             coff_write_object_contents which puts the string index
756
             into the s_name field of the section header.  That is why
757
             we pass hash as FALSE.  */
758
          if (_bfd_stringtab_add (finfo.strtab, o->name, FALSE, FALSE)
759
              == (bfd_size_type) -1)
760
            goto error_return;
761
          long_section_names = TRUE;
762
        }
763
    }
764
 
765
  /* If doing a relocatable link, allocate space for the pointers we
766
     need to keep.  */
767
  if (info->relocatable)
768
    {
769
      unsigned int i;
770
 
771
      /* We use section_count + 1, rather than section_count, because
772
         the target_index fields are 1 based.  */
773
      amt = abfd->section_count + 1;
774
      amt *= sizeof (struct coff_link_section_info);
775
      finfo.section_info = bfd_malloc (amt);
776
      if (finfo.section_info == NULL)
777
        goto error_return;
778
      for (i = 0; i <= abfd->section_count; i++)
779
        {
780
          finfo.section_info[i].relocs = NULL;
781
          finfo.section_info[i].rel_hashes = NULL;
782
        }
783
    }
784
 
785
  /* We now know the size of the relocs, so we can determine the file
786
     positions of the line numbers.  */
787
  line_filepos = rel_filepos;
788
  linesz = bfd_coff_linesz (abfd);
789
  max_output_reloc_count = 0;
790
  for (o = abfd->sections; o != NULL; o = o->next)
791
    {
792
      if (o->lineno_count == 0)
793
        o->line_filepos = 0;
794
      else
795
        {
796
          o->line_filepos = line_filepos;
797
          line_filepos += o->lineno_count * linesz;
798
        }
799
 
800
      if (o->reloc_count != 0)
801
        {
802
          /* We don't know the indices of global symbols until we have
803
             written out all the local symbols.  For each section in
804
             the output file, we keep an array of pointers to hash
805
             table entries.  Each entry in the array corresponds to a
806
             reloc.  When we find a reloc against a global symbol, we
807
             set the corresponding entry in this array so that we can
808
             fix up the symbol index after we have written out all the
809
             local symbols.
810
 
811
             Because of this problem, we also keep the relocs in
812
             memory until the end of the link.  This wastes memory,
813
             but only when doing a relocatable link, which is not the
814
             common case.  */
815
          BFD_ASSERT (info->relocatable);
816
          amt = o->reloc_count;
817
          amt *= sizeof (struct internal_reloc);
818
          finfo.section_info[o->target_index].relocs = bfd_malloc (amt);
819
          amt = o->reloc_count;
820
          amt *= sizeof (struct coff_link_hash_entry *);
821
          finfo.section_info[o->target_index].rel_hashes = bfd_malloc (amt);
822
          if (finfo.section_info[o->target_index].relocs == NULL
823
              || finfo.section_info[o->target_index].rel_hashes == NULL)
824
            goto error_return;
825
 
826
          if (o->reloc_count > max_output_reloc_count)
827
            max_output_reloc_count = o->reloc_count;
828
        }
829
 
830
      /* Reset the reloc and lineno counts, so that we can use them to
831
         count the number of entries we have output so far.  */
832
      o->reloc_count = 0;
833
      o->lineno_count = 0;
834
    }
835
 
836
  obj_sym_filepos (abfd) = line_filepos;
837
 
838
  /* Figure out the largest number of symbols in an input BFD.  Take
839
     the opportunity to clear the output_has_begun fields of all the
840
     input BFD's.  */
841
  max_sym_count = 0;
842
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
843
    {
844
      size_t sz;
845
 
846
      sub->output_has_begun = FALSE;
847
      sz = obj_raw_syment_count (sub);
848
      if (sz > max_sym_count)
849
        max_sym_count = sz;
850
    }
851
 
852
  /* Allocate some buffers used while linking.  */
853
  amt = max_sym_count * sizeof (struct internal_syment);
854
  finfo.internal_syms = bfd_malloc (amt);
855
  amt = max_sym_count * sizeof (asection *);
856
  finfo.sec_ptrs = bfd_malloc (amt);
857
  amt = max_sym_count * sizeof (long);
858
  finfo.sym_indices = bfd_malloc (amt);
859
  finfo.outsyms = bfd_malloc ((max_sym_count + 1) * symesz);
860
  amt = max_lineno_count * bfd_coff_linesz (abfd);
861
  finfo.linenos = bfd_malloc (amt);
862
  finfo.contents = bfd_malloc (max_contents_size);
863
  amt = max_reloc_count * relsz;
864
  finfo.external_relocs = bfd_malloc (amt);
865
  if (! info->relocatable)
866
    {
867
      amt = max_reloc_count * sizeof (struct internal_reloc);
868
      finfo.internal_relocs = bfd_malloc (amt);
869
    }
870
  if ((finfo.internal_syms == NULL && max_sym_count > 0)
871
      || (finfo.sec_ptrs == NULL && max_sym_count > 0)
872
      || (finfo.sym_indices == NULL && max_sym_count > 0)
873
      || finfo.outsyms == NULL
874
      || (finfo.linenos == NULL && max_lineno_count > 0)
875
      || (finfo.contents == NULL && max_contents_size > 0)
876
      || (finfo.external_relocs == NULL && max_reloc_count > 0)
877
      || (! info->relocatable
878
          && finfo.internal_relocs == NULL
879
          && max_reloc_count > 0))
880
    goto error_return;
881
 
882
  /* We now know the position of everything in the file, except that
883
     we don't know the size of the symbol table and therefore we don't
884
     know where the string table starts.  We just build the string
885
     table in memory as we go along.  We process all the relocations
886
     for a single input file at once.  */
887
  obj_raw_syment_count (abfd) = 0;
888
 
889
  if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
890
    {
891
      if (! bfd_coff_start_final_link (abfd, info))
892
        goto error_return;
893
    }
894
 
895
  for (o = abfd->sections; o != NULL; o = o->next)
896
    {
897
      for (p = o->map_head.link_order; p != NULL; p = p->next)
898
        {
899
          if (p->type == bfd_indirect_link_order
900
              && bfd_family_coff (p->u.indirect.section->owner))
901
            {
902
              sub = p->u.indirect.section->owner;
903
              if (! bfd_coff_link_output_has_begun (sub, & finfo))
904
                {
905
                  if (! _bfd_coff_link_input_bfd (&finfo, sub))
906
                    goto error_return;
907
                  sub->output_has_begun = TRUE;
908
                }
909
            }
910
          else if (p->type == bfd_section_reloc_link_order
911
                   || p->type == bfd_symbol_reloc_link_order)
912
            {
913
              if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
914
                goto error_return;
915
            }
916
          else
917
            {
918
              if (! _bfd_default_link_order (abfd, info, o, p))
919
                goto error_return;
920
            }
921
        }
922
    }
923
 
924
  if (! bfd_coff_final_link_postscript (abfd, & finfo))
925
    goto error_return;
926
 
927
  /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
928
 
929
  coff_debug_merge_hash_table_free (&finfo.debug_merge);
930
  debug_merge_allocated = FALSE;
931
 
932
  if (finfo.internal_syms != NULL)
933
    {
934
      free (finfo.internal_syms);
935
      finfo.internal_syms = NULL;
936
    }
937
  if (finfo.sec_ptrs != NULL)
938
    {
939
      free (finfo.sec_ptrs);
940
      finfo.sec_ptrs = NULL;
941
    }
942
  if (finfo.sym_indices != NULL)
943
    {
944
      free (finfo.sym_indices);
945
      finfo.sym_indices = NULL;
946
    }
947
  if (finfo.linenos != NULL)
948
    {
949
      free (finfo.linenos);
950
      finfo.linenos = NULL;
951
    }
952
  if (finfo.contents != NULL)
953
    {
954
      free (finfo.contents);
955
      finfo.contents = NULL;
956
    }
957
  if (finfo.external_relocs != NULL)
958
    {
959
      free (finfo.external_relocs);
960
      finfo.external_relocs = NULL;
961
    }
962
  if (finfo.internal_relocs != NULL)
963
    {
964
      free (finfo.internal_relocs);
965
      finfo.internal_relocs = NULL;
966
    }
967
 
968
  /* The value of the last C_FILE symbol is supposed to be the symbol
969
     index of the first external symbol.  Write it out again if
970
     necessary.  */
971
  if (finfo.last_file_index != -1
972
      && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
973
    {
974
      file_ptr pos;
975
 
976
      finfo.last_file.n_value = obj_raw_syment_count (abfd);
977
      bfd_coff_swap_sym_out (abfd, &finfo.last_file,
978
                             finfo.outsyms);
979
 
980
      pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
981
      if (bfd_seek (abfd, pos, SEEK_SET) != 0
982
          || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
983
        return FALSE;
984
    }
985
 
986
  /* If doing task linking (ld --task-link) then make a pass through the
987
     global symbols, writing out any that are defined, and making them
988
     static.  */
989
  if (info->task_link)
990
    {
991
      finfo.failed = FALSE;
992
      coff_link_hash_traverse (coff_hash_table (info),
993
                               _bfd_coff_write_task_globals, &finfo);
994
      if (finfo.failed)
995
        goto error_return;
996
    }
997
 
998
  /* Write out the global symbols.  */
999
  finfo.failed = FALSE;
1000
  coff_link_hash_traverse (coff_hash_table (info),
1001
                           _bfd_coff_write_global_sym, &finfo);
1002
  if (finfo.failed)
1003
    goto error_return;
1004
 
1005
  /* The outsyms buffer is used by _bfd_coff_write_global_sym.  */
1006
  if (finfo.outsyms != NULL)
1007
    {
1008
      free (finfo.outsyms);
1009
      finfo.outsyms = NULL;
1010
    }
1011
 
1012
  if (info->relocatable && max_output_reloc_count > 0)
1013
    {
1014
      /* Now that we have written out all the global symbols, we know
1015
         the symbol indices to use for relocs against them, and we can
1016
         finally write out the relocs.  */
1017
      amt = max_output_reloc_count * relsz;
1018
      external_relocs = bfd_malloc (amt);
1019
      if (external_relocs == NULL)
1020
        goto error_return;
1021
 
1022
      for (o = abfd->sections; o != NULL; o = o->next)
1023
        {
1024
          struct internal_reloc *irel;
1025
          struct internal_reloc *irelend;
1026
          struct coff_link_hash_entry **rel_hash;
1027
          bfd_byte *erel;
1028
 
1029
          if (o->reloc_count == 0)
1030
            continue;
1031
 
1032
          irel = finfo.section_info[o->target_index].relocs;
1033
          irelend = irel + o->reloc_count;
1034
          rel_hash = finfo.section_info[o->target_index].rel_hashes;
1035
          erel = external_relocs;
1036
          for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1037
            {
1038
              if (*rel_hash != NULL)
1039
                {
1040
                  BFD_ASSERT ((*rel_hash)->indx >= 0);
1041
                  irel->r_symndx = (*rel_hash)->indx;
1042
                }
1043
              bfd_coff_swap_reloc_out (abfd, irel, erel);
1044
            }
1045
 
1046
          if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
1047
            goto error_return;
1048
          if (obj_pe (abfd) && o->reloc_count >= 0xffff)
1049
            {
1050
              /* In PE COFF, write the count of relocs as the first
1051
                 reloc.  The header overflow bit will be set
1052
                 elsewhere. */
1053
              struct internal_reloc incount;
1054
              bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
1055
 
1056
              memset (&incount, 0, sizeof (incount));
1057
              incount.r_vaddr = o->reloc_count + 1;
1058
              bfd_coff_swap_reloc_out (abfd, (PTR) &incount, (PTR) excount);
1059
              if (bfd_bwrite (excount, relsz, abfd) != relsz)
1060
                /* We'll leak, but it's an error anyway. */
1061
                goto error_return;
1062
              free (excount);
1063
            }
1064
          if (bfd_bwrite (external_relocs,
1065
                          (bfd_size_type) relsz * o->reloc_count, abfd)
1066
              != (bfd_size_type) relsz * o->reloc_count)
1067
            goto error_return;
1068
        }
1069
 
1070
      free (external_relocs);
1071
      external_relocs = NULL;
1072
    }
1073
 
1074
  /* Free up the section information.  */
1075
  if (finfo.section_info != NULL)
1076
    {
1077
      unsigned int i;
1078
 
1079
      for (i = 0; i < abfd->section_count; i++)
1080
        {
1081
          if (finfo.section_info[i].relocs != NULL)
1082
            free (finfo.section_info[i].relocs);
1083
          if (finfo.section_info[i].rel_hashes != NULL)
1084
            free (finfo.section_info[i].rel_hashes);
1085
        }
1086
      free (finfo.section_info);
1087
      finfo.section_info = NULL;
1088
    }
1089
 
1090
  /* If we have optimized stabs strings, output them.  */
1091
  if (coff_hash_table (info)->stab_info.stabstr != NULL)
1092
    {
1093
      if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1094
        return FALSE;
1095
    }
1096
 
1097
  /* Write out the string table.  */
1098
  if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1099
    {
1100
      file_ptr pos;
1101
 
1102
      pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1103
      if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1104
        return FALSE;
1105
 
1106
#if STRING_SIZE_SIZE == 4
1107
      H_PUT_32 (abfd,
1108
                _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
1109
                strbuf);
1110
#else
1111
 #error Change H_PUT_32 above
1112
#endif
1113
 
1114
      if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1115
          != STRING_SIZE_SIZE)
1116
        return FALSE;
1117
 
1118
      if (! _bfd_stringtab_emit (abfd, finfo.strtab))
1119
        return FALSE;
1120
 
1121
      obj_coff_strings_written (abfd) = TRUE;
1122
    }
1123
 
1124
  _bfd_stringtab_free (finfo.strtab);
1125
 
1126
  /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1127
     not try to write out the symbols.  */
1128
  bfd_get_symcount (abfd) = 0;
1129
 
1130
  return TRUE;
1131
 
1132
 error_return:
1133
  if (debug_merge_allocated)
1134
    coff_debug_merge_hash_table_free (&finfo.debug_merge);
1135
  if (finfo.strtab != NULL)
1136
    _bfd_stringtab_free (finfo.strtab);
1137
  if (finfo.section_info != NULL)
1138
    {
1139
      unsigned int i;
1140
 
1141
      for (i = 0; i < abfd->section_count; i++)
1142
        {
1143
          if (finfo.section_info[i].relocs != NULL)
1144
            free (finfo.section_info[i].relocs);
1145
          if (finfo.section_info[i].rel_hashes != NULL)
1146
            free (finfo.section_info[i].rel_hashes);
1147
        }
1148
      free (finfo.section_info);
1149
    }
1150
  if (finfo.internal_syms != NULL)
1151
    free (finfo.internal_syms);
1152
  if (finfo.sec_ptrs != NULL)
1153
    free (finfo.sec_ptrs);
1154
  if (finfo.sym_indices != NULL)
1155
    free (finfo.sym_indices);
1156
  if (finfo.outsyms != NULL)
1157
    free (finfo.outsyms);
1158
  if (finfo.linenos != NULL)
1159
    free (finfo.linenos);
1160
  if (finfo.contents != NULL)
1161
    free (finfo.contents);
1162
  if (finfo.external_relocs != NULL)
1163
    free (finfo.external_relocs);
1164
  if (finfo.internal_relocs != NULL)
1165
    free (finfo.internal_relocs);
1166
  if (external_relocs != NULL)
1167
    free (external_relocs);
1168
  return FALSE;
1169
}
1170
 
1171
/* Parse out a -heap <reserved>,<commit> line.  */
1172
 
1173
static char *
1174
dores_com (char *ptr, bfd *output_bfd, int heap)
1175
{
1176
  if (coff_data(output_bfd)->pe)
1177
    {
1178
      int val = strtoul (ptr, &ptr, 0);
1179
 
1180
      if (heap)
1181
        pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1182
      else
1183
        pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1184
 
1185
      if (ptr[0] == ',')
1186
        {
1187
          val = strtoul (ptr+1, &ptr, 0);
1188
          if (heap)
1189
            pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1190
          else
1191
            pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1192
        }
1193
    }
1194
  return ptr;
1195
}
1196
 
1197
static char *
1198
get_name (char *ptr, char **dst)
1199
{
1200
  while (*ptr == ' ')
1201
    ptr++;
1202
  *dst = ptr;
1203
  while (*ptr && *ptr != ' ')
1204
    ptr++;
1205
  *ptr = 0;
1206
  return ptr+1;
1207
}
1208
 
1209
/* Process any magic embedded commands in a section called .drectve.  */
1210
 
1211
static int
1212
process_embedded_commands (bfd *output_bfd,
1213
                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
1214
                           bfd *abfd)
1215
{
1216
  asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1217
  char *s;
1218
  char *e;
1219
  bfd_byte *copy;
1220
 
1221
  if (!sec)
1222
    return 1;
1223
 
1224
  if (!bfd_malloc_and_get_section (abfd, sec, &copy))
1225
    {
1226
      if (copy != NULL)
1227
        free (copy);
1228
      return 0;
1229
    }
1230
  e = (char *) copy + sec->size;
1231
 
1232
  for (s = (char *) copy; s < e ; )
1233
    {
1234
      if (s[0] != '-')
1235
        {
1236
          s++;
1237
          continue;
1238
        }
1239
      if (CONST_STRNEQ (s, "-attr"))
1240
        {
1241
          char *name;
1242
          char *attribs;
1243
          asection *asec;
1244
          int loop = 1;
1245
          int had_write = 0;
1246
          int had_exec= 0;
1247
 
1248
          s += 5;
1249
          s = get_name (s, &name);
1250
          s = get_name (s, &attribs);
1251
 
1252
          while (loop)
1253
            {
1254
              switch (*attribs++)
1255
                {
1256
                case 'W':
1257
                  had_write = 1;
1258
                  break;
1259
                case 'R':
1260
                  break;
1261
                case 'S':
1262
                  break;
1263
                case 'X':
1264
                  had_exec = 1;
1265
                  break;
1266
                default:
1267
                  loop = 0;
1268
                }
1269
            }
1270
          asec = bfd_get_section_by_name (abfd, name);
1271
          if (asec)
1272
            {
1273
              if (had_exec)
1274
                asec->flags |= SEC_CODE;
1275
              if (!had_write)
1276
                asec->flags |= SEC_READONLY;
1277
            }
1278
        }
1279
      else if (CONST_STRNEQ (s, "-heap"))
1280
        s = dores_com (s + 5, output_bfd, 1);
1281
 
1282
      else if (CONST_STRNEQ (s, "-stack"))
1283
        s = dores_com (s + 6, output_bfd, 0);
1284
 
1285
      else
1286
        s++;
1287
    }
1288
  free (copy);
1289
  return 1;
1290
}
1291
 
1292
/* Place a marker against all symbols which are used by relocations.
1293
   This marker can be picked up by the 'do we skip this symbol ?'
1294
   loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1295
   that symbol.  */
1296
 
1297
static void
1298
mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
1299
{
1300
  asection * a;
1301
 
1302
  if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1303
    return;
1304
 
1305
  for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1306
    {
1307
      struct internal_reloc *   internal_relocs;
1308
      struct internal_reloc *   irel;
1309
      struct internal_reloc *   irelend;
1310
 
1311
      if ((a->flags & SEC_RELOC) == 0 || a->reloc_count  < 1)
1312
        continue;
1313
      /* Don't mark relocs in excluded sections.  */
1314
      if (a->output_section == bfd_abs_section_ptr)
1315
        continue;
1316
 
1317
      /* Read in the relocs.  */
1318
      internal_relocs = _bfd_coff_read_internal_relocs
1319
        (input_bfd, a, FALSE,
1320
         finfo->external_relocs,
1321
         finfo->info->relocatable,
1322
         (finfo->info->relocatable
1323
          ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1324
          : finfo->internal_relocs)
1325
        );
1326
 
1327
      if (internal_relocs == NULL)
1328
        continue;
1329
 
1330
      irel     = internal_relocs;
1331
      irelend  = irel + a->reloc_count;
1332
 
1333
      /* Place a mark in the sym_indices array (whose entries have
1334
         been initialised to 0) for all of the symbols that are used
1335
         in the relocation table.  This will then be picked up in the
1336
         skip/don't-skip pass.  */
1337
      for (; irel < irelend; irel++)
1338
        finfo->sym_indices[ irel->r_symndx ] = -1;
1339
    }
1340
}
1341
 
1342
/* Link an input file into the linker output file.  This function
1343
   handles all the sections and relocations of the input file at once.  */
1344
 
1345
bfd_boolean
1346
_bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
1347
{
1348
  unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1349
  unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1350
  bfd_boolean (*adjust_symndx)
1351
    (bfd *, struct bfd_link_info *, bfd *, asection *,
1352
     struct internal_reloc *, bfd_boolean *);
1353
  bfd *output_bfd;
1354
  const char *strings;
1355
  bfd_size_type syment_base;
1356
  bfd_boolean copy, hash;
1357
  bfd_size_type isymesz;
1358
  bfd_size_type osymesz;
1359
  bfd_size_type linesz;
1360
  bfd_byte *esym;
1361
  bfd_byte *esym_end;
1362
  struct internal_syment *isymp;
1363
  asection **secpp;
1364
  long *indexp;
1365
  unsigned long output_index;
1366
  bfd_byte *outsym;
1367
  struct coff_link_hash_entry **sym_hash;
1368
  asection *o;
1369
 
1370
  /* Move all the symbols to the output file.  */
1371
 
1372
  output_bfd = finfo->output_bfd;
1373
  strings = NULL;
1374
  syment_base = obj_raw_syment_count (output_bfd);
1375
  isymesz = bfd_coff_symesz (input_bfd);
1376
  osymesz = bfd_coff_symesz (output_bfd);
1377
  linesz = bfd_coff_linesz (input_bfd);
1378
  BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1379
 
1380
  copy = FALSE;
1381
  if (! finfo->info->keep_memory)
1382
    copy = TRUE;
1383
  hash = TRUE;
1384
  if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1385
    hash = FALSE;
1386
 
1387
  if (! _bfd_coff_get_external_symbols (input_bfd))
1388
    return FALSE;
1389
 
1390
  esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1391
  esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1392
  isymp = finfo->internal_syms;
1393
  secpp = finfo->sec_ptrs;
1394
  indexp = finfo->sym_indices;
1395
  output_index = syment_base;
1396
  outsym = finfo->outsyms;
1397
 
1398
  if (coff_data (output_bfd)->pe
1399
      && ! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1400
    return FALSE;
1401
 
1402
  /* If we are going to perform relocations and also strip/discard some
1403
     symbols then we must make sure that we do not strip/discard those
1404
     symbols that are going to be involved in the relocations.  */
1405
  if ((   finfo->info->strip   != strip_none
1406
       || finfo->info->discard != discard_none)
1407
      && finfo->info->relocatable)
1408
    {
1409
      /* Mark the symbol array as 'not-used'.  */
1410
      memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1411
 
1412
      mark_relocs (finfo, input_bfd);
1413
    }
1414
 
1415
  while (esym < esym_end)
1416
    {
1417
      struct internal_syment isym;
1418
      enum coff_symbol_classification classification;
1419
      bfd_boolean skip;
1420
      bfd_boolean global;
1421
      bfd_boolean dont_skip_symbol;
1422
      int add;
1423
 
1424
      bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1425
 
1426
      /* Make a copy of *isymp so that the relocate_section function
1427
         always sees the original values.  This is more reliable than
1428
         always recomputing the symbol value even if we are stripping
1429
         the symbol.  */
1430
      isym = *isymp;
1431
 
1432
      classification = bfd_coff_classify_symbol (input_bfd, &isym);
1433
      switch (classification)
1434
        {
1435
        default:
1436
          abort ();
1437
        case COFF_SYMBOL_GLOBAL:
1438
        case COFF_SYMBOL_PE_SECTION:
1439
        case COFF_SYMBOL_LOCAL:
1440
          *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1441
          break;
1442
        case COFF_SYMBOL_COMMON:
1443
          *secpp = bfd_com_section_ptr;
1444
          break;
1445
        case COFF_SYMBOL_UNDEFINED:
1446
          *secpp = bfd_und_section_ptr;
1447
          break;
1448
        }
1449
 
1450
      /* Extract the flag indicating if this symbol is used by a
1451
         relocation.  */
1452
      if ((finfo->info->strip != strip_none
1453
           || finfo->info->discard != discard_none)
1454
          && finfo->info->relocatable)
1455
        dont_skip_symbol = *indexp;
1456
      else
1457
        dont_skip_symbol = FALSE;
1458
 
1459
      *indexp = -1;
1460
 
1461
      skip = FALSE;
1462
      global = FALSE;
1463
      add = 1 + isym.n_numaux;
1464
 
1465
      /* If we are stripping all symbols, we want to skip this one.  */
1466
      if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1467
        skip = TRUE;
1468
 
1469
      if (! skip)
1470
        {
1471
          switch (classification)
1472
            {
1473
            default:
1474
              abort ();
1475
            case COFF_SYMBOL_GLOBAL:
1476
            case COFF_SYMBOL_COMMON:
1477
            case COFF_SYMBOL_PE_SECTION:
1478
              /* This is a global symbol.  Global symbols come at the
1479
                 end of the symbol table, so skip them for now.
1480
                 Locally defined function symbols, however, are an
1481
                 exception, and are not moved to the end.  */
1482
              global = TRUE;
1483
              if (! ISFCN (isym.n_type))
1484
                skip = TRUE;
1485
              break;
1486
 
1487
            case COFF_SYMBOL_UNDEFINED:
1488
              /* Undefined symbols are left for the end.  */
1489
              global = TRUE;
1490
              skip = TRUE;
1491
              break;
1492
 
1493
            case COFF_SYMBOL_LOCAL:
1494
              /* This is a local symbol.  Skip it if we are discarding
1495
                 local symbols.  */
1496
              if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1497
                skip = TRUE;
1498
              break;
1499
            }
1500
        }
1501
 
1502
#ifndef COFF_WITH_PE
1503
      /* Skip section symbols for sections which are not going to be
1504
         emitted.  */
1505
      if (!skip
1506
          && dont_skip_symbol == 0
1507
          && isym.n_sclass == C_STAT
1508
          && isym.n_type == T_NULL
1509
          && isym.n_numaux > 0
1510
          && (*secpp)->output_section == bfd_abs_section_ptr)
1511
        skip = TRUE;
1512
#endif
1513
 
1514
      /* If we stripping debugging symbols, and this is a debugging
1515
         symbol, then skip it.  FIXME: gas sets the section to N_ABS
1516
         for some types of debugging symbols; I don't know if this is
1517
         a bug or not.  In any case, we handle it here.  */
1518
      if (! skip
1519
          && finfo->info->strip == strip_debugger
1520
          && ! dont_skip_symbol
1521
          && (isym.n_scnum == N_DEBUG
1522
              || (isym.n_scnum == N_ABS
1523
                  && (isym.n_sclass == C_AUTO
1524
                      || isym.n_sclass == C_REG
1525
                      || isym.n_sclass == C_MOS
1526
                      || isym.n_sclass == C_MOE
1527
                      || isym.n_sclass == C_MOU
1528
                      || isym.n_sclass == C_ARG
1529
                      || isym.n_sclass == C_REGPARM
1530
                      || isym.n_sclass == C_FIELD
1531
                      || isym.n_sclass == C_EOS))))
1532
        skip = TRUE;
1533
 
1534
      /* If some symbols are stripped based on the name, work out the
1535
         name and decide whether to skip this symbol.  */
1536
      if (! skip
1537
          && (finfo->info->strip == strip_some
1538
              || finfo->info->discard == discard_l))
1539
        {
1540
          const char *name;
1541
          char buf[SYMNMLEN + 1];
1542
 
1543
          name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1544
          if (name == NULL)
1545
            return FALSE;
1546
 
1547
          if (! dont_skip_symbol
1548
              && ((finfo->info->strip == strip_some
1549
                   && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE,
1550
                                    FALSE) == NULL))
1551
                   || (! global
1552
                       && finfo->info->discard == discard_l
1553
                       && bfd_is_local_label_name (input_bfd, name))))
1554
            skip = TRUE;
1555
        }
1556
 
1557
      /* If this is an enum, struct, or union tag, see if we have
1558
         already output an identical type.  */
1559
      if (! skip
1560
          && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1561
          && (isym.n_sclass == C_ENTAG
1562
              || isym.n_sclass == C_STRTAG
1563
              || isym.n_sclass == C_UNTAG)
1564
          && isym.n_numaux == 1)
1565
        {
1566
          const char *name;
1567
          char buf[SYMNMLEN + 1];
1568
          struct coff_debug_merge_hash_entry *mh;
1569
          struct coff_debug_merge_type *mt;
1570
          union internal_auxent aux;
1571
          struct coff_debug_merge_element **epp;
1572
          bfd_byte *esl, *eslend;
1573
          struct internal_syment *islp;
1574
          bfd_size_type amt;
1575
 
1576
          name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1577
          if (name == NULL)
1578
            return FALSE;
1579
 
1580
          /* Ignore fake names invented by compiler; treat them all as
1581
             the same name.  */
1582
          if (*name == '~' || *name == '.' || *name == '$'
1583
              || (*name == bfd_get_symbol_leading_char (input_bfd)
1584
                  && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1585
            name = "";
1586
 
1587
          mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1588
                                             TRUE, TRUE);
1589
          if (mh == NULL)
1590
            return FALSE;
1591
 
1592
          /* Allocate memory to hold type information.  If this turns
1593
             out to be a duplicate, we pass this address to
1594
             bfd_release.  */
1595
          amt = sizeof (struct coff_debug_merge_type);
1596
          mt = bfd_alloc (input_bfd, amt);
1597
          if (mt == NULL)
1598
            return FALSE;
1599
          mt->class = isym.n_sclass;
1600
 
1601
          /* Pick up the aux entry, which points to the end of the tag
1602
             entries.  */
1603
          bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1604
                                isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1605
                                &aux);
1606
 
1607
          /* Gather the elements.  */
1608
          epp = &mt->elements;
1609
          mt->elements = NULL;
1610
          islp = isymp + 2;
1611
          esl = esym + 2 * isymesz;
1612
          eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1613
                    + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1614
          while (esl < eslend)
1615
            {
1616
              const char *elename;
1617
              char elebuf[SYMNMLEN + 1];
1618
              char *name_copy;
1619
 
1620
              bfd_coff_swap_sym_in (input_bfd, esl, islp);
1621
 
1622
              amt = sizeof (struct coff_debug_merge_element);
1623
              *epp = bfd_alloc (input_bfd, amt);
1624
              if (*epp == NULL)
1625
                return FALSE;
1626
 
1627
              elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1628
                                                        elebuf);
1629
              if (elename == NULL)
1630
                return FALSE;
1631
 
1632
              amt = strlen (elename) + 1;
1633
              name_copy = bfd_alloc (input_bfd, amt);
1634
              if (name_copy == NULL)
1635
                return FALSE;
1636
              strcpy (name_copy, elename);
1637
 
1638
              (*epp)->name = name_copy;
1639
              (*epp)->type = islp->n_type;
1640
              (*epp)->tagndx = 0;
1641
              if (islp->n_numaux >= 1
1642
                  && islp->n_type != T_NULL
1643
                  && islp->n_sclass != C_EOS)
1644
                {
1645
                  union internal_auxent eleaux;
1646
                  long indx;
1647
 
1648
                  bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1649
                                        islp->n_type, islp->n_sclass, 0,
1650
                                        islp->n_numaux, &eleaux);
1651
                  indx = eleaux.x_sym.x_tagndx.l;
1652
 
1653
                  /* FIXME: If this tagndx entry refers to a symbol
1654
                     defined later in this file, we just ignore it.
1655
                     Handling this correctly would be tedious, and may
1656
                     not be required.  */
1657
                  if (indx > 0
1658
                      && (indx
1659
                          < ((esym -
1660
                              (bfd_byte *) obj_coff_external_syms (input_bfd))
1661
                             / (long) isymesz)))
1662
                    {
1663
                      (*epp)->tagndx = finfo->sym_indices[indx];
1664
                      if ((*epp)->tagndx < 0)
1665
                        (*epp)->tagndx = 0;
1666
                    }
1667
                }
1668
              epp = &(*epp)->next;
1669
              *epp = NULL;
1670
 
1671
              esl += (islp->n_numaux + 1) * isymesz;
1672
              islp += islp->n_numaux + 1;
1673
            }
1674
 
1675
          /* See if we already have a definition which matches this
1676
             type.  We always output the type if it has no elements,
1677
             for simplicity.  */
1678
          if (mt->elements == NULL)
1679
            bfd_release (input_bfd, mt);
1680
          else
1681
            {
1682
              struct coff_debug_merge_type *mtl;
1683
 
1684
              for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1685
                {
1686
                  struct coff_debug_merge_element *me, *mel;
1687
 
1688
                  if (mtl->class != mt->class)
1689
                    continue;
1690
 
1691
                  for (me = mt->elements, mel = mtl->elements;
1692
                       me != NULL && mel != NULL;
1693
                       me = me->next, mel = mel->next)
1694
                    {
1695
                      if (strcmp (me->name, mel->name) != 0
1696
                          || me->type != mel->type
1697
                          || me->tagndx != mel->tagndx)
1698
                        break;
1699
                    }
1700
 
1701
                  if (me == NULL && mel == NULL)
1702
                    break;
1703
                }
1704
 
1705
              if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1706
                {
1707
                  /* This is the first definition of this type.  */
1708
                  mt->indx = output_index;
1709
                  mt->next = mh->types;
1710
                  mh->types = mt;
1711
                }
1712
              else
1713
                {
1714
                  /* This is a redefinition which can be merged.  */
1715
                  bfd_release (input_bfd, mt);
1716
                  *indexp = mtl->indx;
1717
                  add = (eslend - esym) / isymesz;
1718
                  skip = TRUE;
1719
                }
1720
            }
1721
        }
1722
 
1723
      /* We now know whether we are to skip this symbol or not.  */
1724
      if (! skip)
1725
        {
1726
          /* Adjust the symbol in order to output it.  */
1727
 
1728
          if (isym._n._n_n._n_zeroes == 0
1729
              && isym._n._n_n._n_offset != 0)
1730
            {
1731
              const char *name;
1732
              bfd_size_type indx;
1733
 
1734
              /* This symbol has a long name.  Enter it in the string
1735
                 table we are building.  Note that we do not check
1736
                 bfd_coff_symname_in_debug.  That is only true for
1737
                 XCOFF, and XCOFF requires different linking code
1738
                 anyhow.  */
1739
              name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1740
              if (name == NULL)
1741
                return FALSE;
1742
              indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1743
              if (indx == (bfd_size_type) -1)
1744
                return FALSE;
1745
              isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1746
            }
1747
 
1748
          switch (isym.n_sclass)
1749
            {
1750
            case C_AUTO:
1751
            case C_MOS:
1752
            case C_EOS:
1753
            case C_MOE:
1754
            case C_MOU:
1755
            case C_UNTAG:
1756
            case C_STRTAG:
1757
            case C_ENTAG:
1758
            case C_TPDEF:
1759
            case C_ARG:
1760
            case C_USTATIC:
1761
            case C_REG:
1762
            case C_REGPARM:
1763
            case C_FIELD:
1764
              /* The symbol value should not be modified.  */
1765
              break;
1766
 
1767
            case C_FCN:
1768
              if (obj_pe (input_bfd)
1769
                  && strcmp (isym.n_name, ".bf") != 0
1770
                  && isym.n_scnum > 0)
1771
                {
1772
                  /* For PE, .lf and .ef get their value left alone,
1773
                     while .bf gets relocated.  However, they all have
1774
                     "real" section numbers, and need to be moved into
1775
                     the new section.  */
1776
                  isym.n_scnum = (*secpp)->output_section->target_index;
1777
                  break;
1778
                }
1779
              /* Fall through.  */
1780
            default:
1781
            case C_LABEL:  /* Not completely sure about these 2 */
1782
            case C_EXTDEF:
1783
            case C_BLOCK:
1784
            case C_EFCN:
1785
            case C_NULL:
1786
            case C_EXT:
1787
            case C_STAT:
1788
            case C_SECTION:
1789
            case C_NT_WEAK:
1790
              /* Compute new symbol location.  */
1791
            if (isym.n_scnum > 0)
1792
              {
1793
                isym.n_scnum = (*secpp)->output_section->target_index;
1794
                isym.n_value += (*secpp)->output_offset;
1795
                if (! obj_pe (input_bfd))
1796
                  isym.n_value -= (*secpp)->vma;
1797
                if (! obj_pe (finfo->output_bfd))
1798
                  isym.n_value += (*secpp)->output_section->vma;
1799
              }
1800
            break;
1801
 
1802
            case C_FILE:
1803
              /* The value of a C_FILE symbol is the symbol index of
1804
                 the next C_FILE symbol.  The value of the last C_FILE
1805
                 symbol is the symbol index to the first external
1806
                 symbol (actually, coff_renumber_symbols does not get
1807
                 this right--it just sets the value of the last C_FILE
1808
                 symbol to zero--and nobody has ever complained about
1809
                 it).  We try to get this right, below, just before we
1810
                 write the symbols out, but in the general case we may
1811
                 have to write the symbol out twice.  */
1812
              if (finfo->last_file_index != -1
1813
                  && finfo->last_file.n_value != (bfd_vma) output_index)
1814
                {
1815
                  /* We must correct the value of the last C_FILE
1816
                     entry.  */
1817
                  finfo->last_file.n_value = output_index;
1818
                  if ((bfd_size_type) finfo->last_file_index >= syment_base)
1819
                    {
1820
                      /* The last C_FILE symbol is in this input file.  */
1821
                      bfd_coff_swap_sym_out (output_bfd,
1822
                                             &finfo->last_file,
1823
                                             (finfo->outsyms
1824
                                              + ((finfo->last_file_index
1825
                                                  - syment_base)
1826
                                                 * osymesz)));
1827
                    }
1828
                  else
1829
                    {
1830
                      file_ptr pos;
1831
 
1832
                      /* We have already written out the last C_FILE
1833
                         symbol.  We need to write it out again.  We
1834
                         borrow *outsym temporarily.  */
1835
                      bfd_coff_swap_sym_out (output_bfd,
1836
                                             &finfo->last_file, outsym);
1837
                      pos = obj_sym_filepos (output_bfd);
1838
                      pos += finfo->last_file_index * osymesz;
1839
                      if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1840
                          || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1841
                        return FALSE;
1842
                    }
1843
                }
1844
 
1845
              finfo->last_file_index = output_index;
1846
              finfo->last_file = isym;
1847
              break;
1848
            }
1849
 
1850
          /* If doing task linking, convert normal global function symbols to
1851
             static functions.  */
1852
          if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1853
            isym.n_sclass = C_STAT;
1854
 
1855
          /* Output the symbol.  */
1856
          bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1857
 
1858
          *indexp = output_index;
1859
 
1860
          if (global)
1861
            {
1862
              long indx;
1863
              struct coff_link_hash_entry *h;
1864
 
1865
              indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1866
                      / isymesz);
1867
              h = obj_coff_sym_hashes (input_bfd)[indx];
1868
              if (h == NULL)
1869
                {
1870
                  /* This can happen if there were errors earlier in
1871
                     the link.  */
1872
                  bfd_set_error (bfd_error_bad_value);
1873
                  return FALSE;
1874
                }
1875
              h->indx = output_index;
1876
            }
1877
 
1878
          output_index += add;
1879
          outsym += add * osymesz;
1880
        }
1881
 
1882
      esym += add * isymesz;
1883
      isymp += add;
1884
      ++secpp;
1885
      ++indexp;
1886
      for (--add; add > 0; --add)
1887
        {
1888
          *secpp++ = NULL;
1889
          *indexp++ = -1;
1890
        }
1891
    }
1892
 
1893
  /* Fix up the aux entries.  This must be done in a separate pass,
1894
     because we don't know the correct symbol indices until we have
1895
     already decided which symbols we are going to keep.  */
1896
  esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1897
  esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1898
  isymp = finfo->internal_syms;
1899
  indexp = finfo->sym_indices;
1900
  sym_hash = obj_coff_sym_hashes (input_bfd);
1901
  outsym = finfo->outsyms;
1902
 
1903
  while (esym < esym_end)
1904
    {
1905
      int add;
1906
 
1907
      add = 1 + isymp->n_numaux;
1908
 
1909
      if ((*indexp < 0
1910
           || (bfd_size_type) *indexp < syment_base)
1911
          && (*sym_hash == NULL
1912
              || (*sym_hash)->auxbfd != input_bfd))
1913
        esym += add * isymesz;
1914
      else
1915
        {
1916
          struct coff_link_hash_entry *h;
1917
          int i;
1918
 
1919
          h = NULL;
1920
          if (*indexp < 0)
1921
            {
1922
              h = *sym_hash;
1923
 
1924
              /* The m68k-motorola-sysv assembler will sometimes
1925
                 generate two symbols with the same name, but only one
1926
                 will have aux entries.  */
1927
              BFD_ASSERT (isymp->n_numaux == 0
1928
                          || h->numaux == 0
1929
                          || h->numaux == isymp->n_numaux);
1930
            }
1931
 
1932
          esym += isymesz;
1933
 
1934
          if (h == NULL)
1935
            outsym += osymesz;
1936
 
1937
          /* Handle the aux entries.  This handling is based on
1938
             coff_pointerize_aux.  I don't know if it always correct.  */
1939
          for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1940
            {
1941
              union internal_auxent aux;
1942
              union internal_auxent *auxp;
1943
 
1944
              if (h != NULL && h->aux != NULL && (h->numaux > i))
1945
                auxp = h->aux + i;
1946
              else
1947
                {
1948
                  bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
1949
                                        isymp->n_sclass, i, isymp->n_numaux, &aux);
1950
                  auxp = &aux;
1951
                }
1952
 
1953
              if (isymp->n_sclass == C_FILE)
1954
                {
1955
                  /* If this is a long filename, we must put it in the
1956
                     string table.  */
1957
                  if (auxp->x_file.x_n.x_zeroes == 0
1958
                      && auxp->x_file.x_n.x_offset != 0)
1959
                    {
1960
                      const char *filename;
1961
                      bfd_size_type indx;
1962
 
1963
                      BFD_ASSERT (auxp->x_file.x_n.x_offset
1964
                                  >= STRING_SIZE_SIZE);
1965
                      if (strings == NULL)
1966
                        {
1967
                          strings = _bfd_coff_read_string_table (input_bfd);
1968
                          if (strings == NULL)
1969
                            return FALSE;
1970
                        }
1971
                      filename = strings + auxp->x_file.x_n.x_offset;
1972
                      indx = _bfd_stringtab_add (finfo->strtab, filename,
1973
                                                 hash, copy);
1974
                      if (indx == (bfd_size_type) -1)
1975
                        return FALSE;
1976
                      auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
1977
                    }
1978
                }
1979
              else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
1980
                       && isymp->n_sclass != C_NT_WEAK)
1981
                {
1982
                  unsigned long indx;
1983
 
1984
                  if (ISFCN (isymp->n_type)
1985
                      || ISTAG (isymp->n_sclass)
1986
                      || isymp->n_sclass == C_BLOCK
1987
                      || isymp->n_sclass == C_FCN)
1988
                    {
1989
                      indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
1990
                      if (indx > 0
1991
                          && indx < obj_raw_syment_count (input_bfd))
1992
                        {
1993
                          /* We look forward through the symbol for
1994
                             the index of the next symbol we are going
1995
                             to include.  I don't know if this is
1996
                             entirely right.  */
1997
                          while ((finfo->sym_indices[indx] < 0
1998
                                  || ((bfd_size_type) finfo->sym_indices[indx]
1999
                                      < syment_base))
2000
                                 && indx < obj_raw_syment_count (input_bfd))
2001
                            ++indx;
2002
                          if (indx >= obj_raw_syment_count (input_bfd))
2003
                            indx = output_index;
2004
                          else
2005
                            indx = finfo->sym_indices[indx];
2006
                          auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2007
                        }
2008
                    }
2009
 
2010
                  indx = auxp->x_sym.x_tagndx.l;
2011
                  if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2012
                    {
2013
                      long symindx;
2014
 
2015
                      symindx = finfo->sym_indices[indx];
2016
                      if (symindx < 0)
2017
                        auxp->x_sym.x_tagndx.l = 0;
2018
                      else
2019
                        auxp->x_sym.x_tagndx.l = symindx;
2020
                    }
2021
 
2022
                  /* The .bf symbols are supposed to be linked through
2023
                     the endndx field.  We need to carry this list
2024
                     across object files.  */
2025
                  if (i == 0
2026
                      && h == NULL
2027
                      && isymp->n_sclass == C_FCN
2028
                      && (isymp->_n._n_n._n_zeroes != 0
2029
                          || isymp->_n._n_n._n_offset == 0)
2030
                      && isymp->_n._n_name[0] == '.'
2031
                      && isymp->_n._n_name[1] == 'b'
2032
                      && isymp->_n._n_name[2] == 'f'
2033
                      && isymp->_n._n_name[3] == '\0')
2034
                    {
2035
                      if (finfo->last_bf_index != -1)
2036
                        {
2037
                          finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2038
                            *indexp;
2039
 
2040
                          if ((bfd_size_type) finfo->last_bf_index
2041
                              >= syment_base)
2042
                            {
2043
                              void *auxout;
2044
 
2045
                              /* The last .bf symbol is in this input
2046
                                 file.  This will only happen if the
2047
                                 assembler did not set up the .bf
2048
                                 endndx symbols correctly.  */
2049
                              auxout = (finfo->outsyms
2050
                                        + ((finfo->last_bf_index
2051
                                            - syment_base)
2052
                                           * osymesz));
2053
 
2054
                              bfd_coff_swap_aux_out (output_bfd,
2055
                                                     &finfo->last_bf,
2056
                                                     isymp->n_type,
2057
                                                     isymp->n_sclass,
2058
                                                     0, isymp->n_numaux,
2059
                                                     auxout);
2060
                            }
2061
                          else
2062
                            {
2063
                              file_ptr pos;
2064
 
2065
                              /* We have already written out the last
2066
                                 .bf aux entry.  We need to write it
2067
                                 out again.  We borrow *outsym
2068
                                 temporarily.  FIXME: This case should
2069
                                 be made faster.  */
2070
                              bfd_coff_swap_aux_out (output_bfd,
2071
                                                     &finfo->last_bf,
2072
                                                     isymp->n_type,
2073
                                                     isymp->n_sclass,
2074
                                                     0, isymp->n_numaux,
2075
                                                     outsym);
2076
                              pos = obj_sym_filepos (output_bfd);
2077
                              pos += finfo->last_bf_index * osymesz;
2078
                              if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2079
                                  || (bfd_bwrite (outsym, osymesz, output_bfd)
2080
                                      != osymesz))
2081
                                return FALSE;
2082
                            }
2083
                        }
2084
 
2085
                      if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2086
                        finfo->last_bf_index = -1;
2087
                      else
2088
                        {
2089
                          /* The endndx field of this aux entry must
2090
                             be updated with the symbol number of the
2091
                             next .bf symbol.  */
2092
                          finfo->last_bf = *auxp;
2093
                          finfo->last_bf_index = (((outsym - finfo->outsyms)
2094
                                                   / osymesz)
2095
                                                  + syment_base);
2096
                        }
2097
                    }
2098
                }
2099
 
2100
              if (h == NULL)
2101
                {
2102
                  bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2103
                                         isymp->n_sclass, i, isymp->n_numaux,
2104
                                         outsym);
2105
                  outsym += osymesz;
2106
                }
2107
 
2108
              esym += isymesz;
2109
            }
2110
        }
2111
 
2112
      indexp += add;
2113
      isymp += add;
2114
      sym_hash += add;
2115
    }
2116
 
2117
  /* Relocate the line numbers, unless we are stripping them.  */
2118
  if (finfo->info->strip == strip_none
2119
      || finfo->info->strip == strip_some)
2120
    {
2121
      for (o = input_bfd->sections; o != NULL; o = o->next)
2122
        {
2123
          bfd_vma offset;
2124
          bfd_byte *eline;
2125
          bfd_byte *elineend;
2126
          bfd_byte *oeline;
2127
          bfd_boolean skipping;
2128
          file_ptr pos;
2129
          bfd_size_type amt;
2130
 
2131
          /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2132
             build_link_order in ldwrite.c will not have created a
2133
             link order, which means that we will not have seen this
2134
             input section in _bfd_coff_final_link, which means that
2135
             we will not have allocated space for the line numbers of
2136
             this section.  I don't think line numbers can be
2137
             meaningful for a section which does not have
2138
             SEC_HAS_CONTENTS set, but, if they do, this must be
2139
             changed.  */
2140
          if (o->lineno_count == 0
2141
              || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2142
            continue;
2143
 
2144
          if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2145
              || bfd_bread (finfo->linenos, linesz * o->lineno_count,
2146
                           input_bfd) != linesz * o->lineno_count)
2147
            return FALSE;
2148
 
2149
          offset = o->output_section->vma + o->output_offset - o->vma;
2150
          eline = finfo->linenos;
2151
          oeline = finfo->linenos;
2152
          elineend = eline + linesz * o->lineno_count;
2153
          skipping = FALSE;
2154
          for (; eline < elineend; eline += linesz)
2155
            {
2156
              struct internal_lineno iline;
2157
 
2158
              bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2159
 
2160
              if (iline.l_lnno != 0)
2161
                iline.l_addr.l_paddr += offset;
2162
              else if (iline.l_addr.l_symndx >= 0
2163
                       && ((unsigned long) iline.l_addr.l_symndx
2164
                           < obj_raw_syment_count (input_bfd)))
2165
                {
2166
                  long indx;
2167
 
2168
                  indx = finfo->sym_indices[iline.l_addr.l_symndx];
2169
 
2170
                  if (indx < 0)
2171
                    {
2172
                      /* These line numbers are attached to a symbol
2173
                         which we are stripping.  We must discard the
2174
                         line numbers because reading them back with
2175
                         no associated symbol (or associating them all
2176
                         with symbol #0) will fail.  We can't regain
2177
                         the space in the output file, but at least
2178
                         they're dense.  */
2179
                      skipping = TRUE;
2180
                    }
2181
                  else
2182
                    {
2183
                      struct internal_syment is;
2184
                      union internal_auxent ia;
2185
 
2186
                      /* Fix up the lnnoptr field in the aux entry of
2187
                         the symbol.  It turns out that we can't do
2188
                         this when we modify the symbol aux entries,
2189
                         because gas sometimes screws up the lnnoptr
2190
                         field and makes it an offset from the start
2191
                         of the line numbers rather than an absolute
2192
                         file index.  */
2193
                      bfd_coff_swap_sym_in (output_bfd,
2194
                                            (finfo->outsyms
2195
                                             + ((indx - syment_base)
2196
                                                * osymesz)), &is);
2197
                      if ((ISFCN (is.n_type)
2198
                           || is.n_sclass == C_BLOCK)
2199
                          && is.n_numaux >= 1)
2200
                        {
2201
                          void *auxptr;
2202
 
2203
                          auxptr = (finfo->outsyms
2204
                                    + ((indx - syment_base + 1)
2205
                                       * osymesz));
2206
                          bfd_coff_swap_aux_in (output_bfd, auxptr,
2207
                                                is.n_type, is.n_sclass,
2208
                                                0, is.n_numaux, &ia);
2209
                          ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2210
                            (o->output_section->line_filepos
2211
                             + o->output_section->lineno_count * linesz
2212
                             + eline - finfo->linenos);
2213
                          bfd_coff_swap_aux_out (output_bfd, &ia,
2214
                                                 is.n_type, is.n_sclass, 0,
2215
                                                 is.n_numaux, auxptr);
2216
                        }
2217
 
2218
                      skipping = FALSE;
2219
                    }
2220
 
2221
                  iline.l_addr.l_symndx = indx;
2222
                }
2223
 
2224
              if (!skipping)
2225
                {
2226
                  bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2227
                  oeline += linesz;
2228
                }
2229
            }
2230
 
2231
          pos = o->output_section->line_filepos;
2232
          pos += o->output_section->lineno_count * linesz;
2233
          amt = oeline - finfo->linenos;
2234
          if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2235
              || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
2236
            return FALSE;
2237
 
2238
          o->output_section->lineno_count += amt / linesz;
2239
        }
2240
    }
2241
 
2242
  /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2243
     symbol will be the first symbol in the next input file.  In the
2244
     normal case, this will save us from writing out the C_FILE symbol
2245
     again.  */
2246
  if (finfo->last_file_index != -1
2247
      && (bfd_size_type) finfo->last_file_index >= syment_base)
2248
    {
2249
      finfo->last_file.n_value = output_index;
2250
      bfd_coff_swap_sym_out (output_bfd, &finfo->last_file,
2251
                             (finfo->outsyms
2252
                              + ((finfo->last_file_index - syment_base)
2253
                                 * osymesz)));
2254
    }
2255
 
2256
  /* Write the modified symbols to the output file.  */
2257
  if (outsym > finfo->outsyms)
2258
    {
2259
      file_ptr pos;
2260
      bfd_size_type amt;
2261
 
2262
      pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2263
      amt = outsym - finfo->outsyms;
2264
      if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2265
          || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
2266
        return FALSE;
2267
 
2268
      BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2269
                   + (outsym - finfo->outsyms) / osymesz)
2270
                  == output_index);
2271
 
2272
      obj_raw_syment_count (output_bfd) = output_index;
2273
    }
2274
 
2275
  /* Relocate the contents of each section.  */
2276
  adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2277
  for (o = input_bfd->sections; o != NULL; o = o->next)
2278
    {
2279
      bfd_byte *contents;
2280
      struct coff_section_tdata *secdata;
2281
 
2282
      if (! o->linker_mark)
2283
        /* This section was omitted from the link.  */
2284
        continue;
2285
 
2286
      if ((o->flags & SEC_LINKER_CREATED) != 0)
2287
        continue;
2288
 
2289
      if ((o->flags & SEC_HAS_CONTENTS) == 0
2290
          || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
2291
        {
2292
          if ((o->flags & SEC_RELOC) != 0
2293
              && o->reloc_count != 0)
2294
            {
2295
              (*_bfd_error_handler)
2296
                (_("%B: relocs in section `%A', but it has no contents"),
2297
                 input_bfd, o);
2298
              bfd_set_error (bfd_error_no_contents);
2299
              return FALSE;
2300
            }
2301
 
2302
          continue;
2303
        }
2304
 
2305
      secdata = coff_section_data (input_bfd, o);
2306
      if (secdata != NULL && secdata->contents != NULL)
2307
        contents = secdata->contents;
2308
      else
2309
        {
2310
          bfd_size_type x = o->rawsize ? o->rawsize : o->size;
2311
          if (! bfd_get_section_contents (input_bfd, o, finfo->contents, 0, x))
2312
            return FALSE;
2313
          contents = finfo->contents;
2314
        }
2315
 
2316
      if ((o->flags & SEC_RELOC) != 0)
2317
        {
2318
          int target_index;
2319
          struct internal_reloc *internal_relocs;
2320
          struct internal_reloc *irel;
2321
 
2322
          /* Read in the relocs.  */
2323
          target_index = o->output_section->target_index;
2324
          internal_relocs = (_bfd_coff_read_internal_relocs
2325
                             (input_bfd, o, FALSE, finfo->external_relocs,
2326
                              finfo->info->relocatable,
2327
                              (finfo->info->relocatable
2328
                               ? (finfo->section_info[target_index].relocs
2329
                                  + o->output_section->reloc_count)
2330
                               : finfo->internal_relocs)));
2331
          if (internal_relocs == NULL)
2332
            return FALSE;
2333
 
2334
          /* Call processor specific code to relocate the section
2335
             contents.  */
2336
          if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2337
                                           input_bfd, o,
2338
                                           contents,
2339
                                           internal_relocs,
2340
                                           finfo->internal_syms,
2341
                                           finfo->sec_ptrs))
2342
            return FALSE;
2343
 
2344
          if (finfo->info->relocatable)
2345
            {
2346
              bfd_vma offset;
2347
              struct internal_reloc *irelend;
2348
              struct coff_link_hash_entry **rel_hash;
2349
 
2350
              offset = o->output_section->vma + o->output_offset - o->vma;
2351
              irel = internal_relocs;
2352
              irelend = irel + o->reloc_count;
2353
              rel_hash = (finfo->section_info[target_index].rel_hashes
2354
                          + o->output_section->reloc_count);
2355
              for (; irel < irelend; irel++, rel_hash++)
2356
                {
2357
                  struct coff_link_hash_entry *h;
2358
                  bfd_boolean adjusted;
2359
 
2360
                  *rel_hash = NULL;
2361
 
2362
                  /* Adjust the reloc address and symbol index.  */
2363
                  irel->r_vaddr += offset;
2364
 
2365
                  if (irel->r_symndx == -1)
2366
                    continue;
2367
 
2368
                  if (adjust_symndx)
2369
                    {
2370
                      if (! (*adjust_symndx) (output_bfd, finfo->info,
2371
                                              input_bfd, o, irel,
2372
                                              &adjusted))
2373
                        return FALSE;
2374
                      if (adjusted)
2375
                        continue;
2376
                    }
2377
 
2378
                  h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2379
                  if (h != NULL)
2380
                    {
2381
                      /* This is a global symbol.  */
2382
                      if (h->indx >= 0)
2383
                        irel->r_symndx = h->indx;
2384
                      else
2385
                        {
2386
                          /* This symbol is being written at the end
2387
                             of the file, and we do not yet know the
2388
                             symbol index.  We save the pointer to the
2389
                             hash table entry in the rel_hash list.
2390
                             We set the indx field to -2 to indicate
2391
                             that this symbol must not be stripped.  */
2392
                          *rel_hash = h;
2393
                          h->indx = -2;
2394
                        }
2395
                    }
2396
                  else
2397
                    {
2398
                      long indx;
2399
 
2400
                      indx = finfo->sym_indices[irel->r_symndx];
2401
                      if (indx != -1)
2402
                        irel->r_symndx = indx;
2403
                      else
2404
                        {
2405
                          struct internal_syment *is;
2406
                          const char *name;
2407
                          char buf[SYMNMLEN + 1];
2408
 
2409
                          /* This reloc is against a symbol we are
2410
                             stripping.  This should have been handled
2411
                             by the 'dont_skip_symbol' code in the while
2412
                             loop at the top of this function.  */
2413
                          is = finfo->internal_syms + irel->r_symndx;
2414
 
2415
                          name = (_bfd_coff_internal_syment_name
2416
                                  (input_bfd, is, buf));
2417
                          if (name == NULL)
2418
                            return FALSE;
2419
 
2420
                          if (! ((*finfo->info->callbacks->unattached_reloc)
2421
                                 (finfo->info, name, input_bfd, o,
2422
                                  irel->r_vaddr)))
2423
                            return FALSE;
2424
                        }
2425
                    }
2426
                }
2427
 
2428
              o->output_section->reloc_count += o->reloc_count;
2429
            }
2430
        }
2431
 
2432
      /* Write out the modified section contents.  */
2433
      if (secdata == NULL || secdata->stab_info == NULL)
2434
        {
2435
          file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2436
          if (! bfd_set_section_contents (output_bfd, o->output_section,
2437
                                          contents, loc, o->size))
2438
            return FALSE;
2439
        }
2440
      else
2441
        {
2442
          if (! (_bfd_write_section_stabs
2443
                 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2444
                  o, &secdata->stab_info, contents)))
2445
            return FALSE;
2446
        }
2447
    }
2448
 
2449
  if (! finfo->info->keep_memory
2450
      && ! _bfd_coff_free_symbols (input_bfd))
2451
    return FALSE;
2452
 
2453
  return TRUE;
2454
}
2455
 
2456
/* Write out a global symbol.  Called via coff_link_hash_traverse.  */
2457
 
2458
bfd_boolean
2459
_bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
2460
{
2461
  struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2462
  bfd *output_bfd;
2463
  struct internal_syment isym;
2464
  bfd_size_type symesz;
2465
  unsigned int i;
2466
  file_ptr pos;
2467
 
2468
  output_bfd = finfo->output_bfd;
2469
 
2470
  if (h->root.type == bfd_link_hash_warning)
2471
    {
2472
      h = (struct coff_link_hash_entry *) h->root.u.i.link;
2473
      if (h->root.type == bfd_link_hash_new)
2474
        return TRUE;
2475
    }
2476
 
2477
  if (h->indx >= 0)
2478
    return TRUE;
2479
 
2480
  if (h->indx != -2
2481
      && (finfo->info->strip == strip_all
2482
          || (finfo->info->strip == strip_some
2483
              && (bfd_hash_lookup (finfo->info->keep_hash,
2484
                                   h->root.root.string, FALSE, FALSE)
2485
                  == NULL))))
2486
    return TRUE;
2487
 
2488
  switch (h->root.type)
2489
    {
2490
    default:
2491
    case bfd_link_hash_new:
2492
    case bfd_link_hash_warning:
2493
      abort ();
2494
      return FALSE;
2495
 
2496
    case bfd_link_hash_undefined:
2497
    case bfd_link_hash_undefweak:
2498
      isym.n_scnum = N_UNDEF;
2499
      isym.n_value = 0;
2500
      break;
2501
 
2502
    case bfd_link_hash_defined:
2503
    case bfd_link_hash_defweak:
2504
      {
2505
        asection *sec;
2506
 
2507
        sec = h->root.u.def.section->output_section;
2508
        if (bfd_is_abs_section (sec))
2509
          isym.n_scnum = N_ABS;
2510
        else
2511
          isym.n_scnum = sec->target_index;
2512
        isym.n_value = (h->root.u.def.value
2513
                        + h->root.u.def.section->output_offset);
2514
        if (! obj_pe (finfo->output_bfd))
2515
          isym.n_value += sec->vma;
2516
      }
2517
      break;
2518
 
2519
    case bfd_link_hash_common:
2520
      isym.n_scnum = N_UNDEF;
2521
      isym.n_value = h->root.u.c.size;
2522
      break;
2523
 
2524
    case bfd_link_hash_indirect:
2525
      /* Just ignore these.  They can't be handled anyhow.  */
2526
      return TRUE;
2527
    }
2528
 
2529
  if (strlen (h->root.root.string) <= SYMNMLEN)
2530
    strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2531
  else
2532
    {
2533
      bfd_boolean hash;
2534
      bfd_size_type indx;
2535
 
2536
      hash = TRUE;
2537
      if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2538
        hash = FALSE;
2539
      indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2540
                                 FALSE);
2541
      if (indx == (bfd_size_type) -1)
2542
        {
2543
          finfo->failed = TRUE;
2544
          return FALSE;
2545
        }
2546
      isym._n._n_n._n_zeroes = 0;
2547
      isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2548
    }
2549
 
2550
  isym.n_sclass = h->class;
2551
  isym.n_type = h->type;
2552
 
2553
  if (isym.n_sclass == C_NULL)
2554
    isym.n_sclass = C_EXT;
2555
 
2556
  /* If doing task linking and this is the pass where we convert
2557
     defined globals to statics, then do that conversion now.  If the
2558
     symbol is not being converted, just ignore it and it will be
2559
     output during a later pass.  */
2560
  if (finfo->global_to_static)
2561
    {
2562
      if (! IS_EXTERNAL (output_bfd, isym))
2563
        return TRUE;
2564
 
2565
      isym.n_sclass = C_STAT;
2566
    }
2567
 
2568
  /* When a weak symbol is not overridden by a strong one,
2569
     turn it into an external symbol when not building a
2570
     shared or relocatable object.  */
2571
  if (! finfo->info->shared
2572
      && ! finfo->info->relocatable
2573
      && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
2574
    isym.n_sclass = C_EXT;
2575
 
2576
  isym.n_numaux = h->numaux;
2577
 
2578
  bfd_coff_swap_sym_out (output_bfd, &isym, finfo->outsyms);
2579
 
2580
  symesz = bfd_coff_symesz (output_bfd);
2581
 
2582
  pos = obj_sym_filepos (output_bfd);
2583
  pos += obj_raw_syment_count (output_bfd) * symesz;
2584
  if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2585
      || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2586
    {
2587
      finfo->failed = TRUE;
2588
      return FALSE;
2589
    }
2590
 
2591
  h->indx = obj_raw_syment_count (output_bfd);
2592
 
2593
  ++obj_raw_syment_count (output_bfd);
2594
 
2595
  /* Write out any associated aux entries.  Most of the aux entries
2596
     will have been modified in _bfd_coff_link_input_bfd.  We have to
2597
     handle section aux entries here, now that we have the final
2598
     relocation and line number counts.  */
2599
  for (i = 0; i < isym.n_numaux; i++)
2600
    {
2601
      union internal_auxent *auxp;
2602
 
2603
      auxp = h->aux + i;
2604
 
2605
      /* Look for a section aux entry here using the same tests that
2606
         coff_swap_aux_out uses.  */
2607
      if (i == 0
2608
          && (isym.n_sclass == C_STAT
2609
              || isym.n_sclass == C_HIDDEN)
2610
          && isym.n_type == T_NULL
2611
          && (h->root.type == bfd_link_hash_defined
2612
              || h->root.type == bfd_link_hash_defweak))
2613
        {
2614
          asection *sec;
2615
 
2616
          sec = h->root.u.def.section->output_section;
2617
          if (sec != NULL)
2618
            {
2619
              auxp->x_scn.x_scnlen = sec->size;
2620
 
2621
              /* For PE, an overflow on the final link reportedly does
2622
                 not matter.  FIXME: Why not?  */
2623
              if (sec->reloc_count > 0xffff
2624
                  && (! obj_pe (output_bfd)
2625
                      || finfo->info->relocatable))
2626
                (*_bfd_error_handler)
2627
                  (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2628
                   bfd_get_filename (output_bfd),
2629
                   bfd_get_section_name (output_bfd, sec),
2630
                   sec->reloc_count);
2631
 
2632
              if (sec->lineno_count > 0xffff
2633
                  && (! obj_pe (output_bfd)
2634
                      || finfo->info->relocatable))
2635
                (*_bfd_error_handler)
2636
                  (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2637
                   bfd_get_filename (output_bfd),
2638
                   bfd_get_section_name (output_bfd, sec),
2639
                   sec->lineno_count);
2640
 
2641
              auxp->x_scn.x_nreloc = sec->reloc_count;
2642
              auxp->x_scn.x_nlinno = sec->lineno_count;
2643
              auxp->x_scn.x_checksum = 0;
2644
              auxp->x_scn.x_associated = 0;
2645
              auxp->x_scn.x_comdat = 0;
2646
            }
2647
        }
2648
 
2649
      bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2650
                             isym.n_sclass, (int) i, isym.n_numaux,
2651
                             finfo->outsyms);
2652
      if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2653
        {
2654
          finfo->failed = TRUE;
2655
          return FALSE;
2656
        }
2657
      ++obj_raw_syment_count (output_bfd);
2658
    }
2659
 
2660
  return TRUE;
2661
}
2662
 
2663
/* Write out task global symbols, converting them to statics.  Called
2664
   via coff_link_hash_traverse.  Calls bfd_coff_write_global_sym to do
2665
   the dirty work, if the symbol we are processing needs conversion.  */
2666
 
2667
bfd_boolean
2668
_bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2669
{
2670
  struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2671
  bfd_boolean rtnval = TRUE;
2672
  bfd_boolean save_global_to_static;
2673
 
2674
  if (h->root.type == bfd_link_hash_warning)
2675
    h = (struct coff_link_hash_entry *) h->root.u.i.link;
2676
 
2677
  if (h->indx < 0)
2678
    {
2679
      switch (h->root.type)
2680
        {
2681
        case bfd_link_hash_defined:
2682
        case bfd_link_hash_defweak:
2683
          save_global_to_static = finfo->global_to_static;
2684
          finfo->global_to_static = TRUE;
2685
          rtnval = _bfd_coff_write_global_sym (h, data);
2686
          finfo->global_to_static = save_global_to_static;
2687
          break;
2688
        default:
2689
          break;
2690
        }
2691
    }
2692
  return (rtnval);
2693
}
2694
 
2695
/* Handle a link order which is supposed to generate a reloc.  */
2696
 
2697
bfd_boolean
2698
_bfd_coff_reloc_link_order (bfd *output_bfd,
2699
                            struct coff_final_link_info *finfo,
2700
                            asection *output_section,
2701
                            struct bfd_link_order *link_order)
2702
{
2703
  reloc_howto_type *howto;
2704
  struct internal_reloc *irel;
2705
  struct coff_link_hash_entry **rel_hash_ptr;
2706
 
2707
  howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2708
  if (howto == NULL)
2709
    {
2710
      bfd_set_error (bfd_error_bad_value);
2711
      return FALSE;
2712
    }
2713
 
2714
  if (link_order->u.reloc.p->addend != 0)
2715
    {
2716
      bfd_size_type size;
2717
      bfd_byte *buf;
2718
      bfd_reloc_status_type rstat;
2719
      bfd_boolean ok;
2720
      file_ptr loc;
2721
 
2722
      size = bfd_get_reloc_size (howto);
2723
      buf = bfd_zmalloc (size);
2724
      if (buf == NULL)
2725
        return FALSE;
2726
 
2727
      rstat = _bfd_relocate_contents (howto, output_bfd,
2728
                                      (bfd_vma) link_order->u.reloc.p->addend,\
2729
                                      buf);
2730
      switch (rstat)
2731
        {
2732
        case bfd_reloc_ok:
2733
          break;
2734
        default:
2735
        case bfd_reloc_outofrange:
2736
          abort ();
2737
        case bfd_reloc_overflow:
2738
          if (! ((*finfo->info->callbacks->reloc_overflow)
2739
                 (finfo->info, NULL,
2740
                  (link_order->type == bfd_section_reloc_link_order
2741
                   ? bfd_section_name (output_bfd,
2742
                                       link_order->u.reloc.p->u.section)
2743
                   : link_order->u.reloc.p->u.name),
2744
                  howto->name, link_order->u.reloc.p->addend,
2745
                  (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2746
            {
2747
              free (buf);
2748
              return FALSE;
2749
            }
2750
          break;
2751
        }
2752
      loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2753
      ok = bfd_set_section_contents (output_bfd, output_section, buf,
2754
                                     loc, size);
2755
      free (buf);
2756
      if (! ok)
2757
        return FALSE;
2758
    }
2759
 
2760
  /* Store the reloc information in the right place.  It will get
2761
     swapped and written out at the end of the final_link routine.  */
2762
  irel = (finfo->section_info[output_section->target_index].relocs
2763
          + output_section->reloc_count);
2764
  rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2765
                  + output_section->reloc_count);
2766
 
2767
  memset (irel, 0, sizeof (struct internal_reloc));
2768
  *rel_hash_ptr = NULL;
2769
 
2770
  irel->r_vaddr = output_section->vma + link_order->offset;
2771
 
2772
  if (link_order->type == bfd_section_reloc_link_order)
2773
    {
2774
      /* We need to somehow locate a symbol in the right section.  The
2775
         symbol must either have a value of zero, or we must adjust
2776
         the addend by the value of the symbol.  FIXME: Write this
2777
         when we need it.  The old linker couldn't handle this anyhow.  */
2778
      abort ();
2779
      *rel_hash_ptr = NULL;
2780
      irel->r_symndx = 0;
2781
    }
2782
  else
2783
    {
2784
      struct coff_link_hash_entry *h;
2785
 
2786
      h = ((struct coff_link_hash_entry *)
2787
           bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2788
                                         link_order->u.reloc.p->u.name,
2789
                                         FALSE, FALSE, TRUE));
2790
      if (h != NULL)
2791
        {
2792
          if (h->indx >= 0)
2793
            irel->r_symndx = h->indx;
2794
          else
2795
            {
2796
              /* Set the index to -2 to force this symbol to get
2797
                 written out.  */
2798
              h->indx = -2;
2799
              *rel_hash_ptr = h;
2800
              irel->r_symndx = 0;
2801
            }
2802
        }
2803
      else
2804
        {
2805
          if (! ((*finfo->info->callbacks->unattached_reloc)
2806
                 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2807
                  (asection *) NULL, (bfd_vma) 0)))
2808
            return FALSE;
2809
          irel->r_symndx = 0;
2810
        }
2811
    }
2812
 
2813
  /* FIXME: Is this always right?  */
2814
  irel->r_type = howto->type;
2815
 
2816
  /* r_size is only used on the RS/6000, which needs its own linker
2817
     routines anyhow.  r_extern is only used for ECOFF.  */
2818
 
2819
  /* FIXME: What is the right value for r_offset?  Is zero OK?  */
2820
  ++output_section->reloc_count;
2821
 
2822
  return TRUE;
2823
}
2824
 
2825
/* A basic reloc handling routine which may be used by processors with
2826
   simple relocs.  */
2827
 
2828
bfd_boolean
2829
_bfd_coff_generic_relocate_section (bfd *output_bfd,
2830
                                    struct bfd_link_info *info,
2831
                                    bfd *input_bfd,
2832
                                    asection *input_section,
2833
                                    bfd_byte *contents,
2834
                                    struct internal_reloc *relocs,
2835
                                    struct internal_syment *syms,
2836
                                    asection **sections)
2837
{
2838
  struct internal_reloc *rel;
2839
  struct internal_reloc *relend;
2840
 
2841
  rel = relocs;
2842
  relend = rel + input_section->reloc_count;
2843
  for (; rel < relend; rel++)
2844
    {
2845
      long symndx;
2846
      struct coff_link_hash_entry *h;
2847
      struct internal_syment *sym;
2848
      bfd_vma addend;
2849
      bfd_vma val;
2850
      reloc_howto_type *howto;
2851
      bfd_reloc_status_type rstat;
2852
 
2853
      symndx = rel->r_symndx;
2854
 
2855
      if (symndx == -1)
2856
        {
2857
          h = NULL;
2858
          sym = NULL;
2859
        }
2860
      else if (symndx < 0
2861
               || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2862
        {
2863
          (*_bfd_error_handler)
2864
            ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
2865
          return FALSE;
2866
        }
2867
      else
2868
        {
2869
          h = obj_coff_sym_hashes (input_bfd)[symndx];
2870
          sym = syms + symndx;
2871
        }
2872
 
2873
      /* COFF treats common symbols in one of two ways.  Either the
2874
         size of the symbol is included in the section contents, or it
2875
         is not.  We assume that the size is not included, and force
2876
         the rtype_to_howto function to adjust the addend as needed.  */
2877
      if (sym != NULL && sym->n_scnum != 0)
2878
        addend = - sym->n_value;
2879
      else
2880
        addend = 0;
2881
 
2882
      howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2883
                                       sym, &addend);
2884
      if (howto == NULL)
2885
        return FALSE;
2886
 
2887
      /* If we are doing a relocatable link, then we can just ignore
2888
         a PC relative reloc that is pcrel_offset.  It will already
2889
         have the correct value.  If this is not a relocatable link,
2890
         then we should ignore the symbol value.  */
2891
      if (howto->pc_relative && howto->pcrel_offset)
2892
        {
2893
          if (info->relocatable)
2894
            continue;
2895
          if (sym != NULL && sym->n_scnum != 0)
2896
            addend += sym->n_value;
2897
        }
2898
 
2899
      val = 0;
2900
 
2901
      if (h == NULL)
2902
        {
2903
          asection *sec;
2904
 
2905
          if (symndx == -1)
2906
            {
2907
              sec = bfd_abs_section_ptr;
2908
              val = 0;
2909
            }
2910
          else
2911
            {
2912
              sec = sections[symndx];
2913
              val = (sec->output_section->vma
2914
                     + sec->output_offset
2915
                     + sym->n_value);
2916
              if (! obj_pe (input_bfd))
2917
                val -= sec->vma;
2918
            }
2919
        }
2920
      else
2921
        {
2922
          if (h->root.type == bfd_link_hash_defined
2923
              || h->root.type == bfd_link_hash_defweak)
2924
            {
2925
              /* Defined weak symbols are a GNU extension. */
2926
              asection *sec;
2927
 
2928
              sec = h->root.u.def.section;
2929
              val = (h->root.u.def.value
2930
                     + sec->output_section->vma
2931
                     + sec->output_offset);
2932
            }
2933
 
2934
          else if (h->root.type == bfd_link_hash_undefweak)
2935
            {
2936
              if (h->class == C_NT_WEAK && h->numaux == 1)
2937
                {
2938
                  /* See _Microsoft Portable Executable and Common Object
2939
                     File Format Specification_, section 5.5.3.
2940
                     Note that weak symbols without aux records are a GNU
2941
                     extension.
2942
                     FIXME: All weak externals are treated as having
2943
                     characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
2944
                     These behave as per SVR4 ABI:  A library member
2945
                     will resolve a weak external only if a normal
2946
                     external causes the library member to be linked.
2947
                     See also linker.c: generic_link_check_archive_element. */
2948
                  asection *sec;
2949
                  struct coff_link_hash_entry *h2 =
2950
                    input_bfd->tdata.coff_obj_data->sym_hashes[
2951
                    h->aux->x_sym.x_tagndx.l];
2952
 
2953
                  if (!h2 || h2->root.type == bfd_link_hash_undefined)
2954
                    {
2955
                      sec = bfd_abs_section_ptr;
2956
                      val = 0;
2957
                    }
2958
                  else
2959
                    {
2960
                      sec = h2->root.u.def.section;
2961
                      val = h2->root.u.def.value
2962
                        + sec->output_section->vma + sec->output_offset;
2963
                    }
2964
                }
2965
              else
2966
                /* This is a GNU extension.  */
2967
                val = 0;
2968
            }
2969
 
2970
          else if (! info->relocatable)
2971
            {
2972
              if (! ((*info->callbacks->undefined_symbol)
2973
                     (info, h->root.root.string, input_bfd, input_section,
2974
                      rel->r_vaddr - input_section->vma, TRUE)))
2975
                return FALSE;
2976
            }
2977
        }
2978
 
2979
      if (info->base_file)
2980
        {
2981
          /* Emit a reloc if the backend thinks it needs it.  */
2982
          if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
2983
            {
2984
              /* Relocation to a symbol in a section which isn't
2985
                 absolute.  We output the address here to a file.
2986
                 This file is then read by dlltool when generating the
2987
                 reloc section.  Note that the base file is not
2988
                 portable between systems.  We write out a long here,
2989
                 and dlltool reads in a long.  */
2990
              long addr = (rel->r_vaddr
2991
                           - input_section->vma
2992
                           + input_section->output_offset
2993
                           + input_section->output_section->vma);
2994
              if (coff_data (output_bfd)->pe)
2995
                addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
2996
              if (fwrite (&addr, 1, sizeof (long), (FILE *) info->base_file)
2997
                  != sizeof (long))
2998
                {
2999
                  bfd_set_error (bfd_error_system_call);
3000
                  return FALSE;
3001
                }
3002
            }
3003
        }
3004
 
3005
      rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3006
                                        contents,
3007
                                        rel->r_vaddr - input_section->vma,
3008
                                        val, addend);
3009
 
3010
      switch (rstat)
3011
        {
3012
        default:
3013
          abort ();
3014
        case bfd_reloc_ok:
3015
          break;
3016
        case bfd_reloc_outofrange:
3017
          (*_bfd_error_handler)
3018
            (_("%B: bad reloc address 0x%lx in section `%A'"),
3019
             input_bfd, input_section, (unsigned long) rel->r_vaddr);
3020
          return FALSE;
3021
        case bfd_reloc_overflow:
3022
          {
3023
            const char *name;
3024
            char buf[SYMNMLEN + 1];
3025
 
3026
            if (symndx == -1)
3027
              name = "*ABS*";
3028
            else if (h != NULL)
3029
              name = NULL;
3030
            else
3031
              {
3032
                name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3033
                if (name == NULL)
3034
                  return FALSE;
3035
              }
3036
 
3037
            if (! ((*info->callbacks->reloc_overflow)
3038
                   (info, (h ? &h->root : NULL), name, howto->name,
3039
                    (bfd_vma) 0, input_bfd, input_section,
3040
                    rel->r_vaddr - input_section->vma)))
3041
              return FALSE;
3042
          }
3043
        }
3044
    }
3045
  return TRUE;
3046
}

powered by: WebSVN 2.1.0

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