1 /* COFF specific linker code.
2 Copyright (C) 1994-2016 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* This file contains the COFF backend linker code. */
28 #include "coff/internal.h"
30 #include "safe-ctype.h"
32 static bfd_boolean coff_link_add_object_symbols (bfd *, struct bfd_link_info *);
33 static bfd_boolean coff_link_check_archive_element
34 (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
36 static bfd_boolean coff_link_add_symbols (bfd *, struct bfd_link_info *);
38 /* Return TRUE if SYM is a weak, external symbol. */
39 #define IS_WEAK_EXTERNAL(abfd, sym) \
40 ((sym).n_sclass == C_WEAKEXT \
41 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
43 /* Return TRUE if SYM is an external symbol. */
44 #define IS_EXTERNAL(abfd, sym) \
45 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
47 /* Define macros so that the ISFCN, et. al., macros work correctly.
48 These macros are defined in include/coff/internal.h in terms of
49 N_TMASK, etc. These definitions require a user to define local
50 variables with the appropriate names, and with values from the
51 coff_data (abfd) structure. */
53 #define N_TMASK n_tmask
54 #define N_BTSHFT n_btshft
55 #define N_BTMASK n_btmask
57 /* Create an entry in a COFF linker hash table. */
59 struct bfd_hash_entry *
60 _bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
61 struct bfd_hash_table *table,
64 struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
66 /* Allocate the structure if it has not already been allocated by a
68 if (ret == (struct coff_link_hash_entry *) NULL)
69 ret = ((struct coff_link_hash_entry *)
70 bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
71 if (ret == (struct coff_link_hash_entry *) NULL)
72 return (struct bfd_hash_entry *) ret;
74 /* Call the allocation method of the superclass. */
75 ret = ((struct coff_link_hash_entry *)
76 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
78 if (ret != (struct coff_link_hash_entry *) NULL)
80 /* Set local fields. */
83 ret->symbol_class = C_NULL;
89 return (struct bfd_hash_entry *) ret;
92 /* Initialize a COFF linker hash table. */
95 _bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
97 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
98 struct bfd_hash_table *,
100 unsigned int entsize)
102 memset (&table->stab_info, 0, sizeof (table->stab_info));
103 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
106 /* Create a COFF linker hash table. */
108 struct bfd_link_hash_table *
109 _bfd_coff_link_hash_table_create (bfd *abfd)
111 struct coff_link_hash_table *ret;
112 bfd_size_type amt = sizeof (struct coff_link_hash_table);
114 ret = (struct coff_link_hash_table *) bfd_malloc (amt);
118 if (! _bfd_coff_link_hash_table_init (ret, abfd,
119 _bfd_coff_link_hash_newfunc,
120 sizeof (struct coff_link_hash_entry)))
123 return (struct bfd_link_hash_table *) NULL;
128 /* Create an entry in a COFF debug merge hash table. */
130 struct bfd_hash_entry *
131 _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,
132 struct bfd_hash_table *table,
135 struct coff_debug_merge_hash_entry *ret =
136 (struct coff_debug_merge_hash_entry *) entry;
138 /* Allocate the structure if it has not already been allocated by a
140 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
141 ret = ((struct coff_debug_merge_hash_entry *)
142 bfd_hash_allocate (table,
143 sizeof (struct coff_debug_merge_hash_entry)));
144 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
145 return (struct bfd_hash_entry *) ret;
147 /* Call the allocation method of the superclass. */
148 ret = ((struct coff_debug_merge_hash_entry *)
149 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
150 if (ret != (struct coff_debug_merge_hash_entry *) NULL)
152 /* Set local fields. */
156 return (struct bfd_hash_entry *) ret;
159 /* Given a COFF BFD, add symbols to the global hash table as
163 _bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
165 switch (bfd_get_format (abfd))
168 return coff_link_add_object_symbols (abfd, info);
170 return _bfd_generic_link_add_archive_symbols
171 (abfd, info, coff_link_check_archive_element);
173 bfd_set_error (bfd_error_wrong_format);
178 /* Add symbols from a COFF object file. */
181 coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
183 if (! _bfd_coff_get_external_symbols (abfd))
185 if (! coff_link_add_symbols (abfd, info))
188 if (! info->keep_memory
189 && ! _bfd_coff_free_symbols (abfd))
195 /* Check a single archive element to see if we need to include it in
196 the link. *PNEEDED is set according to whether this element is
197 needed in the link or not. This is called via
198 _bfd_generic_link_add_archive_symbols. */
201 coff_link_check_archive_element (bfd *abfd,
202 struct bfd_link_info *info,
203 struct bfd_link_hash_entry *h,
205 bfd_boolean *pneeded)
209 /* We are only interested in symbols that are currently undefined.
210 If a symbol is currently known to be common, COFF linkers do not
211 bring in an object file which defines it. */
212 if (h->type != bfd_link_hash_undefined)
215 /* Include this element? */
216 if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd))
220 return coff_link_add_object_symbols (abfd, info);
223 /* Add all the symbols from an object file to the hash table. */
226 coff_link_add_symbols (bfd *abfd,
227 struct bfd_link_info *info)
229 unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
230 unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
231 unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
232 bfd_boolean keep_syms;
233 bfd_boolean default_copy;
234 bfd_size_type symcount;
235 struct coff_link_hash_entry **sym_hash;
236 bfd_size_type symesz;
241 symcount = obj_raw_syment_count (abfd);
244 return TRUE; /* Nothing to do. */
246 /* Keep the symbols during this function, in case the linker needs
247 to read the generic symbols in order to report an error message. */
248 keep_syms = obj_coff_keep_syms (abfd);
249 obj_coff_keep_syms (abfd) = TRUE;
251 if (info->keep_memory)
252 default_copy = FALSE;
256 /* We keep a list of the linker hash table entries that correspond
257 to particular symbols. */
258 amt = symcount * sizeof (struct coff_link_hash_entry *);
259 sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
260 if (sym_hash == NULL)
262 obj_coff_sym_hashes (abfd) = sym_hash;
264 symesz = bfd_coff_symesz (abfd);
265 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
266 esym = (bfd_byte *) obj_coff_external_syms (abfd);
267 esym_end = esym + symcount * symesz;
268 while (esym < esym_end)
270 struct internal_syment sym;
271 enum coff_symbol_classification classification;
274 bfd_coff_swap_sym_in (abfd, esym, &sym);
276 classification = bfd_coff_classify_symbol (abfd, &sym);
277 if (classification != COFF_SYMBOL_LOCAL)
280 char buf[SYMNMLEN + 1];
286 /* This symbol is externally visible. */
288 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
292 /* We must copy the name into memory if we got it from the
293 syment itself, rather than the string table. */
295 if (sym._n._n_n._n_zeroes != 0
296 || sym._n._n_n._n_offset == 0)
301 switch (classification)
306 case COFF_SYMBOL_GLOBAL:
307 flags = BSF_EXPORT | BSF_GLOBAL;
308 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
310 value -= section->vma;
313 case COFF_SYMBOL_UNDEFINED:
315 section = bfd_und_section_ptr;
318 case COFF_SYMBOL_COMMON:
320 section = bfd_com_section_ptr;
323 case COFF_SYMBOL_PE_SECTION:
324 flags = BSF_SECTION_SYM | BSF_GLOBAL;
325 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
329 if (IS_WEAK_EXTERNAL (abfd, sym))
334 /* In the PE format, section symbols actually refer to the
335 start of the output section. We handle them specially
337 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
339 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
340 name, FALSE, copy, FALSE);
341 if (*sym_hash != NULL)
343 if (((*sym_hash)->coff_link_hash_flags
344 & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
345 && (*sym_hash)->root.type != bfd_link_hash_undefined
346 && (*sym_hash)->root.type != bfd_link_hash_undefweak)
347 (*_bfd_error_handler)
348 ("Warning: symbol `%s' is both section and non-section",
355 /* The Microsoft Visual C compiler does string pooling by
356 hashing the constants to an internal symbol name, and
357 relying on the linker comdat support to discard
358 duplicate names. However, if one string is a literal and
359 one is a data initializer, one will end up in the .data
360 section and one will end up in the .rdata section. The
361 Microsoft linker will combine them into the .data
362 section, which seems to be wrong since it might cause the
365 As long as there are no external references to the
366 symbols, which there shouldn't be, we can treat the .data
367 and .rdata instances as separate symbols. The comdat
368 code in the linker will do the appropriate merging. Here
369 we avoid getting a multiple definition error for one of
370 these special symbols.
372 FIXME: I don't think this will work in the case where
373 there are two object files which use the constants as a
374 literal and two object files which use it as a data
375 initializer. One or the other of the second object files
376 is going to wind up with an inappropriate reference. */
378 && (classification == COFF_SYMBOL_GLOBAL
379 || classification == COFF_SYMBOL_PE_SECTION)
380 && coff_section_data (abfd, section) != NULL
381 && coff_section_data (abfd, section)->comdat != NULL
382 && CONST_STRNEQ (name, "??_")
383 && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
385 if (*sym_hash == NULL)
386 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
387 name, FALSE, copy, FALSE);
388 if (*sym_hash != NULL
389 && (*sym_hash)->root.type == bfd_link_hash_defined
390 && coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL
391 && strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,
392 coff_section_data (abfd, section)->comdat->name) == 0)
398 if (! (bfd_coff_link_add_one_symbol
399 (info, abfd, name, flags, section, value,
400 (const char *) NULL, copy, FALSE,
401 (struct bfd_link_hash_entry **) sym_hash)))
405 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
406 (*sym_hash)->coff_link_hash_flags |=
407 COFF_LINK_HASH_PE_SECTION_SYMBOL;
409 /* Limit the alignment of a common symbol to the possible
410 alignment of a section. There is no point to permitting
411 a higher alignment for a common symbol: we can not
412 guarantee it, and it may cause us to allocate extra space
413 in the common section. */
414 if (section == bfd_com_section_ptr
415 && (*sym_hash)->root.type == bfd_link_hash_common
416 && ((*sym_hash)->root.u.c.p->alignment_power
417 > bfd_coff_default_section_alignment_power (abfd)))
418 (*sym_hash)->root.u.c.p->alignment_power
419 = bfd_coff_default_section_alignment_power (abfd);
421 if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
423 /* If we don't have any symbol information currently in
424 the hash table, or if we are looking at a symbol
425 definition, then update the symbol class and type in
427 if (((*sym_hash)->symbol_class == C_NULL
428 && (*sym_hash)->type == T_NULL)
431 && (*sym_hash)->root.type != bfd_link_hash_defined
432 && (*sym_hash)->root.type != bfd_link_hash_defweak))
434 (*sym_hash)->symbol_class = sym.n_sclass;
435 if (sym.n_type != T_NULL)
437 /* We want to warn if the type changed, but not
438 if it changed from an unspecified type.
439 Testing the whole type byte may work, but the
440 change from (e.g.) a function of unspecified
441 type to function of known type also wants to
443 if ((*sym_hash)->type != T_NULL
444 && (*sym_hash)->type != sym.n_type
445 && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
446 && (BTYPE ((*sym_hash)->type) == T_NULL
447 || BTYPE (sym.n_type) == T_NULL)))
448 (*_bfd_error_handler)
449 (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
450 abfd, name, (*sym_hash)->type, sym.n_type);
452 /* We don't want to change from a meaningful
453 base type to a null one, but if we know
454 nothing, take what little we might now know. */
455 if (BTYPE (sym.n_type) != T_NULL
456 || (*sym_hash)->type == T_NULL)
457 (*sym_hash)->type = sym.n_type;
459 (*sym_hash)->auxbfd = abfd;
460 if (sym.n_numaux != 0)
462 union internal_auxent *alloc;
465 union internal_auxent *iaux;
467 (*sym_hash)->numaux = sym.n_numaux;
468 alloc = ((union internal_auxent *)
469 bfd_hash_allocate (&info->hash->table,
471 * sizeof (*alloc))));
474 for (i = 0, eaux = esym + symesz, iaux = alloc;
476 i++, eaux += symesz, iaux++)
477 bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
478 sym.n_sclass, (int) i,
480 (*sym_hash)->aux = alloc;
485 if (classification == COFF_SYMBOL_PE_SECTION
486 && (*sym_hash)->numaux != 0)
488 /* Some PE sections (such as .bss) have a zero size in
489 the section header, but a non-zero size in the AUX
490 record. Correct that here.
492 FIXME: This is not at all the right place to do this.
493 For example, it won't help objdump. This needs to be
494 done when we swap in the section header. */
495 BFD_ASSERT ((*sym_hash)->numaux == 1);
496 if (section->size == 0)
497 section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;
499 /* FIXME: We could test whether the section sizes
500 matches the size in the aux entry, but apparently
501 that sometimes fails unexpectedly. */
505 esym += (sym.n_numaux + 1) * symesz;
506 sym_hash += sym.n_numaux + 1;
509 /* If this is a non-traditional, non-relocatable link, try to
510 optimize the handling of any .stab/.stabstr sections. */
511 if (! bfd_link_relocatable (info)
512 && ! info->traditional_format
513 && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)
514 && (info->strip != strip_all && info->strip != strip_debugger))
518 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
522 bfd_size_type string_offset = 0;
525 for (stab = abfd->sections; stab; stab = stab->next)
526 if (CONST_STRNEQ (stab->name, ".stab")
528 || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
530 struct coff_link_hash_table *table;
531 struct coff_section_tdata *secdata
532 = coff_section_data (abfd, stab);
536 amt = sizeof (struct coff_section_tdata);
537 stab->used_by_bfd = bfd_zalloc (abfd, amt);
538 if (stab->used_by_bfd == NULL)
540 secdata = coff_section_data (abfd, stab);
543 table = coff_hash_table (info);
545 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
554 obj_coff_keep_syms (abfd) = keep_syms;
559 obj_coff_keep_syms (abfd) = keep_syms;
563 /* Do the final link step. */
566 _bfd_coff_final_link (bfd *abfd,
567 struct bfd_link_info *info)
569 bfd_size_type symesz;
570 struct coff_final_link_info flaginfo;
571 bfd_boolean debug_merge_allocated;
572 bfd_boolean long_section_names;
574 struct bfd_link_order *p;
575 bfd_size_type max_sym_count;
576 bfd_size_type max_lineno_count;
577 bfd_size_type max_reloc_count;
578 bfd_size_type max_output_reloc_count;
579 bfd_size_type max_contents_size;
580 file_ptr rel_filepos;
582 file_ptr line_filepos;
585 bfd_byte *external_relocs = NULL;
586 char strbuf[STRING_SIZE_SIZE];
589 symesz = bfd_coff_symesz (abfd);
591 flaginfo.info = info;
592 flaginfo.output_bfd = abfd;
593 flaginfo.strtab = NULL;
594 flaginfo.section_info = NULL;
595 flaginfo.last_file_index = -1;
596 flaginfo.last_bf_index = -1;
597 flaginfo.internal_syms = NULL;
598 flaginfo.sec_ptrs = NULL;
599 flaginfo.sym_indices = NULL;
600 flaginfo.outsyms = NULL;
601 flaginfo.linenos = NULL;
602 flaginfo.contents = NULL;
603 flaginfo.external_relocs = NULL;
604 flaginfo.internal_relocs = NULL;
605 flaginfo.global_to_static = FALSE;
606 debug_merge_allocated = FALSE;
608 coff_data (abfd)->link_info = info;
610 flaginfo.strtab = _bfd_stringtab_init ();
611 if (flaginfo.strtab == NULL)
614 if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))
616 debug_merge_allocated = TRUE;
618 /* Compute the file positions for all the sections. */
619 if (! abfd->output_has_begun)
621 if (! bfd_coff_compute_section_file_positions (abfd))
625 /* Count the line numbers and relocation entries required for the
626 output file. Set the file positions for the relocs. */
627 rel_filepos = obj_relocbase (abfd);
628 relsz = bfd_coff_relsz (abfd);
629 max_contents_size = 0;
630 max_lineno_count = 0;
633 long_section_names = FALSE;
634 for (o = abfd->sections; o != NULL; o = o->next)
638 for (p = o->map_head.link_order; p != NULL; p = p->next)
640 if (p->type == bfd_indirect_link_order)
644 sec = p->u.indirect.section;
646 /* Mark all sections which are to be included in the
647 link. This will normally be every section. We need
648 to do this so that we can identify any sections which
649 the linker has decided to not include. */
650 sec->linker_mark = TRUE;
652 if (info->strip == strip_none
653 || info->strip == strip_some)
654 o->lineno_count += sec->lineno_count;
656 if (bfd_link_relocatable (info))
657 o->reloc_count += sec->reloc_count;
659 if (sec->rawsize > max_contents_size)
660 max_contents_size = sec->rawsize;
661 if (sec->size > max_contents_size)
662 max_contents_size = sec->size;
663 if (sec->lineno_count > max_lineno_count)
664 max_lineno_count = sec->lineno_count;
665 if (sec->reloc_count > max_reloc_count)
666 max_reloc_count = sec->reloc_count;
668 else if (bfd_link_relocatable (info)
669 && (p->type == bfd_section_reloc_link_order
670 || p->type == bfd_symbol_reloc_link_order))
673 if (o->reloc_count == 0)
677 o->flags |= SEC_RELOC;
678 o->rel_filepos = rel_filepos;
679 rel_filepos += o->reloc_count * relsz;
680 /* In PE COFF, if there are at least 0xffff relocations an
681 extra relocation will be written out to encode the count. */
682 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
683 rel_filepos += relsz;
686 if (bfd_coff_long_section_names (abfd)
687 && strlen (o->name) > SCNNMLEN)
689 /* This section has a long name which must go in the string
690 table. This must correspond to the code in
691 coff_write_object_contents which puts the string index
692 into the s_name field of the section header. That is why
693 we pass hash as FALSE. */
694 if (_bfd_stringtab_add (flaginfo.strtab, o->name, FALSE, FALSE)
695 == (bfd_size_type) -1)
697 long_section_names = TRUE;
701 /* If doing a relocatable link, allocate space for the pointers we
703 if (bfd_link_relocatable (info))
707 /* We use section_count + 1, rather than section_count, because
708 the target_index fields are 1 based. */
709 amt = abfd->section_count + 1;
710 amt *= sizeof (struct coff_link_section_info);
711 flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
712 if (flaginfo.section_info == NULL)
714 for (i = 0; i <= abfd->section_count; i++)
716 flaginfo.section_info[i].relocs = NULL;
717 flaginfo.section_info[i].rel_hashes = NULL;
721 /* We now know the size of the relocs, so we can determine the file
722 positions of the line numbers. */
723 line_filepos = rel_filepos;
724 linesz = bfd_coff_linesz (abfd);
725 max_output_reloc_count = 0;
726 for (o = abfd->sections; o != NULL; o = o->next)
728 if (o->lineno_count == 0)
732 o->line_filepos = line_filepos;
733 line_filepos += o->lineno_count * linesz;
736 if (o->reloc_count != 0)
738 /* We don't know the indices of global symbols until we have
739 written out all the local symbols. For each section in
740 the output file, we keep an array of pointers to hash
741 table entries. Each entry in the array corresponds to a
742 reloc. When we find a reloc against a global symbol, we
743 set the corresponding entry in this array so that we can
744 fix up the symbol index after we have written out all the
747 Because of this problem, we also keep the relocs in
748 memory until the end of the link. This wastes memory,
749 but only when doing a relocatable link, which is not the
751 BFD_ASSERT (bfd_link_relocatable (info));
752 amt = o->reloc_count;
753 amt *= sizeof (struct internal_reloc);
754 flaginfo.section_info[o->target_index].relocs =
755 (struct internal_reloc *) bfd_malloc (amt);
756 amt = o->reloc_count;
757 amt *= sizeof (struct coff_link_hash_entry *);
758 flaginfo.section_info[o->target_index].rel_hashes =
759 (struct coff_link_hash_entry **) bfd_malloc (amt);
760 if (flaginfo.section_info[o->target_index].relocs == NULL
761 || flaginfo.section_info[o->target_index].rel_hashes == NULL)
764 if (o->reloc_count > max_output_reloc_count)
765 max_output_reloc_count = o->reloc_count;
768 /* Reset the reloc and lineno counts, so that we can use them to
769 count the number of entries we have output so far. */
774 obj_sym_filepos (abfd) = line_filepos;
776 /* Figure out the largest number of symbols in an input BFD. Take
777 the opportunity to clear the output_has_begun fields of all the
780 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
784 sub->output_has_begun = FALSE;
785 sz = bfd_family_coff (sub) ? obj_raw_syment_count (sub) : 2;
786 if (sz > max_sym_count)
790 /* Allocate some buffers used while linking. */
791 amt = max_sym_count * sizeof (struct internal_syment);
792 flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
793 amt = max_sym_count * sizeof (asection *);
794 flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);
795 amt = max_sym_count * sizeof (long);
796 flaginfo.sym_indices = (long int *) bfd_malloc (amt);
797 flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
798 amt = max_lineno_count * bfd_coff_linesz (abfd);
799 flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
800 flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
801 amt = max_reloc_count * relsz;
802 flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
803 if (! bfd_link_relocatable (info))
805 amt = max_reloc_count * sizeof (struct internal_reloc);
806 flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
808 if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
809 || (flaginfo.sec_ptrs == NULL && max_sym_count > 0)
810 || (flaginfo.sym_indices == NULL && max_sym_count > 0)
811 || flaginfo.outsyms == NULL
812 || (flaginfo.linenos == NULL && max_lineno_count > 0)
813 || (flaginfo.contents == NULL && max_contents_size > 0)
814 || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
815 || (! bfd_link_relocatable (info)
816 && flaginfo.internal_relocs == NULL
817 && max_reloc_count > 0))
820 /* We now know the position of everything in the file, except that
821 we don't know the size of the symbol table and therefore we don't
822 know where the string table starts. We just build the string
823 table in memory as we go along. We process all the relocations
824 for a single input file at once. */
825 obj_raw_syment_count (abfd) = 0;
827 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
829 if (! bfd_coff_start_final_link (abfd, info))
833 for (o = abfd->sections; o != NULL; o = o->next)
835 for (p = o->map_head.link_order; p != NULL; p = p->next)
837 if (p->type == bfd_indirect_link_order
838 && bfd_family_coff (p->u.indirect.section->owner))
840 sub = p->u.indirect.section->owner;
841 if (! bfd_coff_link_output_has_begun (sub, & flaginfo))
843 if (! _bfd_coff_link_input_bfd (&flaginfo, sub))
845 sub->output_has_begun = TRUE;
848 else if (p->type == bfd_section_reloc_link_order
849 || p->type == bfd_symbol_reloc_link_order)
851 if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))
856 if (! _bfd_default_link_order (abfd, info, o, p))
862 if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all)
864 /* Add local symbols from foreign inputs. */
865 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
869 if (bfd_family_coff (sub) || ! bfd_get_outsymbols (sub))
871 for (i = 0; i < bfd_get_symcount (sub); ++i)
873 asymbol *sym = bfd_get_outsymbols (sub) [i];
875 struct internal_syment isym;
876 union internal_auxent iaux;
877 bfd_size_type string_size = 0, indx;
879 bfd_boolean rewrite = FALSE, hash;
881 if (! (sym->flags & BSF_LOCAL)
882 || (sym->flags & (BSF_SECTION_SYM | BSF_DEBUGGING_RELOC
883 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC
885 || ((sym->flags & BSF_DEBUGGING)
886 && ! (sym->flags & BSF_FILE)))
889 /* See if we are discarding symbols with this name. */
890 if ((flaginfo.info->strip == strip_some
891 && (bfd_hash_lookup (flaginfo.info->keep_hash,
892 bfd_asymbol_name(sym), FALSE, FALSE)
894 || (((flaginfo.info->discard == discard_sec_merge
895 && (bfd_get_section (sym)->flags & SEC_MERGE)
896 && ! bfd_link_relocatable (flaginfo.info))
897 || flaginfo.info->discard == discard_l)
898 && bfd_is_local_label_name (sub, bfd_asymbol_name(sym))))
901 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd)
903 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
905 if (! coff_write_alien_symbol(abfd, sym, &isym, &iaux, &written,
906 &string_size, NULL, NULL))
909 hash = !flaginfo.info->traditional_format;
911 if (string_size >= 6 && isym.n_sclass == C_FILE
912 && ! isym._n._n_n._n_zeroes && isym.n_numaux)
914 indx = _bfd_stringtab_add (flaginfo.strtab, ".file", hash,
916 if (indx == (bfd_size_type) -1)
918 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
919 bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
920 if (bfd_seek (abfd, pos, SEEK_SET) != 0
921 || bfd_bwrite (flaginfo.outsyms, symesz,
929 indx = _bfd_stringtab_add (flaginfo.strtab,
930 bfd_asymbol_name (sym), hash,
932 if (indx == (bfd_size_type) -1)
934 if (isym.n_sclass != C_FILE)
936 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
937 bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
942 BFD_ASSERT (isym.n_numaux == 1);
943 iaux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
944 bfd_coff_swap_aux_out (abfd, &iaux, isym.n_type, C_FILE,
945 0, 1, flaginfo.outsyms + symesz);
946 if (bfd_seek (abfd, pos + symesz, SEEK_SET) != 0
947 || bfd_bwrite (flaginfo.outsyms + symesz, symesz,
953 if (isym.n_sclass == C_FILE)
955 if (flaginfo.last_file_index != -1)
957 flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
958 bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
960 pos = obj_sym_filepos (abfd) + flaginfo.last_file_index
964 flaginfo.last_file_index = obj_raw_syment_count (abfd);
965 flaginfo.last_file = isym;
969 && (bfd_seek (abfd, pos, SEEK_SET) != 0
970 || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz))
973 obj_raw_syment_count (abfd) += written;
978 if (! bfd_coff_final_link_postscript (abfd, & flaginfo))
981 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
983 coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
984 debug_merge_allocated = FALSE;
986 if (flaginfo.internal_syms != NULL)
988 free (flaginfo.internal_syms);
989 flaginfo.internal_syms = NULL;
991 if (flaginfo.sec_ptrs != NULL)
993 free (flaginfo.sec_ptrs);
994 flaginfo.sec_ptrs = NULL;
996 if (flaginfo.sym_indices != NULL)
998 free (flaginfo.sym_indices);
999 flaginfo.sym_indices = NULL;
1001 if (flaginfo.linenos != NULL)
1003 free (flaginfo.linenos);
1004 flaginfo.linenos = NULL;
1006 if (flaginfo.contents != NULL)
1008 free (flaginfo.contents);
1009 flaginfo.contents = NULL;
1011 if (flaginfo.external_relocs != NULL)
1013 free (flaginfo.external_relocs);
1014 flaginfo.external_relocs = NULL;
1016 if (flaginfo.internal_relocs != NULL)
1018 free (flaginfo.internal_relocs);
1019 flaginfo.internal_relocs = NULL;
1022 /* The value of the last C_FILE symbol is supposed to be the symbol
1023 index of the first external symbol. Write it out again if
1025 if (flaginfo.last_file_index != -1
1026 && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))
1030 flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
1031 bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
1034 pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;
1035 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1036 || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)
1040 /* If doing task linking (ld --task-link) then make a pass through the
1041 global symbols, writing out any that are defined, and making them
1043 if (info->task_link)
1045 flaginfo.failed = FALSE;
1046 coff_link_hash_traverse (coff_hash_table (info),
1047 _bfd_coff_write_task_globals, &flaginfo);
1048 if (flaginfo.failed)
1052 /* Write out the global symbols. */
1053 flaginfo.failed = FALSE;
1054 bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);
1055 if (flaginfo.failed)
1058 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
1059 if (flaginfo.outsyms != NULL)
1061 free (flaginfo.outsyms);
1062 flaginfo.outsyms = NULL;
1065 if (bfd_link_relocatable (info) && max_output_reloc_count > 0)
1067 /* Now that we have written out all the global symbols, we know
1068 the symbol indices to use for relocs against them, and we can
1069 finally write out the relocs. */
1070 amt = max_output_reloc_count * relsz;
1071 external_relocs = (bfd_byte *) bfd_malloc (amt);
1072 if (external_relocs == NULL)
1075 for (o = abfd->sections; o != NULL; o = o->next)
1077 struct internal_reloc *irel;
1078 struct internal_reloc *irelend;
1079 struct coff_link_hash_entry **rel_hash;
1082 if (o->reloc_count == 0)
1085 irel = flaginfo.section_info[o->target_index].relocs;
1086 irelend = irel + o->reloc_count;
1087 rel_hash = flaginfo.section_info[o->target_index].rel_hashes;
1088 erel = external_relocs;
1089 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1091 if (*rel_hash != NULL)
1093 BFD_ASSERT ((*rel_hash)->indx >= 0);
1094 irel->r_symndx = (*rel_hash)->indx;
1096 bfd_coff_swap_reloc_out (abfd, irel, erel);
1099 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
1101 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
1103 /* In PE COFF, write the count of relocs as the first
1104 reloc. The header overflow bit will be set
1106 struct internal_reloc incount;
1107 bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
1109 memset (&incount, 0, sizeof (incount));
1110 incount.r_vaddr = o->reloc_count + 1;
1111 bfd_coff_swap_reloc_out (abfd, &incount, excount);
1112 if (bfd_bwrite (excount, relsz, abfd) != relsz)
1113 /* We'll leak, but it's an error anyway. */
1117 if (bfd_bwrite (external_relocs,
1118 (bfd_size_type) relsz * o->reloc_count, abfd)
1119 != (bfd_size_type) relsz * o->reloc_count)
1123 free (external_relocs);
1124 external_relocs = NULL;
1127 /* Free up the section information. */
1128 if (flaginfo.section_info != NULL)
1132 for (i = 0; i < abfd->section_count; i++)
1134 if (flaginfo.section_info[i].relocs != NULL)
1135 free (flaginfo.section_info[i].relocs);
1136 if (flaginfo.section_info[i].rel_hashes != NULL)
1137 free (flaginfo.section_info[i].rel_hashes);
1139 free (flaginfo.section_info);
1140 flaginfo.section_info = NULL;
1143 /* If we have optimized stabs strings, output them. */
1144 if (coff_hash_table (info)->stab_info.stabstr != NULL)
1146 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1150 /* Write out the string table. */
1151 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1155 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1156 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1159 #if STRING_SIZE_SIZE == 4
1161 _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,
1164 #error Change H_PUT_32 above
1167 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1168 != STRING_SIZE_SIZE)
1171 if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
1174 obj_coff_strings_written (abfd) = TRUE;
1177 _bfd_stringtab_free (flaginfo.strtab);
1179 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1180 not try to write out the symbols. */
1181 bfd_get_symcount (abfd) = 0;
1186 if (debug_merge_allocated)
1187 coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
1188 if (flaginfo.strtab != NULL)
1189 _bfd_stringtab_free (flaginfo.strtab);
1190 if (flaginfo.section_info != NULL)
1194 for (i = 0; i < abfd->section_count; i++)
1196 if (flaginfo.section_info[i].relocs != NULL)
1197 free (flaginfo.section_info[i].relocs);
1198 if (flaginfo.section_info[i].rel_hashes != NULL)
1199 free (flaginfo.section_info[i].rel_hashes);
1201 free (flaginfo.section_info);
1203 if (flaginfo.internal_syms != NULL)
1204 free (flaginfo.internal_syms);
1205 if (flaginfo.sec_ptrs != NULL)
1206 free (flaginfo.sec_ptrs);
1207 if (flaginfo.sym_indices != NULL)
1208 free (flaginfo.sym_indices);
1209 if (flaginfo.outsyms != NULL)
1210 free (flaginfo.outsyms);
1211 if (flaginfo.linenos != NULL)
1212 free (flaginfo.linenos);
1213 if (flaginfo.contents != NULL)
1214 free (flaginfo.contents);
1215 if (flaginfo.external_relocs != NULL)
1216 free (flaginfo.external_relocs);
1217 if (flaginfo.internal_relocs != NULL)
1218 free (flaginfo.internal_relocs);
1219 if (external_relocs != NULL)
1220 free (external_relocs);
1224 /* Parse out a -heap <reserved>,<commit> line. */
1227 dores_com (char *ptr, bfd *output_bfd, int heap)
1229 if (coff_data(output_bfd)->pe)
1231 int val = strtoul (ptr, &ptr, 0);
1234 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1236 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1240 val = strtoul (ptr+1, &ptr, 0);
1242 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1244 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1251 get_name (char *ptr, char **dst)
1256 while (*ptr && *ptr != ' ')
1262 /* Process any magic embedded commands in a section called .drectve. */
1265 process_embedded_commands (bfd *output_bfd,
1266 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1269 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1277 if (!bfd_malloc_and_get_section (abfd, sec, ©))
1283 e = (char *) copy + sec->size;
1285 for (s = (char *) copy; s < e ; )
1292 if (CONST_STRNEQ (s, "-attr"))
1302 s = get_name (s, &name);
1303 s = get_name (s, &attribs);
1323 asec = bfd_get_section_by_name (abfd, name);
1327 asec->flags |= SEC_CODE;
1329 asec->flags |= SEC_READONLY;
1332 else if (CONST_STRNEQ (s, "-heap"))
1333 s = dores_com (s + 5, output_bfd, 1);
1335 else if (CONST_STRNEQ (s, "-stack"))
1336 s = dores_com (s + 6, output_bfd, 0);
1338 /* GNU extension for aligned commons. */
1339 else if (CONST_STRNEQ (s, "-aligncomm:"))
1341 /* Common symbols must be aligned on reading, as it
1342 is too late to do anything here, after they have
1343 already been allocated, so just skip the directive. */
1354 /* Place a marker against all symbols which are used by relocations.
1355 This marker can be picked up by the 'do we skip this symbol ?'
1356 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1360 mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd)
1364 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1367 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1369 struct internal_reloc * internal_relocs;
1370 struct internal_reloc * irel;
1371 struct internal_reloc * irelend;
1373 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1
1374 || a->linker_mark == 0)
1376 /* Don't mark relocs in excluded sections. */
1377 if (a->output_section == bfd_abs_section_ptr)
1380 /* Read in the relocs. */
1381 internal_relocs = _bfd_coff_read_internal_relocs
1382 (input_bfd, a, FALSE,
1383 flaginfo->external_relocs,
1384 bfd_link_relocatable (flaginfo->info),
1385 (bfd_link_relocatable (flaginfo->info)
1386 ? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1387 : flaginfo->internal_relocs)
1390 if (internal_relocs == NULL)
1393 irel = internal_relocs;
1394 irelend = irel + a->reloc_count;
1396 /* Place a mark in the sym_indices array (whose entries have
1397 been initialised to 0) for all of the symbols that are used
1398 in the relocation table. This will then be picked up in the
1399 skip/don't-skip pass. */
1400 for (; irel < irelend; irel++)
1401 flaginfo->sym_indices[ irel->r_symndx ] = -1;
1405 /* Link an input file into the linker output file. This function
1406 handles all the sections and relocations of the input file at once. */
1409 _bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd)
1411 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1412 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1413 bfd_boolean (*adjust_symndx)
1414 (bfd *, struct bfd_link_info *, bfd *, asection *,
1415 struct internal_reloc *, bfd_boolean *);
1417 const char *strings;
1418 bfd_size_type syment_base;
1419 bfd_boolean copy, hash;
1420 bfd_size_type isymesz;
1421 bfd_size_type osymesz;
1422 bfd_size_type linesz;
1425 struct internal_syment *isymp;
1428 unsigned long output_index;
1430 struct coff_link_hash_entry **sym_hash;
1433 /* Move all the symbols to the output file. */
1435 output_bfd = flaginfo->output_bfd;
1437 syment_base = obj_raw_syment_count (output_bfd);
1438 isymesz = bfd_coff_symesz (input_bfd);
1439 osymesz = bfd_coff_symesz (output_bfd);
1440 linesz = bfd_coff_linesz (input_bfd);
1441 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1444 if (! flaginfo->info->keep_memory)
1447 if (flaginfo->info->traditional_format)
1450 if (! _bfd_coff_get_external_symbols (input_bfd))
1453 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1454 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1455 isymp = flaginfo->internal_syms;
1456 secpp = flaginfo->sec_ptrs;
1457 indexp = flaginfo->sym_indices;
1458 output_index = syment_base;
1459 outsym = flaginfo->outsyms;
1461 if (coff_data (output_bfd)->pe
1462 && ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd))
1465 /* If we are going to perform relocations and also strip/discard some
1466 symbols then we must make sure that we do not strip/discard those
1467 symbols that are going to be involved in the relocations. */
1468 if (( flaginfo->info->strip != strip_none
1469 || flaginfo->info->discard != discard_none)
1470 && bfd_link_relocatable (flaginfo->info))
1472 /* Mark the symbol array as 'not-used'. */
1473 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1475 mark_relocs (flaginfo, input_bfd);
1478 while (esym < esym_end)
1480 struct internal_syment isym;
1481 enum coff_symbol_classification classification;
1484 bfd_boolean dont_skip_symbol;
1487 bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1489 /* Make a copy of *isymp so that the relocate_section function
1490 always sees the original values. This is more reliable than
1491 always recomputing the symbol value even if we are stripping
1495 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1496 switch (classification)
1500 case COFF_SYMBOL_GLOBAL:
1501 case COFF_SYMBOL_PE_SECTION:
1502 case COFF_SYMBOL_LOCAL:
1503 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1505 case COFF_SYMBOL_COMMON:
1506 *secpp = bfd_com_section_ptr;
1508 case COFF_SYMBOL_UNDEFINED:
1509 *secpp = bfd_und_section_ptr;
1513 /* Extract the flag indicating if this symbol is used by a
1515 if ((flaginfo->info->strip != strip_none
1516 || flaginfo->info->discard != discard_none)
1517 && bfd_link_relocatable (flaginfo->info))
1518 dont_skip_symbol = *indexp;
1520 dont_skip_symbol = FALSE;
1526 add = 1 + isym.n_numaux;
1528 /* If we are stripping all symbols, we want to skip this one. */
1529 if (flaginfo->info->strip == strip_all && ! dont_skip_symbol)
1534 switch (classification)
1538 case COFF_SYMBOL_GLOBAL:
1539 case COFF_SYMBOL_COMMON:
1540 case COFF_SYMBOL_PE_SECTION:
1541 /* This is a global symbol. Global symbols come at the
1542 end of the symbol table, so skip them for now.
1543 Locally defined function symbols, however, are an
1544 exception, and are not moved to the end. */
1546 if (! ISFCN (isym.n_type))
1550 case COFF_SYMBOL_UNDEFINED:
1551 /* Undefined symbols are left for the end. */
1556 case COFF_SYMBOL_LOCAL:
1557 /* This is a local symbol. Skip it if we are discarding
1559 if (flaginfo->info->discard == discard_all && ! dont_skip_symbol)
1565 #ifndef COFF_WITH_PE
1566 /* Skip section symbols for sections which are not going to be
1569 && !dont_skip_symbol
1570 && isym.n_sclass == C_STAT
1571 && isym.n_type == T_NULL
1572 && isym.n_numaux > 0
1573 && ((*secpp)->output_section == bfd_abs_section_ptr
1574 || bfd_section_removed_from_list (output_bfd,
1575 (*secpp)->output_section)))
1579 /* If we stripping debugging symbols, and this is a debugging
1580 symbol, then skip it. FIXME: gas sets the section to N_ABS
1581 for some types of debugging symbols; I don't know if this is
1582 a bug or not. In any case, we handle it here. */
1584 && flaginfo->info->strip == strip_debugger
1585 && ! dont_skip_symbol
1586 && (isym.n_scnum == N_DEBUG
1587 || (isym.n_scnum == N_ABS
1588 && (isym.n_sclass == C_AUTO
1589 || isym.n_sclass == C_REG
1590 || isym.n_sclass == C_MOS
1591 || isym.n_sclass == C_MOE
1592 || isym.n_sclass == C_MOU
1593 || isym.n_sclass == C_ARG
1594 || isym.n_sclass == C_REGPARM
1595 || isym.n_sclass == C_FIELD
1596 || isym.n_sclass == C_EOS))))
1599 /* If some symbols are stripped based on the name, work out the
1600 name and decide whether to skip this symbol. */
1602 && (flaginfo->info->strip == strip_some
1603 || flaginfo->info->discard == discard_l))
1606 char buf[SYMNMLEN + 1];
1608 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1612 if (! dont_skip_symbol
1613 && ((flaginfo->info->strip == strip_some
1614 && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE,
1617 && flaginfo->info->discard == discard_l
1618 && bfd_is_local_label_name (input_bfd, name))))
1622 /* If this is an enum, struct, or union tag, see if we have
1623 already output an identical type. */
1625 && !flaginfo->info->traditional_format
1626 && (isym.n_sclass == C_ENTAG
1627 || isym.n_sclass == C_STRTAG
1628 || isym.n_sclass == C_UNTAG)
1629 && isym.n_numaux == 1)
1632 char buf[SYMNMLEN + 1];
1633 struct coff_debug_merge_hash_entry *mh;
1634 struct coff_debug_merge_type *mt;
1635 union internal_auxent aux;
1636 struct coff_debug_merge_element **epp;
1637 bfd_byte *esl, *eslend;
1638 struct internal_syment *islp;
1641 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1645 /* Ignore fake names invented by compiler; treat them all as
1647 if (*name == '~' || *name == '.' || *name == '$'
1648 || (*name == bfd_get_symbol_leading_char (input_bfd)
1649 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1652 mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name,
1657 /* Allocate memory to hold type information. If this turns
1658 out to be a duplicate, we pass this address to
1660 amt = sizeof (struct coff_debug_merge_type);
1661 mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
1664 mt->type_class = isym.n_sclass;
1666 /* Pick up the aux entry, which points to the end of the tag
1668 bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1669 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1672 /* Gather the elements. */
1673 epp = &mt->elements;
1674 mt->elements = NULL;
1676 esl = esym + 2 * isymesz;
1677 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1678 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1679 while (esl < eslend)
1681 const char *elename;
1682 char elebuf[SYMNMLEN + 1];
1685 bfd_coff_swap_sym_in (input_bfd, esl, islp);
1687 amt = sizeof (struct coff_debug_merge_element);
1688 *epp = (struct coff_debug_merge_element *)
1689 bfd_alloc (input_bfd, amt);
1693 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1695 if (elename == NULL)
1698 amt = strlen (elename) + 1;
1699 name_copy = (char *) bfd_alloc (input_bfd, amt);
1700 if (name_copy == NULL)
1702 strcpy (name_copy, elename);
1704 (*epp)->name = name_copy;
1705 (*epp)->type = islp->n_type;
1707 if (islp->n_numaux >= 1
1708 && islp->n_type != T_NULL
1709 && islp->n_sclass != C_EOS)
1711 union internal_auxent eleaux;
1714 bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1715 islp->n_type, islp->n_sclass, 0,
1716 islp->n_numaux, &eleaux);
1717 indx = eleaux.x_sym.x_tagndx.l;
1719 /* FIXME: If this tagndx entry refers to a symbol
1720 defined later in this file, we just ignore it.
1721 Handling this correctly would be tedious, and may
1726 (bfd_byte *) obj_coff_external_syms (input_bfd))
1729 (*epp)->tagndx = flaginfo->sym_indices[indx];
1730 if ((*epp)->tagndx < 0)
1734 epp = &(*epp)->next;
1737 esl += (islp->n_numaux + 1) * isymesz;
1738 islp += islp->n_numaux + 1;
1741 /* See if we already have a definition which matches this
1742 type. We always output the type if it has no elements,
1744 if (mt->elements == NULL)
1745 bfd_release (input_bfd, mt);
1748 struct coff_debug_merge_type *mtl;
1750 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1752 struct coff_debug_merge_element *me, *mel;
1754 if (mtl->type_class != mt->type_class)
1757 for (me = mt->elements, mel = mtl->elements;
1758 me != NULL && mel != NULL;
1759 me = me->next, mel = mel->next)
1761 if (strcmp (me->name, mel->name) != 0
1762 || me->type != mel->type
1763 || me->tagndx != mel->tagndx)
1767 if (me == NULL && mel == NULL)
1771 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1773 /* This is the first definition of this type. */
1774 mt->indx = output_index;
1775 mt->next = mh->types;
1780 /* This is a redefinition which can be merged. */
1781 bfd_release (input_bfd, mt);
1782 *indexp = mtl->indx;
1783 add = (eslend - esym) / isymesz;
1789 /* We now know whether we are to skip this symbol or not. */
1792 /* Adjust the symbol in order to output it. */
1794 if (isym._n._n_n._n_zeroes == 0
1795 && isym._n._n_n._n_offset != 0)
1800 /* This symbol has a long name. Enter it in the string
1801 table we are building. Note that we do not check
1802 bfd_coff_symname_in_debug. That is only true for
1803 XCOFF, and XCOFF requires different linking code
1805 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1808 indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy);
1809 if (indx == (bfd_size_type) -1)
1811 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1814 switch (isym.n_sclass)
1830 /* The symbol value should not be modified. */
1834 if (obj_pe (input_bfd)
1835 && strcmp (isym.n_name, ".bf") != 0
1836 && isym.n_scnum > 0)
1838 /* For PE, .lf and .ef get their value left alone,
1839 while .bf gets relocated. However, they all have
1840 "real" section numbers, and need to be moved into
1842 isym.n_scnum = (*secpp)->output_section->target_index;
1847 case C_LABEL: /* Not completely sure about these 2 */
1856 /* Compute new symbol location. */
1857 if (isym.n_scnum > 0)
1859 isym.n_scnum = (*secpp)->output_section->target_index;
1860 isym.n_value += (*secpp)->output_offset;
1861 if (! obj_pe (input_bfd))
1862 isym.n_value -= (*secpp)->vma;
1863 if (! obj_pe (flaginfo->output_bfd))
1864 isym.n_value += (*secpp)->output_section->vma;
1869 /* The value of a C_FILE symbol is the symbol index of
1870 the next C_FILE symbol. The value of the last C_FILE
1871 symbol is the symbol index to the first external
1872 symbol (actually, coff_renumber_symbols does not get
1873 this right--it just sets the value of the last C_FILE
1874 symbol to zero--and nobody has ever complained about
1875 it). We try to get this right, below, just before we
1876 write the symbols out, but in the general case we may
1877 have to write the symbol out twice. */
1878 if (flaginfo->last_file_index != -1
1879 && flaginfo->last_file.n_value != (bfd_vma) output_index)
1881 /* We must correct the value of the last C_FILE
1883 flaginfo->last_file.n_value = output_index;
1884 if ((bfd_size_type) flaginfo->last_file_index >= syment_base)
1886 /* The last C_FILE symbol is in this input file. */
1887 bfd_coff_swap_sym_out (output_bfd,
1888 &flaginfo->last_file,
1890 + ((flaginfo->last_file_index
1898 /* We have already written out the last C_FILE
1899 symbol. We need to write it out again. We
1900 borrow *outsym temporarily. */
1901 bfd_coff_swap_sym_out (output_bfd,
1902 &flaginfo->last_file, outsym);
1903 pos = obj_sym_filepos (output_bfd);
1904 pos += flaginfo->last_file_index * osymesz;
1905 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1906 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1911 flaginfo->last_file_index = output_index;
1912 flaginfo->last_file = isym;
1916 /* If doing task linking, convert normal global function symbols to
1917 static functions. */
1918 if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1919 isym.n_sclass = C_STAT;
1921 /* Output the symbol. */
1922 bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1924 *indexp = output_index;
1929 struct coff_link_hash_entry *h;
1931 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1933 h = obj_coff_sym_hashes (input_bfd)[indx];
1936 /* This can happen if there were errors earlier in
1938 bfd_set_error (bfd_error_bad_value);
1941 h->indx = output_index;
1944 output_index += add;
1945 outsym += add * osymesz;
1948 esym += add * isymesz;
1952 for (--add; add > 0; --add)
1959 /* Fix up the aux entries. This must be done in a separate pass,
1960 because we don't know the correct symbol indices until we have
1961 already decided which symbols we are going to keep. */
1962 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1963 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1964 isymp = flaginfo->internal_syms;
1965 indexp = flaginfo->sym_indices;
1966 sym_hash = obj_coff_sym_hashes (input_bfd);
1967 outsym = flaginfo->outsyms;
1969 while (esym < esym_end)
1973 add = 1 + isymp->n_numaux;
1976 || (bfd_size_type) *indexp < syment_base)
1977 && (*sym_hash == NULL
1978 || (*sym_hash)->auxbfd != input_bfd))
1979 esym += add * isymesz;
1982 struct coff_link_hash_entry *h;
1990 /* The m68k-motorola-sysv assembler will sometimes
1991 generate two symbols with the same name, but only one
1992 will have aux entries. */
1993 BFD_ASSERT (isymp->n_numaux == 0
1995 || h->numaux == isymp->n_numaux);
2003 /* Handle the aux entries. This handling is based on
2004 coff_pointerize_aux. I don't know if it always correct. */
2005 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
2007 union internal_auxent aux;
2008 union internal_auxent *auxp;
2010 if (h != NULL && h->aux != NULL && (h->numaux > i))
2014 bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
2015 isymp->n_sclass, i, isymp->n_numaux, &aux);
2019 if (isymp->n_sclass == C_FILE)
2021 /* If this is a long filename, we must put it in the
2023 if (auxp->x_file.x_n.x_zeroes == 0
2024 && auxp->x_file.x_n.x_offset != 0)
2026 const char *filename;
2029 BFD_ASSERT (auxp->x_file.x_n.x_offset
2030 >= STRING_SIZE_SIZE);
2031 if (strings == NULL)
2033 strings = _bfd_coff_read_string_table (input_bfd);
2034 if (strings == NULL)
2037 if ((bfd_size_type) auxp->x_file.x_n.x_offset >= obj_coff_strings_len (input_bfd))
2038 filename = _("<corrupt>");
2040 filename = strings + auxp->x_file.x_n.x_offset;
2041 indx = _bfd_stringtab_add (flaginfo->strtab, filename,
2043 if (indx == (bfd_size_type) -1)
2045 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
2048 else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
2049 && isymp->n_sclass != C_NT_WEAK)
2053 if (ISFCN (isymp->n_type)
2054 || ISTAG (isymp->n_sclass)
2055 || isymp->n_sclass == C_BLOCK
2056 || isymp->n_sclass == C_FCN)
2058 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
2060 && indx < obj_raw_syment_count (input_bfd))
2062 /* We look forward through the symbol for
2063 the index of the next symbol we are going
2064 to include. I don't know if this is
2066 while ((flaginfo->sym_indices[indx] < 0
2067 || ((bfd_size_type) flaginfo->sym_indices[indx]
2069 && indx < obj_raw_syment_count (input_bfd))
2071 if (indx >= obj_raw_syment_count (input_bfd))
2072 indx = output_index;
2074 indx = flaginfo->sym_indices[indx];
2075 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2079 indx = auxp->x_sym.x_tagndx.l;
2080 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2084 symindx = flaginfo->sym_indices[indx];
2086 auxp->x_sym.x_tagndx.l = 0;
2088 auxp->x_sym.x_tagndx.l = symindx;
2091 /* The .bf symbols are supposed to be linked through
2092 the endndx field. We need to carry this list
2093 across object files. */
2096 && isymp->n_sclass == C_FCN
2097 && (isymp->_n._n_n._n_zeroes != 0
2098 || isymp->_n._n_n._n_offset == 0)
2099 && isymp->_n._n_name[0] == '.'
2100 && isymp->_n._n_name[1] == 'b'
2101 && isymp->_n._n_name[2] == 'f'
2102 && isymp->_n._n_name[3] == '\0')
2104 if (flaginfo->last_bf_index != -1)
2106 flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2109 if ((bfd_size_type) flaginfo->last_bf_index
2114 /* The last .bf symbol is in this input
2115 file. This will only happen if the
2116 assembler did not set up the .bf
2117 endndx symbols correctly. */
2118 auxout = (flaginfo->outsyms
2119 + ((flaginfo->last_bf_index
2123 bfd_coff_swap_aux_out (output_bfd,
2134 /* We have already written out the last
2135 .bf aux entry. We need to write it
2136 out again. We borrow *outsym
2137 temporarily. FIXME: This case should
2139 bfd_coff_swap_aux_out (output_bfd,
2145 pos = obj_sym_filepos (output_bfd);
2146 pos += flaginfo->last_bf_index * osymesz;
2147 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2148 || (bfd_bwrite (outsym, osymesz, output_bfd)
2154 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2155 flaginfo->last_bf_index = -1;
2158 /* The endndx field of this aux entry must
2159 be updated with the symbol number of the
2161 flaginfo->last_bf = *auxp;
2162 flaginfo->last_bf_index = (((outsym - flaginfo->outsyms)
2171 bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2172 isymp->n_sclass, i, isymp->n_numaux,
2186 /* Relocate the line numbers, unless we are stripping them. */
2187 if (flaginfo->info->strip == strip_none
2188 || flaginfo->info->strip == strip_some)
2190 for (o = input_bfd->sections; o != NULL; o = o->next)
2196 bfd_boolean skipping;
2200 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2201 build_link_order in ldwrite.c will not have created a
2202 link order, which means that we will not have seen this
2203 input section in _bfd_coff_final_link, which means that
2204 we will not have allocated space for the line numbers of
2205 this section. I don't think line numbers can be
2206 meaningful for a section which does not have
2207 SEC_HAS_CONTENTS set, but, if they do, this must be
2209 if (o->lineno_count == 0
2210 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2213 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2214 || bfd_bread (flaginfo->linenos, linesz * o->lineno_count,
2215 input_bfd) != linesz * o->lineno_count)
2218 offset = o->output_section->vma + o->output_offset - o->vma;
2219 eline = flaginfo->linenos;
2220 oeline = flaginfo->linenos;
2221 elineend = eline + linesz * o->lineno_count;
2223 for (; eline < elineend; eline += linesz)
2225 struct internal_lineno iline;
2227 bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2229 if (iline.l_lnno != 0)
2230 iline.l_addr.l_paddr += offset;
2231 else if (iline.l_addr.l_symndx >= 0
2232 && ((unsigned long) iline.l_addr.l_symndx
2233 < obj_raw_syment_count (input_bfd)))
2237 indx = flaginfo->sym_indices[iline.l_addr.l_symndx];
2241 /* These line numbers are attached to a symbol
2242 which we are stripping. We must discard the
2243 line numbers because reading them back with
2244 no associated symbol (or associating them all
2245 with symbol #0) will fail. We can't regain
2246 the space in the output file, but at least
2252 struct internal_syment is;
2253 union internal_auxent ia;
2255 /* Fix up the lnnoptr field in the aux entry of
2256 the symbol. It turns out that we can't do
2257 this when we modify the symbol aux entries,
2258 because gas sometimes screws up the lnnoptr
2259 field and makes it an offset from the start
2260 of the line numbers rather than an absolute
2262 bfd_coff_swap_sym_in (output_bfd,
2264 + ((indx - syment_base)
2266 if ((ISFCN (is.n_type)
2267 || is.n_sclass == C_BLOCK)
2268 && is.n_numaux >= 1)
2272 auxptr = (flaginfo->outsyms
2273 + ((indx - syment_base + 1)
2275 bfd_coff_swap_aux_in (output_bfd, auxptr,
2276 is.n_type, is.n_sclass,
2277 0, is.n_numaux, &ia);
2278 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2279 (o->output_section->line_filepos
2280 + o->output_section->lineno_count * linesz
2281 + eline - flaginfo->linenos);
2282 bfd_coff_swap_aux_out (output_bfd, &ia,
2283 is.n_type, is.n_sclass, 0,
2284 is.n_numaux, auxptr);
2290 iline.l_addr.l_symndx = indx;
2295 bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2300 pos = o->output_section->line_filepos;
2301 pos += o->output_section->lineno_count * linesz;
2302 amt = oeline - flaginfo->linenos;
2303 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2304 || bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt)
2307 o->output_section->lineno_count += amt / linesz;
2311 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2312 symbol will be the first symbol in the next input file. In the
2313 normal case, this will save us from writing out the C_FILE symbol
2315 if (flaginfo->last_file_index != -1
2316 && (bfd_size_type) flaginfo->last_file_index >= syment_base)
2318 flaginfo->last_file.n_value = output_index;
2319 bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file,
2321 + ((flaginfo->last_file_index - syment_base)
2325 /* Write the modified symbols to the output file. */
2326 if (outsym > flaginfo->outsyms)
2331 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2332 amt = outsym - flaginfo->outsyms;
2333 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2334 || bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt)
2337 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2338 + (outsym - flaginfo->outsyms) / osymesz)
2341 obj_raw_syment_count (output_bfd) = output_index;
2344 /* Relocate the contents of each section. */
2345 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2346 for (o = input_bfd->sections; o != NULL; o = o->next)
2349 struct coff_section_tdata *secdata;
2351 if (! o->linker_mark)
2352 /* This section was omitted from the link. */
2355 if ((o->flags & SEC_LINKER_CREATED) != 0)
2358 if ((o->flags & SEC_HAS_CONTENTS) == 0
2359 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
2361 if ((o->flags & SEC_RELOC) != 0
2362 && o->reloc_count != 0)
2364 (*_bfd_error_handler)
2365 (_("%B: relocs in section `%A', but it has no contents"),
2367 bfd_set_error (bfd_error_no_contents);
2374 secdata = coff_section_data (input_bfd, o);
2375 if (secdata != NULL && secdata->contents != NULL)
2376 contents = secdata->contents;
2379 contents = flaginfo->contents;
2380 if (! bfd_get_full_section_contents (input_bfd, o, &contents))
2384 if ((o->flags & SEC_RELOC) != 0)
2387 struct internal_reloc *internal_relocs;
2388 struct internal_reloc *irel;
2390 /* Read in the relocs. */
2391 target_index = o->output_section->target_index;
2392 internal_relocs = (_bfd_coff_read_internal_relocs
2393 (input_bfd, o, FALSE, flaginfo->external_relocs,
2394 bfd_link_relocatable (flaginfo->info),
2395 (bfd_link_relocatable (flaginfo->info)
2396 ? (flaginfo->section_info[target_index].relocs
2397 + o->output_section->reloc_count)
2398 : flaginfo->internal_relocs)));
2399 if (internal_relocs == NULL
2400 && o->reloc_count > 0)
2403 /* Run through the relocs looking for relocs against symbols
2404 coming from discarded sections and complain about them. */
2405 irel = internal_relocs;
2406 for (; irel < &internal_relocs[o->reloc_count]; irel++)
2408 struct coff_link_hash_entry *h;
2409 asection *ps = NULL;
2410 long symndx = irel->r_symndx;
2413 h = obj_coff_sym_hashes (input_bfd)[symndx];
2416 while (h->root.type == bfd_link_hash_indirect
2417 || h->root.type == bfd_link_hash_warning)
2418 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2419 if (h->root.type == bfd_link_hash_defined
2420 || h->root.type == bfd_link_hash_defweak)
2421 ps = h->root.u.def.section;
2424 /* Complain if definition comes from an excluded section. */
2425 if (ps->flags & SEC_EXCLUDE)
2426 (*flaginfo->info->callbacks->einfo)
2427 (_("%X`%s' referenced in section `%A' of %B: "
2428 "defined in discarded section `%A' of %B\n"),
2429 h->root.root.string, o, input_bfd, ps, ps->owner);
2432 /* Call processor specific code to relocate the section
2434 if (! bfd_coff_relocate_section (output_bfd, flaginfo->info,
2438 flaginfo->internal_syms,
2439 flaginfo->sec_ptrs))
2442 if (bfd_link_relocatable (flaginfo->info))
2445 struct internal_reloc *irelend;
2446 struct coff_link_hash_entry **rel_hash;
2448 offset = o->output_section->vma + o->output_offset - o->vma;
2449 irel = internal_relocs;
2450 irelend = irel + o->reloc_count;
2451 rel_hash = (flaginfo->section_info[target_index].rel_hashes
2452 + o->output_section->reloc_count);
2453 for (; irel < irelend; irel++, rel_hash++)
2455 struct coff_link_hash_entry *h;
2456 bfd_boolean adjusted;
2460 /* Adjust the reloc address and symbol index. */
2461 irel->r_vaddr += offset;
2463 if (irel->r_symndx == -1)
2468 if (! (*adjust_symndx) (output_bfd, flaginfo->info,
2476 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2479 /* This is a global symbol. */
2481 irel->r_symndx = h->indx;
2484 /* This symbol is being written at the end
2485 of the file, and we do not yet know the
2486 symbol index. We save the pointer to the
2487 hash table entry in the rel_hash list.
2488 We set the indx field to -2 to indicate
2489 that this symbol must not be stripped. */
2498 indx = flaginfo->sym_indices[irel->r_symndx];
2500 irel->r_symndx = indx;
2503 struct internal_syment *is;
2505 char buf[SYMNMLEN + 1];
2507 /* This reloc is against a symbol we are
2508 stripping. This should have been handled
2509 by the 'dont_skip_symbol' code in the while
2510 loop at the top of this function. */
2511 is = flaginfo->internal_syms + irel->r_symndx;
2513 name = (_bfd_coff_internal_syment_name
2514 (input_bfd, is, buf));
2518 if (! ((*flaginfo->info->callbacks->unattached_reloc)
2519 (flaginfo->info, name, input_bfd, o,
2526 o->output_section->reloc_count += o->reloc_count;
2530 /* Write out the modified section contents. */
2531 if (secdata == NULL || secdata->stab_info == NULL)
2533 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2534 if (! bfd_set_section_contents (output_bfd, o->output_section,
2535 contents, loc, o->size))
2540 if (! (_bfd_write_section_stabs
2541 (output_bfd, &coff_hash_table (flaginfo->info)->stab_info,
2542 o, &secdata->stab_info, contents)))
2547 if (! flaginfo->info->keep_memory
2548 && ! _bfd_coff_free_symbols (input_bfd))
2554 /* Write out a global symbol. Called via bfd_hash_traverse. */
2557 _bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)
2559 struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;
2560 struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
2562 struct internal_syment isym;
2563 bfd_size_type symesz;
2567 output_bfd = flaginfo->output_bfd;
2569 if (h->root.type == bfd_link_hash_warning)
2571 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2572 if (h->root.type == bfd_link_hash_new)
2580 && (flaginfo->info->strip == strip_all
2581 || (flaginfo->info->strip == strip_some
2582 && (bfd_hash_lookup (flaginfo->info->keep_hash,
2583 h->root.root.string, FALSE, FALSE)
2587 switch (h->root.type)
2590 case bfd_link_hash_new:
2591 case bfd_link_hash_warning:
2595 case bfd_link_hash_undefined:
2596 case bfd_link_hash_undefweak:
2597 isym.n_scnum = N_UNDEF;
2601 case bfd_link_hash_defined:
2602 case bfd_link_hash_defweak:
2606 sec = h->root.u.def.section->output_section;
2607 if (bfd_is_abs_section (sec))
2608 isym.n_scnum = N_ABS;
2610 isym.n_scnum = sec->target_index;
2611 isym.n_value = (h->root.u.def.value
2612 + h->root.u.def.section->output_offset);
2613 if (! obj_pe (flaginfo->output_bfd))
2614 isym.n_value += sec->vma;
2618 case bfd_link_hash_common:
2619 isym.n_scnum = N_UNDEF;
2620 isym.n_value = h->root.u.c.size;
2623 case bfd_link_hash_indirect:
2624 /* Just ignore these. They can't be handled anyhow. */
2628 if (strlen (h->root.root.string) <= SYMNMLEN)
2629 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2636 if (flaginfo->info->traditional_format)
2638 indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash,
2640 if (indx == (bfd_size_type) -1)
2642 flaginfo->failed = TRUE;
2645 isym._n._n_n._n_zeroes = 0;
2646 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2649 isym.n_sclass = h->symbol_class;
2650 isym.n_type = h->type;
2652 if (isym.n_sclass == C_NULL)
2653 isym.n_sclass = C_EXT;
2655 /* If doing task linking and this is the pass where we convert
2656 defined globals to statics, then do that conversion now. If the
2657 symbol is not being converted, just ignore it and it will be
2658 output during a later pass. */
2659 if (flaginfo->global_to_static)
2661 if (! IS_EXTERNAL (output_bfd, isym))
2664 isym.n_sclass = C_STAT;
2667 /* When a weak symbol is not overridden by a strong one,
2668 turn it into an external symbol when not building a
2669 shared or relocatable object. */
2670 if (! bfd_link_pic (flaginfo->info)
2671 && ! bfd_link_relocatable (flaginfo->info)
2672 && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))
2673 isym.n_sclass = C_EXT;
2675 isym.n_numaux = h->numaux;
2677 bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms);
2679 symesz = bfd_coff_symesz (output_bfd);
2681 pos = obj_sym_filepos (output_bfd);
2682 pos += obj_raw_syment_count (output_bfd) * symesz;
2683 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2684 || bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
2686 flaginfo->failed = TRUE;
2690 h->indx = obj_raw_syment_count (output_bfd);
2692 ++obj_raw_syment_count (output_bfd);
2694 /* Write out any associated aux entries. Most of the aux entries
2695 will have been modified in _bfd_coff_link_input_bfd. We have to
2696 handle section aux entries here, now that we have the final
2697 relocation and line number counts. */
2698 for (i = 0; i < isym.n_numaux; i++)
2700 union internal_auxent *auxp;
2704 /* Look for a section aux entry here using the same tests that
2705 coff_swap_aux_out uses. */
2707 && (isym.n_sclass == C_STAT
2708 || isym.n_sclass == C_HIDDEN)
2709 && isym.n_type == T_NULL
2710 && (h->root.type == bfd_link_hash_defined
2711 || h->root.type == bfd_link_hash_defweak))
2715 sec = h->root.u.def.section->output_section;
2718 auxp->x_scn.x_scnlen = sec->size;
2720 /* For PE, an overflow on the final link reportedly does
2721 not matter. FIXME: Why not? */
2722 if (sec->reloc_count > 0xffff
2723 && (! obj_pe (output_bfd)
2724 || bfd_link_relocatable (flaginfo->info)))
2725 (*_bfd_error_handler)
2726 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2727 bfd_get_filename (output_bfd),
2728 bfd_get_section_name (output_bfd, sec),
2731 if (sec->lineno_count > 0xffff
2732 && (! obj_pe (output_bfd)
2733 || bfd_link_relocatable (flaginfo->info)))
2734 (*_bfd_error_handler)
2735 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2736 bfd_get_filename (output_bfd),
2737 bfd_get_section_name (output_bfd, sec),
2740 auxp->x_scn.x_nreloc = sec->reloc_count;
2741 auxp->x_scn.x_nlinno = sec->lineno_count;
2742 auxp->x_scn.x_checksum = 0;
2743 auxp->x_scn.x_associated = 0;
2744 auxp->x_scn.x_comdat = 0;
2748 bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2749 isym.n_sclass, (int) i, isym.n_numaux,
2751 if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
2753 flaginfo->failed = TRUE;
2756 ++obj_raw_syment_count (output_bfd);
2762 /* Write out task global symbols, converting them to statics. Called
2763 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2764 the dirty work, if the symbol we are processing needs conversion. */
2767 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2769 struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
2770 bfd_boolean rtnval = TRUE;
2771 bfd_boolean save_global_to_static;
2773 if (h->root.type == bfd_link_hash_warning)
2774 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2778 switch (h->root.type)
2780 case bfd_link_hash_defined:
2781 case bfd_link_hash_defweak:
2782 save_global_to_static = flaginfo->global_to_static;
2783 flaginfo->global_to_static = TRUE;
2784 rtnval = _bfd_coff_write_global_sym (&h->root.root, data);
2785 flaginfo->global_to_static = save_global_to_static;
2794 /* Handle a link order which is supposed to generate a reloc. */
2797 _bfd_coff_reloc_link_order (bfd *output_bfd,
2798 struct coff_final_link_info *flaginfo,
2799 asection *output_section,
2800 struct bfd_link_order *link_order)
2802 reloc_howto_type *howto;
2803 struct internal_reloc *irel;
2804 struct coff_link_hash_entry **rel_hash_ptr;
2806 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2809 bfd_set_error (bfd_error_bad_value);
2813 if (link_order->u.reloc.p->addend != 0)
2817 bfd_reloc_status_type rstat;
2821 size = bfd_get_reloc_size (howto);
2822 buf = (bfd_byte *) bfd_zmalloc (size);
2823 if (buf == NULL && size != 0)
2826 rstat = _bfd_relocate_contents (howto, output_bfd,
2827 (bfd_vma) link_order->u.reloc.p->addend,\
2834 case bfd_reloc_outofrange:
2836 case bfd_reloc_overflow:
2837 if (! ((*flaginfo->info->callbacks->reloc_overflow)
2838 (flaginfo->info, NULL,
2839 (link_order->type == bfd_section_reloc_link_order
2840 ? bfd_section_name (output_bfd,
2841 link_order->u.reloc.p->u.section)
2842 : link_order->u.reloc.p->u.name),
2843 howto->name, link_order->u.reloc.p->addend,
2844 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2851 loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2852 ok = bfd_set_section_contents (output_bfd, output_section, buf,
2859 /* Store the reloc information in the right place. It will get
2860 swapped and written out at the end of the final_link routine. */
2861 irel = (flaginfo->section_info[output_section->target_index].relocs
2862 + output_section->reloc_count);
2863 rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes
2864 + output_section->reloc_count);
2866 memset (irel, 0, sizeof (struct internal_reloc));
2867 *rel_hash_ptr = NULL;
2869 irel->r_vaddr = output_section->vma + link_order->offset;
2871 if (link_order->type == bfd_section_reloc_link_order)
2873 /* We need to somehow locate a symbol in the right section. The
2874 symbol must either have a value of zero, or we must adjust
2875 the addend by the value of the symbol. FIXME: Write this
2876 when we need it. The old linker couldn't handle this anyhow. */
2878 *rel_hash_ptr = NULL;
2883 struct coff_link_hash_entry *h;
2885 h = ((struct coff_link_hash_entry *)
2886 bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info,
2887 link_order->u.reloc.p->u.name,
2888 FALSE, FALSE, TRUE));
2892 irel->r_symndx = h->indx;
2895 /* Set the index to -2 to force this symbol to get
2904 if (! ((*flaginfo->info->callbacks->unattached_reloc)
2905 (flaginfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2906 (asection *) NULL, (bfd_vma) 0)))
2912 /* FIXME: Is this always right? */
2913 irel->r_type = howto->type;
2915 /* r_size is only used on the RS/6000, which needs its own linker
2916 routines anyhow. r_extern is only used for ECOFF. */
2918 /* FIXME: What is the right value for r_offset? Is zero OK? */
2919 ++output_section->reloc_count;
2924 /* A basic reloc handling routine which may be used by processors with
2928 _bfd_coff_generic_relocate_section (bfd *output_bfd,
2929 struct bfd_link_info *info,
2931 asection *input_section,
2933 struct internal_reloc *relocs,
2934 struct internal_syment *syms,
2935 asection **sections)
2937 struct internal_reloc *rel;
2938 struct internal_reloc *relend;
2941 relend = rel + input_section->reloc_count;
2942 for (; rel < relend; rel++)
2945 struct coff_link_hash_entry *h;
2946 struct internal_syment *sym;
2950 reloc_howto_type *howto;
2951 bfd_reloc_status_type rstat;
2953 symndx = rel->r_symndx;
2961 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2963 (*_bfd_error_handler)
2964 ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
2969 h = obj_coff_sym_hashes (input_bfd)[symndx];
2970 sym = syms + symndx;
2973 /* COFF treats common symbols in one of two ways. Either the
2974 size of the symbol is included in the section contents, or it
2975 is not. We assume that the size is not included, and force
2976 the rtype_to_howto function to adjust the addend as needed. */
2977 if (sym != NULL && sym->n_scnum != 0)
2978 addend = - sym->n_value;
2982 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2987 /* If we are doing a relocatable link, then we can just ignore
2988 a PC relative reloc that is pcrel_offset. It will already
2989 have the correct value. If this is not a relocatable link,
2990 then we should ignore the symbol value. */
2991 if (howto->pc_relative && howto->pcrel_offset)
2993 if (bfd_link_relocatable (info))
2995 if (sym != NULL && sym->n_scnum != 0)
2996 addend += sym->n_value;
3005 sec = bfd_abs_section_ptr;
3010 sec = sections[symndx];
3012 /* PR 19623: Relocations against symbols in
3013 the absolute sections should ignored. */
3014 if (bfd_is_abs_section (sec))
3017 val = (sec->output_section->vma
3018 + sec->output_offset
3020 if (! obj_pe (input_bfd))
3026 if (h->root.type == bfd_link_hash_defined
3027 || h->root.type == bfd_link_hash_defweak)
3029 /* Defined weak symbols are a GNU extension. */
3030 sec = h->root.u.def.section;
3031 val = (h->root.u.def.value
3032 + sec->output_section->vma
3033 + sec->output_offset);
3036 else if (h->root.type == bfd_link_hash_undefweak)
3038 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
3040 /* See _Microsoft Portable Executable and Common Object
3041 File Format Specification_, section 5.5.3.
3042 Note that weak symbols without aux records are a GNU
3044 FIXME: All weak externals are treated as having
3045 characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
3046 These behave as per SVR4 ABI: A library member
3047 will resolve a weak external only if a normal
3048 external causes the library member to be linked.
3049 See also linker.c: generic_link_check_archive_element. */
3050 struct coff_link_hash_entry *h2 =
3051 h->auxbfd->tdata.coff_obj_data->sym_hashes[
3052 h->aux->x_sym.x_tagndx.l];
3054 if (!h2 || h2->root.type == bfd_link_hash_undefined)
3056 sec = bfd_abs_section_ptr;
3061 sec = h2->root.u.def.section;
3062 val = h2->root.u.def.value
3063 + sec->output_section->vma + sec->output_offset;
3067 /* This is a GNU extension. */
3071 else if (! bfd_link_relocatable (info))
3073 if (! ((*info->callbacks->undefined_symbol)
3074 (info, h->root.root.string, input_bfd, input_section,
3075 rel->r_vaddr - input_section->vma, TRUE)))
3080 /* If the input section defining the symbol has been discarded
3081 then zero this reloc field. */
3082 if (sec != NULL && discarded_section (sec))
3084 _bfd_clear_contents (howto, input_bfd, input_section,
3085 contents + (rel->r_vaddr - input_section->vma));
3089 if (info->base_file)
3091 /* Emit a reloc if the backend thinks it needs it. */
3092 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
3094 /* Relocation to a symbol in a section which isn't
3095 absolute. We output the address here to a file.
3096 This file is then read by dlltool when generating the
3097 reloc section. Note that the base file is not
3098 portable between systems. We write out a bfd_vma here,
3099 and dlltool reads in a bfd_vma. */
3100 bfd_vma addr = (rel->r_vaddr
3101 - input_section->vma
3102 + input_section->output_offset
3103 + input_section->output_section->vma);
3104 if (coff_data (output_bfd)->pe)
3105 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
3106 if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)
3107 != sizeof (bfd_vma))
3109 bfd_set_error (bfd_error_system_call);
3115 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3117 rel->r_vaddr - input_section->vma,
3126 case bfd_reloc_outofrange:
3127 (*_bfd_error_handler)
3128 (_("%B: bad reloc address 0x%lx in section `%A'"),
3129 input_bfd, input_section, (unsigned long) rel->r_vaddr);
3131 case bfd_reloc_overflow:
3134 char buf[SYMNMLEN + 1];
3142 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3147 if (! ((*info->callbacks->reloc_overflow)
3148 (info, (h ? &h->root : NULL), name, howto->name,
3149 (bfd_vma) 0, input_bfd, input_section,
3150 rel->r_vaddr - input_section->vma)))