1 /* COFF specific linker code.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This file contains the COFF backend linker code. */
27 #include "coff/internal.h"
30 static boolean coff_link_add_object_symbols
31 PARAMS ((bfd *, struct bfd_link_info *));
32 static boolean coff_link_check_archive_element
33 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
34 static boolean coff_link_check_ar_symbols
35 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
36 static boolean coff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
37 static char *dores_com PARAMS ((char *, bfd *, int));
38 static char *get_name PARAMS ((char *, char **));
39 static int process_embedded_commands
40 PARAMS ((bfd *, struct bfd_link_info *, bfd *));
41 static void mark_relocs PARAMS ((struct coff_final_link_info *, bfd *));
43 /* Return true if SYM is a weak, external symbol. */
44 #define IS_WEAK_EXTERNAL(abfd, sym) \
45 ((sym).n_sclass == C_WEAKEXT \
46 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
48 /* Return true if SYM is an external symbol. */
49 #define IS_EXTERNAL(abfd, sym) \
50 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
52 /* Define macros so that the ISFCN, et. al., macros work correctly.
53 These macros are defined in include/coff/internal.h in terms of
54 N_TMASK, etc. These definitions require a user to define local
55 variables with the appropriate names, and with values from the
56 coff_data (abfd) structure. */
58 #define N_TMASK n_tmask
59 #define N_BTSHFT n_btshft
60 #define N_BTMASK n_btmask
62 /* Create an entry in a COFF linker hash table. */
64 struct bfd_hash_entry *
65 _bfd_coff_link_hash_newfunc (entry, table, string)
66 struct bfd_hash_entry *entry;
67 struct bfd_hash_table *table;
70 struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
72 /* Allocate the structure if it has not already been allocated by a
74 if (ret == (struct coff_link_hash_entry *) NULL)
75 ret = ((struct coff_link_hash_entry *)
76 bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
77 if (ret == (struct coff_link_hash_entry *) NULL)
78 return (struct bfd_hash_entry *) ret;
80 /* Call the allocation method of the superclass. */
81 ret = ((struct coff_link_hash_entry *)
82 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
84 if (ret != (struct coff_link_hash_entry *) NULL)
86 /* Set local fields. */
95 return (struct bfd_hash_entry *) ret;
98 /* Initialize a COFF linker hash table. */
101 _bfd_coff_link_hash_table_init (table, abfd, newfunc)
102 struct coff_link_hash_table *table;
104 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
105 struct bfd_hash_table *,
108 table->stab_info = NULL;
109 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
112 /* Create a COFF linker hash table. */
114 struct bfd_link_hash_table *
115 _bfd_coff_link_hash_table_create (abfd)
118 struct coff_link_hash_table *ret;
120 ret = ((struct coff_link_hash_table *)
121 bfd_alloc (abfd, sizeof (struct coff_link_hash_table)));
124 if (! _bfd_coff_link_hash_table_init (ret, abfd,
125 _bfd_coff_link_hash_newfunc))
127 bfd_release (abfd, ret);
128 return (struct bfd_link_hash_table *) NULL;
133 /* Create an entry in a COFF debug merge hash table. */
135 struct bfd_hash_entry *
136 _bfd_coff_debug_merge_hash_newfunc (entry, table, string)
137 struct bfd_hash_entry *entry;
138 struct bfd_hash_table *table;
141 struct coff_debug_merge_hash_entry *ret =
142 (struct coff_debug_merge_hash_entry *) entry;
144 /* Allocate the structure if it has not already been allocated by a
146 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
147 ret = ((struct coff_debug_merge_hash_entry *)
148 bfd_hash_allocate (table,
149 sizeof (struct coff_debug_merge_hash_entry)));
150 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
151 return (struct bfd_hash_entry *) ret;
153 /* Call the allocation method of the superclass. */
154 ret = ((struct coff_debug_merge_hash_entry *)
155 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
156 if (ret != (struct coff_debug_merge_hash_entry *) NULL)
158 /* Set local fields. */
162 return (struct bfd_hash_entry *) ret;
165 /* Given a COFF BFD, add symbols to the global hash table as
169 _bfd_coff_link_add_symbols (abfd, info)
171 struct bfd_link_info *info;
173 switch (bfd_get_format (abfd))
176 return coff_link_add_object_symbols (abfd, info);
178 return (_bfd_generic_link_add_archive_symbols
179 (abfd, info, coff_link_check_archive_element));
181 bfd_set_error (bfd_error_wrong_format);
186 /* Add symbols from a COFF object file. */
189 coff_link_add_object_symbols (abfd, info)
191 struct bfd_link_info *info;
193 if (! _bfd_coff_get_external_symbols (abfd))
195 if (! coff_link_add_symbols (abfd, info))
198 if (! info->keep_memory)
200 if (! _bfd_coff_free_symbols (abfd))
206 /* Check a single archive element to see if we need to include it in
207 the link. *PNEEDED is set according to whether this element is
208 needed in the link or not. This is called via
209 _bfd_generic_link_add_archive_symbols. */
212 coff_link_check_archive_element (abfd, info, pneeded)
214 struct bfd_link_info *info;
217 if (! _bfd_coff_get_external_symbols (abfd))
220 if (! coff_link_check_ar_symbols (abfd, info, pneeded))
225 if (! coff_link_add_symbols (abfd, info))
229 if (! info->keep_memory || ! *pneeded)
231 if (! _bfd_coff_free_symbols (abfd))
238 /* Look through the symbols to see if this object file should be
239 included in the link. */
242 coff_link_check_ar_symbols (abfd, info, pneeded)
244 struct bfd_link_info *info;
247 bfd_size_type symesz;
253 symesz = bfd_coff_symesz (abfd);
254 esym = (bfd_byte *) obj_coff_external_syms (abfd);
255 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
256 while (esym < esym_end)
258 struct internal_syment sym;
259 enum coff_symbol_classification classification;
261 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
263 classification = bfd_coff_classify_symbol (abfd, &sym);
264 if (classification == COFF_SYMBOL_GLOBAL
265 || classification == COFF_SYMBOL_COMMON)
268 char buf[SYMNMLEN + 1];
269 struct bfd_link_hash_entry *h;
271 /* This symbol is externally visible, and is defined by this
274 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
277 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
279 /* We are only interested in symbols that are currently
280 undefined. If a symbol is currently known to be common,
281 COFF linkers do not bring in an object file which defines
283 if (h != (struct bfd_link_hash_entry *) NULL
284 && h->type == bfd_link_hash_undefined)
286 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
293 esym += (sym.n_numaux + 1) * symesz;
296 /* We do not need this object file. */
300 /* Add all the symbols from an object file to the hash table. */
303 coff_link_add_symbols (abfd, info)
305 struct bfd_link_info *info;
307 unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
308 unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
309 unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
311 boolean default_copy;
312 bfd_size_type symcount;
313 struct coff_link_hash_entry **sym_hash;
314 bfd_size_type symesz;
318 /* Keep the symbols during this function, in case the linker needs
319 to read the generic symbols in order to report an error message. */
320 keep_syms = obj_coff_keep_syms (abfd);
321 obj_coff_keep_syms (abfd) = true;
323 if (info->keep_memory)
324 default_copy = false;
328 symcount = obj_raw_syment_count (abfd);
330 /* We keep a list of the linker hash table entries that correspond
331 to particular symbols. */
332 sym_hash = ((struct coff_link_hash_entry **)
335 * sizeof (struct coff_link_hash_entry *))));
336 if (sym_hash == NULL && symcount != 0)
338 obj_coff_sym_hashes (abfd) = sym_hash;
340 (size_t) symcount * sizeof (struct coff_link_hash_entry *));
342 symesz = bfd_coff_symesz (abfd);
343 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
344 esym = (bfd_byte *) obj_coff_external_syms (abfd);
345 esym_end = esym + symcount * symesz;
346 while (esym < esym_end)
348 struct internal_syment sym;
349 enum coff_symbol_classification classification;
352 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
354 classification = bfd_coff_classify_symbol (abfd, &sym);
355 if (classification != COFF_SYMBOL_LOCAL)
358 char buf[SYMNMLEN + 1];
364 /* This symbol is externally visible. */
366 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
370 /* We must copy the name into memory if we got it from the
371 syment itself, rather than the string table. */
373 if (sym._n._n_n._n_zeroes != 0
374 || sym._n._n_n._n_offset == 0)
379 switch (classification)
384 case COFF_SYMBOL_GLOBAL:
385 flags = BSF_EXPORT | BSF_GLOBAL;
386 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
388 value -= section->vma;
391 case COFF_SYMBOL_UNDEFINED:
393 section = bfd_und_section_ptr;
396 case COFF_SYMBOL_COMMON:
398 section = bfd_com_section_ptr;
401 case COFF_SYMBOL_PE_SECTION:
402 flags = BSF_SECTION_SYM | BSF_GLOBAL;
403 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
407 if (IS_WEAK_EXTERNAL (abfd, sym))
412 /* In the PE format, section symbols actually refer to the
413 start of the output section. We handle them specially
415 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
417 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
418 name, false, copy, false);
419 if (*sym_hash != NULL)
421 if (((*sym_hash)->coff_link_hash_flags
422 & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
423 && (*sym_hash)->root.type != bfd_link_hash_undefined
424 && (*sym_hash)->root.type != bfd_link_hash_undefweak)
425 (*_bfd_error_handler)
426 ("Warning: symbol `%s' is both section and non-section",
433 /* The Microsoft Visual C compiler does string pooling by
434 hashing the constants to an internal symbol name, and
435 relying on the the linker comdat support to discard
436 duplicate names. However, if one string is a literal and
437 one is a data initializer, one will end up in the .data
438 section and one will end up in the .rdata section. The
439 Microsoft linker will combine them into the .data
440 section, which seems to be wrong since it might cause the
443 As long as there are no external references to the
444 symbols, which there shouldn't be, we can treat the .data
445 and .rdata instances as separate symbols. The comdat
446 code in the linker will do the appropriate merging. Here
447 we avoid getting a multiple definition error for one of
448 these special symbols.
450 FIXME: I don't think this will work in the case where
451 there are two object files which use the constants as a
452 literal and two object files which use it as a data
453 initializer. One or the other of the second object files
454 is going to wind up with an inappropriate reference. */
456 && (classification == COFF_SYMBOL_GLOBAL
457 || classification == COFF_SYMBOL_PE_SECTION)
458 && section->comdat != NULL
459 && strncmp (name, "??_", 3) == 0
460 && strcmp (name, section->comdat->name) == 0)
462 if (*sym_hash == NULL)
463 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
464 name, false, copy, false);
465 if (*sym_hash != NULL
466 && (*sym_hash)->root.type == bfd_link_hash_defined
467 && (*sym_hash)->root.u.def.section->comdat != NULL
468 && strcmp ((*sym_hash)->root.u.def.section->comdat->name,
469 section->comdat->name) == 0)
475 if (! (bfd_coff_link_add_one_symbol
476 (info, abfd, name, flags, section, value,
477 (const char *) NULL, copy, false,
478 (struct bfd_link_hash_entry **) sym_hash)))
482 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
483 (*sym_hash)->coff_link_hash_flags |=
484 COFF_LINK_HASH_PE_SECTION_SYMBOL;
486 /* Limit the alignment of a common symbol to the possible
487 alignment of a section. There is no point to permitting
488 a higher alignment for a common symbol: we can not
489 guarantee it, and it may cause us to allocate extra space
490 in the common section. */
491 if (section == bfd_com_section_ptr
492 && (*sym_hash)->root.type == bfd_link_hash_common
493 && ((*sym_hash)->root.u.c.p->alignment_power
494 > bfd_coff_default_section_alignment_power (abfd)))
495 (*sym_hash)->root.u.c.p->alignment_power
496 = bfd_coff_default_section_alignment_power (abfd);
498 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
500 /* If we don't have any symbol information currently in
501 the hash table, or if we are looking at a symbol
502 definition, then update the symbol class and type in
504 if (((*sym_hash)->class == C_NULL
505 && (*sym_hash)->type == T_NULL)
508 && (*sym_hash)->root.type != bfd_link_hash_defined
509 && (*sym_hash)->root.type != bfd_link_hash_defweak))
511 (*sym_hash)->class = sym.n_sclass;
512 if (sym.n_type != T_NULL)
514 /* We want to warn if the type changed, but not
515 if it changed from an unspecified type.
516 Testing the whole type byte may work, but the
517 change from (e.g.) a function of unspecified
518 type to function of known type also wants to
520 if ((*sym_hash)->type != T_NULL
521 && (*sym_hash)->type != sym.n_type
522 && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
523 && (BTYPE ((*sym_hash)->type) == T_NULL
524 || BTYPE (sym.n_type) == T_NULL)))
525 (*_bfd_error_handler)
526 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
527 name, (*sym_hash)->type, sym.n_type,
528 bfd_get_filename (abfd));
530 /* We don't want to change from a meaningful
531 base type to a null one, but if we know
532 nothing, take what little we might now know. */
533 if (BTYPE (sym.n_type) != T_NULL
534 || (*sym_hash)->type == T_NULL)
535 (*sym_hash)->type = sym.n_type;
537 (*sym_hash)->auxbfd = abfd;
538 if (sym.n_numaux != 0)
540 union internal_auxent *alloc;
543 union internal_auxent *iaux;
545 (*sym_hash)->numaux = sym.n_numaux;
546 alloc = ((union internal_auxent *)
547 bfd_hash_allocate (&info->hash->table,
549 * sizeof (*alloc))));
552 for (i = 0, eaux = esym + symesz, iaux = alloc;
554 i++, eaux += symesz, iaux++)
555 bfd_coff_swap_aux_in (abfd, (PTR) eaux, sym.n_type,
556 sym.n_sclass, i, sym.n_numaux,
558 (*sym_hash)->aux = alloc;
563 if (classification == COFF_SYMBOL_PE_SECTION
564 && (*sym_hash)->numaux != 0)
566 /* Some PE sections (such as .bss) have a zero size in
567 the section header, but a non-zero size in the AUX
568 record. Correct that here.
570 FIXME: This is not at all the right place to do this.
571 For example, it won't help objdump. This needs to be
572 done when we swap in the section header. */
574 BFD_ASSERT ((*sym_hash)->numaux == 1);
575 if (section->_raw_size == 0)
576 section->_raw_size = (*sym_hash)->aux[0].x_scn.x_scnlen;
578 /* FIXME: We could test whether the section sizes
579 matches the size in the aux entry, but apparently
580 that sometimes fails unexpectedly. */
584 esym += (sym.n_numaux + 1) * symesz;
585 sym_hash += sym.n_numaux + 1;
588 /* If this is a non-traditional, non-relocateable link, try to
589 optimize the handling of any .stab/.stabstr sections. */
590 if (! info->relocateable
591 && ! info->traditional_format
592 && info->hash->creator->flavour == bfd_get_flavour (abfd)
593 && (info->strip != strip_all && info->strip != strip_debugger))
595 asection *stab, *stabstr;
597 stab = bfd_get_section_by_name (abfd, ".stab");
600 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
604 struct coff_link_hash_table *table;
605 struct coff_section_tdata *secdata;
607 secdata = coff_section_data (abfd, stab);
611 (PTR) bfd_zalloc (abfd,
612 sizeof (struct coff_section_tdata));
613 if (stab->used_by_bfd == NULL)
615 secdata = coff_section_data (abfd, stab);
618 table = coff_hash_table (info);
620 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
622 &secdata->stab_info))
628 obj_coff_keep_syms (abfd) = keep_syms;
633 obj_coff_keep_syms (abfd) = keep_syms;
637 /* Do the final link step. */
640 _bfd_coff_final_link (abfd, info)
642 struct bfd_link_info *info;
644 bfd_size_type symesz;
645 struct coff_final_link_info finfo;
646 boolean debug_merge_allocated;
647 boolean long_section_names;
649 struct bfd_link_order *p;
650 size_t max_sym_count;
651 size_t max_lineno_count;
652 size_t max_reloc_count;
653 size_t max_output_reloc_count;
654 size_t max_contents_size;
655 file_ptr rel_filepos;
657 file_ptr line_filepos;
660 bfd_byte *external_relocs = NULL;
661 char strbuf[STRING_SIZE_SIZE];
663 symesz = bfd_coff_symesz (abfd);
666 finfo.output_bfd = abfd;
668 finfo.section_info = NULL;
669 finfo.last_file_index = -1;
670 finfo.last_bf_index = -1;
671 finfo.internal_syms = NULL;
672 finfo.sec_ptrs = NULL;
673 finfo.sym_indices = NULL;
674 finfo.outsyms = NULL;
675 finfo.linenos = NULL;
676 finfo.contents = NULL;
677 finfo.external_relocs = NULL;
678 finfo.internal_relocs = NULL;
679 finfo.global_to_static = false;
680 debug_merge_allocated = false;
682 coff_data (abfd)->link_info = info;
684 finfo.strtab = _bfd_stringtab_init ();
685 if (finfo.strtab == NULL)
688 if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
690 debug_merge_allocated = true;
692 /* Compute the file positions for all the sections. */
693 if (! abfd->output_has_begun)
695 if (! bfd_coff_compute_section_file_positions (abfd))
699 /* Count the line numbers and relocation entries required for the
700 output file. Set the file positions for the relocs. */
701 rel_filepos = obj_relocbase (abfd);
702 relsz = bfd_coff_relsz (abfd);
703 max_contents_size = 0;
704 max_lineno_count = 0;
707 long_section_names = false;
708 for (o = abfd->sections; o != NULL; o = o->next)
712 for (p = o->link_order_head; p != NULL; p = p->next)
714 if (p->type == bfd_indirect_link_order)
718 sec = p->u.indirect.section;
720 /* Mark all sections which are to be included in the
721 link. This will normally be every section. We need
722 to do this so that we can identify any sections which
723 the linker has decided to not include. */
724 sec->linker_mark = true;
726 if (info->strip == strip_none
727 || info->strip == strip_some)
728 o->lineno_count += sec->lineno_count;
730 if (info->relocateable)
731 o->reloc_count += sec->reloc_count;
733 if (sec->_raw_size > max_contents_size)
734 max_contents_size = sec->_raw_size;
735 if (sec->lineno_count > max_lineno_count)
736 max_lineno_count = sec->lineno_count;
737 if (sec->reloc_count > max_reloc_count)
738 max_reloc_count = sec->reloc_count;
740 else if (info->relocateable
741 && (p->type == bfd_section_reloc_link_order
742 || p->type == bfd_symbol_reloc_link_order))
745 if (o->reloc_count == 0)
749 o->flags |= SEC_RELOC;
750 o->rel_filepos = rel_filepos;
751 rel_filepos += o->reloc_count * relsz;
754 if (bfd_coff_long_section_names (abfd)
755 && strlen (o->name) > SCNNMLEN)
757 /* This section has a long name which must go in the string
758 table. This must correspond to the code in
759 coff_write_object_contents which puts the string index
760 into the s_name field of the section header. That is why
761 we pass hash as false. */
762 if (_bfd_stringtab_add (finfo.strtab, o->name, false, false)
763 == (bfd_size_type) -1)
765 long_section_names = true;
769 /* If doing a relocateable link, allocate space for the pointers we
771 if (info->relocateable)
775 /* We use section_count + 1, rather than section_count, because
776 the target_index fields are 1 based. */
778 ((struct coff_link_section_info *)
779 bfd_malloc ((abfd->section_count + 1)
780 * sizeof (struct coff_link_section_info)));
781 if (finfo.section_info == NULL)
783 for (i = 0; i <= abfd->section_count; i++)
785 finfo.section_info[i].relocs = NULL;
786 finfo.section_info[i].rel_hashes = NULL;
790 /* We now know the size of the relocs, so we can determine the file
791 positions of the line numbers. */
792 line_filepos = rel_filepos;
793 linesz = bfd_coff_linesz (abfd);
794 max_output_reloc_count = 0;
795 for (o = abfd->sections; o != NULL; o = o->next)
797 if (o->lineno_count == 0)
801 o->line_filepos = line_filepos;
802 line_filepos += o->lineno_count * linesz;
805 if (o->reloc_count != 0)
807 /* We don't know the indices of global symbols until we have
808 written out all the local symbols. For each section in
809 the output file, we keep an array of pointers to hash
810 table entries. Each entry in the array corresponds to a
811 reloc. When we find a reloc against a global symbol, we
812 set the corresponding entry in this array so that we can
813 fix up the symbol index after we have written out all the
816 Because of this problem, we also keep the relocs in
817 memory until the end of the link. This wastes memory,
818 but only when doing a relocateable link, which is not the
820 BFD_ASSERT (info->relocateable);
821 finfo.section_info[o->target_index].relocs =
822 ((struct internal_reloc *)
823 bfd_malloc (o->reloc_count * sizeof (struct internal_reloc)));
824 finfo.section_info[o->target_index].rel_hashes =
825 ((struct coff_link_hash_entry **)
826 bfd_malloc (o->reloc_count
827 * sizeof (struct coff_link_hash_entry *)));
828 if (finfo.section_info[o->target_index].relocs == NULL
829 || finfo.section_info[o->target_index].rel_hashes == NULL)
832 if (o->reloc_count > max_output_reloc_count)
833 max_output_reloc_count = o->reloc_count;
836 /* Reset the reloc and lineno counts, so that we can use them to
837 count the number of entries we have output so far. */
842 obj_sym_filepos (abfd) = line_filepos;
844 /* Figure out the largest number of symbols in an input BFD. Take
845 the opportunity to clear the output_has_begun fields of all the
848 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
852 sub->output_has_begun = false;
853 sz = obj_raw_syment_count (sub);
854 if (sz > max_sym_count)
858 /* Allocate some buffers used while linking. */
859 finfo.internal_syms = ((struct internal_syment *)
860 bfd_malloc (max_sym_count
861 * sizeof (struct internal_syment)));
862 finfo.sec_ptrs = (asection **) bfd_malloc (max_sym_count
863 * sizeof (asection *));
864 finfo.sym_indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
865 finfo.outsyms = ((bfd_byte *)
866 bfd_malloc ((size_t) ((max_sym_count + 1) * symesz)));
867 finfo.linenos = (bfd_byte *) bfd_malloc (max_lineno_count
868 * bfd_coff_linesz (abfd));
869 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
870 finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
871 if (! info->relocateable)
872 finfo.internal_relocs = ((struct internal_reloc *)
873 bfd_malloc (max_reloc_count
874 * sizeof (struct internal_reloc)));
875 if ((finfo.internal_syms == NULL && max_sym_count > 0)
876 || (finfo.sec_ptrs == NULL && max_sym_count > 0)
877 || (finfo.sym_indices == NULL && max_sym_count > 0)
878 || finfo.outsyms == NULL
879 || (finfo.linenos == NULL && max_lineno_count > 0)
880 || (finfo.contents == NULL && max_contents_size > 0)
881 || (finfo.external_relocs == NULL && max_reloc_count > 0)
882 || (! info->relocateable
883 && finfo.internal_relocs == NULL
884 && max_reloc_count > 0))
887 /* We now know the position of everything in the file, except that
888 we don't know the size of the symbol table and therefore we don't
889 know where the string table starts. We just build the string
890 table in memory as we go along. We process all the relocations
891 for a single input file at once. */
892 obj_raw_syment_count (abfd) = 0;
894 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
896 if (! bfd_coff_start_final_link (abfd, info))
900 for (o = abfd->sections; o != NULL; o = o->next)
902 for (p = o->link_order_head; p != NULL; p = p->next)
904 if (p->type == bfd_indirect_link_order
905 && bfd_family_coff (p->u.indirect.section->owner))
907 sub = p->u.indirect.section->owner;
908 if (! bfd_coff_link_output_has_begun (sub, & finfo))
910 if (! _bfd_coff_link_input_bfd (&finfo, sub))
912 sub->output_has_begun = true;
915 else if (p->type == bfd_section_reloc_link_order
916 || p->type == bfd_symbol_reloc_link_order)
918 if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
923 if (! _bfd_default_link_order (abfd, info, o, p))
929 if (! bfd_coff_final_link_postscript (abfd, & finfo))
932 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
934 coff_debug_merge_hash_table_free (&finfo.debug_merge);
935 debug_merge_allocated = false;
937 if (finfo.internal_syms != NULL)
939 free (finfo.internal_syms);
940 finfo.internal_syms = NULL;
942 if (finfo.sec_ptrs != NULL)
944 free (finfo.sec_ptrs);
945 finfo.sec_ptrs = NULL;
947 if (finfo.sym_indices != NULL)
949 free (finfo.sym_indices);
950 finfo.sym_indices = NULL;
952 if (finfo.linenos != NULL)
954 free (finfo.linenos);
955 finfo.linenos = NULL;
957 if (finfo.contents != NULL)
959 free (finfo.contents);
960 finfo.contents = NULL;
962 if (finfo.external_relocs != NULL)
964 free (finfo.external_relocs);
965 finfo.external_relocs = NULL;
967 if (finfo.internal_relocs != NULL)
969 free (finfo.internal_relocs);
970 finfo.internal_relocs = NULL;
973 /* The value of the last C_FILE symbol is supposed to be the symbol
974 index of the first external symbol. Write it out again if
976 if (finfo.last_file_index != -1
977 && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
979 finfo.last_file.n_value = obj_raw_syment_count (abfd);
980 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
981 (PTR) finfo.outsyms);
983 (obj_sym_filepos (abfd)
984 + finfo.last_file_index * symesz),
986 || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
990 /* If doing task linking (ld --task-link) then make a pass through the
991 global symbols, writing out any that are defined, and making them
995 finfo.failed = false;
996 coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_task_globals,
1002 /* Write out the global symbols. */
1003 finfo.failed = false;
1004 coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_global_sym,
1009 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
1010 if (finfo.outsyms != NULL)
1012 free (finfo.outsyms);
1013 finfo.outsyms = NULL;
1016 if (info->relocateable && max_output_reloc_count > 0)
1018 /* Now that we have written out all the global symbols, we know
1019 the symbol indices to use for relocs against them, and we can
1020 finally write out the relocs. */
1021 external_relocs = ((bfd_byte *)
1022 bfd_malloc (max_output_reloc_count * relsz));
1023 if (external_relocs == NULL)
1026 for (o = abfd->sections; o != NULL; o = o->next)
1028 struct internal_reloc *irel;
1029 struct internal_reloc *irelend;
1030 struct coff_link_hash_entry **rel_hash;
1033 if (o->reloc_count == 0)
1036 irel = finfo.section_info[o->target_index].relocs;
1037 irelend = irel + o->reloc_count;
1038 rel_hash = finfo.section_info[o->target_index].rel_hashes;
1039 erel = external_relocs;
1040 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1042 if (*rel_hash != NULL)
1044 BFD_ASSERT ((*rel_hash)->indx >= 0);
1045 irel->r_symndx = (*rel_hash)->indx;
1047 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
1050 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
1051 || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
1052 abfd) != relsz * o->reloc_count)
1056 free (external_relocs);
1057 external_relocs = NULL;
1060 /* Free up the section information. */
1061 if (finfo.section_info != NULL)
1065 for (i = 0; i < abfd->section_count; i++)
1067 if (finfo.section_info[i].relocs != NULL)
1068 free (finfo.section_info[i].relocs);
1069 if (finfo.section_info[i].rel_hashes != NULL)
1070 free (finfo.section_info[i].rel_hashes);
1072 free (finfo.section_info);
1073 finfo.section_info = NULL;
1076 /* If we have optimized stabs strings, output them. */
1077 if (coff_hash_table (info)->stab_info != NULL)
1079 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1083 /* Write out the string table. */
1084 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1087 (obj_sym_filepos (abfd)
1088 + obj_raw_syment_count (abfd) * symesz),
1092 #if STRING_SIZE_SIZE == 4
1094 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
1095 (bfd_byte *) strbuf);
1097 #error Change bfd_h_put_32
1100 if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
1103 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
1106 obj_coff_strings_written (abfd) = true;
1109 _bfd_stringtab_free (finfo.strtab);
1111 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1112 not try to write out the symbols. */
1113 bfd_get_symcount (abfd) = 0;
1118 if (debug_merge_allocated)
1119 coff_debug_merge_hash_table_free (&finfo.debug_merge);
1120 if (finfo.strtab != NULL)
1121 _bfd_stringtab_free (finfo.strtab);
1122 if (finfo.section_info != NULL)
1126 for (i = 0; i < abfd->section_count; i++)
1128 if (finfo.section_info[i].relocs != NULL)
1129 free (finfo.section_info[i].relocs);
1130 if (finfo.section_info[i].rel_hashes != NULL)
1131 free (finfo.section_info[i].rel_hashes);
1133 free (finfo.section_info);
1135 if (finfo.internal_syms != NULL)
1136 free (finfo.internal_syms);
1137 if (finfo.sec_ptrs != NULL)
1138 free (finfo.sec_ptrs);
1139 if (finfo.sym_indices != NULL)
1140 free (finfo.sym_indices);
1141 if (finfo.outsyms != NULL)
1142 free (finfo.outsyms);
1143 if (finfo.linenos != NULL)
1144 free (finfo.linenos);
1145 if (finfo.contents != NULL)
1146 free (finfo.contents);
1147 if (finfo.external_relocs != NULL)
1148 free (finfo.external_relocs);
1149 if (finfo.internal_relocs != NULL)
1150 free (finfo.internal_relocs);
1151 if (external_relocs != NULL)
1152 free (external_relocs);
1156 /* parse out a -heap <reserved>,<commit> line */
1159 dores_com (ptr, output_bfd, heap)
1164 if (coff_data(output_bfd)->pe)
1166 int val = strtoul (ptr, &ptr, 0);
1168 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve =val;
1170 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve =val;
1174 int val = strtoul (ptr+1, &ptr, 0);
1176 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit =val;
1178 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit =val;
1184 static char *get_name(ptr, dst)
1191 while (*ptr && *ptr != ' ')
1197 /* Process any magic embedded commands in a section called .drectve */
1200 process_embedded_commands (output_bfd, info, abfd)
1202 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1205 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1212 copy = bfd_malloc ((size_t) sec->_raw_size);
1215 if (! bfd_get_section_contents(abfd, sec, copy, 0, sec->_raw_size))
1220 e = copy + sec->_raw_size;
1221 for (s = copy; s < e ; )
1227 if (strncmp (s,"-attr", 5) == 0)
1239 s = get_name(s, &name);
1240 s = get_name(s, &attribs);
1260 asec = bfd_get_section_by_name (abfd, name);
1263 asec->flags |= SEC_CODE;
1265 asec->flags |= SEC_READONLY;
1268 else if (strncmp (s,"-heap", 5) == 0)
1270 s = dores_com (s+5, output_bfd, 1);
1272 else if (strncmp (s,"-stack", 6) == 0)
1274 s = dores_com (s+6, output_bfd, 0);
1283 /* Place a marker against all symbols which are used by relocations.
1284 This marker can be picked up by the 'do we skip this symbol ?'
1285 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1290 mark_relocs (finfo, input_bfd)
1291 struct coff_final_link_info * finfo;
1296 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1299 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1301 struct internal_reloc * internal_relocs;
1302 struct internal_reloc * irel;
1303 struct internal_reloc * irelend;
1306 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1)
1309 /* Read in the relocs. */
1310 internal_relocs = _bfd_coff_read_internal_relocs
1311 (input_bfd, a, false,
1312 finfo->external_relocs,
1313 finfo->info->relocateable,
1314 (finfo->info->relocateable
1315 ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1316 : finfo->internal_relocs)
1319 if (internal_relocs == NULL)
1322 irel = internal_relocs;
1323 irelend = irel + a->reloc_count;
1325 /* Place a mark in the sym_indices array (whose entries have
1326 been initialised to 0) for all of the symbols that are used
1327 in the relocation table. This will then be picked up in the
1330 for (; irel < irelend; irel++)
1332 finfo->sym_indices[ irel->r_symndx ] = -1;
1337 /* Link an input file into the linker output file. This function
1338 handles all the sections and relocations of the input file at once. */
1341 _bfd_coff_link_input_bfd (finfo, input_bfd)
1342 struct coff_final_link_info *finfo;
1345 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1346 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1348 unsigned int n_btmask = coff_data (input_bfd)->local_n_btmask;
1350 boolean (*adjust_symndx) PARAMS ((bfd *, struct bfd_link_info *, bfd *,
1351 asection *, struct internal_reloc *,
1354 const char *strings;
1355 bfd_size_type syment_base;
1357 bfd_size_type isymesz;
1358 bfd_size_type osymesz;
1359 bfd_size_type linesz;
1362 struct internal_syment *isymp;
1365 unsigned long output_index;
1367 struct coff_link_hash_entry **sym_hash;
1370 /* Move all the symbols to the output file. */
1372 output_bfd = finfo->output_bfd;
1374 syment_base = obj_raw_syment_count (output_bfd);
1375 isymesz = bfd_coff_symesz (input_bfd);
1376 osymesz = bfd_coff_symesz (output_bfd);
1377 linesz = bfd_coff_linesz (input_bfd);
1378 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1381 if (! finfo->info->keep_memory)
1384 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1387 if (! _bfd_coff_get_external_symbols (input_bfd))
1390 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1391 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1392 isymp = finfo->internal_syms;
1393 secpp = finfo->sec_ptrs;
1394 indexp = finfo->sym_indices;
1395 output_index = syment_base;
1396 outsym = finfo->outsyms;
1398 if (coff_data (output_bfd)->pe)
1400 if (! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1404 /* If we are going to perform relocations and also strip/discard some symbols
1405 then we must make sure that we do not strip/discard those symbols that are
1406 going to be involved in the relocations */
1407 if (( finfo->info->strip != strip_none
1408 || finfo->info->discard != discard_none)
1409 && finfo->info->relocateable)
1411 /* mark the symbol array as 'not-used' */
1412 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1414 mark_relocs (finfo, input_bfd);
1417 while (esym < esym_end)
1419 struct internal_syment isym;
1420 enum coff_symbol_classification classification;
1423 boolean dont_skip_symbol;
1426 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
1428 /* Make a copy of *isymp so that the relocate_section function
1429 always sees the original values. This is more reliable than
1430 always recomputing the symbol value even if we are stripping
1434 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1435 switch (classification)
1439 case COFF_SYMBOL_GLOBAL:
1440 case COFF_SYMBOL_PE_SECTION:
1441 case COFF_SYMBOL_LOCAL:
1442 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1444 case COFF_SYMBOL_COMMON:
1445 *secpp = bfd_com_section_ptr;
1447 case COFF_SYMBOL_UNDEFINED:
1448 *secpp = bfd_und_section_ptr;
1452 /* Extract the flag indicating if this symbol is used by a
1454 if ((finfo->info->strip != strip_none
1455 || finfo->info->discard != discard_none)
1456 && finfo->info->relocateable)
1457 dont_skip_symbol = *indexp;
1459 dont_skip_symbol = false;
1465 add = 1 + isym.n_numaux;
1467 /* If we are stripping all symbols, we want to skip this one. */
1468 if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1473 switch (classification)
1477 case COFF_SYMBOL_GLOBAL:
1478 case COFF_SYMBOL_COMMON:
1479 case COFF_SYMBOL_PE_SECTION:
1480 /* This is a global symbol. Global symbols come at the
1481 end of the symbol table, so skip them for now.
1482 Locally defined function symbols, however, are an
1483 exception, and are not moved to the end. */
1485 if (! ISFCN (isym.n_type))
1489 case COFF_SYMBOL_UNDEFINED:
1490 /* Undefined symbols are left for the end. */
1495 case COFF_SYMBOL_LOCAL:
1496 /* This is a local symbol. Skip it if we are discarding
1498 if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1504 /* If we stripping debugging symbols, and this is a debugging
1505 symbol, then skip it. FIXME: gas sets the section to N_ABS
1506 for some types of debugging symbols; I don't know if this is
1507 a bug or not. In any case, we handle it here. */
1509 && finfo->info->strip == strip_debugger
1510 && ! dont_skip_symbol
1511 && (isym.n_scnum == N_DEBUG
1512 || (isym.n_scnum == N_ABS
1513 && (isym.n_sclass == C_AUTO
1514 || isym.n_sclass == C_REG
1515 || isym.n_sclass == C_MOS
1516 || isym.n_sclass == C_MOE
1517 || isym.n_sclass == C_MOU
1518 || isym.n_sclass == C_ARG
1519 || isym.n_sclass == C_REGPARM
1520 || isym.n_sclass == C_FIELD
1521 || isym.n_sclass == C_EOS))))
1524 /* If some symbols are stripped based on the name, work out the
1525 name and decide whether to skip this symbol. */
1527 && (finfo->info->strip == strip_some
1528 || finfo->info->discard == discard_l))
1531 char buf[SYMNMLEN + 1];
1533 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1537 if (! dont_skip_symbol
1538 && ((finfo->info->strip == strip_some
1539 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
1542 && finfo->info->discard == discard_l
1543 && bfd_is_local_label_name (input_bfd, name))))
1547 /* If this is an enum, struct, or union tag, see if we have
1548 already output an identical type. */
1550 && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1551 && (isym.n_sclass == C_ENTAG
1552 || isym.n_sclass == C_STRTAG
1553 || isym.n_sclass == C_UNTAG)
1554 && isym.n_numaux == 1)
1557 char buf[SYMNMLEN + 1];
1558 struct coff_debug_merge_hash_entry *mh;
1559 struct coff_debug_merge_type *mt;
1560 union internal_auxent aux;
1561 struct coff_debug_merge_element **epp;
1562 bfd_byte *esl, *eslend;
1563 struct internal_syment *islp;
1565 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1569 /* Ignore fake names invented by compiler; treat them all as
1571 if (*name == '~' || *name == '.' || *name == '$'
1572 || (*name == bfd_get_symbol_leading_char (input_bfd)
1573 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1576 mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1581 /* Allocate memory to hold type information. If this turns
1582 out to be a duplicate, we pass this address to
1584 mt = ((struct coff_debug_merge_type *)
1585 bfd_alloc (input_bfd,
1586 sizeof (struct coff_debug_merge_type)));
1589 mt->class = isym.n_sclass;
1591 /* Pick up the aux entry, which points to the end of the tag
1593 bfd_coff_swap_aux_in (input_bfd, (PTR) (esym + isymesz),
1594 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1597 /* Gather the elements. */
1598 epp = &mt->elements;
1599 mt->elements = NULL;
1601 esl = esym + 2 * isymesz;
1602 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1603 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1604 while (esl < eslend)
1606 const char *elename;
1607 char elebuf[SYMNMLEN + 1];
1610 bfd_coff_swap_sym_in (input_bfd, (PTR) esl, (PTR) islp);
1612 *epp = ((struct coff_debug_merge_element *)
1613 bfd_alloc (input_bfd,
1614 sizeof (struct coff_debug_merge_element)));
1618 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1620 if (elename == NULL)
1623 name_copy = (char *) bfd_alloc (input_bfd,
1624 strlen (elename) + 1);
1625 if (name_copy == NULL)
1627 strcpy (name_copy, elename);
1629 (*epp)->name = name_copy;
1630 (*epp)->type = islp->n_type;
1632 if (islp->n_numaux >= 1
1633 && islp->n_type != T_NULL
1634 && islp->n_sclass != C_EOS)
1636 union internal_auxent eleaux;
1639 bfd_coff_swap_aux_in (input_bfd, (PTR) (esl + isymesz),
1640 islp->n_type, islp->n_sclass, 0,
1641 islp->n_numaux, (PTR) &eleaux);
1642 indx = eleaux.x_sym.x_tagndx.l;
1644 /* FIXME: If this tagndx entry refers to a symbol
1645 defined later in this file, we just ignore it.
1646 Handling this correctly would be tedious, and may
1652 (bfd_byte *) obj_coff_external_syms (input_bfd))
1655 (*epp)->tagndx = finfo->sym_indices[indx];
1656 if ((*epp)->tagndx < 0)
1660 epp = &(*epp)->next;
1663 esl += (islp->n_numaux + 1) * isymesz;
1664 islp += islp->n_numaux + 1;
1667 /* See if we already have a definition which matches this
1668 type. We always output the type if it has no elements,
1670 if (mt->elements == NULL)
1671 bfd_release (input_bfd, (PTR) mt);
1674 struct coff_debug_merge_type *mtl;
1676 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1678 struct coff_debug_merge_element *me, *mel;
1680 if (mtl->class != mt->class)
1683 for (me = mt->elements, mel = mtl->elements;
1684 me != NULL && mel != NULL;
1685 me = me->next, mel = mel->next)
1687 if (strcmp (me->name, mel->name) != 0
1688 || me->type != mel->type
1689 || me->tagndx != mel->tagndx)
1693 if (me == NULL && mel == NULL)
1697 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1699 /* This is the first definition of this type. */
1700 mt->indx = output_index;
1701 mt->next = mh->types;
1706 /* This is a redefinition which can be merged. */
1707 bfd_release (input_bfd, (PTR) mt);
1708 *indexp = mtl->indx;
1709 add = (eslend - esym) / isymesz;
1715 /* We now know whether we are to skip this symbol or not. */
1718 /* Adjust the symbol in order to output it. */
1720 if (isym._n._n_n._n_zeroes == 0
1721 && isym._n._n_n._n_offset != 0)
1726 /* This symbol has a long name. Enter it in the string
1727 table we are building. Note that we do not check
1728 bfd_coff_symname_in_debug. That is only true for
1729 XCOFF, and XCOFF requires different linking code
1731 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
1735 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1736 if (indx == (bfd_size_type) -1)
1738 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1741 switch (isym.n_sclass)
1757 /* The symbol value should not be modified. */
1761 if (obj_pe (input_bfd)
1762 && strcmp (isym.n_name, ".bf") != 0
1763 && isym.n_scnum > 0)
1765 /* For PE, .lf and .ef get their value left alone,
1766 while .bf gets relocated. However, they all have
1767 "real" section numbers, and need to be moved into
1769 isym.n_scnum = (*secpp)->output_section->target_index;
1774 case C_LABEL: /* Not completely sure about these 2 */
1783 /* Compute new symbol location. */
1784 if (isym.n_scnum > 0)
1786 isym.n_scnum = (*secpp)->output_section->target_index;
1787 isym.n_value += (*secpp)->output_offset;
1788 if (! obj_pe (input_bfd))
1789 isym.n_value -= (*secpp)->vma;
1790 if (! obj_pe (finfo->output_bfd))
1791 isym.n_value += (*secpp)->output_section->vma;
1796 /* The value of a C_FILE symbol is the symbol index of
1797 the next C_FILE symbol. The value of the last C_FILE
1798 symbol is the symbol index to the first external
1799 symbol (actually, coff_renumber_symbols does not get
1800 this right--it just sets the value of the last C_FILE
1801 symbol to zero--and nobody has ever complained about
1802 it). We try to get this right, below, just before we
1803 write the symbols out, but in the general case we may
1804 have to write the symbol out twice. */
1806 if (finfo->last_file_index != -1
1807 && finfo->last_file.n_value != (long) output_index)
1809 /* We must correct the value of the last C_FILE
1811 finfo->last_file.n_value = output_index;
1812 if ((bfd_size_type) finfo->last_file_index >= syment_base)
1814 /* The last C_FILE symbol is in this input file. */
1815 bfd_coff_swap_sym_out (output_bfd,
1816 (PTR) &finfo->last_file,
1817 (PTR) (finfo->outsyms
1818 + ((finfo->last_file_index
1824 /* We have already written out the last C_FILE
1825 symbol. We need to write it out again. We
1826 borrow *outsym temporarily. */
1827 bfd_coff_swap_sym_out (output_bfd,
1828 (PTR) &finfo->last_file,
1830 if (bfd_seek (output_bfd,
1831 (obj_sym_filepos (output_bfd)
1832 + finfo->last_file_index * osymesz),
1834 || (bfd_write (outsym, osymesz, 1, output_bfd)
1840 finfo->last_file_index = output_index;
1841 finfo->last_file = isym;
1845 /* If doing task linking, convert normal global function symbols to
1846 static functions. */
1847 if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1848 isym.n_sclass = C_STAT;
1850 /* Output the symbol. */
1852 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
1854 *indexp = output_index;
1859 struct coff_link_hash_entry *h;
1861 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1863 h = obj_coff_sym_hashes (input_bfd)[indx];
1866 /* This can happen if there were errors earlier in
1868 bfd_set_error (bfd_error_bad_value);
1871 h->indx = output_index;
1874 output_index += add;
1875 outsym += add * osymesz;
1878 esym += add * isymesz;
1882 for (--add; add > 0; --add)
1889 /* Fix up the aux entries. This must be done in a separate pass,
1890 because we don't know the correct symbol indices until we have
1891 already decided which symbols we are going to keep. */
1893 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1894 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1895 isymp = finfo->internal_syms;
1896 indexp = finfo->sym_indices;
1897 sym_hash = obj_coff_sym_hashes (input_bfd);
1898 outsym = finfo->outsyms;
1899 while (esym < esym_end)
1903 add = 1 + isymp->n_numaux;
1906 || (bfd_size_type) *indexp < syment_base)
1907 && (*sym_hash == NULL
1908 || (*sym_hash)->auxbfd != input_bfd))
1909 esym += add * isymesz;
1912 struct coff_link_hash_entry *h;
1920 /* The m68k-motorola-sysv assembler will sometimes
1921 generate two symbols with the same name, but only one
1922 will have aux entries. */
1923 BFD_ASSERT (isymp->n_numaux == 0
1924 || h->numaux == isymp->n_numaux);
1932 /* Handle the aux entries. This handling is based on
1933 coff_pointerize_aux. I don't know if it always correct. */
1934 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1936 union internal_auxent aux;
1937 union internal_auxent *auxp;
1943 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
1944 isymp->n_sclass, i, isymp->n_numaux,
1949 if (isymp->n_sclass == C_FILE)
1951 /* If this is a long filename, we must put it in the
1953 if (auxp->x_file.x_n.x_zeroes == 0
1954 && auxp->x_file.x_n.x_offset != 0)
1956 const char *filename;
1959 BFD_ASSERT (auxp->x_file.x_n.x_offset
1960 >= STRING_SIZE_SIZE);
1961 if (strings == NULL)
1963 strings = _bfd_coff_read_string_table (input_bfd);
1964 if (strings == NULL)
1967 filename = strings + auxp->x_file.x_n.x_offset;
1968 indx = _bfd_stringtab_add (finfo->strtab, filename,
1970 if (indx == (bfd_size_type) -1)
1972 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
1975 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
1979 if (ISFCN (isymp->n_type)
1980 || ISTAG (isymp->n_sclass)
1981 || isymp->n_sclass == C_BLOCK
1982 || isymp->n_sclass == C_FCN)
1984 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
1986 && indx < obj_raw_syment_count (input_bfd))
1988 /* We look forward through the symbol for
1989 the index of the next symbol we are going
1990 to include. I don't know if this is
1992 while ((finfo->sym_indices[indx] < 0
1993 || ((bfd_size_type) finfo->sym_indices[indx]
1995 && indx < obj_raw_syment_count (input_bfd))
1997 if (indx >= obj_raw_syment_count (input_bfd))
1998 indx = output_index;
2000 indx = finfo->sym_indices[indx];
2001 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2005 indx = auxp->x_sym.x_tagndx.l;
2006 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2010 symindx = finfo->sym_indices[indx];
2012 auxp->x_sym.x_tagndx.l = 0;
2014 auxp->x_sym.x_tagndx.l = symindx;
2017 /* The .bf symbols are supposed to be linked through
2018 the endndx field. We need to carry this list
2019 across object files. */
2022 && isymp->n_sclass == C_FCN
2023 && (isymp->_n._n_n._n_zeroes != 0
2024 || isymp->_n._n_n._n_offset == 0)
2025 && isymp->_n._n_name[0] == '.'
2026 && isymp->_n._n_name[1] == 'b'
2027 && isymp->_n._n_name[2] == 'f'
2028 && isymp->_n._n_name[3] == '\0')
2030 if (finfo->last_bf_index != -1)
2032 finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2035 if ((bfd_size_type) finfo->last_bf_index
2040 /* The last .bf symbol is in this input
2041 file. This will only happen if the
2042 assembler did not set up the .bf
2043 endndx symbols correctly. */
2044 auxout = (PTR) (finfo->outsyms
2045 + ((finfo->last_bf_index
2048 bfd_coff_swap_aux_out (output_bfd,
2049 (PTR) &finfo->last_bf,
2057 /* We have already written out the last
2058 .bf aux entry. We need to write it
2059 out again. We borrow *outsym
2060 temporarily. FIXME: This case should
2062 bfd_coff_swap_aux_out (output_bfd,
2063 (PTR) &finfo->last_bf,
2068 if (bfd_seek (output_bfd,
2069 (obj_sym_filepos (output_bfd)
2070 + finfo->last_bf_index * osymesz),
2072 || bfd_write (outsym, osymesz, 1,
2073 output_bfd) != osymesz)
2078 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2079 finfo->last_bf_index = -1;
2082 /* The endndx field of this aux entry must
2083 be updated with the symbol number of the
2085 finfo->last_bf = *auxp;
2086 finfo->last_bf_index = (((outsym - finfo->outsyms)
2095 bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isymp->n_type,
2096 isymp->n_sclass, i, isymp->n_numaux,
2110 /* Relocate the line numbers, unless we are stripping them. */
2111 if (finfo->info->strip == strip_none
2112 || finfo->info->strip == strip_some)
2114 for (o = input_bfd->sections; o != NULL; o = o->next)
2122 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2123 build_link_order in ldwrite.c will not have created a
2124 link order, which means that we will not have seen this
2125 input section in _bfd_coff_final_link, which means that
2126 we will not have allocated space for the line numbers of
2127 this section. I don't think line numbers can be
2128 meaningful for a section which does not have
2129 SEC_HAS_CONTENTS set, but, if they do, this must be
2131 if (o->lineno_count == 0
2132 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2135 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2136 || bfd_read (finfo->linenos, linesz, o->lineno_count,
2137 input_bfd) != linesz * o->lineno_count)
2140 offset = o->output_section->vma + o->output_offset - o->vma;
2141 eline = finfo->linenos;
2142 oeline = finfo->linenos;
2143 elineend = eline + linesz * o->lineno_count;
2145 for (; eline < elineend; eline += linesz)
2147 struct internal_lineno iline;
2149 bfd_coff_swap_lineno_in (input_bfd, (PTR) eline, (PTR) &iline);
2151 if (iline.l_lnno != 0)
2152 iline.l_addr.l_paddr += offset;
2153 else if (iline.l_addr.l_symndx >= 0
2154 && ((unsigned long) iline.l_addr.l_symndx
2155 < obj_raw_syment_count (input_bfd)))
2159 indx = finfo->sym_indices[iline.l_addr.l_symndx];
2163 /* These line numbers are attached to a symbol
2164 which we are stripping. We must discard the
2165 line numbers because reading them back with
2166 no associated symbol (or associating them all
2167 with symbol #0) will fail. We can't regain
2168 the space in the output file, but at least
2174 struct internal_syment is;
2175 union internal_auxent ia;
2177 /* Fix up the lnnoptr field in the aux entry of
2178 the symbol. It turns out that we can't do
2179 this when we modify the symbol aux entries,
2180 because gas sometimes screws up the lnnoptr
2181 field and makes it an offset from the start
2182 of the line numbers rather than an absolute
2184 bfd_coff_swap_sym_in (output_bfd,
2185 (PTR) (finfo->outsyms
2186 + ((indx - syment_base)
2189 if ((ISFCN (is.n_type)
2190 || is.n_sclass == C_BLOCK)
2191 && is.n_numaux >= 1)
2195 auxptr = (PTR) (finfo->outsyms
2196 + ((indx - syment_base + 1)
2198 bfd_coff_swap_aux_in (output_bfd, auxptr,
2199 is.n_type, is.n_sclass,
2200 0, is.n_numaux, (PTR) &ia);
2201 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2202 (o->output_section->line_filepos
2203 + o->output_section->lineno_count * linesz
2204 + eline - finfo->linenos);
2205 bfd_coff_swap_aux_out (output_bfd, (PTR) &ia,
2206 is.n_type, is.n_sclass, 0,
2207 is.n_numaux, auxptr);
2213 iline.l_addr.l_symndx = indx;
2218 bfd_coff_swap_lineno_out (output_bfd, (PTR) &iline,
2224 if (bfd_seek (output_bfd,
2225 (o->output_section->line_filepos
2226 + o->output_section->lineno_count * linesz),
2228 || (bfd_write (finfo->linenos, 1, oeline - finfo->linenos,
2230 != (bfd_size_type) (oeline - finfo->linenos)))
2233 o->output_section->lineno_count +=
2234 (oeline - finfo->linenos) / linesz;
2238 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2239 symbol will be the first symbol in the next input file. In the
2240 normal case, this will save us from writing out the C_FILE symbol
2242 if (finfo->last_file_index != -1
2243 && (bfd_size_type) finfo->last_file_index >= syment_base)
2245 finfo->last_file.n_value = output_index;
2246 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
2247 (PTR) (finfo->outsyms
2248 + ((finfo->last_file_index - syment_base)
2252 /* Write the modified symbols to the output file. */
2253 if (outsym > finfo->outsyms)
2255 if (bfd_seek (output_bfd,
2256 obj_sym_filepos (output_bfd) + syment_base * osymesz,
2258 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
2260 != (bfd_size_type) (outsym - finfo->outsyms)))
2263 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2264 + (outsym - finfo->outsyms) / osymesz)
2267 obj_raw_syment_count (output_bfd) = output_index;
2270 /* Relocate the contents of each section. */
2271 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2272 for (o = input_bfd->sections; o != NULL; o = o->next)
2275 struct coff_section_tdata *secdata;
2277 if (! o->linker_mark)
2279 /* This section was omitted from the link. */
2283 if ((o->flags & SEC_HAS_CONTENTS) == 0
2284 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
2286 if ((o->flags & SEC_RELOC) != 0
2287 && o->reloc_count != 0)
2289 ((*_bfd_error_handler)
2290 (_("%s: relocs in section `%s', but it has no contents"),
2291 bfd_get_filename (input_bfd),
2292 bfd_get_section_name (input_bfd, o)));
2293 bfd_set_error (bfd_error_no_contents);
2300 secdata = coff_section_data (input_bfd, o);
2301 if (secdata != NULL && secdata->contents != NULL)
2302 contents = secdata->contents;
2305 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2306 (file_ptr) 0, o->_raw_size))
2308 contents = finfo->contents;
2311 if ((o->flags & SEC_RELOC) != 0)
2314 struct internal_reloc *internal_relocs;
2315 struct internal_reloc *irel;
2317 /* Read in the relocs. */
2318 target_index = o->output_section->target_index;
2319 internal_relocs = (_bfd_coff_read_internal_relocs
2320 (input_bfd, o, false, finfo->external_relocs,
2321 finfo->info->relocateable,
2322 (finfo->info->relocateable
2323 ? (finfo->section_info[target_index].relocs
2324 + o->output_section->reloc_count)
2325 : finfo->internal_relocs)));
2326 if (internal_relocs == NULL)
2329 /* Call processor specific code to relocate the section
2331 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2335 finfo->internal_syms,
2339 if (finfo->info->relocateable)
2342 struct internal_reloc *irelend;
2343 struct coff_link_hash_entry **rel_hash;
2345 offset = o->output_section->vma + o->output_offset - o->vma;
2346 irel = internal_relocs;
2347 irelend = irel + o->reloc_count;
2348 rel_hash = (finfo->section_info[target_index].rel_hashes
2349 + o->output_section->reloc_count);
2350 for (; irel < irelend; irel++, rel_hash++)
2352 struct coff_link_hash_entry *h;
2357 /* Adjust the reloc address and symbol index. */
2359 irel->r_vaddr += offset;
2361 if (irel->r_symndx == -1)
2366 if (! (*adjust_symndx) (output_bfd, finfo->info,
2374 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2377 /* This is a global symbol. */
2379 irel->r_symndx = h->indx;
2382 /* This symbol is being written at the end
2383 of the file, and we do not yet know the
2384 symbol index. We save the pointer to the
2385 hash table entry in the rel_hash list.
2386 We set the indx field to -2 to indicate
2387 that this symbol must not be stripped. */
2396 indx = finfo->sym_indices[irel->r_symndx];
2398 irel->r_symndx = indx;
2401 struct internal_syment *is;
2403 char buf[SYMNMLEN + 1];
2405 /* This reloc is against a symbol we are
2406 stripping. This should have been handled
2407 by the 'dont_skip_symbol' code in the while
2408 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 if (! bfd_set_section_contents (output_bfd, o->output_section,
2436 bfd_octets_per_byte (output_bfd)),
2437 (o->_cooked_size != 0
2444 if (! (_bfd_write_section_stabs
2445 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2446 o, &secdata->stab_info, contents)))
2451 if (! finfo->info->keep_memory)
2453 if (! _bfd_coff_free_symbols (input_bfd))
2460 /* Write out a global symbol. Called via coff_link_hash_traverse. */
2463 _bfd_coff_write_global_sym (h, data)
2464 struct coff_link_hash_entry *h;
2467 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2469 struct internal_syment isym;
2470 bfd_size_type symesz;
2473 output_bfd = finfo->output_bfd;
2479 && (finfo->info->strip == strip_all
2480 || (finfo->info->strip == strip_some
2481 && (bfd_hash_lookup (finfo->info->keep_hash,
2482 h->root.root.string, false, false)
2486 switch (h->root.type)
2489 case bfd_link_hash_new:
2493 case bfd_link_hash_undefined:
2494 case bfd_link_hash_undefweak:
2495 isym.n_scnum = N_UNDEF;
2499 case bfd_link_hash_defined:
2500 case bfd_link_hash_defweak:
2504 sec = h->root.u.def.section->output_section;
2505 if (bfd_is_abs_section (sec))
2506 isym.n_scnum = N_ABS;
2508 isym.n_scnum = sec->target_index;
2509 isym.n_value = (h->root.u.def.value
2510 + h->root.u.def.section->output_offset);
2511 if (! obj_pe (finfo->output_bfd))
2512 isym.n_value += sec->vma;
2516 case bfd_link_hash_common:
2517 isym.n_scnum = N_UNDEF;
2518 isym.n_value = h->root.u.c.size;
2521 case bfd_link_hash_indirect:
2522 case bfd_link_hash_warning:
2523 /* Just ignore these. They can't be handled anyhow. */
2527 if (strlen (h->root.root.string) <= SYMNMLEN)
2528 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2535 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2537 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2539 if (indx == (bfd_size_type) -1)
2541 finfo->failed = true;
2544 isym._n._n_n._n_zeroes = 0;
2545 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2548 isym.n_sclass = h->class;
2549 isym.n_type = h->type;
2551 if (isym.n_sclass == C_NULL)
2552 isym.n_sclass = C_EXT;
2554 /* If doing task linking and this is the pass where we convert
2555 defined globals to statics, then do that conversion now. If the
2556 symbol is not being converted, just ignore it and it will be
2557 output during a later pass. */
2558 if (finfo->global_to_static)
2560 if (! IS_EXTERNAL (output_bfd, isym))
2563 isym.n_sclass = C_STAT;
2566 /* When a weak symbol is not overriden by a strong one,
2567 turn it into an external symbol when not building a
2568 shared or relocateable object. */
2569 if (! finfo->info->shared
2570 && ! finfo->info->relocateable
2571 && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
2572 isym.n_sclass = C_EXT;
2574 isym.n_numaux = h->numaux;
2576 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) finfo->outsyms);
2578 symesz = bfd_coff_symesz (output_bfd);
2580 if (bfd_seek (output_bfd,
2581 (obj_sym_filepos (output_bfd)
2582 + obj_raw_syment_count (output_bfd) * symesz),
2584 || bfd_write (finfo->outsyms, symesz, 1, 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? */
2625 if (sec->reloc_count > 0xffff
2626 && (! obj_pe (output_bfd)
2627 || finfo->info->relocateable))
2628 (*_bfd_error_handler)
2629 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2630 bfd_get_filename (output_bfd),
2631 bfd_get_section_name (output_bfd, sec),
2634 if (sec->lineno_count > 0xffff
2635 && (! obj_pe (output_bfd)
2636 || finfo->info->relocateable))
2637 (*_bfd_error_handler)
2638 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2639 bfd_get_filename (output_bfd),
2640 bfd_get_section_name (output_bfd, sec),
2643 auxp->x_scn.x_nreloc = sec->reloc_count;
2644 auxp->x_scn.x_nlinno = sec->lineno_count;
2645 auxp->x_scn.x_checksum = 0;
2646 auxp->x_scn.x_associated = 0;
2647 auxp->x_scn.x_comdat = 0;
2651 bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isym.n_type,
2652 isym.n_sclass, i, isym.n_numaux,
2653 (PTR) finfo->outsyms);
2654 if (bfd_write (finfo->outsyms, symesz, 1, output_bfd) != symesz)
2656 finfo->failed = true;
2659 ++obj_raw_syment_count (output_bfd);
2665 /* Write out task global symbols, converting them to statics. Called
2666 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2667 the dirty work, if the symbol we are processing needs conversion. */
2670 _bfd_coff_write_task_globals (h, data)
2671 struct coff_link_hash_entry *h;
2674 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2675 boolean rtnval = true;
2676 boolean save_global_to_static;
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 (output_bfd, finfo, output_section, link_order)
2701 struct coff_final_link_info *finfo;
2702 asection *output_section;
2703 struct bfd_link_order *link_order;
2705 reloc_howto_type *howto;
2706 struct internal_reloc *irel;
2707 struct coff_link_hash_entry **rel_hash_ptr;
2709 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2712 bfd_set_error (bfd_error_bad_value);
2716 if (link_order->u.reloc.p->addend != 0)
2720 bfd_reloc_status_type rstat;
2723 size = bfd_get_reloc_size (howto);
2724 buf = (bfd_byte *) bfd_zmalloc (size);
2728 rstat = _bfd_relocate_contents (howto, output_bfd,
2729 link_order->u.reloc.p->addend, buf);
2735 case bfd_reloc_outofrange:
2737 case bfd_reloc_overflow:
2738 if (! ((*finfo->info->callbacks->reloc_overflow)
2740 (link_order->type == bfd_section_reloc_link_order
2741 ? bfd_section_name (output_bfd,
2742 link_order->u.reloc.p->u.section)
2743 : link_order->u.reloc.p->u.name),
2744 howto->name, link_order->u.reloc.p->addend,
2745 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2752 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
2754 (link_order->offset *
2755 bfd_octets_per_byte (output_bfd)), size);
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. */
2764 irel = (finfo->section_info[output_section->target_index].relocs
2765 + output_section->reloc_count);
2766 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2767 + output_section->reloc_count);
2769 memset (irel, 0, sizeof (struct internal_reloc));
2770 *rel_hash_ptr = NULL;
2772 irel->r_vaddr = output_section->vma + link_order->offset;
2774 if (link_order->type == bfd_section_reloc_link_order)
2776 /* We need to somehow locate a symbol in the right section. The
2777 symbol must either have a value of zero, or we must adjust
2778 the addend by the value of the symbol. FIXME: Write this
2779 when we need it. The old linker couldn't handle this anyhow. */
2781 *rel_hash_ptr = NULL;
2786 struct coff_link_hash_entry *h;
2788 h = ((struct coff_link_hash_entry *)
2789 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2790 link_order->u.reloc.p->u.name,
2791 false, false, true));
2795 irel->r_symndx = h->indx;
2798 /* Set the index to -2 to force this symbol to get
2807 if (! ((*finfo->info->callbacks->unattached_reloc)
2808 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2809 (asection *) NULL, (bfd_vma) 0)))
2815 /* FIXME: Is this always right? */
2816 irel->r_type = howto->type;
2818 /* r_size is only used on the RS/6000, which needs its own linker
2819 routines anyhow. r_extern is only used for ECOFF. */
2821 /* FIXME: What is the right value for r_offset? Is zero OK? */
2823 ++output_section->reloc_count;
2828 /* A basic reloc handling routine which may be used by processors with
2832 _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
2833 input_section, contents, relocs, syms,
2836 struct bfd_link_info *info;
2838 asection *input_section;
2840 struct internal_reloc *relocs;
2841 struct internal_syment *syms;
2842 asection **sections;
2844 struct internal_reloc *rel;
2845 struct internal_reloc *relend;
2848 relend = rel + input_section->reloc_count;
2849 for (; rel < relend; rel++)
2852 struct coff_link_hash_entry *h;
2853 struct internal_syment *sym;
2856 reloc_howto_type *howto;
2857 bfd_reloc_status_type rstat;
2859 symndx = rel->r_symndx;
2867 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2869 (*_bfd_error_handler)
2870 ("%s: illegal symbol index %ld in relocs",
2871 bfd_get_filename (input_bfd), symndx);
2876 h = obj_coff_sym_hashes (input_bfd)[symndx];
2877 sym = syms + symndx;
2880 /* COFF treats common symbols in one of two ways. Either the
2881 size of the symbol is included in the section contents, or it
2882 is not. We assume that the size is not included, and force
2883 the rtype_to_howto function to adjust the addend as needed. */
2885 if (sym != NULL && sym->n_scnum != 0)
2886 addend = - sym->n_value;
2891 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2896 /* If we are doing a relocateable link, then we can just ignore
2897 a PC relative reloc that is pcrel_offset. It will already
2898 have the correct value. If this is not a relocateable link,
2899 then we should ignore the symbol value. */
2900 if (howto->pc_relative && howto->pcrel_offset)
2902 if (info->relocateable)
2904 if (sym != NULL && sym->n_scnum != 0)
2905 addend += sym->n_value;
2916 sec = bfd_abs_section_ptr;
2921 sec = sections[symndx];
2922 val = (sec->output_section->vma
2923 + sec->output_offset
2925 if (! obj_pe (input_bfd))
2931 if (h->root.type == bfd_link_hash_defined
2932 || h->root.type == bfd_link_hash_defweak)
2936 sec = h->root.u.def.section;
2937 val = (h->root.u.def.value
2938 + sec->output_section->vma
2939 + sec->output_offset);
2942 else if (h->root.type == bfd_link_hash_undefweak)
2945 else if (! info->relocateable)
2947 if (! ((*info->callbacks->undefined_symbol)
2948 (info, h->root.root.string, input_bfd, input_section,
2949 rel->r_vaddr - input_section->vma, true)))
2954 if (info->base_file)
2956 /* Emit a reloc if the backend thinks it needs it. */
2957 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
2959 /* Relocation to a symbol in a section which isn't
2960 absolute. We output the address here to a file.
2961 This file is then read by dlltool when generating the
2962 reloc section. Note that the base file is not
2963 portable between systems. We write out a long here,
2964 and dlltool reads in a long. */
2965 long addr = (rel->r_vaddr
2966 - input_section->vma
2967 + input_section->output_offset
2968 + input_section->output_section->vma);
2969 if (coff_data (output_bfd)->pe)
2970 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
2971 if (fwrite (&addr, 1, sizeof (long), (FILE *) info->base_file)
2974 bfd_set_error (bfd_error_system_call);
2980 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
2982 rel->r_vaddr - input_section->vma,
2991 case bfd_reloc_outofrange:
2992 (*_bfd_error_handler)
2993 (_("%s: bad reloc address 0x%lx in section `%s'"),
2994 bfd_get_filename (input_bfd),
2995 (unsigned long) rel->r_vaddr,
2996 bfd_get_section_name (input_bfd, input_section));
2998 case bfd_reloc_overflow:
3001 char buf[SYMNMLEN + 1];
3006 name = h->root.root.string;
3009 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3014 if (! ((*info->callbacks->reloc_overflow)
3015 (info, name, howto->name, (bfd_vma) 0, input_bfd,
3016 input_section, rel->r_vaddr - input_section->vma)))