1 /* COFF specific linker code.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* This file contains the COFF backend linker code. */
28 #include "coff/internal.h"
31 static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info);
32 static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded);
33 static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info);
35 /* Return TRUE if SYM is a weak, external symbol. */
36 #define IS_WEAK_EXTERNAL(abfd, sym) \
37 ((sym).n_sclass == C_WEAKEXT \
38 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
40 /* Return TRUE if SYM is an external symbol. */
41 #define IS_EXTERNAL(abfd, sym) \
42 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
44 /* Define macros so that the ISFCN, et. al., macros work correctly.
45 These macros are defined in include/coff/internal.h in terms of
46 N_TMASK, etc. These definitions require a user to define local
47 variables with the appropriate names, and with values from the
48 coff_data (abfd) structure. */
50 #define N_TMASK n_tmask
51 #define N_BTSHFT n_btshft
52 #define N_BTMASK n_btmask
54 /* Create an entry in a COFF linker hash table. */
56 struct bfd_hash_entry *
57 _bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
58 struct bfd_hash_table *table,
61 struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
63 /* Allocate the structure if it has not already been allocated by a
65 if (ret == (struct coff_link_hash_entry *) NULL)
66 ret = ((struct coff_link_hash_entry *)
67 bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
68 if (ret == (struct coff_link_hash_entry *) NULL)
69 return (struct bfd_hash_entry *) ret;
71 /* Call the allocation method of the superclass. */
72 ret = ((struct coff_link_hash_entry *)
73 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
75 if (ret != (struct coff_link_hash_entry *) NULL)
77 /* Set local fields. */
86 return (struct bfd_hash_entry *) ret;
89 /* Initialize a COFF linker hash table. */
92 _bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
94 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
95 struct bfd_hash_table *,
98 table->stab_info = NULL;
99 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
102 /* Create a COFF linker hash table. */
104 struct bfd_link_hash_table *
105 _bfd_coff_link_hash_table_create (bfd *abfd)
107 struct coff_link_hash_table *ret;
108 bfd_size_type amt = sizeof (struct coff_link_hash_table);
110 ret = bfd_malloc (amt);
114 if (! _bfd_coff_link_hash_table_init (ret, abfd,
115 _bfd_coff_link_hash_newfunc))
118 return (struct bfd_link_hash_table *) NULL;
123 /* Create an entry in a COFF debug merge hash table. */
125 struct bfd_hash_entry *
126 _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,
127 struct bfd_hash_table *table,
130 struct coff_debug_merge_hash_entry *ret =
131 (struct coff_debug_merge_hash_entry *) entry;
133 /* Allocate the structure if it has not already been allocated by a
135 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
136 ret = ((struct coff_debug_merge_hash_entry *)
137 bfd_hash_allocate (table,
138 sizeof (struct coff_debug_merge_hash_entry)));
139 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
140 return (struct bfd_hash_entry *) ret;
142 /* Call the allocation method of the superclass. */
143 ret = ((struct coff_debug_merge_hash_entry *)
144 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
145 if (ret != (struct coff_debug_merge_hash_entry *) NULL)
147 /* Set local fields. */
151 return (struct bfd_hash_entry *) ret;
154 /* Given a COFF BFD, add symbols to the global hash table as
158 _bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
160 switch (bfd_get_format (abfd))
163 return coff_link_add_object_symbols (abfd, info);
165 return _bfd_generic_link_add_archive_symbols
166 (abfd, info, coff_link_check_archive_element);
168 bfd_set_error (bfd_error_wrong_format);
173 /* Add symbols from a COFF object file. */
176 coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
178 if (! _bfd_coff_get_external_symbols (abfd))
180 if (! coff_link_add_symbols (abfd, info))
183 if (! info->keep_memory
184 && ! _bfd_coff_free_symbols (abfd))
190 /* Look through the symbols to see if this object file should be
191 included in the link. */
194 coff_link_check_ar_symbols (bfd *abfd,
195 struct bfd_link_info *info,
196 bfd_boolean *pneeded)
198 bfd_size_type symesz;
204 symesz = bfd_coff_symesz (abfd);
205 esym = (bfd_byte *) obj_coff_external_syms (abfd);
206 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
207 while (esym < esym_end)
209 struct internal_syment sym;
210 enum coff_symbol_classification classification;
212 bfd_coff_swap_sym_in (abfd, esym, &sym);
214 classification = bfd_coff_classify_symbol (abfd, &sym);
215 if (classification == COFF_SYMBOL_GLOBAL
216 || classification == COFF_SYMBOL_COMMON)
219 char buf[SYMNMLEN + 1];
220 struct bfd_link_hash_entry *h;
222 /* This symbol is externally visible, and is defined by this
224 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
227 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
231 && info->pei386_auto_import
232 && !strncmp (name,"__imp_", 6))
233 h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
235 /* We are only interested in symbols that are currently
236 undefined. If a symbol is currently known to be common,
237 COFF linkers do not bring in an object file which defines
239 if (h != (struct bfd_link_hash_entry *) NULL
240 && h->type == bfd_link_hash_undefined)
242 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
249 esym += (sym.n_numaux + 1) * symesz;
252 /* We do not need this object file. */
256 /* Check a single archive element to see if we need to include it in
257 the link. *PNEEDED is set according to whether this element is
258 needed in the link or not. This is called via
259 _bfd_generic_link_add_archive_symbols. */
262 coff_link_check_archive_element (bfd *abfd,
263 struct bfd_link_info *info,
264 bfd_boolean *pneeded)
266 if (! _bfd_coff_get_external_symbols (abfd))
269 if (! coff_link_check_ar_symbols (abfd, info, pneeded))
273 && ! coff_link_add_symbols (abfd, info))
276 if ((! info->keep_memory || ! *pneeded)
277 && ! _bfd_coff_free_symbols (abfd))
283 /* Add all the symbols from an object file to the hash table. */
286 coff_link_add_symbols (bfd *abfd,
287 struct bfd_link_info *info)
289 unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
290 unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
291 unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
292 bfd_boolean keep_syms;
293 bfd_boolean default_copy;
294 bfd_size_type symcount;
295 struct coff_link_hash_entry **sym_hash;
296 bfd_size_type symesz;
301 /* Keep the symbols during this function, in case the linker needs
302 to read the generic symbols in order to report an error message. */
303 keep_syms = obj_coff_keep_syms (abfd);
304 obj_coff_keep_syms (abfd) = TRUE;
306 if (info->keep_memory)
307 default_copy = FALSE;
311 symcount = obj_raw_syment_count (abfd);
313 /* We keep a list of the linker hash table entries that correspond
314 to particular symbols. */
315 amt = symcount * sizeof (struct coff_link_hash_entry *);
316 sym_hash = bfd_zalloc (abfd, amt);
317 if (sym_hash == NULL && symcount != 0)
319 obj_coff_sym_hashes (abfd) = sym_hash;
321 symesz = bfd_coff_symesz (abfd);
322 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
323 esym = (bfd_byte *) obj_coff_external_syms (abfd);
324 esym_end = esym + symcount * symesz;
325 while (esym < esym_end)
327 struct internal_syment sym;
328 enum coff_symbol_classification classification;
331 bfd_coff_swap_sym_in (abfd, esym, &sym);
333 classification = bfd_coff_classify_symbol (abfd, &sym);
334 if (classification != COFF_SYMBOL_LOCAL)
337 char buf[SYMNMLEN + 1];
343 /* This symbol is externally visible. */
345 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
349 /* We must copy the name into memory if we got it from the
350 syment itself, rather than the string table. */
352 if (sym._n._n_n._n_zeroes != 0
353 || sym._n._n_n._n_offset == 0)
358 switch (classification)
363 case COFF_SYMBOL_GLOBAL:
364 flags = BSF_EXPORT | BSF_GLOBAL;
365 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
367 value -= section->vma;
370 case COFF_SYMBOL_UNDEFINED:
372 section = bfd_und_section_ptr;
375 case COFF_SYMBOL_COMMON:
377 section = bfd_com_section_ptr;
380 case COFF_SYMBOL_PE_SECTION:
381 flags = BSF_SECTION_SYM | BSF_GLOBAL;
382 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
386 if (IS_WEAK_EXTERNAL (abfd, sym))
391 /* In the PE format, section symbols actually refer to the
392 start of the output section. We handle them specially
394 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
396 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
397 name, FALSE, copy, FALSE);
398 if (*sym_hash != NULL)
400 if (((*sym_hash)->coff_link_hash_flags
401 & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
402 && (*sym_hash)->root.type != bfd_link_hash_undefined
403 && (*sym_hash)->root.type != bfd_link_hash_undefweak)
404 (*_bfd_error_handler)
405 ("Warning: symbol `%s' is both section and non-section",
412 /* The Microsoft Visual C compiler does string pooling by
413 hashing the constants to an internal symbol name, and
414 relying on the linker comdat support to discard
415 duplicate names. However, if one string is a literal and
416 one is a data initializer, one will end up in the .data
417 section and one will end up in the .rdata section. The
418 Microsoft linker will combine them into the .data
419 section, which seems to be wrong since it might cause the
422 As long as there are no external references to the
423 symbols, which there shouldn't be, we can treat the .data
424 and .rdata instances as separate symbols. The comdat
425 code in the linker will do the appropriate merging. Here
426 we avoid getting a multiple definition error for one of
427 these special symbols.
429 FIXME: I don't think this will work in the case where
430 there are two object files which use the constants as a
431 literal and two object files which use it as a data
432 initializer. One or the other of the second object files
433 is going to wind up with an inappropriate reference. */
435 && (classification == COFF_SYMBOL_GLOBAL
436 || classification == COFF_SYMBOL_PE_SECTION)
437 && section->comdat != NULL
438 && strncmp (name, "??_", 3) == 0
439 && strcmp (name, section->comdat->name) == 0)
441 if (*sym_hash == NULL)
442 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
443 name, FALSE, copy, FALSE);
444 if (*sym_hash != NULL
445 && (*sym_hash)->root.type == bfd_link_hash_defined
446 && (*sym_hash)->root.u.def.section->comdat != NULL
447 && strcmp ((*sym_hash)->root.u.def.section->comdat->name,
448 section->comdat->name) == 0)
454 if (! (bfd_coff_link_add_one_symbol
455 (info, abfd, name, flags, section, value,
456 (const char *) NULL, copy, FALSE,
457 (struct bfd_link_hash_entry **) sym_hash)))
461 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
462 (*sym_hash)->coff_link_hash_flags |=
463 COFF_LINK_HASH_PE_SECTION_SYMBOL;
465 /* Limit the alignment of a common symbol to the possible
466 alignment of a section. There is no point to permitting
467 a higher alignment for a common symbol: we can not
468 guarantee it, and it may cause us to allocate extra space
469 in the common section. */
470 if (section == bfd_com_section_ptr
471 && (*sym_hash)->root.type == bfd_link_hash_common
472 && ((*sym_hash)->root.u.c.p->alignment_power
473 > bfd_coff_default_section_alignment_power (abfd)))
474 (*sym_hash)->root.u.c.p->alignment_power
475 = bfd_coff_default_section_alignment_power (abfd);
477 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
479 /* If we don't have any symbol information currently in
480 the hash table, or if we are looking at a symbol
481 definition, then update the symbol class and type in
483 if (((*sym_hash)->class == C_NULL
484 && (*sym_hash)->type == T_NULL)
487 && (*sym_hash)->root.type != bfd_link_hash_defined
488 && (*sym_hash)->root.type != bfd_link_hash_defweak))
490 (*sym_hash)->class = sym.n_sclass;
491 if (sym.n_type != T_NULL)
493 /* We want to warn if the type changed, but not
494 if it changed from an unspecified type.
495 Testing the whole type byte may work, but the
496 change from (e.g.) a function of unspecified
497 type to function of known type also wants to
499 if ((*sym_hash)->type != T_NULL
500 && (*sym_hash)->type != sym.n_type
501 && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
502 && (BTYPE ((*sym_hash)->type) == T_NULL
503 || BTYPE (sym.n_type) == T_NULL)))
504 (*_bfd_error_handler)
505 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
506 name, (*sym_hash)->type, sym.n_type,
507 bfd_archive_filename (abfd));
509 /* We don't want to change from a meaningful
510 base type to a null one, but if we know
511 nothing, take what little we might now know. */
512 if (BTYPE (sym.n_type) != T_NULL
513 || (*sym_hash)->type == T_NULL)
514 (*sym_hash)->type = sym.n_type;
516 (*sym_hash)->auxbfd = abfd;
517 if (sym.n_numaux != 0)
519 union internal_auxent *alloc;
522 union internal_auxent *iaux;
524 (*sym_hash)->numaux = sym.n_numaux;
525 alloc = ((union internal_auxent *)
526 bfd_hash_allocate (&info->hash->table,
528 * sizeof (*alloc))));
531 for (i = 0, eaux = esym + symesz, iaux = alloc;
533 i++, eaux += symesz, iaux++)
534 bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
535 sym.n_sclass, (int) i,
537 (*sym_hash)->aux = alloc;
542 if (classification == COFF_SYMBOL_PE_SECTION
543 && (*sym_hash)->numaux != 0)
545 /* Some PE sections (such as .bss) have a zero size in
546 the section header, but a non-zero size in the AUX
547 record. Correct that here.
549 FIXME: This is not at all the right place to do this.
550 For example, it won't help objdump. This needs to be
551 done when we swap in the section header. */
552 BFD_ASSERT ((*sym_hash)->numaux == 1);
553 if (section->_raw_size == 0)
554 section->_raw_size = (*sym_hash)->aux[0].x_scn.x_scnlen;
556 /* FIXME: We could test whether the section sizes
557 matches the size in the aux entry, but apparently
558 that sometimes fails unexpectedly. */
562 esym += (sym.n_numaux + 1) * symesz;
563 sym_hash += sym.n_numaux + 1;
566 /* If this is a non-traditional, non-relocatable link, try to
567 optimize the handling of any .stab/.stabstr sections. */
568 if (! info->relocatable
569 && ! info->traditional_format
570 && info->hash->creator->flavour == bfd_get_flavour (abfd)
571 && (info->strip != strip_all && info->strip != strip_debugger))
575 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
579 bfd_size_type string_offset = 0;
582 for (stab = abfd->sections; stab; stab = stab->next)
583 if (strncmp (".stab", stab->name, 5) == 0
585 || (stab->name[5] == '.' && isdigit (stab->name[6]))))
587 struct coff_link_hash_table *table;
588 struct coff_section_tdata *secdata
589 = coff_section_data (abfd, stab);
593 amt = sizeof (struct coff_section_tdata);
594 stab->used_by_bfd = bfd_zalloc (abfd, amt);
595 if (stab->used_by_bfd == NULL)
597 secdata = coff_section_data (abfd, stab);
600 table = coff_hash_table (info);
602 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
611 obj_coff_keep_syms (abfd) = keep_syms;
616 obj_coff_keep_syms (abfd) = keep_syms;
620 /* Do the final link step. */
623 _bfd_coff_final_link (bfd *abfd,
624 struct bfd_link_info *info)
626 bfd_size_type symesz;
627 struct coff_final_link_info finfo;
628 bfd_boolean debug_merge_allocated;
629 bfd_boolean long_section_names;
631 struct bfd_link_order *p;
632 bfd_size_type max_sym_count;
633 bfd_size_type max_lineno_count;
634 bfd_size_type max_reloc_count;
635 bfd_size_type max_output_reloc_count;
636 bfd_size_type max_contents_size;
637 file_ptr rel_filepos;
639 file_ptr line_filepos;
642 bfd_byte *external_relocs = NULL;
643 char strbuf[STRING_SIZE_SIZE];
646 symesz = bfd_coff_symesz (abfd);
649 finfo.output_bfd = abfd;
651 finfo.section_info = NULL;
652 finfo.last_file_index = -1;
653 finfo.last_bf_index = -1;
654 finfo.internal_syms = NULL;
655 finfo.sec_ptrs = NULL;
656 finfo.sym_indices = NULL;
657 finfo.outsyms = NULL;
658 finfo.linenos = NULL;
659 finfo.contents = NULL;
660 finfo.external_relocs = NULL;
661 finfo.internal_relocs = NULL;
662 finfo.global_to_static = FALSE;
663 debug_merge_allocated = FALSE;
665 coff_data (abfd)->link_info = info;
667 finfo.strtab = _bfd_stringtab_init ();
668 if (finfo.strtab == NULL)
671 if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
673 debug_merge_allocated = TRUE;
675 /* Compute the file positions for all the sections. */
676 if (! abfd->output_has_begun)
678 if (! bfd_coff_compute_section_file_positions (abfd))
682 /* Count the line numbers and relocation entries required for the
683 output file. Set the file positions for the relocs. */
684 rel_filepos = obj_relocbase (abfd);
685 relsz = bfd_coff_relsz (abfd);
686 max_contents_size = 0;
687 max_lineno_count = 0;
690 long_section_names = FALSE;
691 for (o = abfd->sections; o != NULL; o = o->next)
695 for (p = o->link_order_head; p != NULL; p = p->next)
697 if (p->type == bfd_indirect_link_order)
701 sec = p->u.indirect.section;
703 /* Mark all sections which are to be included in the
704 link. This will normally be every section. We need
705 to do this so that we can identify any sections which
706 the linker has decided to not include. */
707 sec->linker_mark = TRUE;
709 if (info->strip == strip_none
710 || info->strip == strip_some)
711 o->lineno_count += sec->lineno_count;
713 if (info->relocatable)
714 o->reloc_count += sec->reloc_count;
716 if (sec->_raw_size > max_contents_size)
717 max_contents_size = sec->_raw_size;
718 if (sec->lineno_count > max_lineno_count)
719 max_lineno_count = sec->lineno_count;
720 if (sec->reloc_count > max_reloc_count)
721 max_reloc_count = sec->reloc_count;
723 else if (info->relocatable
724 && (p->type == bfd_section_reloc_link_order
725 || p->type == bfd_symbol_reloc_link_order))
728 if (o->reloc_count == 0)
732 o->flags |= SEC_RELOC;
733 o->rel_filepos = rel_filepos;
734 rel_filepos += o->reloc_count * relsz;
735 /* In PE COFF, if there are at least 0xffff relocations an
736 extra relocation will be written out to encode the count. */
737 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
738 rel_filepos += relsz;
741 if (bfd_coff_long_section_names (abfd)
742 && strlen (o->name) > SCNNMLEN)
744 /* This section has a long name which must go in the string
745 table. This must correspond to the code in
746 coff_write_object_contents which puts the string index
747 into the s_name field of the section header. That is why
748 we pass hash as FALSE. */
749 if (_bfd_stringtab_add (finfo.strtab, o->name, FALSE, FALSE)
750 == (bfd_size_type) -1)
752 long_section_names = TRUE;
756 /* If doing a relocatable link, allocate space for the pointers we
758 if (info->relocatable)
762 /* We use section_count + 1, rather than section_count, because
763 the target_index fields are 1 based. */
764 amt = abfd->section_count + 1;
765 amt *= sizeof (struct coff_link_section_info);
766 finfo.section_info = bfd_malloc (amt);
767 if (finfo.section_info == NULL)
769 for (i = 0; i <= abfd->section_count; i++)
771 finfo.section_info[i].relocs = NULL;
772 finfo.section_info[i].rel_hashes = NULL;
776 /* We now know the size of the relocs, so we can determine the file
777 positions of the line numbers. */
778 line_filepos = rel_filepos;
779 linesz = bfd_coff_linesz (abfd);
780 max_output_reloc_count = 0;
781 for (o = abfd->sections; o != NULL; o = o->next)
783 if (o->lineno_count == 0)
787 o->line_filepos = line_filepos;
788 line_filepos += o->lineno_count * linesz;
791 if (o->reloc_count != 0)
793 /* We don't know the indices of global symbols until we have
794 written out all the local symbols. For each section in
795 the output file, we keep an array of pointers to hash
796 table entries. Each entry in the array corresponds to a
797 reloc. When we find a reloc against a global symbol, we
798 set the corresponding entry in this array so that we can
799 fix up the symbol index after we have written out all the
802 Because of this problem, we also keep the relocs in
803 memory until the end of the link. This wastes memory,
804 but only when doing a relocatable link, which is not the
806 BFD_ASSERT (info->relocatable);
807 amt = o->reloc_count;
808 amt *= sizeof (struct internal_reloc);
809 finfo.section_info[o->target_index].relocs = bfd_malloc (amt);
810 amt = o->reloc_count;
811 amt *= sizeof (struct coff_link_hash_entry *);
812 finfo.section_info[o->target_index].rel_hashes = bfd_malloc (amt);
813 if (finfo.section_info[o->target_index].relocs == NULL
814 || finfo.section_info[o->target_index].rel_hashes == NULL)
817 if (o->reloc_count > max_output_reloc_count)
818 max_output_reloc_count = o->reloc_count;
821 /* Reset the reloc and lineno counts, so that we can use them to
822 count the number of entries we have output so far. */
827 obj_sym_filepos (abfd) = line_filepos;
829 /* Figure out the largest number of symbols in an input BFD. Take
830 the opportunity to clear the output_has_begun fields of all the
833 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
837 sub->output_has_begun = FALSE;
838 sz = obj_raw_syment_count (sub);
839 if (sz > max_sym_count)
843 /* Allocate some buffers used while linking. */
844 amt = max_sym_count * sizeof (struct internal_syment);
845 finfo.internal_syms = bfd_malloc (amt);
846 amt = max_sym_count * sizeof (asection *);
847 finfo.sec_ptrs = bfd_malloc (amt);
848 amt = max_sym_count * sizeof (long);
849 finfo.sym_indices = bfd_malloc (amt);
850 finfo.outsyms = bfd_malloc ((max_sym_count + 1) * symesz);
851 amt = max_lineno_count * bfd_coff_linesz (abfd);
852 finfo.linenos = bfd_malloc (amt);
853 finfo.contents = bfd_malloc (max_contents_size);
854 amt = max_reloc_count * relsz;
855 finfo.external_relocs = bfd_malloc (amt);
856 if (! info->relocatable)
858 amt = max_reloc_count * sizeof (struct internal_reloc);
859 finfo.internal_relocs = bfd_malloc (amt);
861 if ((finfo.internal_syms == NULL && max_sym_count > 0)
862 || (finfo.sec_ptrs == NULL && max_sym_count > 0)
863 || (finfo.sym_indices == NULL && max_sym_count > 0)
864 || finfo.outsyms == NULL
865 || (finfo.linenos == NULL && max_lineno_count > 0)
866 || (finfo.contents == NULL && max_contents_size > 0)
867 || (finfo.external_relocs == NULL && max_reloc_count > 0)
868 || (! info->relocatable
869 && finfo.internal_relocs == NULL
870 && max_reloc_count > 0))
873 /* We now know the position of everything in the file, except that
874 we don't know the size of the symbol table and therefore we don't
875 know where the string table starts. We just build the string
876 table in memory as we go along. We process all the relocations
877 for a single input file at once. */
878 obj_raw_syment_count (abfd) = 0;
880 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
882 if (! bfd_coff_start_final_link (abfd, info))
886 for (o = abfd->sections; o != NULL; o = o->next)
888 for (p = o->link_order_head; p != NULL; p = p->next)
890 if (p->type == bfd_indirect_link_order
891 && bfd_family_coff (p->u.indirect.section->owner))
893 sub = p->u.indirect.section->owner;
894 if (! bfd_coff_link_output_has_begun (sub, & finfo))
896 if (! _bfd_coff_link_input_bfd (&finfo, sub))
898 sub->output_has_begun = TRUE;
901 else if (p->type == bfd_section_reloc_link_order
902 || p->type == bfd_symbol_reloc_link_order)
904 if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
909 if (! _bfd_default_link_order (abfd, info, o, p))
915 if (! bfd_coff_final_link_postscript (abfd, & finfo))
918 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
920 coff_debug_merge_hash_table_free (&finfo.debug_merge);
921 debug_merge_allocated = FALSE;
923 if (finfo.internal_syms != NULL)
925 free (finfo.internal_syms);
926 finfo.internal_syms = NULL;
928 if (finfo.sec_ptrs != NULL)
930 free (finfo.sec_ptrs);
931 finfo.sec_ptrs = NULL;
933 if (finfo.sym_indices != NULL)
935 free (finfo.sym_indices);
936 finfo.sym_indices = NULL;
938 if (finfo.linenos != NULL)
940 free (finfo.linenos);
941 finfo.linenos = NULL;
943 if (finfo.contents != NULL)
945 free (finfo.contents);
946 finfo.contents = NULL;
948 if (finfo.external_relocs != NULL)
950 free (finfo.external_relocs);
951 finfo.external_relocs = NULL;
953 if (finfo.internal_relocs != NULL)
955 free (finfo.internal_relocs);
956 finfo.internal_relocs = NULL;
959 /* The value of the last C_FILE symbol is supposed to be the symbol
960 index of the first external symbol. Write it out again if
962 if (finfo.last_file_index != -1
963 && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
967 finfo.last_file.n_value = obj_raw_syment_count (abfd);
968 bfd_coff_swap_sym_out (abfd, &finfo.last_file,
971 pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
972 if (bfd_seek (abfd, pos, SEEK_SET) != 0
973 || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
977 /* If doing task linking (ld --task-link) then make a pass through the
978 global symbols, writing out any that are defined, and making them
982 finfo.failed = FALSE;
983 coff_link_hash_traverse (coff_hash_table (info),
984 _bfd_coff_write_task_globals, &finfo);
989 /* Write out the global symbols. */
990 finfo.failed = FALSE;
991 coff_link_hash_traverse (coff_hash_table (info),
992 _bfd_coff_write_global_sym, &finfo);
996 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
997 if (finfo.outsyms != NULL)
999 free (finfo.outsyms);
1000 finfo.outsyms = NULL;
1003 if (info->relocatable && max_output_reloc_count > 0)
1005 /* Now that we have written out all the global symbols, we know
1006 the symbol indices to use for relocs against them, and we can
1007 finally write out the relocs. */
1008 amt = max_output_reloc_count * relsz;
1009 external_relocs = bfd_malloc (amt);
1010 if (external_relocs == NULL)
1013 for (o = abfd->sections; o != NULL; o = o->next)
1015 struct internal_reloc *irel;
1016 struct internal_reloc *irelend;
1017 struct coff_link_hash_entry **rel_hash;
1020 if (o->reloc_count == 0)
1023 irel = finfo.section_info[o->target_index].relocs;
1024 irelend = irel + o->reloc_count;
1025 rel_hash = finfo.section_info[o->target_index].rel_hashes;
1026 erel = external_relocs;
1027 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1029 if (*rel_hash != NULL)
1031 BFD_ASSERT ((*rel_hash)->indx >= 0);
1032 irel->r_symndx = (*rel_hash)->indx;
1034 bfd_coff_swap_reloc_out (abfd, irel, erel);
1037 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
1039 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
1041 /* In PE COFF, write the count of relocs as the first
1042 reloc. The header overflow bit will be set
1044 struct internal_reloc incount;
1045 bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
1047 memset (&incount, 0, sizeof (incount));
1048 incount.r_vaddr = o->reloc_count + 1;
1049 bfd_coff_swap_reloc_out (abfd, (PTR) &incount, (PTR) excount);
1050 if (bfd_bwrite (excount, relsz, abfd) != relsz)
1051 /* We'll leak, but it's an error anyway. */
1055 if (bfd_bwrite (external_relocs,
1056 (bfd_size_type) relsz * o->reloc_count, abfd)
1057 != (bfd_size_type) relsz * o->reloc_count)
1061 free (external_relocs);
1062 external_relocs = NULL;
1065 /* Free up the section information. */
1066 if (finfo.section_info != NULL)
1070 for (i = 0; i < abfd->section_count; i++)
1072 if (finfo.section_info[i].relocs != NULL)
1073 free (finfo.section_info[i].relocs);
1074 if (finfo.section_info[i].rel_hashes != NULL)
1075 free (finfo.section_info[i].rel_hashes);
1077 free (finfo.section_info);
1078 finfo.section_info = NULL;
1081 /* If we have optimized stabs strings, output them. */
1082 if (coff_hash_table (info)->stab_info != NULL)
1084 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1088 /* Write out the string table. */
1089 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1093 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1094 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1097 #if STRING_SIZE_SIZE == 4
1099 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
1102 #error Change H_PUT_32 above
1105 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1106 != STRING_SIZE_SIZE)
1109 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
1112 obj_coff_strings_written (abfd) = TRUE;
1115 _bfd_stringtab_free (finfo.strtab);
1117 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1118 not try to write out the symbols. */
1119 bfd_get_symcount (abfd) = 0;
1124 if (debug_merge_allocated)
1125 coff_debug_merge_hash_table_free (&finfo.debug_merge);
1126 if (finfo.strtab != NULL)
1127 _bfd_stringtab_free (finfo.strtab);
1128 if (finfo.section_info != NULL)
1132 for (i = 0; i < abfd->section_count; i++)
1134 if (finfo.section_info[i].relocs != NULL)
1135 free (finfo.section_info[i].relocs);
1136 if (finfo.section_info[i].rel_hashes != NULL)
1137 free (finfo.section_info[i].rel_hashes);
1139 free (finfo.section_info);
1141 if (finfo.internal_syms != NULL)
1142 free (finfo.internal_syms);
1143 if (finfo.sec_ptrs != NULL)
1144 free (finfo.sec_ptrs);
1145 if (finfo.sym_indices != NULL)
1146 free (finfo.sym_indices);
1147 if (finfo.outsyms != NULL)
1148 free (finfo.outsyms);
1149 if (finfo.linenos != NULL)
1150 free (finfo.linenos);
1151 if (finfo.contents != NULL)
1152 free (finfo.contents);
1153 if (finfo.external_relocs != NULL)
1154 free (finfo.external_relocs);
1155 if (finfo.internal_relocs != NULL)
1156 free (finfo.internal_relocs);
1157 if (external_relocs != NULL)
1158 free (external_relocs);
1162 /* Parse out a -heap <reserved>,<commit> line. */
1165 dores_com (char *ptr, bfd *output_bfd, int heap)
1167 if (coff_data(output_bfd)->pe)
1169 int val = strtoul (ptr, &ptr, 0);
1172 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1174 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1178 val = strtoul (ptr+1, &ptr, 0);
1180 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1182 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1189 get_name (char *ptr, char **dst)
1194 while (*ptr && *ptr != ' ')
1200 /* Process any magic embedded commands in a section called .drectve. */
1203 process_embedded_commands (bfd *output_bfd,
1204 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1207 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1215 copy = bfd_malloc (sec->_raw_size);
1219 if (! bfd_get_section_contents (abfd, sec, copy, (bfd_vma) 0, sec->_raw_size))
1224 e = copy + sec->_raw_size;
1226 for (s = copy; s < e ; )
1233 if (strncmp (s,"-attr", 5) == 0)
1245 s = get_name (s, &name);
1246 s = get_name (s, &attribs);
1268 asec = bfd_get_section_by_name (abfd, name);
1272 asec->flags |= SEC_CODE;
1274 asec->flags |= SEC_READONLY;
1277 else if (strncmp (s,"-heap", 5) == 0)
1278 s = dores_com (s+5, output_bfd, 1);
1280 else if (strncmp (s,"-stack", 6) == 0)
1281 s = dores_com (s+6, output_bfd, 0);
1290 /* Place a marker against all symbols which are used by relocations.
1291 This marker can be picked up by the 'do we skip this symbol ?'
1292 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1296 mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
1300 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1303 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1305 struct internal_reloc * internal_relocs;
1306 struct internal_reloc * irel;
1307 struct internal_reloc * irelend;
1309 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1)
1311 /* Don't mark relocs in excluded sections. */
1312 if (a->output_section == bfd_abs_section_ptr)
1315 /* Read in the relocs. */
1316 internal_relocs = _bfd_coff_read_internal_relocs
1317 (input_bfd, a, FALSE,
1318 finfo->external_relocs,
1319 finfo->info->relocatable,
1320 (finfo->info->relocatable
1321 ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1322 : finfo->internal_relocs)
1325 if (internal_relocs == NULL)
1328 irel = internal_relocs;
1329 irelend = irel + a->reloc_count;
1331 /* Place a mark in the sym_indices array (whose entries have
1332 been initialised to 0) for all of the symbols that are used
1333 in the relocation table. This will then be picked up in the
1334 skip/don't-skip pass. */
1335 for (; irel < irelend; irel++)
1336 finfo->sym_indices[ irel->r_symndx ] = -1;
1340 /* Link an input file into the linker output file. This function
1341 handles all the sections and relocations of the input file at once. */
1344 _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
1346 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1347 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1349 unsigned int n_btmask = coff_data (input_bfd)->local_n_btmask;
1351 bfd_boolean (*adjust_symndx)
1352 (bfd *, struct bfd_link_info *, bfd *, asection *,
1353 struct internal_reloc *, bfd_boolean *);
1355 const char *strings;
1356 bfd_size_type syment_base;
1357 bfd_boolean copy, hash;
1358 bfd_size_type isymesz;
1359 bfd_size_type osymesz;
1360 bfd_size_type linesz;
1363 struct internal_syment *isymp;
1366 unsigned long output_index;
1368 struct coff_link_hash_entry **sym_hash;
1371 /* Move all the symbols to the output file. */
1373 output_bfd = finfo->output_bfd;
1375 syment_base = obj_raw_syment_count (output_bfd);
1376 isymesz = bfd_coff_symesz (input_bfd);
1377 osymesz = bfd_coff_symesz (output_bfd);
1378 linesz = bfd_coff_linesz (input_bfd);
1379 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1382 if (! finfo->info->keep_memory)
1385 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1388 if (! _bfd_coff_get_external_symbols (input_bfd))
1391 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1392 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1393 isymp = finfo->internal_syms;
1394 secpp = finfo->sec_ptrs;
1395 indexp = finfo->sym_indices;
1396 output_index = syment_base;
1397 outsym = finfo->outsyms;
1399 if (coff_data (output_bfd)->pe
1400 && ! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1403 /* If we are going to perform relocations and also strip/discard some
1404 symbols then we must make sure that we do not strip/discard those
1405 symbols that are going to be involved in the relocations. */
1406 if (( finfo->info->strip != strip_none
1407 || finfo->info->discard != discard_none)
1408 && finfo->info->relocatable)
1410 /* Mark the symbol array as 'not-used'. */
1411 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1413 mark_relocs (finfo, input_bfd);
1416 while (esym < esym_end)
1418 struct internal_syment isym;
1419 enum coff_symbol_classification classification;
1422 bfd_boolean dont_skip_symbol;
1425 bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1427 /* Make a copy of *isymp so that the relocate_section function
1428 always sees the original values. This is more reliable than
1429 always recomputing the symbol value even if we are stripping
1433 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1434 switch (classification)
1438 case COFF_SYMBOL_GLOBAL:
1439 case COFF_SYMBOL_PE_SECTION:
1440 case COFF_SYMBOL_LOCAL:
1441 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1443 case COFF_SYMBOL_COMMON:
1444 *secpp = bfd_com_section_ptr;
1446 case COFF_SYMBOL_UNDEFINED:
1447 *secpp = bfd_und_section_ptr;
1451 /* Extract the flag indicating if this symbol is used by a
1453 if ((finfo->info->strip != strip_none
1454 || finfo->info->discard != discard_none)
1455 && finfo->info->relocatable)
1456 dont_skip_symbol = *indexp;
1458 dont_skip_symbol = FALSE;
1464 add = 1 + isym.n_numaux;
1466 /* If we are stripping all symbols, we want to skip this one. */
1467 if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1472 switch (classification)
1476 case COFF_SYMBOL_GLOBAL:
1477 case COFF_SYMBOL_COMMON:
1478 case COFF_SYMBOL_PE_SECTION:
1479 /* This is a global symbol. Global symbols come at the
1480 end of the symbol table, so skip them for now.
1481 Locally defined function symbols, however, are an
1482 exception, and are not moved to the end. */
1484 if (! ISFCN (isym.n_type))
1488 case COFF_SYMBOL_UNDEFINED:
1489 /* Undefined symbols are left for the end. */
1494 case COFF_SYMBOL_LOCAL:
1495 /* This is a local symbol. Skip it if we are discarding
1497 if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1503 #ifndef COFF_WITH_PE
1504 /* Skip section symbols for sections which are not going to be
1507 && dont_skip_symbol == 0
1508 && isym.n_sclass == C_STAT
1509 && isym.n_type == T_NULL
1510 && isym.n_numaux > 0
1511 && (*secpp)->output_section == bfd_abs_section_ptr)
1515 /* If we stripping debugging symbols, and this is a debugging
1516 symbol, then skip it. FIXME: gas sets the section to N_ABS
1517 for some types of debugging symbols; I don't know if this is
1518 a bug or not. In any case, we handle it here. */
1520 && finfo->info->strip == strip_debugger
1521 && ! dont_skip_symbol
1522 && (isym.n_scnum == N_DEBUG
1523 || (isym.n_scnum == N_ABS
1524 && (isym.n_sclass == C_AUTO
1525 || isym.n_sclass == C_REG
1526 || isym.n_sclass == C_MOS
1527 || isym.n_sclass == C_MOE
1528 || isym.n_sclass == C_MOU
1529 || isym.n_sclass == C_ARG
1530 || isym.n_sclass == C_REGPARM
1531 || isym.n_sclass == C_FIELD
1532 || isym.n_sclass == C_EOS))))
1535 /* If some symbols are stripped based on the name, work out the
1536 name and decide whether to skip this symbol. */
1538 && (finfo->info->strip == strip_some
1539 || finfo->info->discard == discard_l))
1542 char buf[SYMNMLEN + 1];
1544 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1548 if (! dont_skip_symbol
1549 && ((finfo->info->strip == strip_some
1550 && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE,
1553 && finfo->info->discard == discard_l
1554 && bfd_is_local_label_name (input_bfd, name))))
1558 /* If this is an enum, struct, or union tag, see if we have
1559 already output an identical type. */
1561 && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1562 && (isym.n_sclass == C_ENTAG
1563 || isym.n_sclass == C_STRTAG
1564 || isym.n_sclass == C_UNTAG)
1565 && isym.n_numaux == 1)
1568 char buf[SYMNMLEN + 1];
1569 struct coff_debug_merge_hash_entry *mh;
1570 struct coff_debug_merge_type *mt;
1571 union internal_auxent aux;
1572 struct coff_debug_merge_element **epp;
1573 bfd_byte *esl, *eslend;
1574 struct internal_syment *islp;
1577 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1581 /* Ignore fake names invented by compiler; treat them all as
1583 if (*name == '~' || *name == '.' || *name == '$'
1584 || (*name == bfd_get_symbol_leading_char (input_bfd)
1585 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1588 mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1593 /* Allocate memory to hold type information. If this turns
1594 out to be a duplicate, we pass this address to
1596 amt = sizeof (struct coff_debug_merge_type);
1597 mt = bfd_alloc (input_bfd, amt);
1600 mt->class = isym.n_sclass;
1602 /* Pick up the aux entry, which points to the end of the tag
1604 bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1605 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1608 /* Gather the elements. */
1609 epp = &mt->elements;
1610 mt->elements = NULL;
1612 esl = esym + 2 * isymesz;
1613 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1614 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1615 while (esl < eslend)
1617 const char *elename;
1618 char elebuf[SYMNMLEN + 1];
1621 bfd_coff_swap_sym_in (input_bfd, esl, islp);
1623 amt = sizeof (struct coff_debug_merge_element);
1624 *epp = bfd_alloc (input_bfd, amt);
1628 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1630 if (elename == NULL)
1633 amt = strlen (elename) + 1;
1634 name_copy = bfd_alloc (input_bfd, amt);
1635 if (name_copy == NULL)
1637 strcpy (name_copy, elename);
1639 (*epp)->name = name_copy;
1640 (*epp)->type = islp->n_type;
1642 if (islp->n_numaux >= 1
1643 && islp->n_type != T_NULL
1644 && islp->n_sclass != C_EOS)
1646 union internal_auxent eleaux;
1649 bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1650 islp->n_type, islp->n_sclass, 0,
1651 islp->n_numaux, &eleaux);
1652 indx = eleaux.x_sym.x_tagndx.l;
1654 /* FIXME: If this tagndx entry refers to a symbol
1655 defined later in this file, we just ignore it.
1656 Handling this correctly would be tedious, and may
1661 (bfd_byte *) obj_coff_external_syms (input_bfd))
1664 (*epp)->tagndx = finfo->sym_indices[indx];
1665 if ((*epp)->tagndx < 0)
1669 epp = &(*epp)->next;
1672 esl += (islp->n_numaux + 1) * isymesz;
1673 islp += islp->n_numaux + 1;
1676 /* See if we already have a definition which matches this
1677 type. We always output the type if it has no elements,
1679 if (mt->elements == NULL)
1680 bfd_release (input_bfd, mt);
1683 struct coff_debug_merge_type *mtl;
1685 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1687 struct coff_debug_merge_element *me, *mel;
1689 if (mtl->class != mt->class)
1692 for (me = mt->elements, mel = mtl->elements;
1693 me != NULL && mel != NULL;
1694 me = me->next, mel = mel->next)
1696 if (strcmp (me->name, mel->name) != 0
1697 || me->type != mel->type
1698 || me->tagndx != mel->tagndx)
1702 if (me == NULL && mel == NULL)
1706 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1708 /* This is the first definition of this type. */
1709 mt->indx = output_index;
1710 mt->next = mh->types;
1715 /* This is a redefinition which can be merged. */
1716 bfd_release (input_bfd, mt);
1717 *indexp = mtl->indx;
1718 add = (eslend - esym) / isymesz;
1724 /* We now know whether we are to skip this symbol or not. */
1727 /* Adjust the symbol in order to output it. */
1729 if (isym._n._n_n._n_zeroes == 0
1730 && isym._n._n_n._n_offset != 0)
1735 /* This symbol has a long name. Enter it in the string
1736 table we are building. Note that we do not check
1737 bfd_coff_symname_in_debug. That is only true for
1738 XCOFF, and XCOFF requires different linking code
1740 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1743 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1744 if (indx == (bfd_size_type) -1)
1746 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1749 switch (isym.n_sclass)
1765 /* The symbol value should not be modified. */
1769 if (obj_pe (input_bfd)
1770 && strcmp (isym.n_name, ".bf") != 0
1771 && isym.n_scnum > 0)
1773 /* For PE, .lf and .ef get their value left alone,
1774 while .bf gets relocated. However, they all have
1775 "real" section numbers, and need to be moved into
1777 isym.n_scnum = (*secpp)->output_section->target_index;
1782 case C_LABEL: /* Not completely sure about these 2 */
1791 /* Compute new symbol location. */
1792 if (isym.n_scnum > 0)
1794 isym.n_scnum = (*secpp)->output_section->target_index;
1795 isym.n_value += (*secpp)->output_offset;
1796 if (! obj_pe (input_bfd))
1797 isym.n_value -= (*secpp)->vma;
1798 if (! obj_pe (finfo->output_bfd))
1799 isym.n_value += (*secpp)->output_section->vma;
1804 /* The value of a C_FILE symbol is the symbol index of
1805 the next C_FILE symbol. The value of the last C_FILE
1806 symbol is the symbol index to the first external
1807 symbol (actually, coff_renumber_symbols does not get
1808 this right--it just sets the value of the last C_FILE
1809 symbol to zero--and nobody has ever complained about
1810 it). We try to get this right, below, just before we
1811 write the symbols out, but in the general case we may
1812 have to write the symbol out twice. */
1813 if (finfo->last_file_index != -1
1814 && finfo->last_file.n_value != (bfd_vma) output_index)
1816 /* We must correct the value of the last C_FILE
1818 finfo->last_file.n_value = output_index;
1819 if ((bfd_size_type) finfo->last_file_index >= syment_base)
1821 /* The last C_FILE symbol is in this input file. */
1822 bfd_coff_swap_sym_out (output_bfd,
1825 + ((finfo->last_file_index
1833 /* We have already written out the last C_FILE
1834 symbol. We need to write it out again. We
1835 borrow *outsym temporarily. */
1836 bfd_coff_swap_sym_out (output_bfd,
1837 &finfo->last_file, outsym);
1838 pos = obj_sym_filepos (output_bfd);
1839 pos += finfo->last_file_index * osymesz;
1840 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1841 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1846 finfo->last_file_index = output_index;
1847 finfo->last_file = isym;
1851 /* If doing task linking, convert normal global function symbols to
1852 static functions. */
1853 if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1854 isym.n_sclass = C_STAT;
1856 /* Output the symbol. */
1857 bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1859 *indexp = output_index;
1864 struct coff_link_hash_entry *h;
1866 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1868 h = obj_coff_sym_hashes (input_bfd)[indx];
1871 /* This can happen if there were errors earlier in
1873 bfd_set_error (bfd_error_bad_value);
1876 h->indx = output_index;
1879 output_index += add;
1880 outsym += add * osymesz;
1883 esym += add * isymesz;
1887 for (--add; add > 0; --add)
1894 /* Fix up the aux entries. This must be done in a separate pass,
1895 because we don't know the correct symbol indices until we have
1896 already decided which symbols we are going to keep. */
1897 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1898 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1899 isymp = finfo->internal_syms;
1900 indexp = finfo->sym_indices;
1901 sym_hash = obj_coff_sym_hashes (input_bfd);
1902 outsym = finfo->outsyms;
1904 while (esym < esym_end)
1908 add = 1 + isymp->n_numaux;
1911 || (bfd_size_type) *indexp < syment_base)
1912 && (*sym_hash == NULL
1913 || (*sym_hash)->auxbfd != input_bfd))
1914 esym += add * isymesz;
1917 struct coff_link_hash_entry *h;
1925 /* The m68k-motorola-sysv assembler will sometimes
1926 generate two symbols with the same name, but only one
1927 will have aux entries. */
1928 BFD_ASSERT (isymp->n_numaux == 0
1929 || h->numaux == isymp->n_numaux);
1937 /* Handle the aux entries. This handling is based on
1938 coff_pointerize_aux. I don't know if it always correct. */
1939 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1941 union internal_auxent aux;
1942 union internal_auxent *auxp;
1948 bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
1949 isymp->n_sclass, i, isymp->n_numaux, &aux);
1953 if (isymp->n_sclass == C_FILE)
1955 /* If this is a long filename, we must put it in the
1957 if (auxp->x_file.x_n.x_zeroes == 0
1958 && auxp->x_file.x_n.x_offset != 0)
1960 const char *filename;
1963 BFD_ASSERT (auxp->x_file.x_n.x_offset
1964 >= STRING_SIZE_SIZE);
1965 if (strings == NULL)
1967 strings = _bfd_coff_read_string_table (input_bfd);
1968 if (strings == NULL)
1971 filename = strings + auxp->x_file.x_n.x_offset;
1972 indx = _bfd_stringtab_add (finfo->strtab, filename,
1974 if (indx == (bfd_size_type) -1)
1976 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
1979 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
1983 if (ISFCN (isymp->n_type)
1984 || ISTAG (isymp->n_sclass)
1985 || isymp->n_sclass == C_BLOCK
1986 || isymp->n_sclass == C_FCN)
1988 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
1990 && indx < obj_raw_syment_count (input_bfd))
1992 /* We look forward through the symbol for
1993 the index of the next symbol we are going
1994 to include. I don't know if this is
1996 while ((finfo->sym_indices[indx] < 0
1997 || ((bfd_size_type) finfo->sym_indices[indx]
1999 && indx < obj_raw_syment_count (input_bfd))
2001 if (indx >= obj_raw_syment_count (input_bfd))
2002 indx = output_index;
2004 indx = finfo->sym_indices[indx];
2005 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2009 indx = auxp->x_sym.x_tagndx.l;
2010 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2014 symindx = finfo->sym_indices[indx];
2016 auxp->x_sym.x_tagndx.l = 0;
2018 auxp->x_sym.x_tagndx.l = symindx;
2021 /* The .bf symbols are supposed to be linked through
2022 the endndx field. We need to carry this list
2023 across object files. */
2026 && isymp->n_sclass == C_FCN
2027 && (isymp->_n._n_n._n_zeroes != 0
2028 || isymp->_n._n_n._n_offset == 0)
2029 && isymp->_n._n_name[0] == '.'
2030 && isymp->_n._n_name[1] == 'b'
2031 && isymp->_n._n_name[2] == 'f'
2032 && isymp->_n._n_name[3] == '\0')
2034 if (finfo->last_bf_index != -1)
2036 finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2039 if ((bfd_size_type) finfo->last_bf_index
2044 /* The last .bf symbol is in this input
2045 file. This will only happen if the
2046 assembler did not set up the .bf
2047 endndx symbols correctly. */
2048 auxout = (finfo->outsyms
2049 + ((finfo->last_bf_index
2053 bfd_coff_swap_aux_out (output_bfd,
2064 /* We have already written out the last
2065 .bf aux entry. We need to write it
2066 out again. We borrow *outsym
2067 temporarily. FIXME: This case should
2069 bfd_coff_swap_aux_out (output_bfd,
2075 pos = obj_sym_filepos (output_bfd);
2076 pos += finfo->last_bf_index * osymesz;
2077 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2078 || (bfd_bwrite (outsym, osymesz, output_bfd)
2084 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2085 finfo->last_bf_index = -1;
2088 /* The endndx field of this aux entry must
2089 be updated with the symbol number of the
2091 finfo->last_bf = *auxp;
2092 finfo->last_bf_index = (((outsym - finfo->outsyms)
2101 bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2102 isymp->n_sclass, i, isymp->n_numaux,
2116 /* Relocate the line numbers, unless we are stripping them. */
2117 if (finfo->info->strip == strip_none
2118 || finfo->info->strip == strip_some)
2120 for (o = input_bfd->sections; o != NULL; o = o->next)
2126 bfd_boolean skipping;
2130 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2131 build_link_order in ldwrite.c will not have created a
2132 link order, which means that we will not have seen this
2133 input section in _bfd_coff_final_link, which means that
2134 we will not have allocated space for the line numbers of
2135 this section. I don't think line numbers can be
2136 meaningful for a section which does not have
2137 SEC_HAS_CONTENTS set, but, if they do, this must be
2139 if (o->lineno_count == 0
2140 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2143 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2144 || bfd_bread (finfo->linenos, linesz * o->lineno_count,
2145 input_bfd) != linesz * o->lineno_count)
2148 offset = o->output_section->vma + o->output_offset - o->vma;
2149 eline = finfo->linenos;
2150 oeline = finfo->linenos;
2151 elineend = eline + linesz * o->lineno_count;
2153 for (; eline < elineend; eline += linesz)
2155 struct internal_lineno iline;
2157 bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2159 if (iline.l_lnno != 0)
2160 iline.l_addr.l_paddr += offset;
2161 else if (iline.l_addr.l_symndx >= 0
2162 && ((unsigned long) iline.l_addr.l_symndx
2163 < obj_raw_syment_count (input_bfd)))
2167 indx = finfo->sym_indices[iline.l_addr.l_symndx];
2171 /* These line numbers are attached to a symbol
2172 which we are stripping. We must discard the
2173 line numbers because reading them back with
2174 no associated symbol (or associating them all
2175 with symbol #0) will fail. We can't regain
2176 the space in the output file, but at least
2182 struct internal_syment is;
2183 union internal_auxent ia;
2185 /* Fix up the lnnoptr field in the aux entry of
2186 the symbol. It turns out that we can't do
2187 this when we modify the symbol aux entries,
2188 because gas sometimes screws up the lnnoptr
2189 field and makes it an offset from the start
2190 of the line numbers rather than an absolute
2192 bfd_coff_swap_sym_in (output_bfd,
2194 + ((indx - syment_base)
2196 if ((ISFCN (is.n_type)
2197 || is.n_sclass == C_BLOCK)
2198 && is.n_numaux >= 1)
2202 auxptr = (finfo->outsyms
2203 + ((indx - syment_base + 1)
2205 bfd_coff_swap_aux_in (output_bfd, auxptr,
2206 is.n_type, is.n_sclass,
2207 0, is.n_numaux, &ia);
2208 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2209 (o->output_section->line_filepos
2210 + o->output_section->lineno_count * linesz
2211 + eline - finfo->linenos);
2212 bfd_coff_swap_aux_out (output_bfd, &ia,
2213 is.n_type, is.n_sclass, 0,
2214 is.n_numaux, auxptr);
2220 iline.l_addr.l_symndx = indx;
2225 bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2230 pos = o->output_section->line_filepos;
2231 pos += o->output_section->lineno_count * linesz;
2232 amt = oeline - finfo->linenos;
2233 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2234 || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
2237 o->output_section->lineno_count += amt / linesz;
2241 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2242 symbol will be the first symbol in the next input file. In the
2243 normal case, this will save us from writing out the C_FILE symbol
2245 if (finfo->last_file_index != -1
2246 && (bfd_size_type) finfo->last_file_index >= syment_base)
2248 finfo->last_file.n_value = output_index;
2249 bfd_coff_swap_sym_out (output_bfd, &finfo->last_file,
2251 + ((finfo->last_file_index - syment_base)
2255 /* Write the modified symbols to the output file. */
2256 if (outsym > finfo->outsyms)
2261 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2262 amt = outsym - finfo->outsyms;
2263 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2264 || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
2267 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2268 + (outsym - finfo->outsyms) / osymesz)
2271 obj_raw_syment_count (output_bfd) = output_index;
2274 /* Relocate the contents of each section. */
2275 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2276 for (o = input_bfd->sections; o != NULL; o = o->next)
2279 struct coff_section_tdata *secdata;
2281 if (! o->linker_mark)
2282 /* This section was omitted from the link. */
2285 if ((o->flags & SEC_HAS_CONTENTS) == 0
2286 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
2288 if ((o->flags & SEC_RELOC) != 0
2289 && o->reloc_count != 0)
2291 ((*_bfd_error_handler)
2292 (_("%s: relocs in section `%s', but it has no contents"),
2293 bfd_archive_filename (input_bfd),
2294 bfd_get_section_name (input_bfd, o)));
2295 bfd_set_error (bfd_error_no_contents);
2302 secdata = coff_section_data (input_bfd, o);
2303 if (secdata != NULL && secdata->contents != NULL)
2304 contents = secdata->contents;
2307 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2308 (file_ptr) 0, o->_raw_size))
2310 contents = finfo->contents;
2313 if ((o->flags & SEC_RELOC) != 0)
2316 struct internal_reloc *internal_relocs;
2317 struct internal_reloc *irel;
2319 /* Read in the relocs. */
2320 target_index = o->output_section->target_index;
2321 internal_relocs = (_bfd_coff_read_internal_relocs
2322 (input_bfd, o, FALSE, finfo->external_relocs,
2323 finfo->info->relocatable,
2324 (finfo->info->relocatable
2325 ? (finfo->section_info[target_index].relocs
2326 + o->output_section->reloc_count)
2327 : finfo->internal_relocs)));
2328 if (internal_relocs == NULL)
2331 /* Call processor specific code to relocate the section
2333 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2337 finfo->internal_syms,
2341 if (finfo->info->relocatable)
2344 struct internal_reloc *irelend;
2345 struct coff_link_hash_entry **rel_hash;
2347 offset = o->output_section->vma + o->output_offset - o->vma;
2348 irel = internal_relocs;
2349 irelend = irel + o->reloc_count;
2350 rel_hash = (finfo->section_info[target_index].rel_hashes
2351 + o->output_section->reloc_count);
2352 for (; irel < irelend; irel++, rel_hash++)
2354 struct coff_link_hash_entry *h;
2355 bfd_boolean adjusted;
2359 /* Adjust the reloc address and symbol index. */
2360 irel->r_vaddr += offset;
2362 if (irel->r_symndx == -1)
2367 if (! (*adjust_symndx) (output_bfd, finfo->info,
2375 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2378 /* This is a global symbol. */
2380 irel->r_symndx = h->indx;
2383 /* This symbol is being written at the end
2384 of the file, and we do not yet know the
2385 symbol index. We save the pointer to the
2386 hash table entry in the rel_hash list.
2387 We set the indx field to -2 to indicate
2388 that this symbol must not be stripped. */
2397 indx = finfo->sym_indices[irel->r_symndx];
2399 irel->r_symndx = indx;
2402 struct internal_syment *is;
2404 char buf[SYMNMLEN + 1];
2406 /* This reloc is against a symbol we are
2407 stripping. This should have been handled
2408 by the 'dont_skip_symbol' code in the while
2409 loop at the top of this function. */
2410 is = finfo->internal_syms + irel->r_symndx;
2412 name = (_bfd_coff_internal_syment_name
2413 (input_bfd, is, buf));
2417 if (! ((*finfo->info->callbacks->unattached_reloc)
2418 (finfo->info, name, input_bfd, o,
2425 o->output_section->reloc_count += o->reloc_count;
2429 /* Write out the modified section contents. */
2430 if (secdata == NULL || secdata->stab_info == NULL)
2432 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2433 bfd_size_type amt = (o->_cooked_size != 0
2434 ? o->_cooked_size : o->_raw_size);
2435 if (! bfd_set_section_contents (output_bfd, o->output_section,
2436 contents, loc, amt))
2441 if (! (_bfd_write_section_stabs
2442 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2443 o, &secdata->stab_info, contents)))
2448 if (! finfo->info->keep_memory
2449 && ! _bfd_coff_free_symbols (input_bfd))
2455 /* Write out a global symbol. Called via coff_link_hash_traverse. */
2458 _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
2460 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2462 struct internal_syment isym;
2463 bfd_size_type symesz;
2467 output_bfd = finfo->output_bfd;
2469 if (h->root.type == bfd_link_hash_warning)
2471 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2472 if (h->root.type == bfd_link_hash_new)
2480 && (finfo->info->strip == strip_all
2481 || (finfo->info->strip == strip_some
2482 && (bfd_hash_lookup (finfo->info->keep_hash,
2483 h->root.root.string, FALSE, FALSE)
2487 switch (h->root.type)
2490 case bfd_link_hash_new:
2491 case bfd_link_hash_warning:
2495 case bfd_link_hash_undefined:
2496 case bfd_link_hash_undefweak:
2497 isym.n_scnum = N_UNDEF;
2501 case bfd_link_hash_defined:
2502 case bfd_link_hash_defweak:
2506 sec = h->root.u.def.section->output_section;
2507 if (bfd_is_abs_section (sec))
2508 isym.n_scnum = N_ABS;
2510 isym.n_scnum = sec->target_index;
2511 isym.n_value = (h->root.u.def.value
2512 + h->root.u.def.section->output_offset);
2513 if (! obj_pe (finfo->output_bfd))
2514 isym.n_value += sec->vma;
2518 case bfd_link_hash_common:
2519 isym.n_scnum = N_UNDEF;
2520 isym.n_value = h->root.u.c.size;
2523 case bfd_link_hash_indirect:
2524 /* Just ignore these. They can't be handled anyhow. */
2528 if (strlen (h->root.root.string) <= SYMNMLEN)
2529 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2536 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2538 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2540 if (indx == (bfd_size_type) -1)
2542 finfo->failed = TRUE;
2545 isym._n._n_n._n_zeroes = 0;
2546 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2549 isym.n_sclass = h->class;
2550 isym.n_type = h->type;
2552 if (isym.n_sclass == C_NULL)
2553 isym.n_sclass = C_EXT;
2555 /* If doing task linking and this is the pass where we convert
2556 defined globals to statics, then do that conversion now. If the
2557 symbol is not being converted, just ignore it and it will be
2558 output during a later pass. */
2559 if (finfo->global_to_static)
2561 if (! IS_EXTERNAL (output_bfd, isym))
2564 isym.n_sclass = C_STAT;
2567 /* When a weak symbol is not overriden by a strong one,
2568 turn it into an external symbol when not building a
2569 shared or relocatable object. */
2570 if (! finfo->info->shared
2571 && ! finfo->info->relocatable
2572 && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
2573 isym.n_sclass = C_EXT;
2575 isym.n_numaux = h->numaux;
2577 bfd_coff_swap_sym_out (output_bfd, &isym, finfo->outsyms);
2579 symesz = bfd_coff_symesz (output_bfd);
2581 pos = obj_sym_filepos (output_bfd);
2582 pos += obj_raw_syment_count (output_bfd) * symesz;
2583 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2584 || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2586 finfo->failed = TRUE;
2590 h->indx = obj_raw_syment_count (output_bfd);
2592 ++obj_raw_syment_count (output_bfd);
2594 /* Write out any associated aux entries. Most of the aux entries
2595 will have been modified in _bfd_coff_link_input_bfd. We have to
2596 handle section aux entries here, now that we have the final
2597 relocation and line number counts. */
2598 for (i = 0; i < isym.n_numaux; i++)
2600 union internal_auxent *auxp;
2604 /* Look for a section aux entry here using the same tests that
2605 coff_swap_aux_out uses. */
2607 && (isym.n_sclass == C_STAT
2608 || isym.n_sclass == C_HIDDEN)
2609 && isym.n_type == T_NULL
2610 && (h->root.type == bfd_link_hash_defined
2611 || h->root.type == bfd_link_hash_defweak))
2615 sec = h->root.u.def.section->output_section;
2618 auxp->x_scn.x_scnlen = (sec->_cooked_size != 0
2622 /* For PE, an overflow on the final link reportedly does
2623 not matter. FIXME: Why not? */
2624 if (sec->reloc_count > 0xffff
2625 && (! obj_pe (output_bfd)
2626 || finfo->info->relocatable))
2627 (*_bfd_error_handler)
2628 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2629 bfd_get_filename (output_bfd),
2630 bfd_get_section_name (output_bfd, sec),
2633 if (sec->lineno_count > 0xffff
2634 && (! obj_pe (output_bfd)
2635 || finfo->info->relocatable))
2636 (*_bfd_error_handler)
2637 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2638 bfd_get_filename (output_bfd),
2639 bfd_get_section_name (output_bfd, sec),
2642 auxp->x_scn.x_nreloc = sec->reloc_count;
2643 auxp->x_scn.x_nlinno = sec->lineno_count;
2644 auxp->x_scn.x_checksum = 0;
2645 auxp->x_scn.x_associated = 0;
2646 auxp->x_scn.x_comdat = 0;
2650 bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2651 isym.n_sclass, (int) i, isym.n_numaux,
2653 if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2655 finfo->failed = TRUE;
2658 ++obj_raw_syment_count (output_bfd);
2664 /* Write out task global symbols, converting them to statics. Called
2665 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2666 the dirty work, if the symbol we are processing needs conversion. */
2669 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2671 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2672 bfd_boolean rtnval = TRUE;
2673 bfd_boolean save_global_to_static;
2675 if (h->root.type == bfd_link_hash_warning)
2676 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2680 switch (h->root.type)
2682 case bfd_link_hash_defined:
2683 case bfd_link_hash_defweak:
2684 save_global_to_static = finfo->global_to_static;
2685 finfo->global_to_static = TRUE;
2686 rtnval = _bfd_coff_write_global_sym (h, data);
2687 finfo->global_to_static = save_global_to_static;
2696 /* Handle a link order which is supposed to generate a reloc. */
2699 _bfd_coff_reloc_link_order (bfd *output_bfd,
2700 struct coff_final_link_info *finfo,
2701 asection *output_section,
2702 struct bfd_link_order *link_order)
2704 reloc_howto_type *howto;
2705 struct internal_reloc *irel;
2706 struct coff_link_hash_entry **rel_hash_ptr;
2708 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2711 bfd_set_error (bfd_error_bad_value);
2715 if (link_order->u.reloc.p->addend != 0)
2719 bfd_reloc_status_type rstat;
2723 size = bfd_get_reloc_size (howto);
2724 buf = bfd_zmalloc (size);
2728 rstat = _bfd_relocate_contents (howto, output_bfd,
2729 (bfd_vma) link_order->u.reloc.p->addend,\
2736 case bfd_reloc_outofrange:
2738 case bfd_reloc_overflow:
2739 if (! ((*finfo->info->callbacks->reloc_overflow)
2741 (link_order->type == bfd_section_reloc_link_order
2742 ? bfd_section_name (output_bfd,
2743 link_order->u.reloc.p->u.section)
2744 : link_order->u.reloc.p->u.name),
2745 howto->name, link_order->u.reloc.p->addend,
2746 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2753 loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2754 ok = bfd_set_section_contents (output_bfd, output_section, buf,
2761 /* Store the reloc information in the right place. It will get
2762 swapped and written out at the end of the final_link routine. */
2763 irel = (finfo->section_info[output_section->target_index].relocs
2764 + output_section->reloc_count);
2765 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2766 + output_section->reloc_count);
2768 memset (irel, 0, sizeof (struct internal_reloc));
2769 *rel_hash_ptr = NULL;
2771 irel->r_vaddr = output_section->vma + link_order->offset;
2773 if (link_order->type == bfd_section_reloc_link_order)
2775 /* We need to somehow locate a symbol in the right section. The
2776 symbol must either have a value of zero, or we must adjust
2777 the addend by the value of the symbol. FIXME: Write this
2778 when we need it. The old linker couldn't handle this anyhow. */
2780 *rel_hash_ptr = NULL;
2785 struct coff_link_hash_entry *h;
2787 h = ((struct coff_link_hash_entry *)
2788 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2789 link_order->u.reloc.p->u.name,
2790 FALSE, FALSE, TRUE));
2794 irel->r_symndx = h->indx;
2797 /* Set the index to -2 to force this symbol to get
2806 if (! ((*finfo->info->callbacks->unattached_reloc)
2807 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2808 (asection *) NULL, (bfd_vma) 0)))
2814 /* FIXME: Is this always right? */
2815 irel->r_type = howto->type;
2817 /* r_size is only used on the RS/6000, which needs its own linker
2818 routines anyhow. r_extern is only used for ECOFF. */
2820 /* FIXME: What is the right value for r_offset? Is zero OK? */
2821 ++output_section->reloc_count;
2826 /* A basic reloc handling routine which may be used by processors with
2830 _bfd_coff_generic_relocate_section (bfd *output_bfd,
2831 struct bfd_link_info *info,
2833 asection *input_section,
2835 struct internal_reloc *relocs,
2836 struct internal_syment *syms,
2837 asection **sections)
2839 struct internal_reloc *rel;
2840 struct internal_reloc *relend;
2843 relend = rel + input_section->reloc_count;
2844 for (; rel < relend; rel++)
2847 struct coff_link_hash_entry *h;
2848 struct internal_syment *sym;
2851 reloc_howto_type *howto;
2852 bfd_reloc_status_type rstat;
2854 symndx = rel->r_symndx;
2862 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2864 (*_bfd_error_handler)
2865 ("%s: illegal symbol index %ld in relocs",
2866 bfd_archive_filename (input_bfd), symndx);
2871 h = obj_coff_sym_hashes (input_bfd)[symndx];
2872 sym = syms + symndx;
2875 /* COFF treats common symbols in one of two ways. Either the
2876 size of the symbol is included in the section contents, or it
2877 is not. We assume that the size is not included, and force
2878 the rtype_to_howto function to adjust the addend as needed. */
2879 if (sym != NULL && sym->n_scnum != 0)
2880 addend = - sym->n_value;
2884 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2889 /* If we are doing a relocatable link, then we can just ignore
2890 a PC relative reloc that is pcrel_offset. It will already
2891 have the correct value. If this is not a relocatable link,
2892 then we should ignore the symbol value. */
2893 if (howto->pc_relative && howto->pcrel_offset)
2895 if (info->relocatable)
2897 if (sym != NULL && sym->n_scnum != 0)
2898 addend += sym->n_value;
2909 sec = bfd_abs_section_ptr;
2914 sec = sections[symndx];
2915 val = (sec->output_section->vma
2916 + sec->output_offset
2918 if (! obj_pe (input_bfd))
2924 if (h->root.type == bfd_link_hash_defined
2925 || h->root.type == bfd_link_hash_defweak)
2929 sec = h->root.u.def.section;
2930 val = (h->root.u.def.value
2931 + sec->output_section->vma
2932 + sec->output_offset);
2935 else if (h->root.type == bfd_link_hash_undefweak)
2938 else if (! info->relocatable)
2940 if (! ((*info->callbacks->undefined_symbol)
2941 (info, h->root.root.string, input_bfd, input_section,
2942 rel->r_vaddr - input_section->vma, TRUE)))
2947 if (info->base_file)
2949 /* Emit a reloc if the backend thinks it needs it. */
2950 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
2952 /* Relocation to a symbol in a section which isn't
2953 absolute. We output the address here to a file.
2954 This file is then read by dlltool when generating the
2955 reloc section. Note that the base file is not
2956 portable between systems. We write out a long here,
2957 and dlltool reads in a long. */
2958 long addr = (rel->r_vaddr
2959 - input_section->vma
2960 + input_section->output_offset
2961 + input_section->output_section->vma);
2962 if (coff_data (output_bfd)->pe)
2963 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
2964 if (fwrite (&addr, 1, sizeof (long), (FILE *) info->base_file)
2967 bfd_set_error (bfd_error_system_call);
2973 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
2975 rel->r_vaddr - input_section->vma,
2984 case bfd_reloc_outofrange:
2985 (*_bfd_error_handler)
2986 (_("%s: bad reloc address 0x%lx in section `%s'"),
2987 bfd_archive_filename (input_bfd),
2988 (unsigned long) rel->r_vaddr,
2989 bfd_get_section_name (input_bfd, input_section));
2991 case bfd_reloc_overflow:
2994 char buf[SYMNMLEN + 1];
2999 name = h->root.root.string;
3002 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3007 if (! ((*info->callbacks->reloc_overflow)
3008 (info, name, howto->name, (bfd_vma) 0, input_bfd,
3009 input_section, rel->r_vaddr - input_section->vma)))