1 /* COFF specific linker code.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2011 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
23 /* This file contains the COFF backend linker code. */
29 #include "coff/internal.h"
31 #include "safe-ctype.h"
33 static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info);
34 static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded);
35 static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info);
37 /* Return TRUE if SYM is a weak, external symbol. */
38 #define IS_WEAK_EXTERNAL(abfd, sym) \
39 ((sym).n_sclass == C_WEAKEXT \
40 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
42 /* Return TRUE if SYM is an external symbol. */
43 #define IS_EXTERNAL(abfd, sym) \
44 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
46 /* Define macros so that the ISFCN, et. al., macros work correctly.
47 These macros are defined in include/coff/internal.h in terms of
48 N_TMASK, etc. These definitions require a user to define local
49 variables with the appropriate names, and with values from the
50 coff_data (abfd) structure. */
52 #define N_TMASK n_tmask
53 #define N_BTSHFT n_btshft
54 #define N_BTMASK n_btmask
56 /* Create an entry in a COFF linker hash table. */
58 struct bfd_hash_entry *
59 _bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
60 struct bfd_hash_table *table,
63 struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
65 /* Allocate the structure if it has not already been allocated by a
67 if (ret == (struct coff_link_hash_entry *) NULL)
68 ret = ((struct coff_link_hash_entry *)
69 bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
70 if (ret == (struct coff_link_hash_entry *) NULL)
71 return (struct bfd_hash_entry *) ret;
73 /* Call the allocation method of the superclass. */
74 ret = ((struct coff_link_hash_entry *)
75 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
77 if (ret != (struct coff_link_hash_entry *) NULL)
79 /* Set local fields. */
82 ret->symbol_class = C_NULL;
88 return (struct bfd_hash_entry *) ret;
91 /* Initialize a COFF linker hash table. */
94 _bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
96 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
97 struct bfd_hash_table *,
101 memset (&table->stab_info, 0, sizeof (table->stab_info));
102 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
105 /* Create a COFF linker hash table. */
107 struct bfd_link_hash_table *
108 _bfd_coff_link_hash_table_create (bfd *abfd)
110 struct coff_link_hash_table *ret;
111 bfd_size_type amt = sizeof (struct coff_link_hash_table);
113 ret = (struct coff_link_hash_table *) bfd_malloc (amt);
117 if (! _bfd_coff_link_hash_table_init (ret, abfd,
118 _bfd_coff_link_hash_newfunc,
119 sizeof (struct coff_link_hash_entry)))
122 return (struct bfd_link_hash_table *) NULL;
127 /* Create an entry in a COFF debug merge hash table. */
129 struct bfd_hash_entry *
130 _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,
131 struct bfd_hash_table *table,
134 struct coff_debug_merge_hash_entry *ret =
135 (struct coff_debug_merge_hash_entry *) entry;
137 /* Allocate the structure if it has not already been allocated by a
139 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
140 ret = ((struct coff_debug_merge_hash_entry *)
141 bfd_hash_allocate (table,
142 sizeof (struct coff_debug_merge_hash_entry)));
143 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
144 return (struct bfd_hash_entry *) ret;
146 /* Call the allocation method of the superclass. */
147 ret = ((struct coff_debug_merge_hash_entry *)
148 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
149 if (ret != (struct coff_debug_merge_hash_entry *) NULL)
151 /* Set local fields. */
155 return (struct bfd_hash_entry *) ret;
158 /* Given a COFF BFD, add symbols to the global hash table as
162 _bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
164 switch (bfd_get_format (abfd))
167 return coff_link_add_object_symbols (abfd, info);
169 return _bfd_generic_link_add_archive_symbols
170 (abfd, info, coff_link_check_archive_element);
172 bfd_set_error (bfd_error_wrong_format);
177 /* Add symbols from a COFF object file. */
180 coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
182 if (! _bfd_coff_get_external_symbols (abfd))
184 if (! coff_link_add_symbols (abfd, info))
187 if (! info->keep_memory
188 && ! _bfd_coff_free_symbols (abfd))
194 /* Look through the symbols to see if this object file should be
195 included in the link. */
198 coff_link_check_ar_symbols (bfd *abfd,
199 struct bfd_link_info *info,
200 bfd_boolean *pneeded,
203 bfd_size_type symesz;
209 symesz = bfd_coff_symesz (abfd);
210 esym = (bfd_byte *) obj_coff_external_syms (abfd);
211 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
212 while (esym < esym_end)
214 struct internal_syment sym;
215 enum coff_symbol_classification classification;
217 bfd_coff_swap_sym_in (abfd, esym, &sym);
219 classification = bfd_coff_classify_symbol (abfd, &sym);
220 if (classification == COFF_SYMBOL_GLOBAL
221 || classification == COFF_SYMBOL_COMMON)
224 char buf[SYMNMLEN + 1];
225 struct bfd_link_hash_entry *h;
227 /* This symbol is externally visible, and is defined by this
229 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
232 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
236 && info->pei386_auto_import
237 && CONST_STRNEQ (name, "__imp_"))
238 h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
240 /* We are only interested in symbols that are currently
241 undefined. If a symbol is currently known to be common,
242 COFF linkers do not bring in an object file which defines
244 if (h != (struct bfd_link_hash_entry *) NULL
245 && h->type == bfd_link_hash_undefined)
247 if (!(*info->callbacks
248 ->add_archive_element) (info, abfd, name, subsbfd))
255 esym += (sym.n_numaux + 1) * symesz;
258 /* We do not need this object file. */
262 /* Check a single archive element to see if we need to include it in
263 the link. *PNEEDED is set according to whether this element is
264 needed in the link or not. This is called via
265 _bfd_generic_link_add_archive_symbols. */
268 coff_link_check_archive_element (bfd *abfd,
269 struct bfd_link_info *info,
270 bfd_boolean *pneeded)
275 if (!_bfd_coff_get_external_symbols (abfd))
279 if (!coff_link_check_ar_symbols (abfd, info, pneeded, &abfd))
285 /* Potentially, the add_archive_element hook may have set a
286 substitute BFD for us. */
289 if (!info->keep_memory
290 && !_bfd_coff_free_symbols (oldbfd))
292 if (!_bfd_coff_get_external_symbols (abfd))
295 if (!coff_link_add_symbols (abfd, info))
299 if (!info->keep_memory || !needed)
301 if (!_bfd_coff_free_symbols (abfd))
307 /* Add all the symbols from an object file to the hash table. */
310 coff_link_add_symbols (bfd *abfd,
311 struct bfd_link_info *info)
313 unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
314 unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
315 unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
316 bfd_boolean keep_syms;
317 bfd_boolean default_copy;
318 bfd_size_type symcount;
319 struct coff_link_hash_entry **sym_hash;
320 bfd_size_type symesz;
325 symcount = obj_raw_syment_count (abfd);
328 return TRUE; /* Nothing to do. */
330 /* Keep the symbols during this function, in case the linker needs
331 to read the generic symbols in order to report an error message. */
332 keep_syms = obj_coff_keep_syms (abfd);
333 obj_coff_keep_syms (abfd) = TRUE;
335 if (info->keep_memory)
336 default_copy = FALSE;
340 /* We keep a list of the linker hash table entries that correspond
341 to particular symbols. */
342 amt = symcount * sizeof (struct coff_link_hash_entry *);
343 sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
344 if (sym_hash == NULL)
346 obj_coff_sym_hashes (abfd) = sym_hash;
348 symesz = bfd_coff_symesz (abfd);
349 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
350 esym = (bfd_byte *) obj_coff_external_syms (abfd);
351 esym_end = esym + symcount * symesz;
352 while (esym < esym_end)
354 struct internal_syment sym;
355 enum coff_symbol_classification classification;
358 bfd_coff_swap_sym_in (abfd, esym, &sym);
360 classification = bfd_coff_classify_symbol (abfd, &sym);
361 if (classification != COFF_SYMBOL_LOCAL)
364 char buf[SYMNMLEN + 1];
370 /* This symbol is externally visible. */
372 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
376 /* We must copy the name into memory if we got it from the
377 syment itself, rather than the string table. */
379 if (sym._n._n_n._n_zeroes != 0
380 || sym._n._n_n._n_offset == 0)
385 switch (classification)
390 case COFF_SYMBOL_GLOBAL:
391 flags = BSF_EXPORT | BSF_GLOBAL;
392 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
394 value -= section->vma;
395 /* Treat a symbol from a discarded section as undefined. */
396 if (bfd_is_abs_section (section)
397 || !bfd_is_abs_section (section->output_section))
401 case COFF_SYMBOL_UNDEFINED:
403 section = bfd_und_section_ptr;
406 case COFF_SYMBOL_COMMON:
408 section = bfd_com_section_ptr;
411 case COFF_SYMBOL_PE_SECTION:
412 flags = BSF_SECTION_SYM | BSF_GLOBAL;
413 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
417 if (IS_WEAK_EXTERNAL (abfd, sym))
422 /* In the PE format, section symbols actually refer to the
423 start of the output section. We handle them specially
425 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
427 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
428 name, FALSE, copy, FALSE);
429 if (*sym_hash != NULL)
431 if (((*sym_hash)->coff_link_hash_flags
432 & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
433 && (*sym_hash)->root.type != bfd_link_hash_undefined
434 && (*sym_hash)->root.type != bfd_link_hash_undefweak)
435 (*_bfd_error_handler)
436 ("Warning: symbol `%s' is both section and non-section",
443 /* The Microsoft Visual C compiler does string pooling by
444 hashing the constants to an internal symbol name, and
445 relying on the linker comdat support to discard
446 duplicate names. However, if one string is a literal and
447 one is a data initializer, one will end up in the .data
448 section and one will end up in the .rdata section. The
449 Microsoft linker will combine them into the .data
450 section, which seems to be wrong since it might cause the
453 As long as there are no external references to the
454 symbols, which there shouldn't be, we can treat the .data
455 and .rdata instances as separate symbols. The comdat
456 code in the linker will do the appropriate merging. Here
457 we avoid getting a multiple definition error for one of
458 these special symbols.
460 FIXME: I don't think this will work in the case where
461 there are two object files which use the constants as a
462 literal and two object files which use it as a data
463 initializer. One or the other of the second object files
464 is going to wind up with an inappropriate reference. */
466 && (classification == COFF_SYMBOL_GLOBAL
467 || classification == COFF_SYMBOL_PE_SECTION)
468 && coff_section_data (abfd, section) != NULL
469 && coff_section_data (abfd, section)->comdat != NULL
470 && CONST_STRNEQ (name, "??_")
471 && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
473 if (*sym_hash == NULL)
474 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
475 name, FALSE, copy, FALSE);
476 if (*sym_hash != NULL
477 && (*sym_hash)->root.type == bfd_link_hash_defined
478 && coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL
479 && strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,
480 coff_section_data (abfd, section)->comdat->name) == 0)
486 if (! (bfd_coff_link_add_one_symbol
487 (info, abfd, name, flags, section, value,
488 (const char *) NULL, copy, FALSE,
489 (struct bfd_link_hash_entry **) sym_hash)))
493 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
494 (*sym_hash)->coff_link_hash_flags |=
495 COFF_LINK_HASH_PE_SECTION_SYMBOL;
497 /* Limit the alignment of a common symbol to the possible
498 alignment of a section. There is no point to permitting
499 a higher alignment for a common symbol: we can not
500 guarantee it, and it may cause us to allocate extra space
501 in the common section. */
502 if (section == bfd_com_section_ptr
503 && (*sym_hash)->root.type == bfd_link_hash_common
504 && ((*sym_hash)->root.u.c.p->alignment_power
505 > bfd_coff_default_section_alignment_power (abfd)))
506 (*sym_hash)->root.u.c.p->alignment_power
507 = bfd_coff_default_section_alignment_power (abfd);
509 if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
511 /* If we don't have any symbol information currently in
512 the hash table, or if we are looking at a symbol
513 definition, then update the symbol class and type in
515 if (((*sym_hash)->symbol_class == C_NULL
516 && (*sym_hash)->type == T_NULL)
519 && (*sym_hash)->root.type != bfd_link_hash_defined
520 && (*sym_hash)->root.type != bfd_link_hash_defweak))
522 (*sym_hash)->symbol_class = sym.n_sclass;
523 if (sym.n_type != T_NULL)
525 /* We want to warn if the type changed, but not
526 if it changed from an unspecified type.
527 Testing the whole type byte may work, but the
528 change from (e.g.) a function of unspecified
529 type to function of known type also wants to
531 if ((*sym_hash)->type != T_NULL
532 && (*sym_hash)->type != sym.n_type
533 && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
534 && (BTYPE ((*sym_hash)->type) == T_NULL
535 || BTYPE (sym.n_type) == T_NULL)))
536 (*_bfd_error_handler)
537 (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
538 abfd, name, (*sym_hash)->type, sym.n_type);
540 /* We don't want to change from a meaningful
541 base type to a null one, but if we know
542 nothing, take what little we might now know. */
543 if (BTYPE (sym.n_type) != T_NULL
544 || (*sym_hash)->type == T_NULL)
545 (*sym_hash)->type = sym.n_type;
547 (*sym_hash)->auxbfd = abfd;
548 if (sym.n_numaux != 0)
550 union internal_auxent *alloc;
553 union internal_auxent *iaux;
555 (*sym_hash)->numaux = sym.n_numaux;
556 alloc = ((union internal_auxent *)
557 bfd_hash_allocate (&info->hash->table,
559 * sizeof (*alloc))));
562 for (i = 0, eaux = esym + symesz, iaux = alloc;
564 i++, eaux += symesz, iaux++)
565 bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
566 sym.n_sclass, (int) i,
568 (*sym_hash)->aux = alloc;
573 if (classification == COFF_SYMBOL_PE_SECTION
574 && (*sym_hash)->numaux != 0)
576 /* Some PE sections (such as .bss) have a zero size in
577 the section header, but a non-zero size in the AUX
578 record. Correct that here.
580 FIXME: This is not at all the right place to do this.
581 For example, it won't help objdump. This needs to be
582 done when we swap in the section header. */
583 BFD_ASSERT ((*sym_hash)->numaux == 1);
584 if (section->size == 0)
585 section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;
587 /* FIXME: We could test whether the section sizes
588 matches the size in the aux entry, but apparently
589 that sometimes fails unexpectedly. */
593 esym += (sym.n_numaux + 1) * symesz;
594 sym_hash += sym.n_numaux + 1;
597 /* If this is a non-traditional, non-relocatable link, try to
598 optimize the handling of any .stab/.stabstr sections. */
599 if (! info->relocatable
600 && ! info->traditional_format
601 && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)
602 && (info->strip != strip_all && info->strip != strip_debugger))
606 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
610 bfd_size_type string_offset = 0;
613 for (stab = abfd->sections; stab; stab = stab->next)
614 if (CONST_STRNEQ (stab->name, ".stab")
616 || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
618 struct coff_link_hash_table *table;
619 struct coff_section_tdata *secdata
620 = coff_section_data (abfd, stab);
624 amt = sizeof (struct coff_section_tdata);
625 stab->used_by_bfd = bfd_zalloc (abfd, amt);
626 if (stab->used_by_bfd == NULL)
628 secdata = coff_section_data (abfd, stab);
631 table = coff_hash_table (info);
633 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
642 obj_coff_keep_syms (abfd) = keep_syms;
647 obj_coff_keep_syms (abfd) = keep_syms;
651 /* Do the final link step. */
654 _bfd_coff_final_link (bfd *abfd,
655 struct bfd_link_info *info)
657 bfd_size_type symesz;
658 struct coff_final_link_info finfo;
659 bfd_boolean debug_merge_allocated;
660 bfd_boolean long_section_names;
662 struct bfd_link_order *p;
663 bfd_size_type max_sym_count;
664 bfd_size_type max_lineno_count;
665 bfd_size_type max_reloc_count;
666 bfd_size_type max_output_reloc_count;
667 bfd_size_type max_contents_size;
668 file_ptr rel_filepos;
670 file_ptr line_filepos;
673 bfd_byte *external_relocs = NULL;
674 char strbuf[STRING_SIZE_SIZE];
677 symesz = bfd_coff_symesz (abfd);
680 finfo.output_bfd = abfd;
682 finfo.section_info = NULL;
683 finfo.last_file_index = -1;
684 finfo.last_bf_index = -1;
685 finfo.internal_syms = NULL;
686 finfo.sec_ptrs = NULL;
687 finfo.sym_indices = NULL;
688 finfo.outsyms = NULL;
689 finfo.linenos = NULL;
690 finfo.contents = NULL;
691 finfo.external_relocs = NULL;
692 finfo.internal_relocs = NULL;
693 finfo.global_to_static = FALSE;
694 debug_merge_allocated = FALSE;
696 coff_data (abfd)->link_info = info;
698 finfo.strtab = _bfd_stringtab_init ();
699 if (finfo.strtab == NULL)
702 if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
704 debug_merge_allocated = TRUE;
706 /* Compute the file positions for all the sections. */
707 if (! abfd->output_has_begun)
709 if (! bfd_coff_compute_section_file_positions (abfd))
713 /* Count the line numbers and relocation entries required for the
714 output file. Set the file positions for the relocs. */
715 rel_filepos = obj_relocbase (abfd);
716 relsz = bfd_coff_relsz (abfd);
717 max_contents_size = 0;
718 max_lineno_count = 0;
721 long_section_names = FALSE;
722 for (o = abfd->sections; o != NULL; o = o->next)
726 for (p = o->map_head.link_order; p != NULL; p = p->next)
728 if (p->type == bfd_indirect_link_order)
732 sec = p->u.indirect.section;
734 /* Mark all sections which are to be included in the
735 link. This will normally be every section. We need
736 to do this so that we can identify any sections which
737 the linker has decided to not include. */
738 sec->linker_mark = TRUE;
740 if (info->strip == strip_none
741 || info->strip == strip_some)
742 o->lineno_count += sec->lineno_count;
744 if (info->relocatable)
745 o->reloc_count += sec->reloc_count;
747 if (sec->rawsize > max_contents_size)
748 max_contents_size = sec->rawsize;
749 if (sec->size > max_contents_size)
750 max_contents_size = sec->size;
751 if (sec->lineno_count > max_lineno_count)
752 max_lineno_count = sec->lineno_count;
753 if (sec->reloc_count > max_reloc_count)
754 max_reloc_count = sec->reloc_count;
756 else if (info->relocatable
757 && (p->type == bfd_section_reloc_link_order
758 || p->type == bfd_symbol_reloc_link_order))
761 if (o->reloc_count == 0)
765 o->flags |= SEC_RELOC;
766 o->rel_filepos = rel_filepos;
767 rel_filepos += o->reloc_count * relsz;
768 /* In PE COFF, if there are at least 0xffff relocations an
769 extra relocation will be written out to encode the count. */
770 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
771 rel_filepos += relsz;
774 if (bfd_coff_long_section_names (abfd)
775 && strlen (o->name) > SCNNMLEN)
777 /* This section has a long name which must go in the string
778 table. This must correspond to the code in
779 coff_write_object_contents which puts the string index
780 into the s_name field of the section header. That is why
781 we pass hash as FALSE. */
782 if (_bfd_stringtab_add (finfo.strtab, o->name, FALSE, FALSE)
783 == (bfd_size_type) -1)
785 long_section_names = TRUE;
789 /* If doing a relocatable link, allocate space for the pointers we
791 if (info->relocatable)
795 /* We use section_count + 1, rather than section_count, because
796 the target_index fields are 1 based. */
797 amt = abfd->section_count + 1;
798 amt *= sizeof (struct coff_link_section_info);
799 finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
800 if (finfo.section_info == NULL)
802 for (i = 0; i <= abfd->section_count; i++)
804 finfo.section_info[i].relocs = NULL;
805 finfo.section_info[i].rel_hashes = NULL;
809 /* We now know the size of the relocs, so we can determine the file
810 positions of the line numbers. */
811 line_filepos = rel_filepos;
812 linesz = bfd_coff_linesz (abfd);
813 max_output_reloc_count = 0;
814 for (o = abfd->sections; o != NULL; o = o->next)
816 if (o->lineno_count == 0)
820 o->line_filepos = line_filepos;
821 line_filepos += o->lineno_count * linesz;
824 if (o->reloc_count != 0)
826 /* We don't know the indices of global symbols until we have
827 written out all the local symbols. For each section in
828 the output file, we keep an array of pointers to hash
829 table entries. Each entry in the array corresponds to a
830 reloc. When we find a reloc against a global symbol, we
831 set the corresponding entry in this array so that we can
832 fix up the symbol index after we have written out all the
835 Because of this problem, we also keep the relocs in
836 memory until the end of the link. This wastes memory,
837 but only when doing a relocatable link, which is not the
839 BFD_ASSERT (info->relocatable);
840 amt = o->reloc_count;
841 amt *= sizeof (struct internal_reloc);
842 finfo.section_info[o->target_index].relocs =
843 (struct internal_reloc *) bfd_malloc (amt);
844 amt = o->reloc_count;
845 amt *= sizeof (struct coff_link_hash_entry *);
846 finfo.section_info[o->target_index].rel_hashes =
847 (struct coff_link_hash_entry **) bfd_malloc (amt);
848 if (finfo.section_info[o->target_index].relocs == NULL
849 || finfo.section_info[o->target_index].rel_hashes == NULL)
852 if (o->reloc_count > max_output_reloc_count)
853 max_output_reloc_count = o->reloc_count;
856 /* Reset the reloc and lineno counts, so that we can use them to
857 count the number of entries we have output so far. */
862 obj_sym_filepos (abfd) = line_filepos;
864 /* Figure out the largest number of symbols in an input BFD. Take
865 the opportunity to clear the output_has_begun fields of all the
868 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
872 sub->output_has_begun = FALSE;
873 sz = obj_raw_syment_count (sub);
874 if (sz > max_sym_count)
878 /* Allocate some buffers used while linking. */
879 amt = max_sym_count * sizeof (struct internal_syment);
880 finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
881 amt = max_sym_count * sizeof (asection *);
882 finfo.sec_ptrs = (asection **) bfd_malloc (amt);
883 amt = max_sym_count * sizeof (long);
884 finfo.sym_indices = (long int *) bfd_malloc (amt);
885 finfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
886 amt = max_lineno_count * bfd_coff_linesz (abfd);
887 finfo.linenos = (bfd_byte *) bfd_malloc (amt);
888 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
889 amt = max_reloc_count * relsz;
890 finfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
891 if (! info->relocatable)
893 amt = max_reloc_count * sizeof (struct internal_reloc);
894 finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
896 if ((finfo.internal_syms == NULL && max_sym_count > 0)
897 || (finfo.sec_ptrs == NULL && max_sym_count > 0)
898 || (finfo.sym_indices == NULL && max_sym_count > 0)
899 || finfo.outsyms == NULL
900 || (finfo.linenos == NULL && max_lineno_count > 0)
901 || (finfo.contents == NULL && max_contents_size > 0)
902 || (finfo.external_relocs == NULL && max_reloc_count > 0)
903 || (! info->relocatable
904 && finfo.internal_relocs == NULL
905 && max_reloc_count > 0))
908 /* We now know the position of everything in the file, except that
909 we don't know the size of the symbol table and therefore we don't
910 know where the string table starts. We just build the string
911 table in memory as we go along. We process all the relocations
912 for a single input file at once. */
913 obj_raw_syment_count (abfd) = 0;
915 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
917 if (! bfd_coff_start_final_link (abfd, info))
921 for (o = abfd->sections; o != NULL; o = o->next)
923 for (p = o->map_head.link_order; p != NULL; p = p->next)
925 if (p->type == bfd_indirect_link_order
926 && bfd_family_coff (p->u.indirect.section->owner))
928 sub = p->u.indirect.section->owner;
929 if (! bfd_coff_link_output_has_begun (sub, & finfo))
931 if (! _bfd_coff_link_input_bfd (&finfo, sub))
933 sub->output_has_begun = TRUE;
936 else if (p->type == bfd_section_reloc_link_order
937 || p->type == bfd_symbol_reloc_link_order)
939 if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
944 if (! _bfd_default_link_order (abfd, info, o, p))
950 if (! bfd_coff_final_link_postscript (abfd, & finfo))
953 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
955 coff_debug_merge_hash_table_free (&finfo.debug_merge);
956 debug_merge_allocated = FALSE;
958 if (finfo.internal_syms != NULL)
960 free (finfo.internal_syms);
961 finfo.internal_syms = NULL;
963 if (finfo.sec_ptrs != NULL)
965 free (finfo.sec_ptrs);
966 finfo.sec_ptrs = NULL;
968 if (finfo.sym_indices != NULL)
970 free (finfo.sym_indices);
971 finfo.sym_indices = NULL;
973 if (finfo.linenos != NULL)
975 free (finfo.linenos);
976 finfo.linenos = NULL;
978 if (finfo.contents != NULL)
980 free (finfo.contents);
981 finfo.contents = NULL;
983 if (finfo.external_relocs != NULL)
985 free (finfo.external_relocs);
986 finfo.external_relocs = NULL;
988 if (finfo.internal_relocs != NULL)
990 free (finfo.internal_relocs);
991 finfo.internal_relocs = NULL;
994 /* The value of the last C_FILE symbol is supposed to be the symbol
995 index of the first external symbol. Write it out again if
997 if (finfo.last_file_index != -1
998 && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
1002 finfo.last_file.n_value = obj_raw_syment_count (abfd);
1003 bfd_coff_swap_sym_out (abfd, &finfo.last_file,
1006 pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
1007 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1008 || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
1012 /* If doing task linking (ld --task-link) then make a pass through the
1013 global symbols, writing out any that are defined, and making them
1015 if (info->task_link)
1017 finfo.failed = FALSE;
1018 coff_link_hash_traverse (coff_hash_table (info),
1019 _bfd_coff_write_task_globals, &finfo);
1024 /* Write out the global symbols. */
1025 finfo.failed = FALSE;
1026 bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &finfo);
1030 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
1031 if (finfo.outsyms != NULL)
1033 free (finfo.outsyms);
1034 finfo.outsyms = NULL;
1037 if (info->relocatable && max_output_reloc_count > 0)
1039 /* Now that we have written out all the global symbols, we know
1040 the symbol indices to use for relocs against them, and we can
1041 finally write out the relocs. */
1042 amt = max_output_reloc_count * relsz;
1043 external_relocs = (bfd_byte *) bfd_malloc (amt);
1044 if (external_relocs == NULL)
1047 for (o = abfd->sections; o != NULL; o = o->next)
1049 struct internal_reloc *irel;
1050 struct internal_reloc *irelend;
1051 struct coff_link_hash_entry **rel_hash;
1054 if (o->reloc_count == 0)
1057 irel = finfo.section_info[o->target_index].relocs;
1058 irelend = irel + o->reloc_count;
1059 rel_hash = finfo.section_info[o->target_index].rel_hashes;
1060 erel = external_relocs;
1061 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1063 if (*rel_hash != NULL)
1065 BFD_ASSERT ((*rel_hash)->indx >= 0);
1066 irel->r_symndx = (*rel_hash)->indx;
1068 bfd_coff_swap_reloc_out (abfd, irel, erel);
1071 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
1073 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
1075 /* In PE COFF, write the count of relocs as the first
1076 reloc. The header overflow bit will be set
1078 struct internal_reloc incount;
1079 bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
1081 memset (&incount, 0, sizeof (incount));
1082 incount.r_vaddr = o->reloc_count + 1;
1083 bfd_coff_swap_reloc_out (abfd, (PTR) &incount, (PTR) excount);
1084 if (bfd_bwrite (excount, relsz, abfd) != relsz)
1085 /* We'll leak, but it's an error anyway. */
1089 if (bfd_bwrite (external_relocs,
1090 (bfd_size_type) relsz * o->reloc_count, abfd)
1091 != (bfd_size_type) relsz * o->reloc_count)
1095 free (external_relocs);
1096 external_relocs = NULL;
1099 /* Free up the section information. */
1100 if (finfo.section_info != NULL)
1104 for (i = 0; i < abfd->section_count; i++)
1106 if (finfo.section_info[i].relocs != NULL)
1107 free (finfo.section_info[i].relocs);
1108 if (finfo.section_info[i].rel_hashes != NULL)
1109 free (finfo.section_info[i].rel_hashes);
1111 free (finfo.section_info);
1112 finfo.section_info = NULL;
1115 /* If we have optimized stabs strings, output them. */
1116 if (coff_hash_table (info)->stab_info.stabstr != NULL)
1118 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1122 /* Write out the string table. */
1123 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1127 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1128 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1131 #if STRING_SIZE_SIZE == 4
1133 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
1136 #error Change H_PUT_32 above
1139 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1140 != STRING_SIZE_SIZE)
1143 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
1146 obj_coff_strings_written (abfd) = TRUE;
1149 _bfd_stringtab_free (finfo.strtab);
1151 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1152 not try to write out the symbols. */
1153 bfd_get_symcount (abfd) = 0;
1158 if (debug_merge_allocated)
1159 coff_debug_merge_hash_table_free (&finfo.debug_merge);
1160 if (finfo.strtab != NULL)
1161 _bfd_stringtab_free (finfo.strtab);
1162 if (finfo.section_info != NULL)
1166 for (i = 0; i < abfd->section_count; i++)
1168 if (finfo.section_info[i].relocs != NULL)
1169 free (finfo.section_info[i].relocs);
1170 if (finfo.section_info[i].rel_hashes != NULL)
1171 free (finfo.section_info[i].rel_hashes);
1173 free (finfo.section_info);
1175 if (finfo.internal_syms != NULL)
1176 free (finfo.internal_syms);
1177 if (finfo.sec_ptrs != NULL)
1178 free (finfo.sec_ptrs);
1179 if (finfo.sym_indices != NULL)
1180 free (finfo.sym_indices);
1181 if (finfo.outsyms != NULL)
1182 free (finfo.outsyms);
1183 if (finfo.linenos != NULL)
1184 free (finfo.linenos);
1185 if (finfo.contents != NULL)
1186 free (finfo.contents);
1187 if (finfo.external_relocs != NULL)
1188 free (finfo.external_relocs);
1189 if (finfo.internal_relocs != NULL)
1190 free (finfo.internal_relocs);
1191 if (external_relocs != NULL)
1192 free (external_relocs);
1196 /* Parse out a -heap <reserved>,<commit> line. */
1199 dores_com (char *ptr, bfd *output_bfd, int heap)
1201 if (coff_data(output_bfd)->pe)
1203 int val = strtoul (ptr, &ptr, 0);
1206 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1208 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1212 val = strtoul (ptr+1, &ptr, 0);
1214 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1216 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1223 get_name (char *ptr, char **dst)
1228 while (*ptr && *ptr != ' ')
1234 /* Process any magic embedded commands in a section called .drectve. */
1237 process_embedded_commands (bfd *output_bfd,
1238 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1241 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1249 if (!bfd_malloc_and_get_section (abfd, sec, ©))
1255 e = (char *) copy + sec->size;
1257 for (s = (char *) copy; s < e ; )
1264 if (CONST_STRNEQ (s, "-attr"))
1274 s = get_name (s, &name);
1275 s = get_name (s, &attribs);
1295 asec = bfd_get_section_by_name (abfd, name);
1299 asec->flags |= SEC_CODE;
1301 asec->flags |= SEC_READONLY;
1304 else if (CONST_STRNEQ (s, "-heap"))
1305 s = dores_com (s + 5, output_bfd, 1);
1307 else if (CONST_STRNEQ (s, "-stack"))
1308 s = dores_com (s + 6, output_bfd, 0);
1310 /* GNU extension for aligned commons. */
1311 else if (CONST_STRNEQ (s, "-aligncomm:"))
1313 /* Common symbols must be aligned on reading, as it
1314 is too late to do anything here, after they have
1315 already been allocated, so just skip the directive. */
1326 /* Place a marker against all symbols which are used by relocations.
1327 This marker can be picked up by the 'do we skip this symbol ?'
1328 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1332 mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
1336 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1339 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1341 struct internal_reloc * internal_relocs;
1342 struct internal_reloc * irel;
1343 struct internal_reloc * irelend;
1345 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1)
1347 /* Don't mark relocs in excluded sections. */
1348 if (a->output_section == bfd_abs_section_ptr)
1351 /* Read in the relocs. */
1352 internal_relocs = _bfd_coff_read_internal_relocs
1353 (input_bfd, a, FALSE,
1354 finfo->external_relocs,
1355 finfo->info->relocatable,
1356 (finfo->info->relocatable
1357 ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1358 : finfo->internal_relocs)
1361 if (internal_relocs == NULL)
1364 irel = internal_relocs;
1365 irelend = irel + a->reloc_count;
1367 /* Place a mark in the sym_indices array (whose entries have
1368 been initialised to 0) for all of the symbols that are used
1369 in the relocation table. This will then be picked up in the
1370 skip/don't-skip pass. */
1371 for (; irel < irelend; irel++)
1372 finfo->sym_indices[ irel->r_symndx ] = -1;
1376 /* Link an input file into the linker output file. This function
1377 handles all the sections and relocations of the input file at once. */
1380 _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
1382 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1383 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1384 bfd_boolean (*adjust_symndx)
1385 (bfd *, struct bfd_link_info *, bfd *, asection *,
1386 struct internal_reloc *, bfd_boolean *);
1388 const char *strings;
1389 bfd_size_type syment_base;
1390 bfd_boolean copy, hash;
1391 bfd_size_type isymesz;
1392 bfd_size_type osymesz;
1393 bfd_size_type linesz;
1396 struct internal_syment *isymp;
1399 unsigned long output_index;
1401 struct coff_link_hash_entry **sym_hash;
1404 /* Move all the symbols to the output file. */
1406 output_bfd = finfo->output_bfd;
1408 syment_base = obj_raw_syment_count (output_bfd);
1409 isymesz = bfd_coff_symesz (input_bfd);
1410 osymesz = bfd_coff_symesz (output_bfd);
1411 linesz = bfd_coff_linesz (input_bfd);
1412 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1415 if (! finfo->info->keep_memory)
1418 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1421 if (! _bfd_coff_get_external_symbols (input_bfd))
1424 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1425 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1426 isymp = finfo->internal_syms;
1427 secpp = finfo->sec_ptrs;
1428 indexp = finfo->sym_indices;
1429 output_index = syment_base;
1430 outsym = finfo->outsyms;
1432 if (coff_data (output_bfd)->pe
1433 && ! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1436 /* If we are going to perform relocations and also strip/discard some
1437 symbols then we must make sure that we do not strip/discard those
1438 symbols that are going to be involved in the relocations. */
1439 if (( finfo->info->strip != strip_none
1440 || finfo->info->discard != discard_none)
1441 && finfo->info->relocatable)
1443 /* Mark the symbol array as 'not-used'. */
1444 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1446 mark_relocs (finfo, input_bfd);
1449 while (esym < esym_end)
1451 struct internal_syment isym;
1452 enum coff_symbol_classification classification;
1455 bfd_boolean dont_skip_symbol;
1458 bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1460 /* Make a copy of *isymp so that the relocate_section function
1461 always sees the original values. This is more reliable than
1462 always recomputing the symbol value even if we are stripping
1466 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1467 switch (classification)
1471 case COFF_SYMBOL_GLOBAL:
1472 case COFF_SYMBOL_PE_SECTION:
1473 case COFF_SYMBOL_LOCAL:
1474 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1476 case COFF_SYMBOL_COMMON:
1477 *secpp = bfd_com_section_ptr;
1479 case COFF_SYMBOL_UNDEFINED:
1480 *secpp = bfd_und_section_ptr;
1484 /* Extract the flag indicating if this symbol is used by a
1486 if ((finfo->info->strip != strip_none
1487 || finfo->info->discard != discard_none)
1488 && finfo->info->relocatable)
1489 dont_skip_symbol = *indexp;
1491 dont_skip_symbol = FALSE;
1497 add = 1 + isym.n_numaux;
1499 /* If we are stripping all symbols, we want to skip this one. */
1500 if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1505 switch (classification)
1509 case COFF_SYMBOL_GLOBAL:
1510 case COFF_SYMBOL_COMMON:
1511 case COFF_SYMBOL_PE_SECTION:
1512 /* This is a global symbol. Global symbols come at the
1513 end of the symbol table, so skip them for now.
1514 Locally defined function symbols, however, are an
1515 exception, and are not moved to the end. */
1517 if (! ISFCN (isym.n_type))
1521 case COFF_SYMBOL_UNDEFINED:
1522 /* Undefined symbols are left for the end. */
1527 case COFF_SYMBOL_LOCAL:
1528 /* This is a local symbol. Skip it if we are discarding
1530 if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1536 #ifndef COFF_WITH_PE
1537 /* Skip section symbols for sections which are not going to be
1540 && !dont_skip_symbol
1541 && isym.n_sclass == C_STAT
1542 && isym.n_type == T_NULL
1543 && isym.n_numaux > 0
1544 && ((*secpp)->output_section == bfd_abs_section_ptr
1545 || bfd_section_removed_from_list (output_bfd,
1546 (*secpp)->output_section)))
1550 /* If we stripping debugging symbols, and this is a debugging
1551 symbol, then skip it. FIXME: gas sets the section to N_ABS
1552 for some types of debugging symbols; I don't know if this is
1553 a bug or not. In any case, we handle it here. */
1555 && finfo->info->strip == strip_debugger
1556 && ! dont_skip_symbol
1557 && (isym.n_scnum == N_DEBUG
1558 || (isym.n_scnum == N_ABS
1559 && (isym.n_sclass == C_AUTO
1560 || isym.n_sclass == C_REG
1561 || isym.n_sclass == C_MOS
1562 || isym.n_sclass == C_MOE
1563 || isym.n_sclass == C_MOU
1564 || isym.n_sclass == C_ARG
1565 || isym.n_sclass == C_REGPARM
1566 || isym.n_sclass == C_FIELD
1567 || isym.n_sclass == C_EOS))))
1570 /* If some symbols are stripped based on the name, work out the
1571 name and decide whether to skip this symbol. */
1573 && (finfo->info->strip == strip_some
1574 || finfo->info->discard == discard_l))
1577 char buf[SYMNMLEN + 1];
1579 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1583 if (! dont_skip_symbol
1584 && ((finfo->info->strip == strip_some
1585 && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE,
1588 && finfo->info->discard == discard_l
1589 && bfd_is_local_label_name (input_bfd, name))))
1593 /* If this is an enum, struct, or union tag, see if we have
1594 already output an identical type. */
1596 && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1597 && (isym.n_sclass == C_ENTAG
1598 || isym.n_sclass == C_STRTAG
1599 || isym.n_sclass == C_UNTAG)
1600 && isym.n_numaux == 1)
1603 char buf[SYMNMLEN + 1];
1604 struct coff_debug_merge_hash_entry *mh;
1605 struct coff_debug_merge_type *mt;
1606 union internal_auxent aux;
1607 struct coff_debug_merge_element **epp;
1608 bfd_byte *esl, *eslend;
1609 struct internal_syment *islp;
1612 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1616 /* Ignore fake names invented by compiler; treat them all as
1618 if (*name == '~' || *name == '.' || *name == '$'
1619 || (*name == bfd_get_symbol_leading_char (input_bfd)
1620 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1623 mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1628 /* Allocate memory to hold type information. If this turns
1629 out to be a duplicate, we pass this address to
1631 amt = sizeof (struct coff_debug_merge_type);
1632 mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
1635 mt->type_class = isym.n_sclass;
1637 /* Pick up the aux entry, which points to the end of the tag
1639 bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1640 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1643 /* Gather the elements. */
1644 epp = &mt->elements;
1645 mt->elements = NULL;
1647 esl = esym + 2 * isymesz;
1648 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1649 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1650 while (esl < eslend)
1652 const char *elename;
1653 char elebuf[SYMNMLEN + 1];
1656 bfd_coff_swap_sym_in (input_bfd, esl, islp);
1658 amt = sizeof (struct coff_debug_merge_element);
1659 *epp = (struct coff_debug_merge_element *)
1660 bfd_alloc (input_bfd, amt);
1664 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1666 if (elename == NULL)
1669 amt = strlen (elename) + 1;
1670 name_copy = (char *) bfd_alloc (input_bfd, amt);
1671 if (name_copy == NULL)
1673 strcpy (name_copy, elename);
1675 (*epp)->name = name_copy;
1676 (*epp)->type = islp->n_type;
1678 if (islp->n_numaux >= 1
1679 && islp->n_type != T_NULL
1680 && islp->n_sclass != C_EOS)
1682 union internal_auxent eleaux;
1685 bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1686 islp->n_type, islp->n_sclass, 0,
1687 islp->n_numaux, &eleaux);
1688 indx = eleaux.x_sym.x_tagndx.l;
1690 /* FIXME: If this tagndx entry refers to a symbol
1691 defined later in this file, we just ignore it.
1692 Handling this correctly would be tedious, and may
1697 (bfd_byte *) obj_coff_external_syms (input_bfd))
1700 (*epp)->tagndx = finfo->sym_indices[indx];
1701 if ((*epp)->tagndx < 0)
1705 epp = &(*epp)->next;
1708 esl += (islp->n_numaux + 1) * isymesz;
1709 islp += islp->n_numaux + 1;
1712 /* See if we already have a definition which matches this
1713 type. We always output the type if it has no elements,
1715 if (mt->elements == NULL)
1716 bfd_release (input_bfd, mt);
1719 struct coff_debug_merge_type *mtl;
1721 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1723 struct coff_debug_merge_element *me, *mel;
1725 if (mtl->type_class != mt->type_class)
1728 for (me = mt->elements, mel = mtl->elements;
1729 me != NULL && mel != NULL;
1730 me = me->next, mel = mel->next)
1732 if (strcmp (me->name, mel->name) != 0
1733 || me->type != mel->type
1734 || me->tagndx != mel->tagndx)
1738 if (me == NULL && mel == NULL)
1742 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1744 /* This is the first definition of this type. */
1745 mt->indx = output_index;
1746 mt->next = mh->types;
1751 /* This is a redefinition which can be merged. */
1752 bfd_release (input_bfd, mt);
1753 *indexp = mtl->indx;
1754 add = (eslend - esym) / isymesz;
1760 /* We now know whether we are to skip this symbol or not. */
1763 /* Adjust the symbol in order to output it. */
1765 if (isym._n._n_n._n_zeroes == 0
1766 && isym._n._n_n._n_offset != 0)
1771 /* This symbol has a long name. Enter it in the string
1772 table we are building. Note that we do not check
1773 bfd_coff_symname_in_debug. That is only true for
1774 XCOFF, and XCOFF requires different linking code
1776 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1779 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1780 if (indx == (bfd_size_type) -1)
1782 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1785 switch (isym.n_sclass)
1801 /* The symbol value should not be modified. */
1805 if (obj_pe (input_bfd)
1806 && strcmp (isym.n_name, ".bf") != 0
1807 && isym.n_scnum > 0)
1809 /* For PE, .lf and .ef get their value left alone,
1810 while .bf gets relocated. However, they all have
1811 "real" section numbers, and need to be moved into
1813 isym.n_scnum = (*secpp)->output_section->target_index;
1818 case C_LABEL: /* Not completely sure about these 2 */
1827 /* Compute new symbol location. */
1828 if (isym.n_scnum > 0)
1830 isym.n_scnum = (*secpp)->output_section->target_index;
1831 isym.n_value += (*secpp)->output_offset;
1832 if (! obj_pe (input_bfd))
1833 isym.n_value -= (*secpp)->vma;
1834 if (! obj_pe (finfo->output_bfd))
1835 isym.n_value += (*secpp)->output_section->vma;
1840 /* The value of a C_FILE symbol is the symbol index of
1841 the next C_FILE symbol. The value of the last C_FILE
1842 symbol is the symbol index to the first external
1843 symbol (actually, coff_renumber_symbols does not get
1844 this right--it just sets the value of the last C_FILE
1845 symbol to zero--and nobody has ever complained about
1846 it). We try to get this right, below, just before we
1847 write the symbols out, but in the general case we may
1848 have to write the symbol out twice. */
1849 if (finfo->last_file_index != -1
1850 && finfo->last_file.n_value != (bfd_vma) output_index)
1852 /* We must correct the value of the last C_FILE
1854 finfo->last_file.n_value = output_index;
1855 if ((bfd_size_type) finfo->last_file_index >= syment_base)
1857 /* The last C_FILE symbol is in this input file. */
1858 bfd_coff_swap_sym_out (output_bfd,
1861 + ((finfo->last_file_index
1869 /* We have already written out the last C_FILE
1870 symbol. We need to write it out again. We
1871 borrow *outsym temporarily. */
1872 bfd_coff_swap_sym_out (output_bfd,
1873 &finfo->last_file, outsym);
1874 pos = obj_sym_filepos (output_bfd);
1875 pos += finfo->last_file_index * osymesz;
1876 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1877 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1882 finfo->last_file_index = output_index;
1883 finfo->last_file = isym;
1887 /* If doing task linking, convert normal global function symbols to
1888 static functions. */
1889 if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1890 isym.n_sclass = C_STAT;
1892 /* Output the symbol. */
1893 bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1895 *indexp = output_index;
1900 struct coff_link_hash_entry *h;
1902 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1904 h = obj_coff_sym_hashes (input_bfd)[indx];
1907 /* This can happen if there were errors earlier in
1909 bfd_set_error (bfd_error_bad_value);
1912 h->indx = output_index;
1915 output_index += add;
1916 outsym += add * osymesz;
1919 esym += add * isymesz;
1923 for (--add; add > 0; --add)
1930 /* Fix up the aux entries. This must be done in a separate pass,
1931 because we don't know the correct symbol indices until we have
1932 already decided which symbols we are going to keep. */
1933 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1934 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1935 isymp = finfo->internal_syms;
1936 indexp = finfo->sym_indices;
1937 sym_hash = obj_coff_sym_hashes (input_bfd);
1938 outsym = finfo->outsyms;
1940 while (esym < esym_end)
1944 add = 1 + isymp->n_numaux;
1947 || (bfd_size_type) *indexp < syment_base)
1948 && (*sym_hash == NULL
1949 || (*sym_hash)->auxbfd != input_bfd))
1950 esym += add * isymesz;
1953 struct coff_link_hash_entry *h;
1961 /* The m68k-motorola-sysv assembler will sometimes
1962 generate two symbols with the same name, but only one
1963 will have aux entries. */
1964 BFD_ASSERT (isymp->n_numaux == 0
1966 || h->numaux == isymp->n_numaux);
1974 /* Handle the aux entries. This handling is based on
1975 coff_pointerize_aux. I don't know if it always correct. */
1976 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1978 union internal_auxent aux;
1979 union internal_auxent *auxp;
1981 if (h != NULL && h->aux != NULL && (h->numaux > i))
1985 bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
1986 isymp->n_sclass, i, isymp->n_numaux, &aux);
1990 if (isymp->n_sclass == C_FILE)
1992 /* If this is a long filename, we must put it in the
1994 if (auxp->x_file.x_n.x_zeroes == 0
1995 && auxp->x_file.x_n.x_offset != 0)
1997 const char *filename;
2000 BFD_ASSERT (auxp->x_file.x_n.x_offset
2001 >= STRING_SIZE_SIZE);
2002 if (strings == NULL)
2004 strings = _bfd_coff_read_string_table (input_bfd);
2005 if (strings == NULL)
2008 filename = strings + auxp->x_file.x_n.x_offset;
2009 indx = _bfd_stringtab_add (finfo->strtab, filename,
2011 if (indx == (bfd_size_type) -1)
2013 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
2016 else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
2017 && isymp->n_sclass != C_NT_WEAK)
2021 if (ISFCN (isymp->n_type)
2022 || ISTAG (isymp->n_sclass)
2023 || isymp->n_sclass == C_BLOCK
2024 || isymp->n_sclass == C_FCN)
2026 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
2028 && indx < obj_raw_syment_count (input_bfd))
2030 /* We look forward through the symbol for
2031 the index of the next symbol we are going
2032 to include. I don't know if this is
2034 while ((finfo->sym_indices[indx] < 0
2035 || ((bfd_size_type) finfo->sym_indices[indx]
2037 && indx < obj_raw_syment_count (input_bfd))
2039 if (indx >= obj_raw_syment_count (input_bfd))
2040 indx = output_index;
2042 indx = finfo->sym_indices[indx];
2043 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2047 indx = auxp->x_sym.x_tagndx.l;
2048 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2052 symindx = finfo->sym_indices[indx];
2054 auxp->x_sym.x_tagndx.l = 0;
2056 auxp->x_sym.x_tagndx.l = symindx;
2059 /* The .bf symbols are supposed to be linked through
2060 the endndx field. We need to carry this list
2061 across object files. */
2064 && isymp->n_sclass == C_FCN
2065 && (isymp->_n._n_n._n_zeroes != 0
2066 || isymp->_n._n_n._n_offset == 0)
2067 && isymp->_n._n_name[0] == '.'
2068 && isymp->_n._n_name[1] == 'b'
2069 && isymp->_n._n_name[2] == 'f'
2070 && isymp->_n._n_name[3] == '\0')
2072 if (finfo->last_bf_index != -1)
2074 finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2077 if ((bfd_size_type) finfo->last_bf_index
2082 /* The last .bf symbol is in this input
2083 file. This will only happen if the
2084 assembler did not set up the .bf
2085 endndx symbols correctly. */
2086 auxout = (finfo->outsyms
2087 + ((finfo->last_bf_index
2091 bfd_coff_swap_aux_out (output_bfd,
2102 /* We have already written out the last
2103 .bf aux entry. We need to write it
2104 out again. We borrow *outsym
2105 temporarily. FIXME: This case should
2107 bfd_coff_swap_aux_out (output_bfd,
2113 pos = obj_sym_filepos (output_bfd);
2114 pos += finfo->last_bf_index * osymesz;
2115 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2116 || (bfd_bwrite (outsym, osymesz, output_bfd)
2122 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2123 finfo->last_bf_index = -1;
2126 /* The endndx field of this aux entry must
2127 be updated with the symbol number of the
2129 finfo->last_bf = *auxp;
2130 finfo->last_bf_index = (((outsym - finfo->outsyms)
2139 bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2140 isymp->n_sclass, i, isymp->n_numaux,
2154 /* Relocate the line numbers, unless we are stripping them. */
2155 if (finfo->info->strip == strip_none
2156 || finfo->info->strip == strip_some)
2158 for (o = input_bfd->sections; o != NULL; o = o->next)
2164 bfd_boolean skipping;
2168 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2169 build_link_order in ldwrite.c will not have created a
2170 link order, which means that we will not have seen this
2171 input section in _bfd_coff_final_link, which means that
2172 we will not have allocated space for the line numbers of
2173 this section. I don't think line numbers can be
2174 meaningful for a section which does not have
2175 SEC_HAS_CONTENTS set, but, if they do, this must be
2177 if (o->lineno_count == 0
2178 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2181 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2182 || bfd_bread (finfo->linenos, linesz * o->lineno_count,
2183 input_bfd) != linesz * o->lineno_count)
2186 offset = o->output_section->vma + o->output_offset - o->vma;
2187 eline = finfo->linenos;
2188 oeline = finfo->linenos;
2189 elineend = eline + linesz * o->lineno_count;
2191 for (; eline < elineend; eline += linesz)
2193 struct internal_lineno iline;
2195 bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2197 if (iline.l_lnno != 0)
2198 iline.l_addr.l_paddr += offset;
2199 else if (iline.l_addr.l_symndx >= 0
2200 && ((unsigned long) iline.l_addr.l_symndx
2201 < obj_raw_syment_count (input_bfd)))
2205 indx = finfo->sym_indices[iline.l_addr.l_symndx];
2209 /* These line numbers are attached to a symbol
2210 which we are stripping. We must discard the
2211 line numbers because reading them back with
2212 no associated symbol (or associating them all
2213 with symbol #0) will fail. We can't regain
2214 the space in the output file, but at least
2220 struct internal_syment is;
2221 union internal_auxent ia;
2223 /* Fix up the lnnoptr field in the aux entry of
2224 the symbol. It turns out that we can't do
2225 this when we modify the symbol aux entries,
2226 because gas sometimes screws up the lnnoptr
2227 field and makes it an offset from the start
2228 of the line numbers rather than an absolute
2230 bfd_coff_swap_sym_in (output_bfd,
2232 + ((indx - syment_base)
2234 if ((ISFCN (is.n_type)
2235 || is.n_sclass == C_BLOCK)
2236 && is.n_numaux >= 1)
2240 auxptr = (finfo->outsyms
2241 + ((indx - syment_base + 1)
2243 bfd_coff_swap_aux_in (output_bfd, auxptr,
2244 is.n_type, is.n_sclass,
2245 0, is.n_numaux, &ia);
2246 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2247 (o->output_section->line_filepos
2248 + o->output_section->lineno_count * linesz
2249 + eline - finfo->linenos);
2250 bfd_coff_swap_aux_out (output_bfd, &ia,
2251 is.n_type, is.n_sclass, 0,
2252 is.n_numaux, auxptr);
2258 iline.l_addr.l_symndx = indx;
2263 bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2268 pos = o->output_section->line_filepos;
2269 pos += o->output_section->lineno_count * linesz;
2270 amt = oeline - finfo->linenos;
2271 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2272 || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
2275 o->output_section->lineno_count += amt / linesz;
2279 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2280 symbol will be the first symbol in the next input file. In the
2281 normal case, this will save us from writing out the C_FILE symbol
2283 if (finfo->last_file_index != -1
2284 && (bfd_size_type) finfo->last_file_index >= syment_base)
2286 finfo->last_file.n_value = output_index;
2287 bfd_coff_swap_sym_out (output_bfd, &finfo->last_file,
2289 + ((finfo->last_file_index - syment_base)
2293 /* Write the modified symbols to the output file. */
2294 if (outsym > finfo->outsyms)
2299 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2300 amt = outsym - finfo->outsyms;
2301 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2302 || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
2305 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2306 + (outsym - finfo->outsyms) / osymesz)
2309 obj_raw_syment_count (output_bfd) = output_index;
2312 /* Relocate the contents of each section. */
2313 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2314 for (o = input_bfd->sections; o != NULL; o = o->next)
2317 struct coff_section_tdata *secdata;
2319 if (! o->linker_mark)
2320 /* This section was omitted from the link. */
2323 if ((o->flags & SEC_LINKER_CREATED) != 0)
2326 if ((o->flags & SEC_HAS_CONTENTS) == 0
2327 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
2329 if ((o->flags & SEC_RELOC) != 0
2330 && o->reloc_count != 0)
2332 (*_bfd_error_handler)
2333 (_("%B: relocs in section `%A', but it has no contents"),
2335 bfd_set_error (bfd_error_no_contents);
2342 secdata = coff_section_data (input_bfd, o);
2343 if (secdata != NULL && secdata->contents != NULL)
2344 contents = secdata->contents;
2347 bfd_size_type x = o->rawsize ? o->rawsize : o->size;
2348 if (! bfd_get_section_contents (input_bfd, o, finfo->contents, 0, x))
2350 contents = finfo->contents;
2353 if ((o->flags & SEC_RELOC) != 0)
2356 struct internal_reloc *internal_relocs;
2357 struct internal_reloc *irel;
2359 /* Read in the relocs. */
2360 target_index = o->output_section->target_index;
2361 internal_relocs = (_bfd_coff_read_internal_relocs
2362 (input_bfd, o, FALSE, finfo->external_relocs,
2363 finfo->info->relocatable,
2364 (finfo->info->relocatable
2365 ? (finfo->section_info[target_index].relocs
2366 + o->output_section->reloc_count)
2367 : finfo->internal_relocs)));
2368 if (internal_relocs == NULL)
2371 /* Run through the relocs looking for relocs against symbols
2372 coming from discarded sections and complain about them. */
2373 irel = internal_relocs;
2374 for (; irel < &internal_relocs[o->reloc_count]; irel++)
2376 struct coff_link_hash_entry *h;
2377 asection *ps = NULL;
2378 long symndx = irel->r_symndx;
2381 h = obj_coff_sym_hashes (input_bfd)[symndx];
2384 while (h->root.type == bfd_link_hash_indirect
2385 || h->root.type == bfd_link_hash_warning)
2386 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2387 if (h->root.type == bfd_link_hash_defined
2388 || h->root.type == bfd_link_hash_defweak)
2389 ps = h->root.u.def.section;
2392 /* Complain if definition comes from an excluded section. */
2393 if (ps->flags & SEC_EXCLUDE)
2394 (*finfo->info->callbacks->einfo)
2395 (_("%X`%s' referenced in section `%A' of %B: "
2396 "defined in discarded section `%A' of %B\n"),
2397 h->root.root.string, o, input_bfd, ps, ps->owner);
2400 /* Call processor specific code to relocate the section
2402 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2406 finfo->internal_syms,
2410 if (finfo->info->relocatable)
2413 struct internal_reloc *irelend;
2414 struct coff_link_hash_entry **rel_hash;
2416 offset = o->output_section->vma + o->output_offset - o->vma;
2417 irel = internal_relocs;
2418 irelend = irel + o->reloc_count;
2419 rel_hash = (finfo->section_info[target_index].rel_hashes
2420 + o->output_section->reloc_count);
2421 for (; irel < irelend; irel++, rel_hash++)
2423 struct coff_link_hash_entry *h;
2424 bfd_boolean adjusted;
2428 /* Adjust the reloc address and symbol index. */
2429 irel->r_vaddr += offset;
2431 if (irel->r_symndx == -1)
2436 if (! (*adjust_symndx) (output_bfd, finfo->info,
2444 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2447 /* This is a global symbol. */
2449 irel->r_symndx = h->indx;
2452 /* This symbol is being written at the end
2453 of the file, and we do not yet know the
2454 symbol index. We save the pointer to the
2455 hash table entry in the rel_hash list.
2456 We set the indx field to -2 to indicate
2457 that this symbol must not be stripped. */
2466 indx = finfo->sym_indices[irel->r_symndx];
2468 irel->r_symndx = indx;
2471 struct internal_syment *is;
2473 char buf[SYMNMLEN + 1];
2475 /* This reloc is against a symbol we are
2476 stripping. This should have been handled
2477 by the 'dont_skip_symbol' code in the while
2478 loop at the top of this function. */
2479 is = finfo->internal_syms + irel->r_symndx;
2481 name = (_bfd_coff_internal_syment_name
2482 (input_bfd, is, buf));
2486 if (! ((*finfo->info->callbacks->unattached_reloc)
2487 (finfo->info, name, input_bfd, o,
2494 o->output_section->reloc_count += o->reloc_count;
2498 /* Write out the modified section contents. */
2499 if (secdata == NULL || secdata->stab_info == NULL)
2501 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2502 if (! bfd_set_section_contents (output_bfd, o->output_section,
2503 contents, loc, o->size))
2508 if (! (_bfd_write_section_stabs
2509 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2510 o, &secdata->stab_info, contents)))
2515 if (! finfo->info->keep_memory
2516 && ! _bfd_coff_free_symbols (input_bfd))
2522 /* Write out a global symbol. Called via bfd_hash_traverse. */
2525 _bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)
2527 struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;
2528 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2530 struct internal_syment isym;
2531 bfd_size_type symesz;
2535 output_bfd = finfo->output_bfd;
2537 if (h->root.type == bfd_link_hash_warning)
2539 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2540 if (h->root.type == bfd_link_hash_new)
2548 && (finfo->info->strip == strip_all
2549 || (finfo->info->strip == strip_some
2550 && (bfd_hash_lookup (finfo->info->keep_hash,
2551 h->root.root.string, FALSE, FALSE)
2555 switch (h->root.type)
2558 case bfd_link_hash_new:
2559 case bfd_link_hash_warning:
2563 case bfd_link_hash_undefined:
2564 case bfd_link_hash_undefweak:
2565 isym.n_scnum = N_UNDEF;
2569 case bfd_link_hash_defined:
2570 case bfd_link_hash_defweak:
2574 sec = h->root.u.def.section->output_section;
2575 if (bfd_is_abs_section (sec))
2576 isym.n_scnum = N_ABS;
2578 isym.n_scnum = sec->target_index;
2579 isym.n_value = (h->root.u.def.value
2580 + h->root.u.def.section->output_offset);
2581 if (! obj_pe (finfo->output_bfd))
2582 isym.n_value += sec->vma;
2586 case bfd_link_hash_common:
2587 isym.n_scnum = N_UNDEF;
2588 isym.n_value = h->root.u.c.size;
2591 case bfd_link_hash_indirect:
2592 /* Just ignore these. They can't be handled anyhow. */
2596 if (strlen (h->root.root.string) <= SYMNMLEN)
2597 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2604 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2606 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2608 if (indx == (bfd_size_type) -1)
2610 finfo->failed = TRUE;
2613 isym._n._n_n._n_zeroes = 0;
2614 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2617 isym.n_sclass = h->symbol_class;
2618 isym.n_type = h->type;
2620 if (isym.n_sclass == C_NULL)
2621 isym.n_sclass = C_EXT;
2623 /* If doing task linking and this is the pass where we convert
2624 defined globals to statics, then do that conversion now. If the
2625 symbol is not being converted, just ignore it and it will be
2626 output during a later pass. */
2627 if (finfo->global_to_static)
2629 if (! IS_EXTERNAL (output_bfd, isym))
2632 isym.n_sclass = C_STAT;
2635 /* When a weak symbol is not overridden by a strong one,
2636 turn it into an external symbol when not building a
2637 shared or relocatable object. */
2638 if (! finfo->info->shared
2639 && ! finfo->info->relocatable
2640 && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
2641 isym.n_sclass = C_EXT;
2643 isym.n_numaux = h->numaux;
2645 bfd_coff_swap_sym_out (output_bfd, &isym, finfo->outsyms);
2647 symesz = bfd_coff_symesz (output_bfd);
2649 pos = obj_sym_filepos (output_bfd);
2650 pos += obj_raw_syment_count (output_bfd) * symesz;
2651 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2652 || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2654 finfo->failed = TRUE;
2658 h->indx = obj_raw_syment_count (output_bfd);
2660 ++obj_raw_syment_count (output_bfd);
2662 /* Write out any associated aux entries. Most of the aux entries
2663 will have been modified in _bfd_coff_link_input_bfd. We have to
2664 handle section aux entries here, now that we have the final
2665 relocation and line number counts. */
2666 for (i = 0; i < isym.n_numaux; i++)
2668 union internal_auxent *auxp;
2672 /* Look for a section aux entry here using the same tests that
2673 coff_swap_aux_out uses. */
2675 && (isym.n_sclass == C_STAT
2676 || isym.n_sclass == C_HIDDEN)
2677 && isym.n_type == T_NULL
2678 && (h->root.type == bfd_link_hash_defined
2679 || h->root.type == bfd_link_hash_defweak))
2683 sec = h->root.u.def.section->output_section;
2686 auxp->x_scn.x_scnlen = sec->size;
2688 /* For PE, an overflow on the final link reportedly does
2689 not matter. FIXME: Why not? */
2690 if (sec->reloc_count > 0xffff
2691 && (! obj_pe (output_bfd)
2692 || finfo->info->relocatable))
2693 (*_bfd_error_handler)
2694 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2695 bfd_get_filename (output_bfd),
2696 bfd_get_section_name (output_bfd, sec),
2699 if (sec->lineno_count > 0xffff
2700 && (! obj_pe (output_bfd)
2701 || finfo->info->relocatable))
2702 (*_bfd_error_handler)
2703 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2704 bfd_get_filename (output_bfd),
2705 bfd_get_section_name (output_bfd, sec),
2708 auxp->x_scn.x_nreloc = sec->reloc_count;
2709 auxp->x_scn.x_nlinno = sec->lineno_count;
2710 auxp->x_scn.x_checksum = 0;
2711 auxp->x_scn.x_associated = 0;
2712 auxp->x_scn.x_comdat = 0;
2716 bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2717 isym.n_sclass, (int) i, isym.n_numaux,
2719 if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2721 finfo->failed = TRUE;
2724 ++obj_raw_syment_count (output_bfd);
2730 /* Write out task global symbols, converting them to statics. Called
2731 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2732 the dirty work, if the symbol we are processing needs conversion. */
2735 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2737 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2738 bfd_boolean rtnval = TRUE;
2739 bfd_boolean save_global_to_static;
2741 if (h->root.type == bfd_link_hash_warning)
2742 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2746 switch (h->root.type)
2748 case bfd_link_hash_defined:
2749 case bfd_link_hash_defweak:
2750 save_global_to_static = finfo->global_to_static;
2751 finfo->global_to_static = TRUE;
2752 rtnval = _bfd_coff_write_global_sym (&h->root.root, data);
2753 finfo->global_to_static = save_global_to_static;
2762 /* Handle a link order which is supposed to generate a reloc. */
2765 _bfd_coff_reloc_link_order (bfd *output_bfd,
2766 struct coff_final_link_info *finfo,
2767 asection *output_section,
2768 struct bfd_link_order *link_order)
2770 reloc_howto_type *howto;
2771 struct internal_reloc *irel;
2772 struct coff_link_hash_entry **rel_hash_ptr;
2774 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2777 bfd_set_error (bfd_error_bad_value);
2781 if (link_order->u.reloc.p->addend != 0)
2785 bfd_reloc_status_type rstat;
2789 size = bfd_get_reloc_size (howto);
2790 buf = (bfd_byte *) bfd_zmalloc (size);
2794 rstat = _bfd_relocate_contents (howto, output_bfd,
2795 (bfd_vma) link_order->u.reloc.p->addend,\
2802 case bfd_reloc_outofrange:
2804 case bfd_reloc_overflow:
2805 if (! ((*finfo->info->callbacks->reloc_overflow)
2807 (link_order->type == bfd_section_reloc_link_order
2808 ? bfd_section_name (output_bfd,
2809 link_order->u.reloc.p->u.section)
2810 : link_order->u.reloc.p->u.name),
2811 howto->name, link_order->u.reloc.p->addend,
2812 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2819 loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2820 ok = bfd_set_section_contents (output_bfd, output_section, buf,
2827 /* Store the reloc information in the right place. It will get
2828 swapped and written out at the end of the final_link routine. */
2829 irel = (finfo->section_info[output_section->target_index].relocs
2830 + output_section->reloc_count);
2831 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2832 + output_section->reloc_count);
2834 memset (irel, 0, sizeof (struct internal_reloc));
2835 *rel_hash_ptr = NULL;
2837 irel->r_vaddr = output_section->vma + link_order->offset;
2839 if (link_order->type == bfd_section_reloc_link_order)
2841 /* We need to somehow locate a symbol in the right section. The
2842 symbol must either have a value of zero, or we must adjust
2843 the addend by the value of the symbol. FIXME: Write this
2844 when we need it. The old linker couldn't handle this anyhow. */
2846 *rel_hash_ptr = NULL;
2851 struct coff_link_hash_entry *h;
2853 h = ((struct coff_link_hash_entry *)
2854 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2855 link_order->u.reloc.p->u.name,
2856 FALSE, FALSE, TRUE));
2860 irel->r_symndx = h->indx;
2863 /* Set the index to -2 to force this symbol to get
2872 if (! ((*finfo->info->callbacks->unattached_reloc)
2873 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2874 (asection *) NULL, (bfd_vma) 0)))
2880 /* FIXME: Is this always right? */
2881 irel->r_type = howto->type;
2883 /* r_size is only used on the RS/6000, which needs its own linker
2884 routines anyhow. r_extern is only used for ECOFF. */
2886 /* FIXME: What is the right value for r_offset? Is zero OK? */
2887 ++output_section->reloc_count;
2892 /* A basic reloc handling routine which may be used by processors with
2896 _bfd_coff_generic_relocate_section (bfd *output_bfd,
2897 struct bfd_link_info *info,
2899 asection *input_section,
2901 struct internal_reloc *relocs,
2902 struct internal_syment *syms,
2903 asection **sections)
2905 struct internal_reloc *rel;
2906 struct internal_reloc *relend;
2909 relend = rel + input_section->reloc_count;
2910 for (; rel < relend; rel++)
2913 struct coff_link_hash_entry *h;
2914 struct internal_syment *sym;
2917 reloc_howto_type *howto;
2918 bfd_reloc_status_type rstat;
2920 symndx = rel->r_symndx;
2928 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2930 (*_bfd_error_handler)
2931 ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
2936 h = obj_coff_sym_hashes (input_bfd)[symndx];
2937 sym = syms + symndx;
2940 /* COFF treats common symbols in one of two ways. Either the
2941 size of the symbol is included in the section contents, or it
2942 is not. We assume that the size is not included, and force
2943 the rtype_to_howto function to adjust the addend as needed. */
2944 if (sym != NULL && sym->n_scnum != 0)
2945 addend = - sym->n_value;
2949 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2954 /* If we are doing a relocatable link, then we can just ignore
2955 a PC relative reloc that is pcrel_offset. It will already
2956 have the correct value. If this is not a relocatable link,
2957 then we should ignore the symbol value. */
2958 if (howto->pc_relative && howto->pcrel_offset)
2960 if (info->relocatable)
2962 if (sym != NULL && sym->n_scnum != 0)
2963 addend += sym->n_value;
2974 sec = bfd_abs_section_ptr;
2979 sec = sections[symndx];
2980 val = (sec->output_section->vma
2981 + sec->output_offset
2983 if (! obj_pe (input_bfd))
2989 if (h->root.type == bfd_link_hash_defined
2990 || h->root.type == bfd_link_hash_defweak)
2992 /* Defined weak symbols are a GNU extension. */
2995 sec = h->root.u.def.section;
2996 val = (h->root.u.def.value
2997 + sec->output_section->vma
2998 + sec->output_offset);
3001 else if (h->root.type == bfd_link_hash_undefweak)
3003 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
3005 /* See _Microsoft Portable Executable and Common Object
3006 File Format Specification_, section 5.5.3.
3007 Note that weak symbols without aux records are a GNU
3009 FIXME: All weak externals are treated as having
3010 characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
3011 These behave as per SVR4 ABI: A library member
3012 will resolve a weak external only if a normal
3013 external causes the library member to be linked.
3014 See also linker.c: generic_link_check_archive_element. */
3016 struct coff_link_hash_entry *h2 =
3017 h->auxbfd->tdata.coff_obj_data->sym_hashes[
3018 h->aux->x_sym.x_tagndx.l];
3020 if (!h2 || h2->root.type == bfd_link_hash_undefined)
3022 sec = bfd_abs_section_ptr;
3027 sec = h2->root.u.def.section;
3028 val = h2->root.u.def.value
3029 + sec->output_section->vma + sec->output_offset;
3033 /* This is a GNU extension. */
3037 else if (! info->relocatable)
3039 if (! ((*info->callbacks->undefined_symbol)
3040 (info, h->root.root.string, input_bfd, input_section,
3041 rel->r_vaddr - input_section->vma, TRUE)))
3046 if (info->base_file)
3048 /* Emit a reloc if the backend thinks it needs it. */
3049 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
3051 /* Relocation to a symbol in a section which isn't
3052 absolute. We output the address here to a file.
3053 This file is then read by dlltool when generating the
3054 reloc section. Note that the base file is not
3055 portable between systems. We write out a bfd_vma here,
3056 and dlltool reads in a bfd_vma. */
3057 bfd_vma addr = (rel->r_vaddr
3058 - input_section->vma
3059 + input_section->output_offset
3060 + input_section->output_section->vma);
3061 if (coff_data (output_bfd)->pe)
3062 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
3063 if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)
3064 != sizeof (bfd_vma))
3066 bfd_set_error (bfd_error_system_call);
3072 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3074 rel->r_vaddr - input_section->vma,
3083 case bfd_reloc_outofrange:
3084 (*_bfd_error_handler)
3085 (_("%B: bad reloc address 0x%lx in section `%A'"),
3086 input_bfd, input_section, (unsigned long) rel->r_vaddr);
3088 case bfd_reloc_overflow:
3091 char buf[SYMNMLEN + 1];
3099 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3104 if (! ((*info->callbacks->reloc_overflow)
3105 (info, (h ? &h->root : NULL), name, howto->name,
3106 (bfd_vma) 0, input_bfd, input_section,
3107 rel->r_vaddr - input_section->vma)))