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 if ((unsigned long) irel->r_symndx < obj_raw_syment_count (input_bfd))
1402 flaginfo->sym_indices[irel->r_symndx] = -1;
1406 /* Link an input file into the linker output file. This function
1407 handles all the sections and relocations of the input file at once. */
1410 _bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd)
1412 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1413 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1414 bfd_boolean (*adjust_symndx)
1415 (bfd *, struct bfd_link_info *, bfd *, asection *,
1416 struct internal_reloc *, bfd_boolean *);
1418 const char *strings;
1419 bfd_size_type syment_base;
1420 bfd_boolean copy, hash;
1421 bfd_size_type isymesz;
1422 bfd_size_type osymesz;
1423 bfd_size_type linesz;
1426 struct internal_syment *isymp;
1429 unsigned long output_index;
1431 struct coff_link_hash_entry **sym_hash;
1434 /* Move all the symbols to the output file. */
1436 output_bfd = flaginfo->output_bfd;
1438 syment_base = obj_raw_syment_count (output_bfd);
1439 isymesz = bfd_coff_symesz (input_bfd);
1440 osymesz = bfd_coff_symesz (output_bfd);
1441 linesz = bfd_coff_linesz (input_bfd);
1442 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1445 if (! flaginfo->info->keep_memory)
1448 if (flaginfo->info->traditional_format)
1451 if (! _bfd_coff_get_external_symbols (input_bfd))
1454 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1455 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1456 isymp = flaginfo->internal_syms;
1457 secpp = flaginfo->sec_ptrs;
1458 indexp = flaginfo->sym_indices;
1459 output_index = syment_base;
1460 outsym = flaginfo->outsyms;
1462 if (coff_data (output_bfd)->pe
1463 && ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd))
1466 /* If we are going to perform relocations and also strip/discard some
1467 symbols then we must make sure that we do not strip/discard those
1468 symbols that are going to be involved in the relocations. */
1469 if (( flaginfo->info->strip != strip_none
1470 || flaginfo->info->discard != discard_none)
1471 && bfd_link_relocatable (flaginfo->info))
1473 /* Mark the symbol array as 'not-used'. */
1474 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1476 mark_relocs (flaginfo, input_bfd);
1479 while (esym < esym_end)
1481 struct internal_syment isym;
1482 enum coff_symbol_classification classification;
1485 bfd_boolean dont_skip_symbol;
1488 bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1490 /* Make a copy of *isymp so that the relocate_section function
1491 always sees the original values. This is more reliable than
1492 always recomputing the symbol value even if we are stripping
1496 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1497 switch (classification)
1501 case COFF_SYMBOL_GLOBAL:
1502 case COFF_SYMBOL_PE_SECTION:
1503 case COFF_SYMBOL_LOCAL:
1504 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1506 case COFF_SYMBOL_COMMON:
1507 *secpp = bfd_com_section_ptr;
1509 case COFF_SYMBOL_UNDEFINED:
1510 *secpp = bfd_und_section_ptr;
1514 /* Extract the flag indicating if this symbol is used by a
1516 if ((flaginfo->info->strip != strip_none
1517 || flaginfo->info->discard != discard_none)
1518 && bfd_link_relocatable (flaginfo->info))
1519 dont_skip_symbol = *indexp;
1521 dont_skip_symbol = FALSE;
1527 add = 1 + isym.n_numaux;
1529 /* If we are stripping all symbols, we want to skip this one. */
1530 if (flaginfo->info->strip == strip_all && ! dont_skip_symbol)
1535 switch (classification)
1539 case COFF_SYMBOL_GLOBAL:
1540 case COFF_SYMBOL_COMMON:
1541 case COFF_SYMBOL_PE_SECTION:
1542 /* This is a global symbol. Global symbols come at the
1543 end of the symbol table, so skip them for now.
1544 Locally defined function symbols, however, are an
1545 exception, and are not moved to the end. */
1547 if (! ISFCN (isym.n_type))
1551 case COFF_SYMBOL_UNDEFINED:
1552 /* Undefined symbols are left for the end. */
1557 case COFF_SYMBOL_LOCAL:
1558 /* This is a local symbol. Skip it if we are discarding
1560 if (flaginfo->info->discard == discard_all && ! dont_skip_symbol)
1566 #ifndef COFF_WITH_PE
1567 /* Skip section symbols for sections which are not going to be
1570 && !dont_skip_symbol
1571 && isym.n_sclass == C_STAT
1572 && isym.n_type == T_NULL
1573 && isym.n_numaux > 0
1574 && ((*secpp)->output_section == bfd_abs_section_ptr
1575 || bfd_section_removed_from_list (output_bfd,
1576 (*secpp)->output_section)))
1580 /* If we stripping debugging symbols, and this is a debugging
1581 symbol, then skip it. FIXME: gas sets the section to N_ABS
1582 for some types of debugging symbols; I don't know if this is
1583 a bug or not. In any case, we handle it here. */
1585 && flaginfo->info->strip == strip_debugger
1586 && ! dont_skip_symbol
1587 && (isym.n_scnum == N_DEBUG
1588 || (isym.n_scnum == N_ABS
1589 && (isym.n_sclass == C_AUTO
1590 || isym.n_sclass == C_REG
1591 || isym.n_sclass == C_MOS
1592 || isym.n_sclass == C_MOE
1593 || isym.n_sclass == C_MOU
1594 || isym.n_sclass == C_ARG
1595 || isym.n_sclass == C_REGPARM
1596 || isym.n_sclass == C_FIELD
1597 || isym.n_sclass == C_EOS))))
1600 /* If some symbols are stripped based on the name, work out the
1601 name and decide whether to skip this symbol. */
1603 && (flaginfo->info->strip == strip_some
1604 || flaginfo->info->discard == discard_l))
1607 char buf[SYMNMLEN + 1];
1609 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1613 if (! dont_skip_symbol
1614 && ((flaginfo->info->strip == strip_some
1615 && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE,
1618 && flaginfo->info->discard == discard_l
1619 && bfd_is_local_label_name (input_bfd, name))))
1623 /* If this is an enum, struct, or union tag, see if we have
1624 already output an identical type. */
1626 && !flaginfo->info->traditional_format
1627 && (isym.n_sclass == C_ENTAG
1628 || isym.n_sclass == C_STRTAG
1629 || isym.n_sclass == C_UNTAG)
1630 && isym.n_numaux == 1)
1633 char buf[SYMNMLEN + 1];
1634 struct coff_debug_merge_hash_entry *mh;
1635 struct coff_debug_merge_type *mt;
1636 union internal_auxent aux;
1637 struct coff_debug_merge_element **epp;
1638 bfd_byte *esl, *eslend;
1639 struct internal_syment *islp;
1642 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1646 /* Ignore fake names invented by compiler; treat them all as
1648 if (*name == '~' || *name == '.' || *name == '$'
1649 || (*name == bfd_get_symbol_leading_char (input_bfd)
1650 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1653 mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name,
1658 /* Allocate memory to hold type information. If this turns
1659 out to be a duplicate, we pass this address to
1661 amt = sizeof (struct coff_debug_merge_type);
1662 mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
1665 mt->type_class = isym.n_sclass;
1667 /* Pick up the aux entry, which points to the end of the tag
1669 bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1670 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1673 /* Gather the elements. */
1674 epp = &mt->elements;
1675 mt->elements = NULL;
1677 esl = esym + 2 * isymesz;
1678 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1679 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1680 while (esl < eslend)
1682 const char *elename;
1683 char elebuf[SYMNMLEN + 1];
1686 bfd_coff_swap_sym_in (input_bfd, esl, islp);
1688 amt = sizeof (struct coff_debug_merge_element);
1689 *epp = (struct coff_debug_merge_element *)
1690 bfd_alloc (input_bfd, amt);
1694 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1696 if (elename == NULL)
1699 amt = strlen (elename) + 1;
1700 name_copy = (char *) bfd_alloc (input_bfd, amt);
1701 if (name_copy == NULL)
1703 strcpy (name_copy, elename);
1705 (*epp)->name = name_copy;
1706 (*epp)->type = islp->n_type;
1708 if (islp->n_numaux >= 1
1709 && islp->n_type != T_NULL
1710 && islp->n_sclass != C_EOS)
1712 union internal_auxent eleaux;
1715 bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1716 islp->n_type, islp->n_sclass, 0,
1717 islp->n_numaux, &eleaux);
1718 indx = eleaux.x_sym.x_tagndx.l;
1720 /* FIXME: If this tagndx entry refers to a symbol
1721 defined later in this file, we just ignore it.
1722 Handling this correctly would be tedious, and may
1727 (bfd_byte *) obj_coff_external_syms (input_bfd))
1730 (*epp)->tagndx = flaginfo->sym_indices[indx];
1731 if ((*epp)->tagndx < 0)
1735 epp = &(*epp)->next;
1738 esl += (islp->n_numaux + 1) * isymesz;
1739 islp += islp->n_numaux + 1;
1742 /* See if we already have a definition which matches this
1743 type. We always output the type if it has no elements,
1745 if (mt->elements == NULL)
1746 bfd_release (input_bfd, mt);
1749 struct coff_debug_merge_type *mtl;
1751 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1753 struct coff_debug_merge_element *me, *mel;
1755 if (mtl->type_class != mt->type_class)
1758 for (me = mt->elements, mel = mtl->elements;
1759 me != NULL && mel != NULL;
1760 me = me->next, mel = mel->next)
1762 if (strcmp (me->name, mel->name) != 0
1763 || me->type != mel->type
1764 || me->tagndx != mel->tagndx)
1768 if (me == NULL && mel == NULL)
1772 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1774 /* This is the first definition of this type. */
1775 mt->indx = output_index;
1776 mt->next = mh->types;
1781 /* This is a redefinition which can be merged. */
1782 bfd_release (input_bfd, mt);
1783 *indexp = mtl->indx;
1784 add = (eslend - esym) / isymesz;
1790 /* We now know whether we are to skip this symbol or not. */
1793 /* Adjust the symbol in order to output it. */
1795 if (isym._n._n_n._n_zeroes == 0
1796 && isym._n._n_n._n_offset != 0)
1801 /* This symbol has a long name. Enter it in the string
1802 table we are building. Note that we do not check
1803 bfd_coff_symname_in_debug. That is only true for
1804 XCOFF, and XCOFF requires different linking code
1806 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1809 indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy);
1810 if (indx == (bfd_size_type) -1)
1812 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1815 switch (isym.n_sclass)
1831 /* The symbol value should not be modified. */
1835 if (obj_pe (input_bfd)
1836 && strcmp (isym.n_name, ".bf") != 0
1837 && isym.n_scnum > 0)
1839 /* For PE, .lf and .ef get their value left alone,
1840 while .bf gets relocated. However, they all have
1841 "real" section numbers, and need to be moved into
1843 isym.n_scnum = (*secpp)->output_section->target_index;
1848 case C_LABEL: /* Not completely sure about these 2 */
1857 /* Compute new symbol location. */
1858 if (isym.n_scnum > 0)
1860 isym.n_scnum = (*secpp)->output_section->target_index;
1861 isym.n_value += (*secpp)->output_offset;
1862 if (! obj_pe (input_bfd))
1863 isym.n_value -= (*secpp)->vma;
1864 if (! obj_pe (flaginfo->output_bfd))
1865 isym.n_value += (*secpp)->output_section->vma;
1870 /* The value of a C_FILE symbol is the symbol index of
1871 the next C_FILE symbol. The value of the last C_FILE
1872 symbol is the symbol index to the first external
1873 symbol (actually, coff_renumber_symbols does not get
1874 this right--it just sets the value of the last C_FILE
1875 symbol to zero--and nobody has ever complained about
1876 it). We try to get this right, below, just before we
1877 write the symbols out, but in the general case we may
1878 have to write the symbol out twice. */
1879 if (flaginfo->last_file_index != -1
1880 && flaginfo->last_file.n_value != (bfd_vma) output_index)
1882 /* We must correct the value of the last C_FILE
1884 flaginfo->last_file.n_value = output_index;
1885 if ((bfd_size_type) flaginfo->last_file_index >= syment_base)
1887 /* The last C_FILE symbol is in this input file. */
1888 bfd_coff_swap_sym_out (output_bfd,
1889 &flaginfo->last_file,
1891 + ((flaginfo->last_file_index
1899 /* We have already written out the last C_FILE
1900 symbol. We need to write it out again. We
1901 borrow *outsym temporarily. */
1902 bfd_coff_swap_sym_out (output_bfd,
1903 &flaginfo->last_file, outsym);
1904 pos = obj_sym_filepos (output_bfd);
1905 pos += flaginfo->last_file_index * osymesz;
1906 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1907 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1912 flaginfo->last_file_index = output_index;
1913 flaginfo->last_file = isym;
1917 /* If doing task linking, convert normal global function symbols to
1918 static functions. */
1919 if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1920 isym.n_sclass = C_STAT;
1922 /* Output the symbol. */
1923 bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1925 *indexp = output_index;
1930 struct coff_link_hash_entry *h;
1932 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1934 h = obj_coff_sym_hashes (input_bfd)[indx];
1937 /* This can happen if there were errors earlier in
1939 bfd_set_error (bfd_error_bad_value);
1942 h->indx = output_index;
1945 output_index += add;
1946 outsym += add * osymesz;
1949 esym += add * isymesz;
1953 for (--add; add > 0; --add)
1960 /* Fix up the aux entries. This must be done in a separate pass,
1961 because we don't know the correct symbol indices until we have
1962 already decided which symbols we are going to keep. */
1963 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1964 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1965 isymp = flaginfo->internal_syms;
1966 indexp = flaginfo->sym_indices;
1967 sym_hash = obj_coff_sym_hashes (input_bfd);
1968 outsym = flaginfo->outsyms;
1970 while (esym < esym_end)
1974 add = 1 + isymp->n_numaux;
1977 || (bfd_size_type) *indexp < syment_base)
1978 && (*sym_hash == NULL
1979 || (*sym_hash)->auxbfd != input_bfd))
1980 esym += add * isymesz;
1983 struct coff_link_hash_entry *h;
1991 /* The m68k-motorola-sysv assembler will sometimes
1992 generate two symbols with the same name, but only one
1993 will have aux entries. */
1994 BFD_ASSERT (isymp->n_numaux == 0
1996 || h->numaux == isymp->n_numaux);
2004 /* Handle the aux entries. This handling is based on
2005 coff_pointerize_aux. I don't know if it always correct. */
2006 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
2008 union internal_auxent aux;
2009 union internal_auxent *auxp;
2011 if (h != NULL && h->aux != NULL && (h->numaux > i))
2015 bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
2016 isymp->n_sclass, i, isymp->n_numaux, &aux);
2020 if (isymp->n_sclass == C_FILE)
2022 /* If this is a long filename, we must put it in the
2024 if (auxp->x_file.x_n.x_zeroes == 0
2025 && auxp->x_file.x_n.x_offset != 0)
2027 const char *filename;
2030 BFD_ASSERT (auxp->x_file.x_n.x_offset
2031 >= STRING_SIZE_SIZE);
2032 if (strings == NULL)
2034 strings = _bfd_coff_read_string_table (input_bfd);
2035 if (strings == NULL)
2038 if ((bfd_size_type) auxp->x_file.x_n.x_offset >= obj_coff_strings_len (input_bfd))
2039 filename = _("<corrupt>");
2041 filename = strings + auxp->x_file.x_n.x_offset;
2042 indx = _bfd_stringtab_add (flaginfo->strtab, filename,
2044 if (indx == (bfd_size_type) -1)
2046 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
2049 else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
2050 && isymp->n_sclass != C_NT_WEAK)
2054 if (ISFCN (isymp->n_type)
2055 || ISTAG (isymp->n_sclass)
2056 || isymp->n_sclass == C_BLOCK
2057 || isymp->n_sclass == C_FCN)
2059 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
2061 && indx < obj_raw_syment_count (input_bfd))
2063 /* We look forward through the symbol for
2064 the index of the next symbol we are going
2065 to include. I don't know if this is
2067 while ((flaginfo->sym_indices[indx] < 0
2068 || ((bfd_size_type) flaginfo->sym_indices[indx]
2070 && indx < obj_raw_syment_count (input_bfd))
2072 if (indx >= obj_raw_syment_count (input_bfd))
2073 indx = output_index;
2075 indx = flaginfo->sym_indices[indx];
2076 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2080 indx = auxp->x_sym.x_tagndx.l;
2081 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2085 symindx = flaginfo->sym_indices[indx];
2087 auxp->x_sym.x_tagndx.l = 0;
2089 auxp->x_sym.x_tagndx.l = symindx;
2092 /* The .bf symbols are supposed to be linked through
2093 the endndx field. We need to carry this list
2094 across object files. */
2097 && isymp->n_sclass == C_FCN
2098 && (isymp->_n._n_n._n_zeroes != 0
2099 || isymp->_n._n_n._n_offset == 0)
2100 && isymp->_n._n_name[0] == '.'
2101 && isymp->_n._n_name[1] == 'b'
2102 && isymp->_n._n_name[2] == 'f'
2103 && isymp->_n._n_name[3] == '\0')
2105 if (flaginfo->last_bf_index != -1)
2107 flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2110 if ((bfd_size_type) flaginfo->last_bf_index
2115 /* The last .bf symbol is in this input
2116 file. This will only happen if the
2117 assembler did not set up the .bf
2118 endndx symbols correctly. */
2119 auxout = (flaginfo->outsyms
2120 + ((flaginfo->last_bf_index
2124 bfd_coff_swap_aux_out (output_bfd,
2135 /* We have already written out the last
2136 .bf aux entry. We need to write it
2137 out again. We borrow *outsym
2138 temporarily. FIXME: This case should
2140 bfd_coff_swap_aux_out (output_bfd,
2146 pos = obj_sym_filepos (output_bfd);
2147 pos += flaginfo->last_bf_index * osymesz;
2148 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2149 || (bfd_bwrite (outsym, osymesz, output_bfd)
2155 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2156 flaginfo->last_bf_index = -1;
2159 /* The endndx field of this aux entry must
2160 be updated with the symbol number of the
2162 flaginfo->last_bf = *auxp;
2163 flaginfo->last_bf_index = (((outsym - flaginfo->outsyms)
2172 bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2173 isymp->n_sclass, i, isymp->n_numaux,
2187 /* Relocate the line numbers, unless we are stripping them. */
2188 if (flaginfo->info->strip == strip_none
2189 || flaginfo->info->strip == strip_some)
2191 for (o = input_bfd->sections; o != NULL; o = o->next)
2197 bfd_boolean skipping;
2201 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2202 build_link_order in ldwrite.c will not have created a
2203 link order, which means that we will not have seen this
2204 input section in _bfd_coff_final_link, which means that
2205 we will not have allocated space for the line numbers of
2206 this section. I don't think line numbers can be
2207 meaningful for a section which does not have
2208 SEC_HAS_CONTENTS set, but, if they do, this must be
2210 if (o->lineno_count == 0
2211 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2214 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2215 || bfd_bread (flaginfo->linenos, linesz * o->lineno_count,
2216 input_bfd) != linesz * o->lineno_count)
2219 offset = o->output_section->vma + o->output_offset - o->vma;
2220 eline = flaginfo->linenos;
2221 oeline = flaginfo->linenos;
2222 elineend = eline + linesz * o->lineno_count;
2224 for (; eline < elineend; eline += linesz)
2226 struct internal_lineno iline;
2228 bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2230 if (iline.l_lnno != 0)
2231 iline.l_addr.l_paddr += offset;
2232 else if (iline.l_addr.l_symndx >= 0
2233 && ((unsigned long) iline.l_addr.l_symndx
2234 < obj_raw_syment_count (input_bfd)))
2238 indx = flaginfo->sym_indices[iline.l_addr.l_symndx];
2242 /* These line numbers are attached to a symbol
2243 which we are stripping. We must discard the
2244 line numbers because reading them back with
2245 no associated symbol (or associating them all
2246 with symbol #0) will fail. We can't regain
2247 the space in the output file, but at least
2253 struct internal_syment is;
2254 union internal_auxent ia;
2256 /* Fix up the lnnoptr field in the aux entry of
2257 the symbol. It turns out that we can't do
2258 this when we modify the symbol aux entries,
2259 because gas sometimes screws up the lnnoptr
2260 field and makes it an offset from the start
2261 of the line numbers rather than an absolute
2263 bfd_coff_swap_sym_in (output_bfd,
2265 + ((indx - syment_base)
2267 if ((ISFCN (is.n_type)
2268 || is.n_sclass == C_BLOCK)
2269 && is.n_numaux >= 1)
2273 auxptr = (flaginfo->outsyms
2274 + ((indx - syment_base + 1)
2276 bfd_coff_swap_aux_in (output_bfd, auxptr,
2277 is.n_type, is.n_sclass,
2278 0, is.n_numaux, &ia);
2279 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2280 (o->output_section->line_filepos
2281 + o->output_section->lineno_count * linesz
2282 + eline - flaginfo->linenos);
2283 bfd_coff_swap_aux_out (output_bfd, &ia,
2284 is.n_type, is.n_sclass, 0,
2285 is.n_numaux, auxptr);
2291 iline.l_addr.l_symndx = indx;
2296 bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2301 pos = o->output_section->line_filepos;
2302 pos += o->output_section->lineno_count * linesz;
2303 amt = oeline - flaginfo->linenos;
2304 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2305 || bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt)
2308 o->output_section->lineno_count += amt / linesz;
2312 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2313 symbol will be the first symbol in the next input file. In the
2314 normal case, this will save us from writing out the C_FILE symbol
2316 if (flaginfo->last_file_index != -1
2317 && (bfd_size_type) flaginfo->last_file_index >= syment_base)
2319 flaginfo->last_file.n_value = output_index;
2320 bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file,
2322 + ((flaginfo->last_file_index - syment_base)
2326 /* Write the modified symbols to the output file. */
2327 if (outsym > flaginfo->outsyms)
2332 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2333 amt = outsym - flaginfo->outsyms;
2334 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2335 || bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt)
2338 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2339 + (outsym - flaginfo->outsyms) / osymesz)
2342 obj_raw_syment_count (output_bfd) = output_index;
2345 /* Relocate the contents of each section. */
2346 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2347 for (o = input_bfd->sections; o != NULL; o = o->next)
2350 struct coff_section_tdata *secdata;
2352 if (! o->linker_mark)
2353 /* This section was omitted from the link. */
2356 if ((o->flags & SEC_LINKER_CREATED) != 0)
2359 if ((o->flags & SEC_HAS_CONTENTS) == 0
2360 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
2362 if ((o->flags & SEC_RELOC) != 0
2363 && o->reloc_count != 0)
2365 (*_bfd_error_handler)
2366 (_("%B: relocs in section `%A', but it has no contents"),
2368 bfd_set_error (bfd_error_no_contents);
2375 secdata = coff_section_data (input_bfd, o);
2376 if (secdata != NULL && secdata->contents != NULL)
2377 contents = secdata->contents;
2380 contents = flaginfo->contents;
2381 if (! bfd_get_full_section_contents (input_bfd, o, &contents))
2385 if ((o->flags & SEC_RELOC) != 0)
2388 struct internal_reloc *internal_relocs;
2389 struct internal_reloc *irel;
2391 /* Read in the relocs. */
2392 target_index = o->output_section->target_index;
2393 internal_relocs = (_bfd_coff_read_internal_relocs
2394 (input_bfd, o, FALSE, flaginfo->external_relocs,
2395 bfd_link_relocatable (flaginfo->info),
2396 (bfd_link_relocatable (flaginfo->info)
2397 ? (flaginfo->section_info[target_index].relocs
2398 + o->output_section->reloc_count)
2399 : flaginfo->internal_relocs)));
2400 if (internal_relocs == NULL
2401 && o->reloc_count > 0)
2404 /* Run through the relocs looking for relocs against symbols
2405 coming from discarded sections and complain about them. */
2406 irel = internal_relocs;
2407 for (; irel < &internal_relocs[o->reloc_count]; irel++)
2409 struct coff_link_hash_entry *h;
2410 asection *ps = NULL;
2411 long symndx = irel->r_symndx;
2414 h = obj_coff_sym_hashes (input_bfd)[symndx];
2417 while (h->root.type == bfd_link_hash_indirect
2418 || h->root.type == bfd_link_hash_warning)
2419 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2420 if (h->root.type == bfd_link_hash_defined
2421 || h->root.type == bfd_link_hash_defweak)
2422 ps = h->root.u.def.section;
2425 /* Complain if definition comes from an excluded section. */
2426 if (ps->flags & SEC_EXCLUDE)
2427 (*flaginfo->info->callbacks->einfo)
2428 (_("%X`%s' referenced in section `%A' of %B: "
2429 "defined in discarded section `%A' of %B\n"),
2430 h->root.root.string, o, input_bfd, ps, ps->owner);
2433 /* Call processor specific code to relocate the section
2435 if (! bfd_coff_relocate_section (output_bfd, flaginfo->info,
2439 flaginfo->internal_syms,
2440 flaginfo->sec_ptrs))
2443 if (bfd_link_relocatable (flaginfo->info))
2446 struct internal_reloc *irelend;
2447 struct coff_link_hash_entry **rel_hash;
2449 offset = o->output_section->vma + o->output_offset - o->vma;
2450 irel = internal_relocs;
2451 irelend = irel + o->reloc_count;
2452 rel_hash = (flaginfo->section_info[target_index].rel_hashes
2453 + o->output_section->reloc_count);
2454 for (; irel < irelend; irel++, rel_hash++)
2456 struct coff_link_hash_entry *h;
2457 bfd_boolean adjusted;
2461 /* Adjust the reloc address and symbol index. */
2462 irel->r_vaddr += offset;
2464 if (irel->r_symndx == -1)
2469 if (! (*adjust_symndx) (output_bfd, flaginfo->info,
2477 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2480 /* This is a global symbol. */
2482 irel->r_symndx = h->indx;
2485 /* This symbol is being written at the end
2486 of the file, and we do not yet know the
2487 symbol index. We save the pointer to the
2488 hash table entry in the rel_hash list.
2489 We set the indx field to -2 to indicate
2490 that this symbol must not be stripped. */
2499 indx = flaginfo->sym_indices[irel->r_symndx];
2501 irel->r_symndx = indx;
2504 struct internal_syment *is;
2506 char buf[SYMNMLEN + 1];
2508 /* This reloc is against a symbol we are
2509 stripping. This should have been handled
2510 by the 'dont_skip_symbol' code in the while
2511 loop at the top of this function. */
2512 is = flaginfo->internal_syms + irel->r_symndx;
2514 name = (_bfd_coff_internal_syment_name
2515 (input_bfd, is, buf));
2519 (*flaginfo->info->callbacks->unattached_reloc)
2520 (flaginfo->info, name, input_bfd, o, irel->r_vaddr);
2525 o->output_section->reloc_count += o->reloc_count;
2529 /* Write out the modified section contents. */
2530 if (secdata == NULL || secdata->stab_info == NULL)
2532 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2533 if (! bfd_set_section_contents (output_bfd, o->output_section,
2534 contents, loc, o->size))
2539 if (! (_bfd_write_section_stabs
2540 (output_bfd, &coff_hash_table (flaginfo->info)->stab_info,
2541 o, &secdata->stab_info, contents)))
2546 if (! flaginfo->info->keep_memory
2547 && ! _bfd_coff_free_symbols (input_bfd))
2553 /* Write out a global symbol. Called via bfd_hash_traverse. */
2556 _bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)
2558 struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;
2559 struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
2561 struct internal_syment isym;
2562 bfd_size_type symesz;
2566 output_bfd = flaginfo->output_bfd;
2568 if (h->root.type == bfd_link_hash_warning)
2570 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2571 if (h->root.type == bfd_link_hash_new)
2579 && (flaginfo->info->strip == strip_all
2580 || (flaginfo->info->strip == strip_some
2581 && (bfd_hash_lookup (flaginfo->info->keep_hash,
2582 h->root.root.string, FALSE, FALSE)
2586 switch (h->root.type)
2589 case bfd_link_hash_new:
2590 case bfd_link_hash_warning:
2594 case bfd_link_hash_undefined:
2595 case bfd_link_hash_undefweak:
2596 isym.n_scnum = N_UNDEF;
2600 case bfd_link_hash_defined:
2601 case bfd_link_hash_defweak:
2605 sec = h->root.u.def.section->output_section;
2606 if (bfd_is_abs_section (sec))
2607 isym.n_scnum = N_ABS;
2609 isym.n_scnum = sec->target_index;
2610 isym.n_value = (h->root.u.def.value
2611 + h->root.u.def.section->output_offset);
2612 if (! obj_pe (flaginfo->output_bfd))
2613 isym.n_value += sec->vma;
2617 case bfd_link_hash_common:
2618 isym.n_scnum = N_UNDEF;
2619 isym.n_value = h->root.u.c.size;
2622 case bfd_link_hash_indirect:
2623 /* Just ignore these. They can't be handled anyhow. */
2627 if (strlen (h->root.root.string) <= SYMNMLEN)
2628 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2635 if (flaginfo->info->traditional_format)
2637 indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash,
2639 if (indx == (bfd_size_type) -1)
2641 flaginfo->failed = TRUE;
2644 isym._n._n_n._n_zeroes = 0;
2645 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2648 isym.n_sclass = h->symbol_class;
2649 isym.n_type = h->type;
2651 if (isym.n_sclass == C_NULL)
2652 isym.n_sclass = C_EXT;
2654 /* If doing task linking and this is the pass where we convert
2655 defined globals to statics, then do that conversion now. If the
2656 symbol is not being converted, just ignore it and it will be
2657 output during a later pass. */
2658 if (flaginfo->global_to_static)
2660 if (! IS_EXTERNAL (output_bfd, isym))
2663 isym.n_sclass = C_STAT;
2666 /* When a weak symbol is not overridden by a strong one,
2667 turn it into an external symbol when not building a
2668 shared or relocatable object. */
2669 if (! bfd_link_pic (flaginfo->info)
2670 && ! bfd_link_relocatable (flaginfo->info)
2671 && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))
2672 isym.n_sclass = C_EXT;
2674 isym.n_numaux = h->numaux;
2676 bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms);
2678 symesz = bfd_coff_symesz (output_bfd);
2680 pos = obj_sym_filepos (output_bfd);
2681 pos += obj_raw_syment_count (output_bfd) * symesz;
2682 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2683 || bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
2685 flaginfo->failed = TRUE;
2689 h->indx = obj_raw_syment_count (output_bfd);
2691 ++obj_raw_syment_count (output_bfd);
2693 /* Write out any associated aux entries. Most of the aux entries
2694 will have been modified in _bfd_coff_link_input_bfd. We have to
2695 handle section aux entries here, now that we have the final
2696 relocation and line number counts. */
2697 for (i = 0; i < isym.n_numaux; i++)
2699 union internal_auxent *auxp;
2703 /* Look for a section aux entry here using the same tests that
2704 coff_swap_aux_out uses. */
2706 && (isym.n_sclass == C_STAT
2707 || isym.n_sclass == C_HIDDEN)
2708 && isym.n_type == T_NULL
2709 && (h->root.type == bfd_link_hash_defined
2710 || h->root.type == bfd_link_hash_defweak))
2714 sec = h->root.u.def.section->output_section;
2717 auxp->x_scn.x_scnlen = sec->size;
2719 /* For PE, an overflow on the final link reportedly does
2720 not matter. FIXME: Why not? */
2721 if (sec->reloc_count > 0xffff
2722 && (! obj_pe (output_bfd)
2723 || bfd_link_relocatable (flaginfo->info)))
2724 (*_bfd_error_handler)
2725 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2726 bfd_get_filename (output_bfd),
2727 bfd_get_section_name (output_bfd, sec),
2730 if (sec->lineno_count > 0xffff
2731 && (! obj_pe (output_bfd)
2732 || bfd_link_relocatable (flaginfo->info)))
2733 (*_bfd_error_handler)
2734 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2735 bfd_get_filename (output_bfd),
2736 bfd_get_section_name (output_bfd, sec),
2739 auxp->x_scn.x_nreloc = sec->reloc_count;
2740 auxp->x_scn.x_nlinno = sec->lineno_count;
2741 auxp->x_scn.x_checksum = 0;
2742 auxp->x_scn.x_associated = 0;
2743 auxp->x_scn.x_comdat = 0;
2747 bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2748 isym.n_sclass, (int) i, isym.n_numaux,
2750 if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
2752 flaginfo->failed = TRUE;
2755 ++obj_raw_syment_count (output_bfd);
2761 /* Write out task global symbols, converting them to statics. Called
2762 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2763 the dirty work, if the symbol we are processing needs conversion. */
2766 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2768 struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
2769 bfd_boolean rtnval = TRUE;
2770 bfd_boolean save_global_to_static;
2772 if (h->root.type == bfd_link_hash_warning)
2773 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2777 switch (h->root.type)
2779 case bfd_link_hash_defined:
2780 case bfd_link_hash_defweak:
2781 save_global_to_static = flaginfo->global_to_static;
2782 flaginfo->global_to_static = TRUE;
2783 rtnval = _bfd_coff_write_global_sym (&h->root.root, data);
2784 flaginfo->global_to_static = save_global_to_static;
2793 /* Handle a link order which is supposed to generate a reloc. */
2796 _bfd_coff_reloc_link_order (bfd *output_bfd,
2797 struct coff_final_link_info *flaginfo,
2798 asection *output_section,
2799 struct bfd_link_order *link_order)
2801 reloc_howto_type *howto;
2802 struct internal_reloc *irel;
2803 struct coff_link_hash_entry **rel_hash_ptr;
2805 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2808 bfd_set_error (bfd_error_bad_value);
2812 if (link_order->u.reloc.p->addend != 0)
2816 bfd_reloc_status_type rstat;
2820 size = bfd_get_reloc_size (howto);
2821 buf = (bfd_byte *) bfd_zmalloc (size);
2822 if (buf == NULL && size != 0)
2825 rstat = _bfd_relocate_contents (howto, output_bfd,
2826 (bfd_vma) link_order->u.reloc.p->addend,\
2833 case bfd_reloc_outofrange:
2835 case bfd_reloc_overflow:
2836 (*flaginfo->info->callbacks->reloc_overflow)
2837 (flaginfo->info, NULL,
2838 (link_order->type == bfd_section_reloc_link_order
2839 ? bfd_section_name (output_bfd,
2840 link_order->u.reloc.p->u.section)
2841 : link_order->u.reloc.p->u.name),
2842 howto->name, link_order->u.reloc.p->addend,
2843 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0);
2846 loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2847 ok = bfd_set_section_contents (output_bfd, output_section, buf,
2854 /* Store the reloc information in the right place. It will get
2855 swapped and written out at the end of the final_link routine. */
2856 irel = (flaginfo->section_info[output_section->target_index].relocs
2857 + output_section->reloc_count);
2858 rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes
2859 + output_section->reloc_count);
2861 memset (irel, 0, sizeof (struct internal_reloc));
2862 *rel_hash_ptr = NULL;
2864 irel->r_vaddr = output_section->vma + link_order->offset;
2866 if (link_order->type == bfd_section_reloc_link_order)
2868 /* We need to somehow locate a symbol in the right section. The
2869 symbol must either have a value of zero, or we must adjust
2870 the addend by the value of the symbol. FIXME: Write this
2871 when we need it. The old linker couldn't handle this anyhow. */
2873 *rel_hash_ptr = NULL;
2878 struct coff_link_hash_entry *h;
2880 h = ((struct coff_link_hash_entry *)
2881 bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info,
2882 link_order->u.reloc.p->u.name,
2883 FALSE, FALSE, TRUE));
2887 irel->r_symndx = h->indx;
2890 /* Set the index to -2 to force this symbol to get
2899 (*flaginfo->info->callbacks->unattached_reloc)
2900 (flaginfo->info, link_order->u.reloc.p->u.name,
2901 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0);
2906 /* FIXME: Is this always right? */
2907 irel->r_type = howto->type;
2909 /* r_size is only used on the RS/6000, which needs its own linker
2910 routines anyhow. r_extern is only used for ECOFF. */
2912 /* FIXME: What is the right value for r_offset? Is zero OK? */
2913 ++output_section->reloc_count;
2918 /* A basic reloc handling routine which may be used by processors with
2922 _bfd_coff_generic_relocate_section (bfd *output_bfd,
2923 struct bfd_link_info *info,
2925 asection *input_section,
2927 struct internal_reloc *relocs,
2928 struct internal_syment *syms,
2929 asection **sections)
2931 struct internal_reloc *rel;
2932 struct internal_reloc *relend;
2935 relend = rel + input_section->reloc_count;
2936 for (; rel < relend; rel++)
2939 struct coff_link_hash_entry *h;
2940 struct internal_syment *sym;
2944 reloc_howto_type *howto;
2945 bfd_reloc_status_type rstat;
2947 symndx = rel->r_symndx;
2955 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2957 (*_bfd_error_handler)
2958 ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
2963 h = obj_coff_sym_hashes (input_bfd)[symndx];
2964 sym = syms + symndx;
2967 /* COFF treats common symbols in one of two ways. Either the
2968 size of the symbol is included in the section contents, or it
2969 is not. We assume that the size is not included, and force
2970 the rtype_to_howto function to adjust the addend as needed. */
2971 if (sym != NULL && sym->n_scnum != 0)
2972 addend = - sym->n_value;
2976 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2981 /* If we are doing a relocatable link, then we can just ignore
2982 a PC relative reloc that is pcrel_offset. It will already
2983 have the correct value. If this is not a relocatable link,
2984 then we should ignore the symbol value. */
2985 if (howto->pc_relative && howto->pcrel_offset)
2987 if (bfd_link_relocatable (info))
2989 if (sym != NULL && sym->n_scnum != 0)
2990 addend += sym->n_value;
2999 sec = bfd_abs_section_ptr;
3004 sec = sections[symndx];
3006 /* PR 19623: Relocations against symbols in
3007 the absolute sections should ignored. */
3008 if (bfd_is_abs_section (sec))
3011 val = (sec->output_section->vma
3012 + sec->output_offset
3014 if (! obj_pe (input_bfd))
3020 if (h->root.type == bfd_link_hash_defined
3021 || h->root.type == bfd_link_hash_defweak)
3023 /* Defined weak symbols are a GNU extension. */
3024 sec = h->root.u.def.section;
3025 val = (h->root.u.def.value
3026 + sec->output_section->vma
3027 + sec->output_offset);
3030 else if (h->root.type == bfd_link_hash_undefweak)
3032 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
3034 /* See _Microsoft Portable Executable and Common Object
3035 File Format Specification_, section 5.5.3.
3036 Note that weak symbols without aux records are a GNU
3038 FIXME: All weak externals are treated as having
3039 characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
3040 These behave as per SVR4 ABI: A library member
3041 will resolve a weak external only if a normal
3042 external causes the library member to be linked.
3043 See also linker.c: generic_link_check_archive_element. */
3044 struct coff_link_hash_entry *h2 =
3045 h->auxbfd->tdata.coff_obj_data->sym_hashes[
3046 h->aux->x_sym.x_tagndx.l];
3048 if (!h2 || h2->root.type == bfd_link_hash_undefined)
3050 sec = bfd_abs_section_ptr;
3055 sec = h2->root.u.def.section;
3056 val = h2->root.u.def.value
3057 + sec->output_section->vma + sec->output_offset;
3061 /* This is a GNU extension. */
3065 else if (! bfd_link_relocatable (info))
3066 (*info->callbacks->undefined_symbol)
3067 (info, h->root.root.string, input_bfd, input_section,
3068 rel->r_vaddr - input_section->vma, TRUE);
3071 /* If the input section defining the symbol has been discarded
3072 then zero this reloc field. */
3073 if (sec != NULL && discarded_section (sec))
3075 _bfd_clear_contents (howto, input_bfd, input_section,
3076 contents + (rel->r_vaddr - input_section->vma));
3080 if (info->base_file)
3082 /* Emit a reloc if the backend thinks it needs it. */
3083 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
3085 /* Relocation to a symbol in a section which isn't
3086 absolute. We output the address here to a file.
3087 This file is then read by dlltool when generating the
3088 reloc section. Note that the base file is not
3089 portable between systems. We write out a bfd_vma here,
3090 and dlltool reads in a bfd_vma. */
3091 bfd_vma addr = (rel->r_vaddr
3092 - input_section->vma
3093 + input_section->output_offset
3094 + input_section->output_section->vma);
3095 if (coff_data (output_bfd)->pe)
3096 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
3097 if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)
3098 != sizeof (bfd_vma))
3100 bfd_set_error (bfd_error_system_call);
3106 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3108 rel->r_vaddr - input_section->vma,
3117 case bfd_reloc_outofrange:
3118 (*_bfd_error_handler)
3119 (_("%B: bad reloc address 0x%lx in section `%A'"),
3120 input_bfd, input_section, (unsigned long) rel->r_vaddr);
3122 case bfd_reloc_overflow:
3125 char buf[SYMNMLEN + 1];
3133 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3138 (*info->callbacks->reloc_overflow)
3139 (info, (h ? &h->root : NULL), name, howto->name,
3140 (bfd_vma) 0, input_bfd, input_section,
3141 rel->r_vaddr - input_section->vma);