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