1 /* COFF specific linker code.
2 Copyright (C) 1994-2016 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* This file contains the COFF backend linker code. */
28 #include "coff/internal.h"
30 #include "safe-ctype.h"
32 static bfd_boolean coff_link_add_object_symbols (bfd *, struct bfd_link_info *);
33 static bfd_boolean coff_link_check_archive_element
34 (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
36 static bfd_boolean coff_link_add_symbols (bfd *, struct bfd_link_info *);
38 /* Return TRUE if SYM is a weak, external symbol. */
39 #define IS_WEAK_EXTERNAL(abfd, sym) \
40 ((sym).n_sclass == C_WEAKEXT \
41 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
43 /* Return TRUE if SYM is an external symbol. */
44 #define IS_EXTERNAL(abfd, sym) \
45 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
47 /* Define macros so that the ISFCN, et. al., macros work correctly.
48 These macros are defined in include/coff/internal.h in terms of
49 N_TMASK, etc. These definitions require a user to define local
50 variables with the appropriate names, and with values from the
51 coff_data (abfd) structure. */
53 #define N_TMASK n_tmask
54 #define N_BTSHFT n_btshft
55 #define N_BTMASK n_btmask
57 /* Create an entry in a COFF linker hash table. */
59 struct bfd_hash_entry *
60 _bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
61 struct bfd_hash_table *table,
64 struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
66 /* Allocate the structure if it has not already been allocated by a
68 if (ret == (struct coff_link_hash_entry *) NULL)
69 ret = ((struct coff_link_hash_entry *)
70 bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
71 if (ret == (struct coff_link_hash_entry *) NULL)
72 return (struct bfd_hash_entry *) ret;
74 /* Call the allocation method of the superclass. */
75 ret = ((struct coff_link_hash_entry *)
76 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
78 if (ret != (struct coff_link_hash_entry *) NULL)
80 /* Set local fields. */
83 ret->symbol_class = C_NULL;
89 return (struct bfd_hash_entry *) ret;
92 /* Initialize a COFF linker hash table. */
95 _bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
97 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
98 struct bfd_hash_table *,
100 unsigned int entsize)
102 memset (&table->stab_info, 0, sizeof (table->stab_info));
103 return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
106 /* Create a COFF linker hash table. */
108 struct bfd_link_hash_table *
109 _bfd_coff_link_hash_table_create (bfd *abfd)
111 struct coff_link_hash_table *ret;
112 bfd_size_type amt = sizeof (struct coff_link_hash_table);
114 ret = (struct coff_link_hash_table *) bfd_malloc (amt);
118 if (! _bfd_coff_link_hash_table_init (ret, abfd,
119 _bfd_coff_link_hash_newfunc,
120 sizeof (struct coff_link_hash_entry)))
123 return (struct bfd_link_hash_table *) NULL;
128 /* Create an entry in a COFF debug merge hash table. */
130 struct bfd_hash_entry *
131 _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,
132 struct bfd_hash_table *table,
135 struct coff_debug_merge_hash_entry *ret =
136 (struct coff_debug_merge_hash_entry *) entry;
138 /* Allocate the structure if it has not already been allocated by a
140 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
141 ret = ((struct coff_debug_merge_hash_entry *)
142 bfd_hash_allocate (table,
143 sizeof (struct coff_debug_merge_hash_entry)));
144 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
145 return (struct bfd_hash_entry *) ret;
147 /* Call the allocation method of the superclass. */
148 ret = ((struct coff_debug_merge_hash_entry *)
149 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
150 if (ret != (struct coff_debug_merge_hash_entry *) NULL)
152 /* Set local fields. */
156 return (struct bfd_hash_entry *) ret;
159 /* Given a COFF BFD, add symbols to the global hash table as
163 _bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
165 switch (bfd_get_format (abfd))
168 return coff_link_add_object_symbols (abfd, info);
170 return _bfd_generic_link_add_archive_symbols
171 (abfd, info, coff_link_check_archive_element);
173 bfd_set_error (bfd_error_wrong_format);
178 /* Add symbols from a COFF object file. */
181 coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
183 if (! _bfd_coff_get_external_symbols (abfd))
185 if (! coff_link_add_symbols (abfd, info))
188 if (! info->keep_memory
189 && ! _bfd_coff_free_symbols (abfd))
195 /* Check a single archive element to see if we need to include it in
196 the link. *PNEEDED is set according to whether this element is
197 needed in the link or not. This is called via
198 _bfd_generic_link_add_archive_symbols. */
201 coff_link_check_archive_element (bfd *abfd,
202 struct bfd_link_info *info,
203 struct bfd_link_hash_entry *h,
205 bfd_boolean *pneeded)
209 /* We are only interested in symbols that are currently undefined.
210 If a symbol is currently known to be common, COFF linkers do not
211 bring in an object file which defines it. */
212 if (h->type != bfd_link_hash_undefined)
215 if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd))
219 return coff_link_add_object_symbols (abfd, info);
222 /* Add all the symbols from an object file to the hash table. */
225 coff_link_add_symbols (bfd *abfd,
226 struct bfd_link_info *info)
228 unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
229 unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
230 unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
231 bfd_boolean keep_syms;
232 bfd_boolean default_copy;
233 bfd_size_type symcount;
234 struct coff_link_hash_entry **sym_hash;
235 bfd_size_type symesz;
240 symcount = obj_raw_syment_count (abfd);
243 return TRUE; /* Nothing to do. */
245 /* Keep the symbols during this function, in case the linker needs
246 to read the generic symbols in order to report an error message. */
247 keep_syms = obj_coff_keep_syms (abfd);
248 obj_coff_keep_syms (abfd) = TRUE;
250 if (info->keep_memory)
251 default_copy = FALSE;
255 /* We keep a list of the linker hash table entries that correspond
256 to particular symbols. */
257 amt = symcount * sizeof (struct coff_link_hash_entry *);
258 sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
259 if (sym_hash == NULL)
261 obj_coff_sym_hashes (abfd) = sym_hash;
263 symesz = bfd_coff_symesz (abfd);
264 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
265 esym = (bfd_byte *) obj_coff_external_syms (abfd);
266 esym_end = esym + symcount * symesz;
267 while (esym < esym_end)
269 struct internal_syment sym;
270 enum coff_symbol_classification classification;
273 bfd_coff_swap_sym_in (abfd, esym, &sym);
275 classification = bfd_coff_classify_symbol (abfd, &sym);
276 if (classification != COFF_SYMBOL_LOCAL)
279 char buf[SYMNMLEN + 1];
285 /* This symbol is externally visible. */
287 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
291 /* We must copy the name into memory if we got it from the
292 syment itself, rather than the string table. */
294 if (sym._n._n_n._n_zeroes != 0
295 || sym._n._n_n._n_offset == 0)
300 switch (classification)
305 case COFF_SYMBOL_GLOBAL:
306 flags = BSF_EXPORT | BSF_GLOBAL;
307 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
309 value -= section->vma;
312 case COFF_SYMBOL_UNDEFINED:
314 section = bfd_und_section_ptr;
317 case COFF_SYMBOL_COMMON:
319 section = bfd_com_section_ptr;
322 case COFF_SYMBOL_PE_SECTION:
323 flags = BSF_SECTION_SYM | BSF_GLOBAL;
324 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
328 if (IS_WEAK_EXTERNAL (abfd, sym))
333 /* In the PE format, section symbols actually refer to the
334 start of the output section. We handle them specially
336 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
338 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
339 name, FALSE, copy, FALSE);
340 if (*sym_hash != NULL)
342 if (((*sym_hash)->coff_link_hash_flags
343 & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
344 && (*sym_hash)->root.type != bfd_link_hash_undefined
345 && (*sym_hash)->root.type != bfd_link_hash_undefweak)
346 (*_bfd_error_handler)
347 ("Warning: symbol `%s' is both section and non-section",
354 /* The Microsoft Visual C compiler does string pooling by
355 hashing the constants to an internal symbol name, and
356 relying on the linker comdat support to discard
357 duplicate names. However, if one string is a literal and
358 one is a data initializer, one will end up in the .data
359 section and one will end up in the .rdata section. The
360 Microsoft linker will combine them into the .data
361 section, which seems to be wrong since it might cause the
364 As long as there are no external references to the
365 symbols, which there shouldn't be, we can treat the .data
366 and .rdata instances as separate symbols. The comdat
367 code in the linker will do the appropriate merging. Here
368 we avoid getting a multiple definition error for one of
369 these special symbols.
371 FIXME: I don't think this will work in the case where
372 there are two object files which use the constants as a
373 literal and two object files which use it as a data
374 initializer. One or the other of the second object files
375 is going to wind up with an inappropriate reference. */
377 && (classification == COFF_SYMBOL_GLOBAL
378 || classification == COFF_SYMBOL_PE_SECTION)
379 && coff_section_data (abfd, section) != NULL
380 && coff_section_data (abfd, section)->comdat != NULL
381 && CONST_STRNEQ (name, "??_")
382 && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
384 if (*sym_hash == NULL)
385 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
386 name, FALSE, copy, FALSE);
387 if (*sym_hash != NULL
388 && (*sym_hash)->root.type == bfd_link_hash_defined
389 && coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL
390 && strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,
391 coff_section_data (abfd, section)->comdat->name) == 0)
397 if (! (bfd_coff_link_add_one_symbol
398 (info, abfd, name, flags, section, value,
399 (const char *) NULL, copy, FALSE,
400 (struct bfd_link_hash_entry **) sym_hash)))
404 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
405 (*sym_hash)->coff_link_hash_flags |=
406 COFF_LINK_HASH_PE_SECTION_SYMBOL;
408 /* Limit the alignment of a common symbol to the possible
409 alignment of a section. There is no point to permitting
410 a higher alignment for a common symbol: we can not
411 guarantee it, and it may cause us to allocate extra space
412 in the common section. */
413 if (section == bfd_com_section_ptr
414 && (*sym_hash)->root.type == bfd_link_hash_common
415 && ((*sym_hash)->root.u.c.p->alignment_power
416 > bfd_coff_default_section_alignment_power (abfd)))
417 (*sym_hash)->root.u.c.p->alignment_power
418 = bfd_coff_default_section_alignment_power (abfd);
420 if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
422 /* If we don't have any symbol information currently in
423 the hash table, or if we are looking at a symbol
424 definition, then update the symbol class and type in
426 if (((*sym_hash)->symbol_class == C_NULL
427 && (*sym_hash)->type == T_NULL)
430 && (*sym_hash)->root.type != bfd_link_hash_defined
431 && (*sym_hash)->root.type != bfd_link_hash_defweak))
433 (*sym_hash)->symbol_class = sym.n_sclass;
434 if (sym.n_type != T_NULL)
436 /* We want to warn if the type changed, but not
437 if it changed from an unspecified type.
438 Testing the whole type byte may work, but the
439 change from (e.g.) a function of unspecified
440 type to function of known type also wants to
442 if ((*sym_hash)->type != T_NULL
443 && (*sym_hash)->type != sym.n_type
444 && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
445 && (BTYPE ((*sym_hash)->type) == T_NULL
446 || BTYPE (sym.n_type) == T_NULL)))
447 (*_bfd_error_handler)
448 (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
449 abfd, name, (*sym_hash)->type, sym.n_type);
451 /* We don't want to change from a meaningful
452 base type to a null one, but if we know
453 nothing, take what little we might now know. */
454 if (BTYPE (sym.n_type) != T_NULL
455 || (*sym_hash)->type == T_NULL)
456 (*sym_hash)->type = sym.n_type;
458 (*sym_hash)->auxbfd = abfd;
459 if (sym.n_numaux != 0)
461 union internal_auxent *alloc;
464 union internal_auxent *iaux;
466 (*sym_hash)->numaux = sym.n_numaux;
467 alloc = ((union internal_auxent *)
468 bfd_hash_allocate (&info->hash->table,
470 * sizeof (*alloc))));
473 for (i = 0, eaux = esym + symesz, iaux = alloc;
475 i++, eaux += symesz, iaux++)
476 bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
477 sym.n_sclass, (int) i,
479 (*sym_hash)->aux = alloc;
484 if (classification == COFF_SYMBOL_PE_SECTION
485 && (*sym_hash)->numaux != 0)
487 /* Some PE sections (such as .bss) have a zero size in
488 the section header, but a non-zero size in the AUX
489 record. Correct that here.
491 FIXME: This is not at all the right place to do this.
492 For example, it won't help objdump. This needs to be
493 done when we swap in the section header. */
494 BFD_ASSERT ((*sym_hash)->numaux == 1);
495 if (section->size == 0)
496 section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;
498 /* FIXME: We could test whether the section sizes
499 matches the size in the aux entry, but apparently
500 that sometimes fails unexpectedly. */
504 esym += (sym.n_numaux + 1) * symesz;
505 sym_hash += sym.n_numaux + 1;
508 /* If this is a non-traditional, non-relocatable link, try to
509 optimize the handling of any .stab/.stabstr sections. */
510 if (! bfd_link_relocatable (info)
511 && ! info->traditional_format
512 && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)
513 && (info->strip != strip_all && info->strip != strip_debugger))
517 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
521 bfd_size_type string_offset = 0;
524 for (stab = abfd->sections; stab; stab = stab->next)
525 if (CONST_STRNEQ (stab->name, ".stab")
527 || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
529 struct coff_link_hash_table *table;
530 struct coff_section_tdata *secdata
531 = coff_section_data (abfd, stab);
535 amt = sizeof (struct coff_section_tdata);
536 stab->used_by_bfd = bfd_zalloc (abfd, amt);
537 if (stab->used_by_bfd == NULL)
539 secdata = coff_section_data (abfd, stab);
542 table = coff_hash_table (info);
544 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
553 obj_coff_keep_syms (abfd) = keep_syms;
558 obj_coff_keep_syms (abfd) = keep_syms;
562 /* Do the final link step. */
565 _bfd_coff_final_link (bfd *abfd,
566 struct bfd_link_info *info)
568 bfd_size_type symesz;
569 struct coff_final_link_info flaginfo;
570 bfd_boolean debug_merge_allocated;
571 bfd_boolean long_section_names;
573 struct bfd_link_order *p;
574 bfd_size_type max_sym_count;
575 bfd_size_type max_lineno_count;
576 bfd_size_type max_reloc_count;
577 bfd_size_type max_output_reloc_count;
578 bfd_size_type max_contents_size;
579 file_ptr rel_filepos;
581 file_ptr line_filepos;
584 bfd_byte *external_relocs = NULL;
585 char strbuf[STRING_SIZE_SIZE];
588 symesz = bfd_coff_symesz (abfd);
590 flaginfo.info = info;
591 flaginfo.output_bfd = abfd;
592 flaginfo.strtab = NULL;
593 flaginfo.section_info = NULL;
594 flaginfo.last_file_index = -1;
595 flaginfo.last_bf_index = -1;
596 flaginfo.internal_syms = NULL;
597 flaginfo.sec_ptrs = NULL;
598 flaginfo.sym_indices = NULL;
599 flaginfo.outsyms = NULL;
600 flaginfo.linenos = NULL;
601 flaginfo.contents = NULL;
602 flaginfo.external_relocs = NULL;
603 flaginfo.internal_relocs = NULL;
604 flaginfo.global_to_static = FALSE;
605 debug_merge_allocated = FALSE;
607 coff_data (abfd)->link_info = info;
609 flaginfo.strtab = _bfd_stringtab_init ();
610 if (flaginfo.strtab == NULL)
613 if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))
615 debug_merge_allocated = TRUE;
617 /* Compute the file positions for all the sections. */
618 if (! abfd->output_has_begun)
620 if (! bfd_coff_compute_section_file_positions (abfd))
624 /* Count the line numbers and relocation entries required for the
625 output file. Set the file positions for the relocs. */
626 rel_filepos = obj_relocbase (abfd);
627 relsz = bfd_coff_relsz (abfd);
628 max_contents_size = 0;
629 max_lineno_count = 0;
632 long_section_names = FALSE;
633 for (o = abfd->sections; o != NULL; o = o->next)
637 for (p = o->map_head.link_order; p != NULL; p = p->next)
639 if (p->type == bfd_indirect_link_order)
643 sec = p->u.indirect.section;
645 /* Mark all sections which are to be included in the
646 link. This will normally be every section. We need
647 to do this so that we can identify any sections which
648 the linker has decided to not include. */
649 sec->linker_mark = TRUE;
651 if (info->strip == strip_none
652 || info->strip == strip_some)
653 o->lineno_count += sec->lineno_count;
655 if (bfd_link_relocatable (info))
656 o->reloc_count += sec->reloc_count;
658 if (sec->rawsize > max_contents_size)
659 max_contents_size = sec->rawsize;
660 if (sec->size > max_contents_size)
661 max_contents_size = sec->size;
662 if (sec->lineno_count > max_lineno_count)
663 max_lineno_count = sec->lineno_count;
664 if (sec->reloc_count > max_reloc_count)
665 max_reloc_count = sec->reloc_count;
667 else if (bfd_link_relocatable (info)
668 && (p->type == bfd_section_reloc_link_order
669 || p->type == bfd_symbol_reloc_link_order))
672 if (o->reloc_count == 0)
676 o->flags |= SEC_RELOC;
677 o->rel_filepos = rel_filepos;
678 rel_filepos += o->reloc_count * relsz;
679 /* In PE COFF, if there are at least 0xffff relocations an
680 extra relocation will be written out to encode the count. */
681 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
682 rel_filepos += relsz;
685 if (bfd_coff_long_section_names (abfd)
686 && strlen (o->name) > SCNNMLEN)
688 /* This section has a long name which must go in the string
689 table. This must correspond to the code in
690 coff_write_object_contents which puts the string index
691 into the s_name field of the section header. That is why
692 we pass hash as FALSE. */
693 if (_bfd_stringtab_add (flaginfo.strtab, o->name, FALSE, FALSE)
694 == (bfd_size_type) -1)
696 long_section_names = TRUE;
700 /* If doing a relocatable link, allocate space for the pointers we
702 if (bfd_link_relocatable (info))
706 /* We use section_count + 1, rather than section_count, because
707 the target_index fields are 1 based. */
708 amt = abfd->section_count + 1;
709 amt *= sizeof (struct coff_link_section_info);
710 flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
711 if (flaginfo.section_info == NULL)
713 for (i = 0; i <= abfd->section_count; i++)
715 flaginfo.section_info[i].relocs = NULL;
716 flaginfo.section_info[i].rel_hashes = NULL;
720 /* We now know the size of the relocs, so we can determine the file
721 positions of the line numbers. */
722 line_filepos = rel_filepos;
723 linesz = bfd_coff_linesz (abfd);
724 max_output_reloc_count = 0;
725 for (o = abfd->sections; o != NULL; o = o->next)
727 if (o->lineno_count == 0)
731 o->line_filepos = line_filepos;
732 line_filepos += o->lineno_count * linesz;
735 if (o->reloc_count != 0)
737 /* We don't know the indices of global symbols until we have
738 written out all the local symbols. For each section in
739 the output file, we keep an array of pointers to hash
740 table entries. Each entry in the array corresponds to a
741 reloc. When we find a reloc against a global symbol, we
742 set the corresponding entry in this array so that we can
743 fix up the symbol index after we have written out all the
746 Because of this problem, we also keep the relocs in
747 memory until the end of the link. This wastes memory,
748 but only when doing a relocatable link, which is not the
750 BFD_ASSERT (bfd_link_relocatable (info));
751 amt = o->reloc_count;
752 amt *= sizeof (struct internal_reloc);
753 flaginfo.section_info[o->target_index].relocs =
754 (struct internal_reloc *) bfd_malloc (amt);
755 amt = o->reloc_count;
756 amt *= sizeof (struct coff_link_hash_entry *);
757 flaginfo.section_info[o->target_index].rel_hashes =
758 (struct coff_link_hash_entry **) bfd_malloc (amt);
759 if (flaginfo.section_info[o->target_index].relocs == NULL
760 || flaginfo.section_info[o->target_index].rel_hashes == NULL)
763 if (o->reloc_count > max_output_reloc_count)
764 max_output_reloc_count = o->reloc_count;
767 /* Reset the reloc and lineno counts, so that we can use them to
768 count the number of entries we have output so far. */
773 obj_sym_filepos (abfd) = line_filepos;
775 /* Figure out the largest number of symbols in an input BFD. Take
776 the opportunity to clear the output_has_begun fields of all the
779 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
783 sub->output_has_begun = FALSE;
784 sz = bfd_family_coff (sub) ? obj_raw_syment_count (sub) : 2;
785 if (sz > max_sym_count)
789 /* Allocate some buffers used while linking. */
790 amt = max_sym_count * sizeof (struct internal_syment);
791 flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
792 amt = max_sym_count * sizeof (asection *);
793 flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);
794 amt = max_sym_count * sizeof (long);
795 flaginfo.sym_indices = (long int *) bfd_malloc (amt);
796 flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
797 amt = max_lineno_count * bfd_coff_linesz (abfd);
798 flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
799 flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
800 amt = max_reloc_count * relsz;
801 flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
802 if (! bfd_link_relocatable (info))
804 amt = max_reloc_count * sizeof (struct internal_reloc);
805 flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
807 if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
808 || (flaginfo.sec_ptrs == NULL && max_sym_count > 0)
809 || (flaginfo.sym_indices == NULL && max_sym_count > 0)
810 || flaginfo.outsyms == NULL
811 || (flaginfo.linenos == NULL && max_lineno_count > 0)
812 || (flaginfo.contents == NULL && max_contents_size > 0)
813 || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
814 || (! bfd_link_relocatable (info)
815 && flaginfo.internal_relocs == NULL
816 && max_reloc_count > 0))
819 /* We now know the position of everything in the file, except that
820 we don't know the size of the symbol table and therefore we don't
821 know where the string table starts. We just build the string
822 table in memory as we go along. We process all the relocations
823 for a single input file at once. */
824 obj_raw_syment_count (abfd) = 0;
826 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
828 if (! bfd_coff_start_final_link (abfd, info))
832 for (o = abfd->sections; o != NULL; o = o->next)
834 for (p = o->map_head.link_order; p != NULL; p = p->next)
836 if (p->type == bfd_indirect_link_order
837 && bfd_family_coff (p->u.indirect.section->owner))
839 sub = p->u.indirect.section->owner;
840 if (! bfd_coff_link_output_has_begun (sub, & flaginfo))
842 if (! _bfd_coff_link_input_bfd (&flaginfo, sub))
844 sub->output_has_begun = TRUE;
847 else if (p->type == bfd_section_reloc_link_order
848 || p->type == bfd_symbol_reloc_link_order)
850 if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))
855 if (! _bfd_default_link_order (abfd, info, o, p))
861 if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all)
863 /* Add local symbols from foreign inputs. */
864 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
868 if (bfd_family_coff (sub) || ! bfd_get_outsymbols (sub))
870 for (i = 0; i < bfd_get_symcount (sub); ++i)
872 asymbol *sym = bfd_get_outsymbols (sub) [i];
874 struct internal_syment isym;
875 union internal_auxent iaux;
876 bfd_size_type string_size = 0, indx;
878 bfd_boolean rewrite = FALSE, hash;
880 if (! (sym->flags & BSF_LOCAL)
881 || (sym->flags & (BSF_SECTION_SYM | BSF_DEBUGGING_RELOC
882 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC
884 || ((sym->flags & BSF_DEBUGGING)
885 && ! (sym->flags & BSF_FILE)))
888 /* See if we are discarding symbols with this name. */
889 if ((flaginfo.info->strip == strip_some
890 && (bfd_hash_lookup (flaginfo.info->keep_hash,
891 bfd_asymbol_name(sym), FALSE, FALSE)
893 || (((flaginfo.info->discard == discard_sec_merge
894 && (bfd_get_section (sym)->flags & SEC_MERGE)
895 && ! bfd_link_relocatable (flaginfo.info))
896 || flaginfo.info->discard == discard_l)
897 && bfd_is_local_label_name (sub, bfd_asymbol_name(sym))))
900 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd)
902 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
904 if (! coff_write_alien_symbol(abfd, sym, &isym, &iaux, &written,
905 &string_size, NULL, NULL))
908 hash = !flaginfo.info->traditional_format;
910 if (string_size >= 6 && isym.n_sclass == C_FILE
911 && ! isym._n._n_n._n_zeroes && isym.n_numaux)
913 indx = _bfd_stringtab_add (flaginfo.strtab, ".file", hash,
915 if (indx == (bfd_size_type) -1)
917 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
918 bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
919 if (bfd_seek (abfd, pos, SEEK_SET) != 0
920 || bfd_bwrite (flaginfo.outsyms, symesz,
928 indx = _bfd_stringtab_add (flaginfo.strtab,
929 bfd_asymbol_name (sym), hash,
931 if (indx == (bfd_size_type) -1)
933 if (isym.n_sclass != C_FILE)
935 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
936 bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
941 BFD_ASSERT (isym.n_numaux == 1);
942 iaux.x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
943 bfd_coff_swap_aux_out (abfd, &iaux, isym.n_type, C_FILE,
944 0, 1, flaginfo.outsyms + symesz);
945 if (bfd_seek (abfd, pos + symesz, SEEK_SET) != 0
946 || bfd_bwrite (flaginfo.outsyms + symesz, symesz,
952 if (isym.n_sclass == C_FILE)
954 if (flaginfo.last_file_index != -1)
956 flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
957 bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
959 pos = obj_sym_filepos (abfd) + flaginfo.last_file_index
963 flaginfo.last_file_index = obj_raw_syment_count (abfd);
964 flaginfo.last_file = isym;
968 && (bfd_seek (abfd, pos, SEEK_SET) != 0
969 || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz))
972 obj_raw_syment_count (abfd) += written;
977 if (! bfd_coff_final_link_postscript (abfd, & flaginfo))
980 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
982 coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
983 debug_merge_allocated = FALSE;
985 if (flaginfo.internal_syms != NULL)
987 free (flaginfo.internal_syms);
988 flaginfo.internal_syms = NULL;
990 if (flaginfo.sec_ptrs != NULL)
992 free (flaginfo.sec_ptrs);
993 flaginfo.sec_ptrs = NULL;
995 if (flaginfo.sym_indices != NULL)
997 free (flaginfo.sym_indices);
998 flaginfo.sym_indices = NULL;
1000 if (flaginfo.linenos != NULL)
1002 free (flaginfo.linenos);
1003 flaginfo.linenos = NULL;
1005 if (flaginfo.contents != NULL)
1007 free (flaginfo.contents);
1008 flaginfo.contents = NULL;
1010 if (flaginfo.external_relocs != NULL)
1012 free (flaginfo.external_relocs);
1013 flaginfo.external_relocs = NULL;
1015 if (flaginfo.internal_relocs != NULL)
1017 free (flaginfo.internal_relocs);
1018 flaginfo.internal_relocs = NULL;
1021 /* The value of the last C_FILE symbol is supposed to be the symbol
1022 index of the first external symbol. Write it out again if
1024 if (flaginfo.last_file_index != -1
1025 && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))
1029 flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
1030 bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
1033 pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;
1034 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1035 || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)
1039 /* If doing task linking (ld --task-link) then make a pass through the
1040 global symbols, writing out any that are defined, and making them
1042 if (info->task_link)
1044 flaginfo.failed = FALSE;
1045 coff_link_hash_traverse (coff_hash_table (info),
1046 _bfd_coff_write_task_globals, &flaginfo);
1047 if (flaginfo.failed)
1051 /* Write out the global symbols. */
1052 flaginfo.failed = FALSE;
1053 bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);
1054 if (flaginfo.failed)
1057 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
1058 if (flaginfo.outsyms != NULL)
1060 free (flaginfo.outsyms);
1061 flaginfo.outsyms = NULL;
1064 if (bfd_link_relocatable (info) && max_output_reloc_count > 0)
1066 /* Now that we have written out all the global symbols, we know
1067 the symbol indices to use for relocs against them, and we can
1068 finally write out the relocs. */
1069 amt = max_output_reloc_count * relsz;
1070 external_relocs = (bfd_byte *) bfd_malloc (amt);
1071 if (external_relocs == NULL)
1074 for (o = abfd->sections; o != NULL; o = o->next)
1076 struct internal_reloc *irel;
1077 struct internal_reloc *irelend;
1078 struct coff_link_hash_entry **rel_hash;
1081 if (o->reloc_count == 0)
1084 irel = flaginfo.section_info[o->target_index].relocs;
1085 irelend = irel + o->reloc_count;
1086 rel_hash = flaginfo.section_info[o->target_index].rel_hashes;
1087 erel = external_relocs;
1088 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1090 if (*rel_hash != NULL)
1092 BFD_ASSERT ((*rel_hash)->indx >= 0);
1093 irel->r_symndx = (*rel_hash)->indx;
1095 bfd_coff_swap_reloc_out (abfd, irel, erel);
1098 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
1100 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
1102 /* In PE COFF, write the count of relocs as the first
1103 reloc. The header overflow bit will be set
1105 struct internal_reloc incount;
1106 bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
1108 memset (&incount, 0, sizeof (incount));
1109 incount.r_vaddr = o->reloc_count + 1;
1110 bfd_coff_swap_reloc_out (abfd, &incount, excount);
1111 if (bfd_bwrite (excount, relsz, abfd) != relsz)
1112 /* We'll leak, but it's an error anyway. */
1116 if (bfd_bwrite (external_relocs,
1117 (bfd_size_type) relsz * o->reloc_count, abfd)
1118 != (bfd_size_type) relsz * o->reloc_count)
1122 free (external_relocs);
1123 external_relocs = NULL;
1126 /* Free up the section information. */
1127 if (flaginfo.section_info != NULL)
1131 for (i = 0; i < abfd->section_count; i++)
1133 if (flaginfo.section_info[i].relocs != NULL)
1134 free (flaginfo.section_info[i].relocs);
1135 if (flaginfo.section_info[i].rel_hashes != NULL)
1136 free (flaginfo.section_info[i].rel_hashes);
1138 free (flaginfo.section_info);
1139 flaginfo.section_info = NULL;
1142 /* If we have optimized stabs strings, output them. */
1143 if (coff_hash_table (info)->stab_info.stabstr != NULL)
1145 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1149 /* Write out the string table. */
1150 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1154 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1155 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1158 #if STRING_SIZE_SIZE == 4
1160 _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,
1163 #error Change H_PUT_32 above
1166 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1167 != STRING_SIZE_SIZE)
1170 if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
1173 obj_coff_strings_written (abfd) = TRUE;
1176 _bfd_stringtab_free (flaginfo.strtab);
1178 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1179 not try to write out the symbols. */
1180 bfd_get_symcount (abfd) = 0;
1185 if (debug_merge_allocated)
1186 coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
1187 if (flaginfo.strtab != NULL)
1188 _bfd_stringtab_free (flaginfo.strtab);
1189 if (flaginfo.section_info != NULL)
1193 for (i = 0; i < abfd->section_count; i++)
1195 if (flaginfo.section_info[i].relocs != NULL)
1196 free (flaginfo.section_info[i].relocs);
1197 if (flaginfo.section_info[i].rel_hashes != NULL)
1198 free (flaginfo.section_info[i].rel_hashes);
1200 free (flaginfo.section_info);
1202 if (flaginfo.internal_syms != NULL)
1203 free (flaginfo.internal_syms);
1204 if (flaginfo.sec_ptrs != NULL)
1205 free (flaginfo.sec_ptrs);
1206 if (flaginfo.sym_indices != NULL)
1207 free (flaginfo.sym_indices);
1208 if (flaginfo.outsyms != NULL)
1209 free (flaginfo.outsyms);
1210 if (flaginfo.linenos != NULL)
1211 free (flaginfo.linenos);
1212 if (flaginfo.contents != NULL)
1213 free (flaginfo.contents);
1214 if (flaginfo.external_relocs != NULL)
1215 free (flaginfo.external_relocs);
1216 if (flaginfo.internal_relocs != NULL)
1217 free (flaginfo.internal_relocs);
1218 if (external_relocs != NULL)
1219 free (external_relocs);
1223 /* Parse out a -heap <reserved>,<commit> line. */
1226 dores_com (char *ptr, bfd *output_bfd, int heap)
1228 if (coff_data(output_bfd)->pe)
1230 int val = strtoul (ptr, &ptr, 0);
1233 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1235 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1239 val = strtoul (ptr+1, &ptr, 0);
1241 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1243 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1250 get_name (char *ptr, char **dst)
1255 while (*ptr && *ptr != ' ')
1261 /* Process any magic embedded commands in a section called .drectve. */
1264 process_embedded_commands (bfd *output_bfd,
1265 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1268 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1276 if (!bfd_malloc_and_get_section (abfd, sec, ©))
1282 e = (char *) copy + sec->size;
1284 for (s = (char *) copy; s < e ; )
1291 if (CONST_STRNEQ (s, "-attr"))
1301 s = get_name (s, &name);
1302 s = get_name (s, &attribs);
1322 asec = bfd_get_section_by_name (abfd, name);
1326 asec->flags |= SEC_CODE;
1328 asec->flags |= SEC_READONLY;
1331 else if (CONST_STRNEQ (s, "-heap"))
1332 s = dores_com (s + 5, output_bfd, 1);
1334 else if (CONST_STRNEQ (s, "-stack"))
1335 s = dores_com (s + 6, output_bfd, 0);
1337 /* GNU extension for aligned commons. */
1338 else if (CONST_STRNEQ (s, "-aligncomm:"))
1340 /* Common symbols must be aligned on reading, as it
1341 is too late to do anything here, after they have
1342 already been allocated, so just skip the directive. */
1353 /* Place a marker against all symbols which are used by relocations.
1354 This marker can be picked up by the 'do we skip this symbol ?'
1355 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1359 mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd)
1363 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1366 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1368 struct internal_reloc * internal_relocs;
1369 struct internal_reloc * irel;
1370 struct internal_reloc * irelend;
1372 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1
1373 || a->linker_mark == 0)
1375 /* Don't mark relocs in excluded sections. */
1376 if (a->output_section == bfd_abs_section_ptr)
1379 /* Read in the relocs. */
1380 internal_relocs = _bfd_coff_read_internal_relocs
1381 (input_bfd, a, FALSE,
1382 flaginfo->external_relocs,
1383 bfd_link_relocatable (flaginfo->info),
1384 (bfd_link_relocatable (flaginfo->info)
1385 ? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1386 : flaginfo->internal_relocs)
1389 if (internal_relocs == NULL)
1392 irel = internal_relocs;
1393 irelend = irel + a->reloc_count;
1395 /* Place a mark in the sym_indices array (whose entries have
1396 been initialised to 0) for all of the symbols that are used
1397 in the relocation table. This will then be picked up in the
1398 skip/don't-skip pass. */
1399 for (; irel < irelend; irel++)
1400 flaginfo->sym_indices[ irel->r_symndx ] = -1;
1404 /* Link an input file into the linker output file. This function
1405 handles all the sections and relocations of the input file at once. */
1408 _bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd)
1410 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1411 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1412 bfd_boolean (*adjust_symndx)
1413 (bfd *, struct bfd_link_info *, bfd *, asection *,
1414 struct internal_reloc *, bfd_boolean *);
1416 const char *strings;
1417 bfd_size_type syment_base;
1418 bfd_boolean copy, hash;
1419 bfd_size_type isymesz;
1420 bfd_size_type osymesz;
1421 bfd_size_type linesz;
1424 struct internal_syment *isymp;
1427 unsigned long output_index;
1429 struct coff_link_hash_entry **sym_hash;
1432 /* Move all the symbols to the output file. */
1434 output_bfd = flaginfo->output_bfd;
1436 syment_base = obj_raw_syment_count (output_bfd);
1437 isymesz = bfd_coff_symesz (input_bfd);
1438 osymesz = bfd_coff_symesz (output_bfd);
1439 linesz = bfd_coff_linesz (input_bfd);
1440 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1443 if (! flaginfo->info->keep_memory)
1446 if (flaginfo->info->traditional_format)
1449 if (! _bfd_coff_get_external_symbols (input_bfd))
1452 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1453 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1454 isymp = flaginfo->internal_syms;
1455 secpp = flaginfo->sec_ptrs;
1456 indexp = flaginfo->sym_indices;
1457 output_index = syment_base;
1458 outsym = flaginfo->outsyms;
1460 if (coff_data (output_bfd)->pe
1461 && ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd))
1464 /* If we are going to perform relocations and also strip/discard some
1465 symbols then we must make sure that we do not strip/discard those
1466 symbols that are going to be involved in the relocations. */
1467 if (( flaginfo->info->strip != strip_none
1468 || flaginfo->info->discard != discard_none)
1469 && bfd_link_relocatable (flaginfo->info))
1471 /* Mark the symbol array as 'not-used'. */
1472 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1474 mark_relocs (flaginfo, input_bfd);
1477 while (esym < esym_end)
1479 struct internal_syment isym;
1480 enum coff_symbol_classification classification;
1483 bfd_boolean dont_skip_symbol;
1486 bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1488 /* Make a copy of *isymp so that the relocate_section function
1489 always sees the original values. This is more reliable than
1490 always recomputing the symbol value even if we are stripping
1494 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1495 switch (classification)
1499 case COFF_SYMBOL_GLOBAL:
1500 case COFF_SYMBOL_PE_SECTION:
1501 case COFF_SYMBOL_LOCAL:
1502 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1504 case COFF_SYMBOL_COMMON:
1505 *secpp = bfd_com_section_ptr;
1507 case COFF_SYMBOL_UNDEFINED:
1508 *secpp = bfd_und_section_ptr;
1512 /* Extract the flag indicating if this symbol is used by a
1514 if ((flaginfo->info->strip != strip_none
1515 || flaginfo->info->discard != discard_none)
1516 && bfd_link_relocatable (flaginfo->info))
1517 dont_skip_symbol = *indexp;
1519 dont_skip_symbol = FALSE;
1525 add = 1 + isym.n_numaux;
1527 /* If we are stripping all symbols, we want to skip this one. */
1528 if (flaginfo->info->strip == strip_all && ! dont_skip_symbol)
1533 switch (classification)
1537 case COFF_SYMBOL_GLOBAL:
1538 case COFF_SYMBOL_COMMON:
1539 case COFF_SYMBOL_PE_SECTION:
1540 /* This is a global symbol. Global symbols come at the
1541 end of the symbol table, so skip them for now.
1542 Locally defined function symbols, however, are an
1543 exception, and are not moved to the end. */
1545 if (! ISFCN (isym.n_type))
1549 case COFF_SYMBOL_UNDEFINED:
1550 /* Undefined symbols are left for the end. */
1555 case COFF_SYMBOL_LOCAL:
1556 /* This is a local symbol. Skip it if we are discarding
1558 if (flaginfo->info->discard == discard_all && ! dont_skip_symbol)
1564 #ifndef COFF_WITH_PE
1565 /* Skip section symbols for sections which are not going to be
1568 && !dont_skip_symbol
1569 && isym.n_sclass == C_STAT
1570 && isym.n_type == T_NULL
1571 && isym.n_numaux > 0
1572 && ((*secpp)->output_section == bfd_abs_section_ptr
1573 || bfd_section_removed_from_list (output_bfd,
1574 (*secpp)->output_section)))
1578 /* If we stripping debugging symbols, and this is a debugging
1579 symbol, then skip it. FIXME: gas sets the section to N_ABS
1580 for some types of debugging symbols; I don't know if this is
1581 a bug or not. In any case, we handle it here. */
1583 && flaginfo->info->strip == strip_debugger
1584 && ! dont_skip_symbol
1585 && (isym.n_scnum == N_DEBUG
1586 || (isym.n_scnum == N_ABS
1587 && (isym.n_sclass == C_AUTO
1588 || isym.n_sclass == C_REG
1589 || isym.n_sclass == C_MOS
1590 || isym.n_sclass == C_MOE
1591 || isym.n_sclass == C_MOU
1592 || isym.n_sclass == C_ARG
1593 || isym.n_sclass == C_REGPARM
1594 || isym.n_sclass == C_FIELD
1595 || isym.n_sclass == C_EOS))))
1598 /* If some symbols are stripped based on the name, work out the
1599 name and decide whether to skip this symbol. */
1601 && (flaginfo->info->strip == strip_some
1602 || flaginfo->info->discard == discard_l))
1605 char buf[SYMNMLEN + 1];
1607 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1611 if (! dont_skip_symbol
1612 && ((flaginfo->info->strip == strip_some
1613 && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE,
1616 && flaginfo->info->discard == discard_l
1617 && bfd_is_local_label_name (input_bfd, name))))
1621 /* If this is an enum, struct, or union tag, see if we have
1622 already output an identical type. */
1624 && !flaginfo->info->traditional_format
1625 && (isym.n_sclass == C_ENTAG
1626 || isym.n_sclass == C_STRTAG
1627 || isym.n_sclass == C_UNTAG)
1628 && isym.n_numaux == 1)
1631 char buf[SYMNMLEN + 1];
1632 struct coff_debug_merge_hash_entry *mh;
1633 struct coff_debug_merge_type *mt;
1634 union internal_auxent aux;
1635 struct coff_debug_merge_element **epp;
1636 bfd_byte *esl, *eslend;
1637 struct internal_syment *islp;
1640 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1644 /* Ignore fake names invented by compiler; treat them all as
1646 if (*name == '~' || *name == '.' || *name == '$'
1647 || (*name == bfd_get_symbol_leading_char (input_bfd)
1648 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1651 mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name,
1656 /* Allocate memory to hold type information. If this turns
1657 out to be a duplicate, we pass this address to
1659 amt = sizeof (struct coff_debug_merge_type);
1660 mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
1663 mt->type_class = isym.n_sclass;
1665 /* Pick up the aux entry, which points to the end of the tag
1667 bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1668 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1671 /* Gather the elements. */
1672 epp = &mt->elements;
1673 mt->elements = NULL;
1675 esl = esym + 2 * isymesz;
1676 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1677 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1678 while (esl < eslend)
1680 const char *elename;
1681 char elebuf[SYMNMLEN + 1];
1684 bfd_coff_swap_sym_in (input_bfd, esl, islp);
1686 amt = sizeof (struct coff_debug_merge_element);
1687 *epp = (struct coff_debug_merge_element *)
1688 bfd_alloc (input_bfd, amt);
1692 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1694 if (elename == NULL)
1697 amt = strlen (elename) + 1;
1698 name_copy = (char *) bfd_alloc (input_bfd, amt);
1699 if (name_copy == NULL)
1701 strcpy (name_copy, elename);
1703 (*epp)->name = name_copy;
1704 (*epp)->type = islp->n_type;
1706 if (islp->n_numaux >= 1
1707 && islp->n_type != T_NULL
1708 && islp->n_sclass != C_EOS)
1710 union internal_auxent eleaux;
1713 bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1714 islp->n_type, islp->n_sclass, 0,
1715 islp->n_numaux, &eleaux);
1716 indx = eleaux.x_sym.x_tagndx.l;
1718 /* FIXME: If this tagndx entry refers to a symbol
1719 defined later in this file, we just ignore it.
1720 Handling this correctly would be tedious, and may
1725 (bfd_byte *) obj_coff_external_syms (input_bfd))
1728 (*epp)->tagndx = flaginfo->sym_indices[indx];
1729 if ((*epp)->tagndx < 0)
1733 epp = &(*epp)->next;
1736 esl += (islp->n_numaux + 1) * isymesz;
1737 islp += islp->n_numaux + 1;
1740 /* See if we already have a definition which matches this
1741 type. We always output the type if it has no elements,
1743 if (mt->elements == NULL)
1744 bfd_release (input_bfd, mt);
1747 struct coff_debug_merge_type *mtl;
1749 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1751 struct coff_debug_merge_element *me, *mel;
1753 if (mtl->type_class != mt->type_class)
1756 for (me = mt->elements, mel = mtl->elements;
1757 me != NULL && mel != NULL;
1758 me = me->next, mel = mel->next)
1760 if (strcmp (me->name, mel->name) != 0
1761 || me->type != mel->type
1762 || me->tagndx != mel->tagndx)
1766 if (me == NULL && mel == NULL)
1770 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1772 /* This is the first definition of this type. */
1773 mt->indx = output_index;
1774 mt->next = mh->types;
1779 /* This is a redefinition which can be merged. */
1780 bfd_release (input_bfd, mt);
1781 *indexp = mtl->indx;
1782 add = (eslend - esym) / isymesz;
1788 /* We now know whether we are to skip this symbol or not. */
1791 /* Adjust the symbol in order to output it. */
1793 if (isym._n._n_n._n_zeroes == 0
1794 && isym._n._n_n._n_offset != 0)
1799 /* This symbol has a long name. Enter it in the string
1800 table we are building. Note that we do not check
1801 bfd_coff_symname_in_debug. That is only true for
1802 XCOFF, and XCOFF requires different linking code
1804 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1807 indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy);
1808 if (indx == (bfd_size_type) -1)
1810 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1813 switch (isym.n_sclass)
1829 /* The symbol value should not be modified. */
1833 if (obj_pe (input_bfd)
1834 && strcmp (isym.n_name, ".bf") != 0
1835 && isym.n_scnum > 0)
1837 /* For PE, .lf and .ef get their value left alone,
1838 while .bf gets relocated. However, they all have
1839 "real" section numbers, and need to be moved into
1841 isym.n_scnum = (*secpp)->output_section->target_index;
1846 case C_LABEL: /* Not completely sure about these 2 */
1855 /* Compute new symbol location. */
1856 if (isym.n_scnum > 0)
1858 isym.n_scnum = (*secpp)->output_section->target_index;
1859 isym.n_value += (*secpp)->output_offset;
1860 if (! obj_pe (input_bfd))
1861 isym.n_value -= (*secpp)->vma;
1862 if (! obj_pe (flaginfo->output_bfd))
1863 isym.n_value += (*secpp)->output_section->vma;
1868 /* The value of a C_FILE symbol is the symbol index of
1869 the next C_FILE symbol. The value of the last C_FILE
1870 symbol is the symbol index to the first external
1871 symbol (actually, coff_renumber_symbols does not get
1872 this right--it just sets the value of the last C_FILE
1873 symbol to zero--and nobody has ever complained about
1874 it). We try to get this right, below, just before we
1875 write the symbols out, but in the general case we may
1876 have to write the symbol out twice. */
1877 if (flaginfo->last_file_index != -1
1878 && flaginfo->last_file.n_value != (bfd_vma) output_index)
1880 /* We must correct the value of the last C_FILE
1882 flaginfo->last_file.n_value = output_index;
1883 if ((bfd_size_type) flaginfo->last_file_index >= syment_base)
1885 /* The last C_FILE symbol is in this input file. */
1886 bfd_coff_swap_sym_out (output_bfd,
1887 &flaginfo->last_file,
1889 + ((flaginfo->last_file_index
1897 /* We have already written out the last C_FILE
1898 symbol. We need to write it out again. We
1899 borrow *outsym temporarily. */
1900 bfd_coff_swap_sym_out (output_bfd,
1901 &flaginfo->last_file, outsym);
1902 pos = obj_sym_filepos (output_bfd);
1903 pos += flaginfo->last_file_index * osymesz;
1904 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1905 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1910 flaginfo->last_file_index = output_index;
1911 flaginfo->last_file = isym;
1915 /* If doing task linking, convert normal global function symbols to
1916 static functions. */
1917 if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1918 isym.n_sclass = C_STAT;
1920 /* Output the symbol. */
1921 bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1923 *indexp = output_index;
1928 struct coff_link_hash_entry *h;
1930 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1932 h = obj_coff_sym_hashes (input_bfd)[indx];
1935 /* This can happen if there were errors earlier in
1937 bfd_set_error (bfd_error_bad_value);
1940 h->indx = output_index;
1943 output_index += add;
1944 outsym += add * osymesz;
1947 esym += add * isymesz;
1951 for (--add; add > 0; --add)
1958 /* Fix up the aux entries. This must be done in a separate pass,
1959 because we don't know the correct symbol indices until we have
1960 already decided which symbols we are going to keep. */
1961 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1962 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1963 isymp = flaginfo->internal_syms;
1964 indexp = flaginfo->sym_indices;
1965 sym_hash = obj_coff_sym_hashes (input_bfd);
1966 outsym = flaginfo->outsyms;
1968 while (esym < esym_end)
1972 add = 1 + isymp->n_numaux;
1975 || (bfd_size_type) *indexp < syment_base)
1976 && (*sym_hash == NULL
1977 || (*sym_hash)->auxbfd != input_bfd))
1978 esym += add * isymesz;
1981 struct coff_link_hash_entry *h;
1989 /* The m68k-motorola-sysv assembler will sometimes
1990 generate two symbols with the same name, but only one
1991 will have aux entries. */
1992 BFD_ASSERT (isymp->n_numaux == 0
1994 || h->numaux == isymp->n_numaux);
2002 /* Handle the aux entries. This handling is based on
2003 coff_pointerize_aux. I don't know if it always correct. */
2004 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
2006 union internal_auxent aux;
2007 union internal_auxent *auxp;
2009 if (h != NULL && h->aux != NULL && (h->numaux > i))
2013 bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
2014 isymp->n_sclass, i, isymp->n_numaux, &aux);
2018 if (isymp->n_sclass == C_FILE)
2020 /* If this is a long filename, we must put it in the
2022 if (auxp->x_file.x_n.x_zeroes == 0
2023 && auxp->x_file.x_n.x_offset != 0)
2025 const char *filename;
2028 BFD_ASSERT (auxp->x_file.x_n.x_offset
2029 >= STRING_SIZE_SIZE);
2030 if (strings == NULL)
2032 strings = _bfd_coff_read_string_table (input_bfd);
2033 if (strings == NULL)
2036 if ((bfd_size_type) auxp->x_file.x_n.x_offset >= obj_coff_strings_len (input_bfd))
2037 filename = _("<corrupt>");
2039 filename = strings + auxp->x_file.x_n.x_offset;
2040 indx = _bfd_stringtab_add (flaginfo->strtab, filename,
2042 if (indx == (bfd_size_type) -1)
2044 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
2047 else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
2048 && isymp->n_sclass != C_NT_WEAK)
2052 if (ISFCN (isymp->n_type)
2053 || ISTAG (isymp->n_sclass)
2054 || isymp->n_sclass == C_BLOCK
2055 || isymp->n_sclass == C_FCN)
2057 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
2059 && indx < obj_raw_syment_count (input_bfd))
2061 /* We look forward through the symbol for
2062 the index of the next symbol we are going
2063 to include. I don't know if this is
2065 while ((flaginfo->sym_indices[indx] < 0
2066 || ((bfd_size_type) flaginfo->sym_indices[indx]
2068 && indx < obj_raw_syment_count (input_bfd))
2070 if (indx >= obj_raw_syment_count (input_bfd))
2071 indx = output_index;
2073 indx = flaginfo->sym_indices[indx];
2074 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2078 indx = auxp->x_sym.x_tagndx.l;
2079 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2083 symindx = flaginfo->sym_indices[indx];
2085 auxp->x_sym.x_tagndx.l = 0;
2087 auxp->x_sym.x_tagndx.l = symindx;
2090 /* The .bf symbols are supposed to be linked through
2091 the endndx field. We need to carry this list
2092 across object files. */
2095 && isymp->n_sclass == C_FCN
2096 && (isymp->_n._n_n._n_zeroes != 0
2097 || isymp->_n._n_n._n_offset == 0)
2098 && isymp->_n._n_name[0] == '.'
2099 && isymp->_n._n_name[1] == 'b'
2100 && isymp->_n._n_name[2] == 'f'
2101 && isymp->_n._n_name[3] == '\0')
2103 if (flaginfo->last_bf_index != -1)
2105 flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2108 if ((bfd_size_type) flaginfo->last_bf_index
2113 /* The last .bf symbol is in this input
2114 file. This will only happen if the
2115 assembler did not set up the .bf
2116 endndx symbols correctly. */
2117 auxout = (flaginfo->outsyms
2118 + ((flaginfo->last_bf_index
2122 bfd_coff_swap_aux_out (output_bfd,
2133 /* We have already written out the last
2134 .bf aux entry. We need to write it
2135 out again. We borrow *outsym
2136 temporarily. FIXME: This case should
2138 bfd_coff_swap_aux_out (output_bfd,
2144 pos = obj_sym_filepos (output_bfd);
2145 pos += flaginfo->last_bf_index * osymesz;
2146 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2147 || (bfd_bwrite (outsym, osymesz, output_bfd)
2153 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2154 flaginfo->last_bf_index = -1;
2157 /* The endndx field of this aux entry must
2158 be updated with the symbol number of the
2160 flaginfo->last_bf = *auxp;
2161 flaginfo->last_bf_index = (((outsym - flaginfo->outsyms)
2170 bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2171 isymp->n_sclass, i, isymp->n_numaux,
2185 /* Relocate the line numbers, unless we are stripping them. */
2186 if (flaginfo->info->strip == strip_none
2187 || flaginfo->info->strip == strip_some)
2189 for (o = input_bfd->sections; o != NULL; o = o->next)
2195 bfd_boolean skipping;
2199 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2200 build_link_order in ldwrite.c will not have created a
2201 link order, which means that we will not have seen this
2202 input section in _bfd_coff_final_link, which means that
2203 we will not have allocated space for the line numbers of
2204 this section. I don't think line numbers can be
2205 meaningful for a section which does not have
2206 SEC_HAS_CONTENTS set, but, if they do, this must be
2208 if (o->lineno_count == 0
2209 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2212 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2213 || bfd_bread (flaginfo->linenos, linesz * o->lineno_count,
2214 input_bfd) != linesz * o->lineno_count)
2217 offset = o->output_section->vma + o->output_offset - o->vma;
2218 eline = flaginfo->linenos;
2219 oeline = flaginfo->linenos;
2220 elineend = eline + linesz * o->lineno_count;
2222 for (; eline < elineend; eline += linesz)
2224 struct internal_lineno iline;
2226 bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2228 if (iline.l_lnno != 0)
2229 iline.l_addr.l_paddr += offset;
2230 else if (iline.l_addr.l_symndx >= 0
2231 && ((unsigned long) iline.l_addr.l_symndx
2232 < obj_raw_syment_count (input_bfd)))
2236 indx = flaginfo->sym_indices[iline.l_addr.l_symndx];
2240 /* These line numbers are attached to a symbol
2241 which we are stripping. We must discard the
2242 line numbers because reading them back with
2243 no associated symbol (or associating them all
2244 with symbol #0) will fail. We can't regain
2245 the space in the output file, but at least
2251 struct internal_syment is;
2252 union internal_auxent ia;
2254 /* Fix up the lnnoptr field in the aux entry of
2255 the symbol. It turns out that we can't do
2256 this when we modify the symbol aux entries,
2257 because gas sometimes screws up the lnnoptr
2258 field and makes it an offset from the start
2259 of the line numbers rather than an absolute
2261 bfd_coff_swap_sym_in (output_bfd,
2263 + ((indx - syment_base)
2265 if ((ISFCN (is.n_type)
2266 || is.n_sclass == C_BLOCK)
2267 && is.n_numaux >= 1)
2271 auxptr = (flaginfo->outsyms
2272 + ((indx - syment_base + 1)
2274 bfd_coff_swap_aux_in (output_bfd, auxptr,
2275 is.n_type, is.n_sclass,
2276 0, is.n_numaux, &ia);
2277 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2278 (o->output_section->line_filepos
2279 + o->output_section->lineno_count * linesz
2280 + eline - flaginfo->linenos);
2281 bfd_coff_swap_aux_out (output_bfd, &ia,
2282 is.n_type, is.n_sclass, 0,
2283 is.n_numaux, auxptr);
2289 iline.l_addr.l_symndx = indx;
2294 bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2299 pos = o->output_section->line_filepos;
2300 pos += o->output_section->lineno_count * linesz;
2301 amt = oeline - flaginfo->linenos;
2302 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2303 || bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt)
2306 o->output_section->lineno_count += amt / linesz;
2310 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2311 symbol will be the first symbol in the next input file. In the
2312 normal case, this will save us from writing out the C_FILE symbol
2314 if (flaginfo->last_file_index != -1
2315 && (bfd_size_type) flaginfo->last_file_index >= syment_base)
2317 flaginfo->last_file.n_value = output_index;
2318 bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file,
2320 + ((flaginfo->last_file_index - syment_base)
2324 /* Write the modified symbols to the output file. */
2325 if (outsym > flaginfo->outsyms)
2330 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2331 amt = outsym - flaginfo->outsyms;
2332 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2333 || bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt)
2336 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2337 + (outsym - flaginfo->outsyms) / osymesz)
2340 obj_raw_syment_count (output_bfd) = output_index;
2343 /* Relocate the contents of each section. */
2344 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2345 for (o = input_bfd->sections; o != NULL; o = o->next)
2348 struct coff_section_tdata *secdata;
2350 if (! o->linker_mark)
2351 /* This section was omitted from the link. */
2354 if ((o->flags & SEC_LINKER_CREATED) != 0)
2357 if ((o->flags & SEC_HAS_CONTENTS) == 0
2358 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
2360 if ((o->flags & SEC_RELOC) != 0
2361 && o->reloc_count != 0)
2363 (*_bfd_error_handler)
2364 (_("%B: relocs in section `%A', but it has no contents"),
2366 bfd_set_error (bfd_error_no_contents);
2373 secdata = coff_section_data (input_bfd, o);
2374 if (secdata != NULL && secdata->contents != NULL)
2375 contents = secdata->contents;
2378 contents = flaginfo->contents;
2379 if (! bfd_get_full_section_contents (input_bfd, o, &contents))
2383 if ((o->flags & SEC_RELOC) != 0)
2386 struct internal_reloc *internal_relocs;
2387 struct internal_reloc *irel;
2389 /* Read in the relocs. */
2390 target_index = o->output_section->target_index;
2391 internal_relocs = (_bfd_coff_read_internal_relocs
2392 (input_bfd, o, FALSE, flaginfo->external_relocs,
2393 bfd_link_relocatable (flaginfo->info),
2394 (bfd_link_relocatable (flaginfo->info)
2395 ? (flaginfo->section_info[target_index].relocs
2396 + o->output_section->reloc_count)
2397 : flaginfo->internal_relocs)));
2398 if (internal_relocs == NULL
2399 && o->reloc_count > 0)
2402 /* Run through the relocs looking for relocs against symbols
2403 coming from discarded sections and complain about them. */
2404 irel = internal_relocs;
2405 for (; irel < &internal_relocs[o->reloc_count]; irel++)
2407 struct coff_link_hash_entry *h;
2408 asection *ps = NULL;
2409 long symndx = irel->r_symndx;
2412 h = obj_coff_sym_hashes (input_bfd)[symndx];
2415 while (h->root.type == bfd_link_hash_indirect
2416 || h->root.type == bfd_link_hash_warning)
2417 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2418 if (h->root.type == bfd_link_hash_defined
2419 || h->root.type == bfd_link_hash_defweak)
2420 ps = h->root.u.def.section;
2423 /* Complain if definition comes from an excluded section. */
2424 if (ps->flags & SEC_EXCLUDE)
2425 (*flaginfo->info->callbacks->einfo)
2426 (_("%X`%s' referenced in section `%A' of %B: "
2427 "defined in discarded section `%A' of %B\n"),
2428 h->root.root.string, o, input_bfd, ps, ps->owner);
2431 /* Call processor specific code to relocate the section
2433 if (! bfd_coff_relocate_section (output_bfd, flaginfo->info,
2437 flaginfo->internal_syms,
2438 flaginfo->sec_ptrs))
2441 if (bfd_link_relocatable (flaginfo->info))
2444 struct internal_reloc *irelend;
2445 struct coff_link_hash_entry **rel_hash;
2447 offset = o->output_section->vma + o->output_offset - o->vma;
2448 irel = internal_relocs;
2449 irelend = irel + o->reloc_count;
2450 rel_hash = (flaginfo->section_info[target_index].rel_hashes
2451 + o->output_section->reloc_count);
2452 for (; irel < irelend; irel++, rel_hash++)
2454 struct coff_link_hash_entry *h;
2455 bfd_boolean adjusted;
2459 /* Adjust the reloc address and symbol index. */
2460 irel->r_vaddr += offset;
2462 if (irel->r_symndx == -1)
2467 if (! (*adjust_symndx) (output_bfd, flaginfo->info,
2475 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2478 /* This is a global symbol. */
2480 irel->r_symndx = h->indx;
2483 /* This symbol is being written at the end
2484 of the file, and we do not yet know the
2485 symbol index. We save the pointer to the
2486 hash table entry in the rel_hash list.
2487 We set the indx field to -2 to indicate
2488 that this symbol must not be stripped. */
2497 indx = flaginfo->sym_indices[irel->r_symndx];
2499 irel->r_symndx = indx;
2502 struct internal_syment *is;
2504 char buf[SYMNMLEN + 1];
2506 /* This reloc is against a symbol we are
2507 stripping. This should have been handled
2508 by the 'dont_skip_symbol' code in the while
2509 loop at the top of this function. */
2510 is = flaginfo->internal_syms + irel->r_symndx;
2512 name = (_bfd_coff_internal_syment_name
2513 (input_bfd, is, buf));
2517 if (! ((*flaginfo->info->callbacks->unattached_reloc)
2518 (flaginfo->info, name, input_bfd, o,
2525 o->output_section->reloc_count += o->reloc_count;
2529 /* Write out the modified section contents. */
2530 if (secdata == NULL || secdata->stab_info == NULL)
2532 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2533 if (! bfd_set_section_contents (output_bfd, o->output_section,
2534 contents, loc, o->size))
2539 if (! (_bfd_write_section_stabs
2540 (output_bfd, &coff_hash_table (flaginfo->info)->stab_info,
2541 o, &secdata->stab_info, contents)))
2546 if (! flaginfo->info->keep_memory
2547 && ! _bfd_coff_free_symbols (input_bfd))
2553 /* Write out a global symbol. Called via bfd_hash_traverse. */
2556 _bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)
2558 struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;
2559 struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
2561 struct internal_syment isym;
2562 bfd_size_type symesz;
2566 output_bfd = flaginfo->output_bfd;
2568 if (h->root.type == bfd_link_hash_warning)
2570 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2571 if (h->root.type == bfd_link_hash_new)
2579 && (flaginfo->info->strip == strip_all
2580 || (flaginfo->info->strip == strip_some
2581 && (bfd_hash_lookup (flaginfo->info->keep_hash,
2582 h->root.root.string, FALSE, FALSE)
2586 switch (h->root.type)
2589 case bfd_link_hash_new:
2590 case bfd_link_hash_warning:
2594 case bfd_link_hash_undefined:
2595 case bfd_link_hash_undefweak:
2596 isym.n_scnum = N_UNDEF;
2600 case bfd_link_hash_defined:
2601 case bfd_link_hash_defweak:
2605 sec = h->root.u.def.section->output_section;
2606 if (bfd_is_abs_section (sec))
2607 isym.n_scnum = N_ABS;
2609 isym.n_scnum = sec->target_index;
2610 isym.n_value = (h->root.u.def.value
2611 + h->root.u.def.section->output_offset);
2612 if (! obj_pe (flaginfo->output_bfd))
2613 isym.n_value += sec->vma;
2617 case bfd_link_hash_common:
2618 isym.n_scnum = N_UNDEF;
2619 isym.n_value = h->root.u.c.size;
2622 case bfd_link_hash_indirect:
2623 /* Just ignore these. They can't be handled anyhow. */
2627 if (strlen (h->root.root.string) <= SYMNMLEN)
2628 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2635 if (flaginfo->info->traditional_format)
2637 indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash,
2639 if (indx == (bfd_size_type) -1)
2641 flaginfo->failed = TRUE;
2644 isym._n._n_n._n_zeroes = 0;
2645 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2648 isym.n_sclass = h->symbol_class;
2649 isym.n_type = h->type;
2651 if (isym.n_sclass == C_NULL)
2652 isym.n_sclass = C_EXT;
2654 /* If doing task linking and this is the pass where we convert
2655 defined globals to statics, then do that conversion now. If the
2656 symbol is not being converted, just ignore it and it will be
2657 output during a later pass. */
2658 if (flaginfo->global_to_static)
2660 if (! IS_EXTERNAL (output_bfd, isym))
2663 isym.n_sclass = C_STAT;
2666 /* When a weak symbol is not overridden by a strong one,
2667 turn it into an external symbol when not building a
2668 shared or relocatable object. */
2669 if (! bfd_link_pic (flaginfo->info)
2670 && ! bfd_link_relocatable (flaginfo->info)
2671 && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))
2672 isym.n_sclass = C_EXT;
2674 isym.n_numaux = h->numaux;
2676 bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms);
2678 symesz = bfd_coff_symesz (output_bfd);
2680 pos = obj_sym_filepos (output_bfd);
2681 pos += obj_raw_syment_count (output_bfd) * symesz;
2682 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2683 || bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
2685 flaginfo->failed = TRUE;
2689 h->indx = obj_raw_syment_count (output_bfd);
2691 ++obj_raw_syment_count (output_bfd);
2693 /* Write out any associated aux entries. Most of the aux entries
2694 will have been modified in _bfd_coff_link_input_bfd. We have to
2695 handle section aux entries here, now that we have the final
2696 relocation and line number counts. */
2697 for (i = 0; i < isym.n_numaux; i++)
2699 union internal_auxent *auxp;
2703 /* Look for a section aux entry here using the same tests that
2704 coff_swap_aux_out uses. */
2706 && (isym.n_sclass == C_STAT
2707 || isym.n_sclass == C_HIDDEN)
2708 && isym.n_type == T_NULL
2709 && (h->root.type == bfd_link_hash_defined
2710 || h->root.type == bfd_link_hash_defweak))
2714 sec = h->root.u.def.section->output_section;
2717 auxp->x_scn.x_scnlen = sec->size;
2719 /* For PE, an overflow on the final link reportedly does
2720 not matter. FIXME: Why not? */
2721 if (sec->reloc_count > 0xffff
2722 && (! obj_pe (output_bfd)
2723 || bfd_link_relocatable (flaginfo->info)))
2724 (*_bfd_error_handler)
2725 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2726 bfd_get_filename (output_bfd),
2727 bfd_get_section_name (output_bfd, sec),
2730 if (sec->lineno_count > 0xffff
2731 && (! obj_pe (output_bfd)
2732 || bfd_link_relocatable (flaginfo->info)))
2733 (*_bfd_error_handler)
2734 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2735 bfd_get_filename (output_bfd),
2736 bfd_get_section_name (output_bfd, sec),
2739 auxp->x_scn.x_nreloc = sec->reloc_count;
2740 auxp->x_scn.x_nlinno = sec->lineno_count;
2741 auxp->x_scn.x_checksum = 0;
2742 auxp->x_scn.x_associated = 0;
2743 auxp->x_scn.x_comdat = 0;
2747 bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2748 isym.n_sclass, (int) i, isym.n_numaux,
2750 if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
2752 flaginfo->failed = TRUE;
2755 ++obj_raw_syment_count (output_bfd);
2761 /* Write out task global symbols, converting them to statics. Called
2762 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2763 the dirty work, if the symbol we are processing needs conversion. */
2766 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2768 struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
2769 bfd_boolean rtnval = TRUE;
2770 bfd_boolean save_global_to_static;
2772 if (h->root.type == bfd_link_hash_warning)
2773 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2777 switch (h->root.type)
2779 case bfd_link_hash_defined:
2780 case bfd_link_hash_defweak:
2781 save_global_to_static = flaginfo->global_to_static;
2782 flaginfo->global_to_static = TRUE;
2783 rtnval = _bfd_coff_write_global_sym (&h->root.root, data);
2784 flaginfo->global_to_static = save_global_to_static;
2793 /* Handle a link order which is supposed to generate a reloc. */
2796 _bfd_coff_reloc_link_order (bfd *output_bfd,
2797 struct coff_final_link_info *flaginfo,
2798 asection *output_section,
2799 struct bfd_link_order *link_order)
2801 reloc_howto_type *howto;
2802 struct internal_reloc *irel;
2803 struct coff_link_hash_entry **rel_hash_ptr;
2805 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2808 bfd_set_error (bfd_error_bad_value);
2812 if (link_order->u.reloc.p->addend != 0)
2816 bfd_reloc_status_type rstat;
2820 size = bfd_get_reloc_size (howto);
2821 buf = (bfd_byte *) bfd_zmalloc (size);
2822 if (buf == NULL && size != 0)
2825 rstat = _bfd_relocate_contents (howto, output_bfd,
2826 (bfd_vma) link_order->u.reloc.p->addend,\
2833 case bfd_reloc_outofrange:
2835 case bfd_reloc_overflow:
2836 if (! ((*flaginfo->info->callbacks->reloc_overflow)
2837 (flaginfo->info, NULL,
2838 (link_order->type == bfd_section_reloc_link_order
2839 ? bfd_section_name (output_bfd,
2840 link_order->u.reloc.p->u.section)
2841 : link_order->u.reloc.p->u.name),
2842 howto->name, link_order->u.reloc.p->addend,
2843 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2850 loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2851 ok = bfd_set_section_contents (output_bfd, output_section, buf,
2858 /* Store the reloc information in the right place. It will get
2859 swapped and written out at the end of the final_link routine. */
2860 irel = (flaginfo->section_info[output_section->target_index].relocs
2861 + output_section->reloc_count);
2862 rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes
2863 + output_section->reloc_count);
2865 memset (irel, 0, sizeof (struct internal_reloc));
2866 *rel_hash_ptr = NULL;
2868 irel->r_vaddr = output_section->vma + link_order->offset;
2870 if (link_order->type == bfd_section_reloc_link_order)
2872 /* We need to somehow locate a symbol in the right section. The
2873 symbol must either have a value of zero, or we must adjust
2874 the addend by the value of the symbol. FIXME: Write this
2875 when we need it. The old linker couldn't handle this anyhow. */
2877 *rel_hash_ptr = NULL;
2882 struct coff_link_hash_entry *h;
2884 h = ((struct coff_link_hash_entry *)
2885 bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info,
2886 link_order->u.reloc.p->u.name,
2887 FALSE, FALSE, TRUE));
2891 irel->r_symndx = h->indx;
2894 /* Set the index to -2 to force this symbol to get
2903 if (! ((*flaginfo->info->callbacks->unattached_reloc)
2904 (flaginfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2905 (asection *) NULL, (bfd_vma) 0)))
2911 /* FIXME: Is this always right? */
2912 irel->r_type = howto->type;
2914 /* r_size is only used on the RS/6000, which needs its own linker
2915 routines anyhow. r_extern is only used for ECOFF. */
2917 /* FIXME: What is the right value for r_offset? Is zero OK? */
2918 ++output_section->reloc_count;
2923 /* A basic reloc handling routine which may be used by processors with
2927 _bfd_coff_generic_relocate_section (bfd *output_bfd,
2928 struct bfd_link_info *info,
2930 asection *input_section,
2932 struct internal_reloc *relocs,
2933 struct internal_syment *syms,
2934 asection **sections)
2936 struct internal_reloc *rel;
2937 struct internal_reloc *relend;
2940 relend = rel + input_section->reloc_count;
2941 for (; rel < relend; rel++)
2944 struct coff_link_hash_entry *h;
2945 struct internal_syment *sym;
2949 reloc_howto_type *howto;
2950 bfd_reloc_status_type rstat;
2952 symndx = rel->r_symndx;
2960 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2962 (*_bfd_error_handler)
2963 ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
2968 h = obj_coff_sym_hashes (input_bfd)[symndx];
2969 sym = syms + symndx;
2972 /* COFF treats common symbols in one of two ways. Either the
2973 size of the symbol is included in the section contents, or it
2974 is not. We assume that the size is not included, and force
2975 the rtype_to_howto function to adjust the addend as needed. */
2976 if (sym != NULL && sym->n_scnum != 0)
2977 addend = - sym->n_value;
2981 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2986 /* If we are doing a relocatable link, then we can just ignore
2987 a PC relative reloc that is pcrel_offset. It will already
2988 have the correct value. If this is not a relocatable link,
2989 then we should ignore the symbol value. */
2990 if (howto->pc_relative && howto->pcrel_offset)
2992 if (bfd_link_relocatable (info))
2994 if (sym != NULL && sym->n_scnum != 0)
2995 addend += sym->n_value;
3004 sec = bfd_abs_section_ptr;
3009 sec = sections[symndx];
3010 val = (sec->output_section->vma
3011 + sec->output_offset
3013 if (! obj_pe (input_bfd))
3019 if (h->root.type == bfd_link_hash_defined
3020 || h->root.type == bfd_link_hash_defweak)
3022 /* Defined weak symbols are a GNU extension. */
3023 sec = h->root.u.def.section;
3024 val = (h->root.u.def.value
3025 + sec->output_section->vma
3026 + sec->output_offset);
3029 else if (h->root.type == bfd_link_hash_undefweak)
3031 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
3033 /* See _Microsoft Portable Executable and Common Object
3034 File Format Specification_, section 5.5.3.
3035 Note that weak symbols without aux records are a GNU
3037 FIXME: All weak externals are treated as having
3038 characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
3039 These behave as per SVR4 ABI: A library member
3040 will resolve a weak external only if a normal
3041 external causes the library member to be linked.
3042 See also linker.c: generic_link_check_archive_element. */
3043 struct coff_link_hash_entry *h2 =
3044 h->auxbfd->tdata.coff_obj_data->sym_hashes[
3045 h->aux->x_sym.x_tagndx.l];
3047 if (!h2 || h2->root.type == bfd_link_hash_undefined)
3049 sec = bfd_abs_section_ptr;
3054 sec = h2->root.u.def.section;
3055 val = h2->root.u.def.value
3056 + sec->output_section->vma + sec->output_offset;
3060 /* This is a GNU extension. */
3064 else if (! bfd_link_relocatable (info))
3066 if (! ((*info->callbacks->undefined_symbol)
3067 (info, h->root.root.string, input_bfd, input_section,
3068 rel->r_vaddr - input_section->vma, TRUE)))
3073 /* If the input section defining the symbol has been discarded
3074 then zero this reloc field. */
3075 if (sec != NULL && discarded_section (sec))
3077 _bfd_clear_contents (howto, input_bfd, input_section,
3078 contents + (rel->r_vaddr - input_section->vma));
3082 if (info->base_file)
3084 /* Emit a reloc if the backend thinks it needs it. */
3085 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
3087 /* Relocation to a symbol in a section which isn't
3088 absolute. We output the address here to a file.
3089 This file is then read by dlltool when generating the
3090 reloc section. Note that the base file is not
3091 portable between systems. We write out a bfd_vma here,
3092 and dlltool reads in a bfd_vma. */
3093 bfd_vma addr = (rel->r_vaddr
3094 - input_section->vma
3095 + input_section->output_offset
3096 + input_section->output_section->vma);
3097 if (coff_data (output_bfd)->pe)
3098 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
3099 if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)
3100 != sizeof (bfd_vma))
3102 bfd_set_error (bfd_error_system_call);
3108 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3110 rel->r_vaddr - input_section->vma,
3119 case bfd_reloc_outofrange:
3120 (*_bfd_error_handler)
3121 (_("%B: bad reloc address 0x%lx in section `%A'"),
3122 input_bfd, input_section, (unsigned long) rel->r_vaddr);
3124 case bfd_reloc_overflow:
3127 char buf[SYMNMLEN + 1];
3135 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3140 if (! ((*info->callbacks->reloc_overflow)
3141 (info, (h ? &h->root : NULL), name, howto->name,
3142 (bfd_vma) 0, input_bfd, input_section,
3143 rel->r_vaddr - input_section->vma)))