1 /* COFF specific linker code.
2 Copyright 1994, 1995, 1996, 1997 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 *));
42 /* Create an entry in a COFF linker hash table. */
44 struct bfd_hash_entry *
45 _bfd_coff_link_hash_newfunc (entry, table, string)
46 struct bfd_hash_entry *entry;
47 struct bfd_hash_table *table;
50 struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
52 /* Allocate the structure if it has not already been allocated by a
54 if (ret == (struct coff_link_hash_entry *) NULL)
55 ret = ((struct coff_link_hash_entry *)
56 bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
57 if (ret == (struct coff_link_hash_entry *) NULL)
58 return (struct bfd_hash_entry *) ret;
60 /* Call the allocation method of the superclass. */
61 ret = ((struct coff_link_hash_entry *)
62 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
64 if (ret != (struct coff_link_hash_entry *) NULL)
66 /* Set local fields. */
75 return (struct bfd_hash_entry *) ret;
78 /* Initialize a COFF linker hash table. */
81 _bfd_coff_link_hash_table_init (table, abfd, newfunc)
82 struct coff_link_hash_table *table;
84 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
85 struct bfd_hash_table *,
88 table->stab_info = NULL;
89 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
92 /* Create a COFF linker hash table. */
94 struct bfd_link_hash_table *
95 _bfd_coff_link_hash_table_create (abfd)
98 struct coff_link_hash_table *ret;
100 ret = ((struct coff_link_hash_table *)
101 bfd_alloc (abfd, sizeof (struct coff_link_hash_table)));
104 if (! _bfd_coff_link_hash_table_init (ret, abfd,
105 _bfd_coff_link_hash_newfunc))
107 bfd_release (abfd, ret);
108 return (struct bfd_link_hash_table *) NULL;
113 /* Create an entry in a COFF debug merge hash table. */
115 struct bfd_hash_entry *
116 _bfd_coff_debug_merge_hash_newfunc (entry, table, string)
117 struct bfd_hash_entry *entry;
118 struct bfd_hash_table *table;
121 struct coff_debug_merge_hash_entry *ret =
122 (struct coff_debug_merge_hash_entry *) entry;
124 /* Allocate the structure if it has not already been allocated by a
126 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
127 ret = ((struct coff_debug_merge_hash_entry *)
128 bfd_hash_allocate (table,
129 sizeof (struct coff_debug_merge_hash_entry)));
130 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
131 return (struct bfd_hash_entry *) ret;
133 /* Call the allocation method of the superclass. */
134 ret = ((struct coff_debug_merge_hash_entry *)
135 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
136 if (ret != (struct coff_debug_merge_hash_entry *) NULL)
138 /* Set local fields. */
142 return (struct bfd_hash_entry *) ret;
145 /* Given a COFF BFD, add symbols to the global hash table as
149 _bfd_coff_link_add_symbols (abfd, info)
151 struct bfd_link_info *info;
153 switch (bfd_get_format (abfd))
156 return coff_link_add_object_symbols (abfd, info);
158 return (_bfd_generic_link_add_archive_symbols
159 (abfd, info, coff_link_check_archive_element));
161 bfd_set_error (bfd_error_wrong_format);
166 /* Add symbols from a COFF object file. */
169 coff_link_add_object_symbols (abfd, info)
171 struct bfd_link_info *info;
173 if (! _bfd_coff_get_external_symbols (abfd))
175 if (! coff_link_add_symbols (abfd, info))
178 if (! info->keep_memory)
180 if (! _bfd_coff_free_symbols (abfd))
186 /* Check a single archive element to see if we need to include it in
187 the link. *PNEEDED is set according to whether this element is
188 needed in the link or not. This is called via
189 _bfd_generic_link_add_archive_symbols. */
192 coff_link_check_archive_element (abfd, info, pneeded)
194 struct bfd_link_info *info;
197 if (! _bfd_coff_get_external_symbols (abfd))
200 if (! coff_link_check_ar_symbols (abfd, info, pneeded))
205 if (! coff_link_add_symbols (abfd, info))
209 if (! info->keep_memory || ! *pneeded)
211 if (! _bfd_coff_free_symbols (abfd))
218 /* Look through the symbols to see if this object file should be
219 included in the link. */
222 coff_link_check_ar_symbols (abfd, info, pneeded)
224 struct bfd_link_info *info;
227 boolean (*sym_is_global) PARAMS ((bfd *, struct internal_syment *));
228 bfd_size_type symesz;
234 sym_is_global = coff_backend_info (abfd)->_bfd_coff_sym_is_global;
236 symesz = bfd_coff_symesz (abfd);
237 esym = (bfd_byte *) obj_coff_external_syms (abfd);
238 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
239 while (esym < esym_end)
241 struct internal_syment sym;
243 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
245 if ((sym.n_sclass == C_EXT
246 || (sym_is_global && (*sym_is_global) (abfd, &sym)))
247 && (sym.n_scnum != 0 || sym.n_value != 0))
250 char buf[SYMNMLEN + 1];
251 struct bfd_link_hash_entry *h;
253 /* This symbol is externally visible, and is defined by this
256 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
259 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
261 /* We are only interested in symbols that are currently
262 undefined. If a symbol is currently known to be common,
263 COFF linkers do not bring in an object file which defines
265 if (h != (struct bfd_link_hash_entry *) NULL
266 && h->type == bfd_link_hash_undefined)
268 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
275 esym += (sym.n_numaux + 1) * symesz;
278 /* We do not need this object file. */
282 /* Add all the symbols from an object file to the hash table. */
285 coff_link_add_symbols (abfd, info)
287 struct bfd_link_info *info;
289 boolean (*sym_is_global) PARAMS ((bfd *, struct internal_syment *));
291 boolean default_copy;
292 bfd_size_type symcount;
293 struct coff_link_hash_entry **sym_hash;
294 bfd_size_type symesz;
298 /* Keep the symbols during this function, in case the linker needs
299 to read the generic symbols in order to report an error message. */
300 keep_syms = obj_coff_keep_syms (abfd);
301 obj_coff_keep_syms (abfd) = true;
303 sym_is_global = coff_backend_info (abfd)->_bfd_coff_sym_is_global;
305 if (info->keep_memory)
306 default_copy = false;
310 symcount = obj_raw_syment_count (abfd);
312 /* We keep a list of the linker hash table entries that correspond
313 to particular symbols. */
314 sym_hash = ((struct coff_link_hash_entry **)
317 * sizeof (struct coff_link_hash_entry *))));
318 if (sym_hash == NULL && symcount != 0)
320 obj_coff_sym_hashes (abfd) = sym_hash;
322 (size_t) symcount * sizeof (struct coff_link_hash_entry *));
324 symesz = bfd_coff_symesz (abfd);
325 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
326 esym = (bfd_byte *) obj_coff_external_syms (abfd);
327 esym_end = esym + symcount * symesz;
328 while (esym < esym_end)
330 struct internal_syment sym;
333 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
335 if (sym.n_sclass == C_EXT
336 || (sym_is_global && (*sym_is_global) (abfd, &sym)))
339 char buf[SYMNMLEN + 1];
344 /* This symbol is externally visible. */
346 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
350 /* We must copy the name into memory if we got it from the
351 syment itself, rather than the string table. */
353 if (sym._n._n_n._n_zeroes != 0
354 || sym._n._n_n._n_offset == 0)
359 if (sym.n_scnum == 0)
364 section = bfd_und_section_ptr;
369 section = bfd_com_section_ptr;
374 flags = BSF_EXPORT | BSF_GLOBAL;
375 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
376 value -= section->vma;
379 if (! (bfd_coff_link_add_one_symbol
380 (info, abfd, name, flags, section, value,
381 (const char *) NULL, copy, false,
382 (struct bfd_link_hash_entry **) sym_hash)))
385 if (section == bfd_com_section_ptr
386 && (*sym_hash)->root.type == bfd_link_hash_common
387 && ((*sym_hash)->root.u.c.p->alignment_power
388 > bfd_coff_default_section_alignment_power (abfd)))
389 (*sym_hash)->root.u.c.p->alignment_power
390 = bfd_coff_default_section_alignment_power (abfd);
392 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
394 if (((*sym_hash)->class == C_NULL
395 && (*sym_hash)->type == T_NULL)
398 && (*sym_hash)->root.type != bfd_link_hash_defined))
400 (*sym_hash)->class = sym.n_sclass;
401 if (sym.n_type != T_NULL)
403 if ((*sym_hash)->type != T_NULL
404 && (*sym_hash)->type != sym.n_type)
405 (*_bfd_error_handler)
406 ("Warning: type of symbol `%s' changed from %d to %d in %s",
407 name, (*sym_hash)->type, sym.n_type,
408 bfd_get_filename (abfd));
409 (*sym_hash)->type = sym.n_type;
411 (*sym_hash)->auxbfd = abfd;
412 if (sym.n_numaux != 0)
414 union internal_auxent *alloc;
417 union internal_auxent *iaux;
419 (*sym_hash)->numaux = sym.n_numaux;
420 alloc = ((union internal_auxent *)
421 bfd_hash_allocate (&info->hash->table,
423 * sizeof (*alloc))));
426 for (i = 0, eaux = esym + symesz, iaux = alloc;
428 i++, eaux += symesz, iaux++)
429 bfd_coff_swap_aux_in (abfd, (PTR) eaux, sym.n_type,
430 sym.n_sclass, i, sym.n_numaux,
432 (*sym_hash)->aux = alloc;
438 esym += (sym.n_numaux + 1) * symesz;
439 sym_hash += sym.n_numaux + 1;
442 /* If this is a non-traditional, non-relocateable link, try to
443 optimize the handling of any .stab/.stabstr sections. */
444 if (! info->relocateable
445 && ! info->traditional_format
446 && info->hash->creator->flavour == bfd_get_flavour (abfd)
447 && (info->strip != strip_all && info->strip != strip_debugger))
449 asection *stab, *stabstr;
451 stab = bfd_get_section_by_name (abfd, ".stab");
454 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
458 struct coff_link_hash_table *table;
459 struct coff_section_tdata *secdata;
461 secdata = coff_section_data (abfd, stab);
465 (PTR) bfd_zalloc (abfd,
466 sizeof (struct coff_section_tdata));
467 if (stab->used_by_bfd == NULL)
469 secdata = coff_section_data (abfd, stab);
472 table = coff_hash_table (info);
474 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
476 &secdata->stab_info))
482 obj_coff_keep_syms (abfd) = keep_syms;
487 obj_coff_keep_syms (abfd) = keep_syms;
491 /* Do the final link step. */
494 _bfd_coff_final_link (abfd, info)
496 struct bfd_link_info *info;
498 bfd_size_type symesz;
499 struct coff_final_link_info finfo;
500 boolean debug_merge_allocated;
501 boolean long_section_names;
503 struct bfd_link_order *p;
504 size_t max_sym_count;
505 size_t max_lineno_count;
506 size_t max_reloc_count;
507 size_t max_output_reloc_count;
508 size_t max_contents_size;
509 file_ptr rel_filepos;
511 file_ptr line_filepos;
514 bfd_byte *external_relocs = NULL;
515 char strbuf[STRING_SIZE_SIZE];
517 symesz = bfd_coff_symesz (abfd);
520 finfo.output_bfd = abfd;
522 finfo.section_info = NULL;
523 finfo.last_file_index = -1;
524 finfo.last_bf_index = -1;
525 finfo.internal_syms = NULL;
526 finfo.sec_ptrs = NULL;
527 finfo.sym_indices = NULL;
528 finfo.outsyms = NULL;
529 finfo.linenos = NULL;
530 finfo.contents = NULL;
531 finfo.external_relocs = NULL;
532 finfo.internal_relocs = NULL;
533 debug_merge_allocated = false;
535 coff_data (abfd)->link_info = info;
537 finfo.strtab = _bfd_stringtab_init ();
538 if (finfo.strtab == NULL)
541 if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
543 debug_merge_allocated = true;
545 /* Compute the file positions for all the sections. */
546 if (! abfd->output_has_begun)
548 if (! bfd_coff_compute_section_file_positions (abfd))
552 /* Count the line numbers and relocation entries required for the
553 output file. Set the file positions for the relocs. */
554 rel_filepos = obj_relocbase (abfd);
555 relsz = bfd_coff_relsz (abfd);
556 max_contents_size = 0;
557 max_lineno_count = 0;
560 long_section_names = false;
561 for (o = abfd->sections; o != NULL; o = o->next)
565 for (p = o->link_order_head; p != NULL; p = p->next)
567 if (p->type == bfd_indirect_link_order)
571 sec = p->u.indirect.section;
573 /* Mark all sections which are to be included in the
574 link. This will normally be every section. We need
575 to do this so that we can identify any sections which
576 the linker has decided to not include. */
577 sec->linker_mark = true;
579 if (info->strip == strip_none
580 || info->strip == strip_some)
581 o->lineno_count += sec->lineno_count;
583 if (info->relocateable)
584 o->reloc_count += sec->reloc_count;
586 if (sec->_raw_size > max_contents_size)
587 max_contents_size = sec->_raw_size;
588 if (sec->lineno_count > max_lineno_count)
589 max_lineno_count = sec->lineno_count;
590 if (sec->reloc_count > max_reloc_count)
591 max_reloc_count = sec->reloc_count;
593 else if (info->relocateable
594 && (p->type == bfd_section_reloc_link_order
595 || p->type == bfd_symbol_reloc_link_order))
598 if (o->reloc_count == 0)
602 o->flags |= SEC_RELOC;
603 o->rel_filepos = rel_filepos;
604 rel_filepos += o->reloc_count * relsz;
607 if (bfd_coff_long_section_names (abfd)
608 && strlen (o->name) > SCNNMLEN)
610 /* This section has a long name which must go in the string
611 table. This must correspond to the code in
612 coff_write_object_contents which puts the string index
613 into the s_name field of the section header. That is why
614 we pass hash as false. */
615 if (_bfd_stringtab_add (finfo.strtab, o->name, false, false)
616 == (bfd_size_type) -1)
618 long_section_names = true;
622 /* If doing a relocateable link, allocate space for the pointers we
624 if (info->relocateable)
628 /* We use section_count + 1, rather than section_count, because
629 the target_index fields are 1 based. */
631 ((struct coff_link_section_info *)
632 bfd_malloc ((abfd->section_count + 1)
633 * sizeof (struct coff_link_section_info)));
634 if (finfo.section_info == NULL)
636 for (i = 0; i <= abfd->section_count; i++)
638 finfo.section_info[i].relocs = NULL;
639 finfo.section_info[i].rel_hashes = NULL;
643 /* We now know the size of the relocs, so we can determine the file
644 positions of the line numbers. */
645 line_filepos = rel_filepos;
646 linesz = bfd_coff_linesz (abfd);
647 max_output_reloc_count = 0;
648 for (o = abfd->sections; o != NULL; o = o->next)
650 if (o->lineno_count == 0)
654 o->line_filepos = line_filepos;
655 line_filepos += o->lineno_count * linesz;
658 if (o->reloc_count != 0)
660 /* We don't know the indices of global symbols until we have
661 written out all the local symbols. For each section in
662 the output file, we keep an array of pointers to hash
663 table entries. Each entry in the array corresponds to a
664 reloc. When we find a reloc against a global symbol, we
665 set the corresponding entry in this array so that we can
666 fix up the symbol index after we have written out all the
669 Because of this problem, we also keep the relocs in
670 memory until the end of the link. This wastes memory,
671 but only when doing a relocateable link, which is not the
673 BFD_ASSERT (info->relocateable);
674 finfo.section_info[o->target_index].relocs =
675 ((struct internal_reloc *)
676 bfd_malloc (o->reloc_count * sizeof (struct internal_reloc)));
677 finfo.section_info[o->target_index].rel_hashes =
678 ((struct coff_link_hash_entry **)
679 bfd_malloc (o->reloc_count
680 * sizeof (struct coff_link_hash_entry *)));
681 if (finfo.section_info[o->target_index].relocs == NULL
682 || finfo.section_info[o->target_index].rel_hashes == NULL)
685 if (o->reloc_count > max_output_reloc_count)
686 max_output_reloc_count = o->reloc_count;
689 /* Reset the reloc and lineno counts, so that we can use them to
690 count the number of entries we have output so far. */
695 obj_sym_filepos (abfd) = line_filepos;
697 /* Figure out the largest number of symbols in an input BFD. Take
698 the opportunity to clear the output_has_begun fields of all the
701 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
705 sub->output_has_begun = false;
706 sz = obj_raw_syment_count (sub);
707 if (sz > max_sym_count)
711 /* Allocate some buffers used while linking. */
712 finfo.internal_syms = ((struct internal_syment *)
713 bfd_malloc (max_sym_count
714 * sizeof (struct internal_syment)));
715 finfo.sec_ptrs = (asection **) bfd_malloc (max_sym_count
716 * sizeof (asection *));
717 finfo.sym_indices = (long *) bfd_malloc (max_sym_count * sizeof (long));
718 finfo.outsyms = ((bfd_byte *)
719 bfd_malloc ((size_t) ((max_sym_count + 1) * symesz)));
720 finfo.linenos = (bfd_byte *) bfd_malloc (max_lineno_count
721 * bfd_coff_linesz (abfd));
722 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
723 finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
724 if (! info->relocateable)
725 finfo.internal_relocs = ((struct internal_reloc *)
726 bfd_malloc (max_reloc_count
727 * sizeof (struct internal_reloc)));
728 if ((finfo.internal_syms == NULL && max_sym_count > 0)
729 || (finfo.sec_ptrs == NULL && max_sym_count > 0)
730 || (finfo.sym_indices == NULL && max_sym_count > 0)
731 || finfo.outsyms == NULL
732 || (finfo.linenos == NULL && max_lineno_count > 0)
733 || (finfo.contents == NULL && max_contents_size > 0)
734 || (finfo.external_relocs == NULL && max_reloc_count > 0)
735 || (! info->relocateable
736 && finfo.internal_relocs == NULL
737 && max_reloc_count > 0))
740 /* We now know the position of everything in the file, except that
741 we don't know the size of the symbol table and therefore we don't
742 know where the string table starts. We just build the string
743 table in memory as we go along. We process all the relocations
744 for a single input file at once. */
745 obj_raw_syment_count (abfd) = 0;
747 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
749 if (! bfd_coff_start_final_link (abfd, info))
753 for (o = abfd->sections; o != NULL; o = o->next)
755 for (p = o->link_order_head; p != NULL; p = p->next)
757 if (p->type == bfd_indirect_link_order
758 && (bfd_get_flavour (p->u.indirect.section->owner)
759 == bfd_target_coff_flavour))
761 sub = p->u.indirect.section->owner;
762 if (! sub->output_has_begun)
764 if (! _bfd_coff_link_input_bfd (&finfo, sub))
766 sub->output_has_begun = true;
769 else if (p->type == bfd_section_reloc_link_order
770 || p->type == bfd_symbol_reloc_link_order)
772 if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
777 if (! _bfd_default_link_order (abfd, info, o, p))
783 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
785 coff_debug_merge_hash_table_free (&finfo.debug_merge);
786 debug_merge_allocated = false;
788 if (finfo.internal_syms != NULL)
790 free (finfo.internal_syms);
791 finfo.internal_syms = NULL;
793 if (finfo.sec_ptrs != NULL)
795 free (finfo.sec_ptrs);
796 finfo.sec_ptrs = NULL;
798 if (finfo.sym_indices != NULL)
800 free (finfo.sym_indices);
801 finfo.sym_indices = NULL;
803 if (finfo.linenos != NULL)
805 free (finfo.linenos);
806 finfo.linenos = NULL;
808 if (finfo.contents != NULL)
810 free (finfo.contents);
811 finfo.contents = NULL;
813 if (finfo.external_relocs != NULL)
815 free (finfo.external_relocs);
816 finfo.external_relocs = NULL;
818 if (finfo.internal_relocs != NULL)
820 free (finfo.internal_relocs);
821 finfo.internal_relocs = NULL;
824 /* The value of the last C_FILE symbol is supposed to be the symbol
825 index of the first external symbol. Write it out again if
827 if (finfo.last_file_index != -1
828 && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
830 finfo.last_file.n_value = obj_raw_syment_count (abfd);
831 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
832 (PTR) finfo.outsyms);
834 (obj_sym_filepos (abfd)
835 + finfo.last_file_index * symesz),
837 || bfd_write (finfo.outsyms, symesz, 1, abfd) != symesz)
841 /* If doing task linking (ld --task-link) then make a pass through the
842 global symbols, writing out any that are defined, and making them
846 finfo.failed = false;
847 coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_task_globals,
853 /* Write out the global symbols. */
854 finfo.failed = false;
855 coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_global_sym,
860 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
861 if (finfo.outsyms != NULL)
863 free (finfo.outsyms);
864 finfo.outsyms = NULL;
867 if (info->relocateable && max_output_reloc_count > 0)
869 /* Now that we have written out all the global symbols, we know
870 the symbol indices to use for relocs against them, and we can
871 finally write out the relocs. */
872 external_relocs = ((bfd_byte *)
873 bfd_malloc (max_output_reloc_count * relsz));
874 if (external_relocs == NULL)
877 for (o = abfd->sections; o != NULL; o = o->next)
879 struct internal_reloc *irel;
880 struct internal_reloc *irelend;
881 struct coff_link_hash_entry **rel_hash;
884 if (o->reloc_count == 0)
887 irel = finfo.section_info[o->target_index].relocs;
888 irelend = irel + o->reloc_count;
889 rel_hash = finfo.section_info[o->target_index].rel_hashes;
890 erel = external_relocs;
891 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
893 if (*rel_hash != NULL)
895 BFD_ASSERT ((*rel_hash)->indx >= 0);
896 irel->r_symndx = (*rel_hash)->indx;
898 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
901 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
902 || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
903 abfd) != relsz * o->reloc_count)
907 free (external_relocs);
908 external_relocs = NULL;
911 /* Free up the section information. */
912 if (finfo.section_info != NULL)
916 for (i = 0; i < abfd->section_count; i++)
918 if (finfo.section_info[i].relocs != NULL)
919 free (finfo.section_info[i].relocs);
920 if (finfo.section_info[i].rel_hashes != NULL)
921 free (finfo.section_info[i].rel_hashes);
923 free (finfo.section_info);
924 finfo.section_info = NULL;
927 /* If we have optimized stabs strings, output them. */
928 if (coff_hash_table (info)->stab_info != NULL)
930 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
934 /* Write out the string table. */
935 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
938 (obj_sym_filepos (abfd)
939 + obj_raw_syment_count (abfd) * symesz),
943 #if STRING_SIZE_SIZE == 4
945 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
946 (bfd_byte *) strbuf);
948 #error Change bfd_h_put_32
951 if (bfd_write (strbuf, 1, STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE)
954 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
958 _bfd_stringtab_free (finfo.strtab);
960 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
961 not try to write out the symbols. */
962 bfd_get_symcount (abfd) = 0;
967 if (debug_merge_allocated)
968 coff_debug_merge_hash_table_free (&finfo.debug_merge);
969 if (finfo.strtab != NULL)
970 _bfd_stringtab_free (finfo.strtab);
971 if (finfo.section_info != NULL)
975 for (i = 0; i < abfd->section_count; i++)
977 if (finfo.section_info[i].relocs != NULL)
978 free (finfo.section_info[i].relocs);
979 if (finfo.section_info[i].rel_hashes != NULL)
980 free (finfo.section_info[i].rel_hashes);
982 free (finfo.section_info);
984 if (finfo.internal_syms != NULL)
985 free (finfo.internal_syms);
986 if (finfo.sec_ptrs != NULL)
987 free (finfo.sec_ptrs);
988 if (finfo.sym_indices != NULL)
989 free (finfo.sym_indices);
990 if (finfo.outsyms != NULL)
991 free (finfo.outsyms);
992 if (finfo.linenos != NULL)
993 free (finfo.linenos);
994 if (finfo.contents != NULL)
995 free (finfo.contents);
996 if (finfo.external_relocs != NULL)
997 free (finfo.external_relocs);
998 if (finfo.internal_relocs != NULL)
999 free (finfo.internal_relocs);
1000 if (external_relocs != NULL)
1001 free (external_relocs);
1005 /* parse out a -heap <reserved>,<commit> line */
1008 dores_com (ptr, output_bfd, heap)
1013 if (coff_data(output_bfd)->pe)
1015 int val = strtoul (ptr, &ptr, 0);
1017 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve =val;
1019 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve =val;
1023 int val = strtoul (ptr+1, &ptr, 0);
1025 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit =val;
1027 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit =val;
1033 static char *get_name(ptr, dst)
1040 while (*ptr && *ptr != ' ')
1046 /* Process any magic embedded commands in a section called .drectve */
1049 process_embedded_commands (output_bfd, info, abfd)
1051 struct bfd_link_info *info;
1054 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1061 copy = bfd_malloc ((size_t) sec->_raw_size);
1064 if (! bfd_get_section_contents(abfd, sec, copy, 0, sec->_raw_size))
1069 e = copy + sec->_raw_size;
1070 for (s = copy; s < e ; )
1076 if (strncmp (s,"-attr", 5) == 0)
1088 s = get_name(s, &name);
1089 s = get_name(s, &attribs);
1109 asec = bfd_get_section_by_name (abfd, name);
1112 asec->flags |= SEC_CODE;
1114 asec->flags |= SEC_READONLY;
1117 else if (strncmp (s,"-heap", 5) == 0)
1119 s = dores_com (s+5, output_bfd, 1);
1121 else if (strncmp (s,"-stack", 6) == 0)
1123 s = dores_com (s+6, output_bfd, 0);
1132 /* Place a marker against all symbols which are used by relocations.
1133 This marker can be picked up by the 'do we skip this symbol ?'
1134 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1139 mark_relocs (finfo, input_bfd)
1140 struct coff_final_link_info * finfo;
1145 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1148 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1150 struct internal_reloc * internal_relocs;
1151 struct internal_reloc * irel;
1152 struct internal_reloc * irelend;
1155 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1)
1158 /* Read in the relocs. */
1159 internal_relocs = _bfd_coff_read_internal_relocs
1160 (input_bfd, a, false,
1161 finfo->external_relocs,
1162 finfo->info->relocateable,
1163 (finfo->info->relocateable
1164 ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1165 : finfo->internal_relocs)
1168 if (internal_relocs == NULL)
1171 irel = internal_relocs;
1172 irelend = irel + a->reloc_count;
1174 /* Place a mark in the sym_indices array (whose entries have
1175 been initialised to 0) for all of the symbols that are used
1176 in the relocation table. This will then be picked up in the
1179 for (; irel < irelend; irel++)
1181 finfo->sym_indices[ irel->r_symndx ] = -1;
1186 /* Link an input file into the linker output file. This function
1187 handles all the sections and relocations of the input file at once. */
1190 _bfd_coff_link_input_bfd (finfo, input_bfd)
1191 struct coff_final_link_info *finfo;
1194 boolean (*sym_is_global) PARAMS ((bfd *, struct internal_syment *));
1195 boolean (*adjust_symndx) PARAMS ((bfd *, struct bfd_link_info *, bfd *,
1196 asection *, struct internal_reloc *,
1199 const char *strings;
1200 bfd_size_type syment_base;
1201 unsigned int n_tmask;
1202 unsigned int n_btshft;
1204 bfd_size_type isymesz;
1205 bfd_size_type osymesz;
1206 bfd_size_type linesz;
1209 struct internal_syment *isymp;
1212 unsigned long output_index;
1214 struct coff_link_hash_entry **sym_hash;
1217 /* Move all the symbols to the output file. */
1219 output_bfd = finfo->output_bfd;
1220 sym_is_global = coff_backend_info (input_bfd)->_bfd_coff_sym_is_global;
1222 syment_base = obj_raw_syment_count (output_bfd);
1223 isymesz = bfd_coff_symesz (input_bfd);
1224 osymesz = bfd_coff_symesz (output_bfd);
1225 linesz = bfd_coff_linesz (input_bfd);
1226 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1228 n_tmask = coff_data (input_bfd)->local_n_tmask;
1229 n_btshft = coff_data (input_bfd)->local_n_btshft;
1231 /* Define macros so that ISFCN, et. al., macros work correctly. */
1232 #define N_TMASK n_tmask
1233 #define N_BTSHFT n_btshft
1236 if (! finfo->info->keep_memory)
1239 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1242 if (! _bfd_coff_get_external_symbols (input_bfd))
1245 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1246 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1247 isymp = finfo->internal_syms;
1248 secpp = finfo->sec_ptrs;
1249 indexp = finfo->sym_indices;
1250 output_index = syment_base;
1251 outsym = finfo->outsyms;
1253 if (coff_data (output_bfd)->pe)
1255 if (! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1259 /* If we are going to perform relocations and also strip/discard some symbols
1260 then we must make sure that we do not strip/discard those symbols that are
1261 going to be involved in the relocations */
1262 if (( finfo->info->strip != strip_none
1263 || finfo->info->discard != discard_none)
1264 && finfo->info->relocateable)
1266 /* mark the symbol array as 'not-used' */
1267 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1269 mark_relocs (finfo, input_bfd);
1272 while (esym < esym_end)
1274 struct internal_syment isym;
1277 boolean dont_skip_symbol;
1280 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
1282 /* Make a copy of *isymp so that the relocate_section function
1283 always sees the original values. This is more reliable than
1284 always recomputing the symbol value even if we are stripping
1288 if (isym.n_scnum != 0)
1289 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1292 if (isym.n_value == 0)
1293 *secpp = bfd_und_section_ptr;
1295 *secpp = bfd_com_section_ptr;
1298 /* Extract the flag indicating if this symbol is used by a relocation */
1299 if (( finfo->info->strip != strip_none
1300 || finfo->info->discard != discard_none)
1301 && finfo->info->relocateable)
1302 dont_skip_symbol = *indexp;
1304 dont_skip_symbol = false;
1310 add = 1 + isym.n_numaux;
1312 /* If we are stripping all symbols, we want to skip this one. */
1313 if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1318 if (isym.n_sclass == C_EXT
1319 || (sym_is_global && (*sym_is_global) (input_bfd, &isym)))
1321 /* This is a global symbol. Global symbols come at the
1322 end of the symbol table, so skip them for now.
1323 Function symbols, however, are an exception, and are
1324 not moved to the end. */
1326 if (! ISFCN (isym.n_type))
1331 /* This is a local symbol. Skip it if we are discarding
1333 if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1338 /* If we stripping debugging symbols, and this is a debugging
1339 symbol, then skip it. */
1341 && finfo->info->strip == strip_debugger
1342 && ! dont_skip_symbol
1343 && isym.n_scnum == N_DEBUG)
1346 /* If some symbols are stripped based on the name, work out the
1347 name and decide whether to skip this symbol. */
1349 && (finfo->info->strip == strip_some
1350 || finfo->info->discard == discard_l))
1353 char buf[SYMNMLEN + 1];
1355 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1359 if (! dont_skip_symbol
1360 && ((finfo->info->strip == strip_some
1361 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
1364 && finfo->info->discard == discard_l
1365 && bfd_is_local_label_name (input_bfd, name))))
1369 /* If this is an enum, struct, or union tag, see if we have
1370 already output an identical type. */
1372 && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1373 && (isym.n_sclass == C_ENTAG
1374 || isym.n_sclass == C_STRTAG
1375 || isym.n_sclass == C_UNTAG)
1376 && isym.n_numaux == 1)
1379 char buf[SYMNMLEN + 1];
1380 struct coff_debug_merge_hash_entry *mh;
1381 struct coff_debug_merge_type *mt;
1382 union internal_auxent aux;
1383 struct coff_debug_merge_element **epp;
1384 bfd_byte *esl, *eslend;
1385 struct internal_syment *islp;
1387 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1391 /* Ignore fake names invented by compiler; treat them all as
1393 if (*name == '~' || *name == '.' || *name == '$'
1394 || (*name == bfd_get_symbol_leading_char (input_bfd)
1395 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1398 mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1403 /* Allocate memory to hold type information. If this turns
1404 out to be a duplicate, we pass this address to
1406 mt = ((struct coff_debug_merge_type *)
1407 bfd_alloc (input_bfd,
1408 sizeof (struct coff_debug_merge_type)));
1411 mt->class = isym.n_sclass;
1413 /* Pick up the aux entry, which points to the end of the tag
1415 bfd_coff_swap_aux_in (input_bfd, (PTR) (esym + isymesz),
1416 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1419 /* Gather the elements. */
1420 epp = &mt->elements;
1421 mt->elements = NULL;
1423 esl = esym + 2 * isymesz;
1424 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1425 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1426 while (esl < eslend)
1428 const char *elename;
1429 char elebuf[SYMNMLEN + 1];
1432 bfd_coff_swap_sym_in (input_bfd, (PTR) esl, (PTR) islp);
1434 *epp = ((struct coff_debug_merge_element *)
1435 bfd_alloc (input_bfd,
1436 sizeof (struct coff_debug_merge_element)));
1440 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1442 if (elename == NULL)
1445 copy = (char *) bfd_alloc (input_bfd, strlen (elename) + 1);
1448 strcpy (copy, elename);
1450 (*epp)->name = copy;
1451 (*epp)->type = islp->n_type;
1453 if (islp->n_numaux >= 1
1454 && islp->n_type != T_NULL
1455 && islp->n_sclass != C_EOS)
1457 union internal_auxent eleaux;
1460 bfd_coff_swap_aux_in (input_bfd, (PTR) (esl + isymesz),
1461 islp->n_type, islp->n_sclass, 0,
1462 islp->n_numaux, (PTR) &eleaux);
1463 indx = eleaux.x_sym.x_tagndx.l;
1465 /* FIXME: If this tagndx entry refers to a symbol
1466 defined later in this file, we just ignore it.
1467 Handling this correctly would be tedious, and may
1473 (bfd_byte *) obj_coff_external_syms (input_bfd))
1476 (*epp)->tagndx = finfo->sym_indices[indx];
1477 if ((*epp)->tagndx < 0)
1481 epp = &(*epp)->next;
1484 esl += (islp->n_numaux + 1) * isymesz;
1485 islp += islp->n_numaux + 1;
1488 /* See if we already have a definition which matches this
1489 type. We always output the type if it has no elements,
1491 if (mt->elements == NULL)
1492 bfd_release (input_bfd, (PTR) mt);
1495 struct coff_debug_merge_type *mtl;
1497 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1499 struct coff_debug_merge_element *me, *mel;
1501 if (mtl->class != mt->class)
1504 for (me = mt->elements, mel = mtl->elements;
1505 me != NULL && mel != NULL;
1506 me = me->next, mel = mel->next)
1508 if (strcmp (me->name, mel->name) != 0
1509 || me->type != mel->type
1510 || me->tagndx != mel->tagndx)
1514 if (me == NULL && mel == NULL)
1518 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1520 /* This is the first definition of this type. */
1521 mt->indx = output_index;
1522 mt->next = mh->types;
1527 /* This is a redefinition which can be merged. */
1528 bfd_release (input_bfd, (PTR) mt);
1529 *indexp = mtl->indx;
1530 add = (eslend - esym) / isymesz;
1536 /* We now know whether we are to skip this symbol or not. */
1539 /* Adjust the symbol in order to output it. */
1541 if (isym._n._n_n._n_zeroes == 0
1542 && isym._n._n_n._n_offset != 0)
1547 /* This symbol has a long name. Enter it in the string
1548 table we are building. Note that we do not check
1549 bfd_coff_symname_in_debug. That is only true for
1550 XCOFF, and XCOFF requires different linking code
1552 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
1556 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1557 if (indx == (bfd_size_type) -1)
1559 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1562 if (isym.n_scnum > 0)
1564 isym.n_scnum = (*secpp)->output_section->target_index;
1565 isym.n_value += (*secpp)->output_offset;
1566 if (! obj_pe (finfo->output_bfd))
1567 isym.n_value += ((*secpp)->output_section->vma
1571 /* The value of a C_FILE symbol is the symbol index of the
1572 next C_FILE symbol. The value of the last C_FILE symbol
1573 is the symbol index to the first external symbol
1574 (actually, coff_renumber_symbols does not get this
1575 right--it just sets the value of the last C_FILE symbol
1576 to zero--and nobody has ever complained about it). We
1577 try to get this right, below, just before we write the
1578 symbols out, but in the general case we may have to write
1579 the symbol out twice. */
1580 if (isym.n_sclass == C_FILE)
1582 if (finfo->last_file_index != -1
1583 && finfo->last_file.n_value != (long) output_index)
1585 /* We must correct the value of the last C_FILE entry. */
1586 finfo->last_file.n_value = output_index;
1587 if ((bfd_size_type) finfo->last_file_index >= syment_base)
1589 /* The last C_FILE symbol is in this input file. */
1590 bfd_coff_swap_sym_out (output_bfd,
1591 (PTR) &finfo->last_file,
1592 (PTR) (finfo->outsyms
1593 + ((finfo->last_file_index
1599 /* We have already written out the last C_FILE
1600 symbol. We need to write it out again. We
1601 borrow *outsym temporarily. */
1602 bfd_coff_swap_sym_out (output_bfd,
1603 (PTR) &finfo->last_file,
1605 if (bfd_seek (output_bfd,
1606 (obj_sym_filepos (output_bfd)
1607 + finfo->last_file_index * osymesz),
1609 || (bfd_write (outsym, osymesz, 1, output_bfd)
1615 finfo->last_file_index = output_index;
1616 finfo->last_file = isym;
1619 /* If doing task linking, convert normal global function symbols to
1620 static functions. */
1622 if (finfo->info->task_link && isym.n_sclass == C_EXT)
1623 isym.n_sclass = C_STAT;
1625 /* Output the symbol. */
1627 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
1629 *indexp = output_index;
1634 struct coff_link_hash_entry *h;
1636 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1638 h = obj_coff_sym_hashes (input_bfd)[indx];
1641 /* This can happen if there were errors earlier in
1643 bfd_set_error (bfd_error_bad_value);
1646 h->indx = output_index;
1649 output_index += add;
1650 outsym += add * osymesz;
1653 esym += add * isymesz;
1657 for (--add; add > 0; --add)
1664 /* Fix up the aux entries. This must be done in a separate pass,
1665 because we don't know the correct symbol indices until we have
1666 already decided which symbols we are going to keep. */
1668 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1669 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1670 isymp = finfo->internal_syms;
1671 indexp = finfo->sym_indices;
1672 sym_hash = obj_coff_sym_hashes (input_bfd);
1673 outsym = finfo->outsyms;
1674 while (esym < esym_end)
1678 add = 1 + isymp->n_numaux;
1681 || (bfd_size_type) *indexp < syment_base)
1682 && (*sym_hash == NULL
1683 || (*sym_hash)->auxbfd != input_bfd))
1684 esym += add * isymesz;
1687 struct coff_link_hash_entry *h;
1695 /* The m68k-motorola-sysv assembler will sometimes
1696 generate two symbols with the same name, but only one
1697 will have aux entries. */
1698 BFD_ASSERT (isymp->n_numaux == 0
1699 || h->numaux == isymp->n_numaux);
1707 /* Handle the aux entries. This handling is based on
1708 coff_pointerize_aux. I don't know if it always correct. */
1709 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1711 union internal_auxent aux;
1712 union internal_auxent *auxp;
1718 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
1719 isymp->n_sclass, i, isymp->n_numaux,
1724 if (isymp->n_sclass == C_FILE)
1726 /* If this is a long filename, we must put it in the
1728 if (auxp->x_file.x_n.x_zeroes == 0
1729 && auxp->x_file.x_n.x_offset != 0)
1731 const char *filename;
1734 BFD_ASSERT (auxp->x_file.x_n.x_offset
1735 >= STRING_SIZE_SIZE);
1736 if (strings == NULL)
1738 strings = _bfd_coff_read_string_table (input_bfd);
1739 if (strings == NULL)
1742 filename = strings + auxp->x_file.x_n.x_offset;
1743 indx = _bfd_stringtab_add (finfo->strtab, filename,
1745 if (indx == (bfd_size_type) -1)
1747 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
1750 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
1754 if (ISFCN (isymp->n_type)
1755 || ISTAG (isymp->n_sclass)
1756 || isymp->n_sclass == C_BLOCK
1757 || isymp->n_sclass == C_FCN)
1759 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
1761 && indx < obj_raw_syment_count (input_bfd))
1763 /* We look forward through the symbol for
1764 the index of the next symbol we are going
1765 to include. I don't know if this is
1767 while ((finfo->sym_indices[indx] < 0
1768 || ((bfd_size_type) finfo->sym_indices[indx]
1770 && indx < obj_raw_syment_count (input_bfd))
1772 if (indx >= obj_raw_syment_count (input_bfd))
1773 indx = output_index;
1775 indx = finfo->sym_indices[indx];
1776 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
1780 indx = auxp->x_sym.x_tagndx.l;
1781 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
1785 symindx = finfo->sym_indices[indx];
1787 auxp->x_sym.x_tagndx.l = 0;
1789 auxp->x_sym.x_tagndx.l = symindx;
1792 /* The .bf symbols are supposed to be linked through
1793 the endndx field. We need to carry this list
1794 across object files. */
1797 && isymp->n_sclass == C_FCN
1798 && (isymp->_n._n_n._n_zeroes != 0
1799 || isymp->_n._n_n._n_offset == 0)
1800 && isymp->_n._n_name[0] == '.'
1801 && isymp->_n._n_name[1] == 'b'
1802 && isymp->_n._n_name[2] == 'f'
1803 && isymp->_n._n_name[3] == '\0')
1805 if (finfo->last_bf_index != -1)
1807 finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
1810 if ((bfd_size_type) finfo->last_bf_index
1815 /* The last .bf symbol is in this input
1816 file. This will only happen if the
1817 assembler did not set up the .bf
1818 endndx symbols correctly. */
1819 auxout = (PTR) (finfo->outsyms
1820 + ((finfo->last_bf_index
1823 bfd_coff_swap_aux_out (output_bfd,
1824 (PTR) &finfo->last_bf,
1832 /* We have already written out the last
1833 .bf aux entry. We need to write it
1834 out again. We borrow *outsym
1835 temporarily. FIXME: This case should
1837 bfd_coff_swap_aux_out (output_bfd,
1838 (PTR) &finfo->last_bf,
1843 if (bfd_seek (output_bfd,
1844 (obj_sym_filepos (output_bfd)
1845 + finfo->last_bf_index * osymesz),
1847 || bfd_write (outsym, osymesz, 1,
1848 output_bfd) != osymesz)
1853 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
1854 finfo->last_bf_index = -1;
1857 /* The endndx field of this aux entry must
1858 be updated with the symbol number of the
1860 finfo->last_bf = *auxp;
1861 finfo->last_bf_index = (((outsym - finfo->outsyms)
1870 bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isymp->n_type,
1871 isymp->n_sclass, i, isymp->n_numaux,
1885 /* Relocate the line numbers, unless we are stripping them. */
1886 if (finfo->info->strip == strip_none
1887 || finfo->info->strip == strip_some)
1889 for (o = input_bfd->sections; o != NULL; o = o->next)
1895 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
1896 build_link_order in ldwrite.c will not have created a
1897 link order, which means that we will not have seen this
1898 input section in _bfd_coff_final_link, which means that
1899 we will not have allocated space for the line numbers of
1900 this section. I don't think line numbers can be
1901 meaningful for a section which does not have
1902 SEC_HAS_CONTENTS set, but, if they do, this must be
1904 if (o->lineno_count == 0
1905 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
1908 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
1909 || bfd_read (finfo->linenos, linesz, o->lineno_count,
1910 input_bfd) != linesz * o->lineno_count)
1913 offset = o->output_section->vma + o->output_offset - o->vma;
1914 eline = finfo->linenos;
1915 elineend = eline + linesz * o->lineno_count;
1916 for (; eline < elineend; eline += linesz)
1918 struct internal_lineno iline;
1920 bfd_coff_swap_lineno_in (input_bfd, (PTR) eline, (PTR) &iline);
1922 if (iline.l_lnno != 0)
1923 iline.l_addr.l_paddr += offset;
1924 else if (iline.l_addr.l_symndx >= 0
1925 && ((unsigned long) iline.l_addr.l_symndx
1926 < obj_raw_syment_count (input_bfd)))
1930 indx = finfo->sym_indices[iline.l_addr.l_symndx];
1934 /* These line numbers are attached to a symbol
1935 which we are stripping. We should really
1936 just discard the line numbers, but that would
1937 be a pain because we have already counted
1943 struct internal_syment is;
1944 union internal_auxent ia;
1946 /* Fix up the lnnoptr field in the aux entry of
1947 the symbol. It turns out that we can't do
1948 this when we modify the symbol aux entries,
1949 because gas sometimes screws up the lnnoptr
1950 field and makes it an offset from the start
1951 of the line numbers rather than an absolute
1953 bfd_coff_swap_sym_in (output_bfd,
1954 (PTR) (finfo->outsyms
1955 + ((indx - syment_base)
1958 if ((ISFCN (is.n_type)
1959 || is.n_sclass == C_BLOCK)
1960 && is.n_numaux >= 1)
1964 auxptr = (PTR) (finfo->outsyms
1965 + ((indx - syment_base + 1)
1967 bfd_coff_swap_aux_in (output_bfd, auxptr,
1968 is.n_type, is.n_sclass,
1969 0, is.n_numaux, (PTR) &ia);
1970 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
1971 (o->output_section->line_filepos
1972 + o->output_section->lineno_count * linesz
1973 + eline - finfo->linenos);
1974 bfd_coff_swap_aux_out (output_bfd, (PTR) &ia,
1975 is.n_type, is.n_sclass, 0,
1976 is.n_numaux, auxptr);
1980 iline.l_addr.l_symndx = indx;
1983 bfd_coff_swap_lineno_out (output_bfd, (PTR) &iline, (PTR) eline);
1986 if (bfd_seek (output_bfd,
1987 (o->output_section->line_filepos
1988 + o->output_section->lineno_count * linesz),
1990 || bfd_write (finfo->linenos, linesz, o->lineno_count,
1991 output_bfd) != linesz * o->lineno_count)
1994 o->output_section->lineno_count += o->lineno_count;
1998 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
1999 symbol will be the first symbol in the next input file. In the
2000 normal case, this will save us from writing out the C_FILE symbol
2002 if (finfo->last_file_index != -1
2003 && (bfd_size_type) finfo->last_file_index >= syment_base)
2005 finfo->last_file.n_value = output_index;
2006 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
2007 (PTR) (finfo->outsyms
2008 + ((finfo->last_file_index - syment_base)
2012 /* Write the modified symbols to the output file. */
2013 if (outsym > finfo->outsyms)
2015 if (bfd_seek (output_bfd,
2016 obj_sym_filepos (output_bfd) + syment_base * osymesz,
2018 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
2020 != (bfd_size_type) (outsym - finfo->outsyms)))
2023 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2024 + (outsym - finfo->outsyms) / osymesz)
2027 obj_raw_syment_count (output_bfd) = output_index;
2030 /* Relocate the contents of each section. */
2031 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2032 for (o = input_bfd->sections; o != NULL; o = o->next)
2035 struct coff_section_tdata *secdata;
2037 if (! o->linker_mark)
2039 /* This section was omitted from the link. */
2043 if ((o->flags & SEC_HAS_CONTENTS) == 0
2044 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
2046 if ((o->flags & SEC_RELOC) != 0
2047 && o->reloc_count != 0)
2049 ((*_bfd_error_handler)
2050 ("%s: relocs in section `%s', but it has no contents",
2051 bfd_get_filename (input_bfd),
2052 bfd_get_section_name (input_bfd, o)));
2053 bfd_set_error (bfd_error_no_contents);
2060 secdata = coff_section_data (input_bfd, o);
2061 if (secdata != NULL && secdata->contents != NULL)
2062 contents = secdata->contents;
2065 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2066 (file_ptr) 0, o->_raw_size))
2068 contents = finfo->contents;
2071 if ((o->flags & SEC_RELOC) != 0)
2074 struct internal_reloc *internal_relocs;
2075 struct internal_reloc *irel;
2077 /* Read in the relocs. */
2078 target_index = o->output_section->target_index;
2079 internal_relocs = (_bfd_coff_read_internal_relocs
2080 (input_bfd, o, false, finfo->external_relocs,
2081 finfo->info->relocateable,
2082 (finfo->info->relocateable
2083 ? (finfo->section_info[target_index].relocs
2084 + o->output_section->reloc_count)
2085 : finfo->internal_relocs)));
2086 if (internal_relocs == NULL)
2089 /* Call processor specific code to relocate the section
2091 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2095 finfo->internal_syms,
2099 if (finfo->info->relocateable)
2102 struct internal_reloc *irelend;
2103 struct coff_link_hash_entry **rel_hash;
2105 offset = o->output_section->vma + o->output_offset - o->vma;
2106 irel = internal_relocs;
2107 irelend = irel + o->reloc_count;
2108 rel_hash = (finfo->section_info[target_index].rel_hashes
2109 + o->output_section->reloc_count);
2110 for (; irel < irelend; irel++, rel_hash++)
2112 struct coff_link_hash_entry *h;
2117 /* Adjust the reloc address and symbol index. */
2119 irel->r_vaddr += offset;
2121 if (irel->r_symndx == -1)
2126 if (! (*adjust_symndx) (output_bfd, finfo->info,
2134 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2137 /* This is a global symbol. */
2139 irel->r_symndx = h->indx;
2142 /* This symbol is being written at the end
2143 of the file, and we do not yet know the
2144 symbol index. We save the pointer to the
2145 hash table entry in the rel_hash list.
2146 We set the indx field to -2 to indicate
2147 that this symbol must not be stripped. */
2156 indx = finfo->sym_indices[irel->r_symndx];
2158 irel->r_symndx = indx;
2161 struct internal_syment *is;
2163 char buf[SYMNMLEN + 1];
2165 /* This reloc is against a symbol we are
2166 stripping. This should have been handled
2167 by the 'dont_skip_symbol' code in the while
2168 loop at the top of this function. */
2170 is = finfo->internal_syms + irel->r_symndx;
2172 name = (_bfd_coff_internal_syment_name
2173 (input_bfd, is, buf));
2177 if (! ((*finfo->info->callbacks->unattached_reloc)
2178 (finfo->info, name, input_bfd, o,
2185 o->output_section->reloc_count += o->reloc_count;
2189 /* Write out the modified section contents. */
2190 if (secdata == NULL || secdata->stab_info == NULL)
2192 if (! bfd_set_section_contents (output_bfd, o->output_section,
2193 contents, o->output_offset,
2194 (o->_cooked_size != 0
2201 if (! (_bfd_write_section_stabs
2202 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2203 o, &secdata->stab_info, contents)))
2208 if (! finfo->info->keep_memory)
2210 if (! _bfd_coff_free_symbols (input_bfd))
2217 /* Write out a global symbol. Called via coff_link_hash_traverse. */
2220 _bfd_coff_write_global_sym (h, data)
2221 struct coff_link_hash_entry *h;
2224 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2226 struct internal_syment isym;
2227 bfd_size_type symesz;
2230 output_bfd = finfo->output_bfd;
2236 && (finfo->info->strip == strip_all
2237 || (finfo->info->strip == strip_some
2238 && (bfd_hash_lookup (finfo->info->keep_hash,
2239 h->root.root.string, false, false)
2243 switch (h->root.type)
2246 case bfd_link_hash_new:
2250 case bfd_link_hash_undefined:
2251 case bfd_link_hash_undefweak:
2252 isym.n_scnum = N_UNDEF;
2256 case bfd_link_hash_defined:
2257 case bfd_link_hash_defweak:
2261 sec = h->root.u.def.section->output_section;
2262 if (bfd_is_abs_section (sec))
2263 isym.n_scnum = N_ABS;
2265 isym.n_scnum = sec->target_index;
2266 isym.n_value = (h->root.u.def.value
2267 + h->root.u.def.section->output_offset);
2268 if (! obj_pe (finfo->output_bfd))
2269 isym.n_value += sec->vma;
2273 case bfd_link_hash_common:
2274 isym.n_scnum = N_UNDEF;
2275 isym.n_value = h->root.u.c.size;
2278 case bfd_link_hash_indirect:
2279 case bfd_link_hash_warning:
2280 /* Just ignore these. They can't be handled anyhow. */
2284 if (strlen (h->root.root.string) <= SYMNMLEN)
2285 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2292 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2294 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2296 if (indx == (bfd_size_type) -1)
2298 finfo->failed = true;
2301 isym._n._n_n._n_zeroes = 0;
2302 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2305 isym.n_sclass = h->class;
2306 isym.n_type = h->type;
2308 if (isym.n_sclass == C_NULL)
2309 isym.n_sclass = C_EXT;
2311 /* If doing task linking and this is the pass where we convert defined globals to
2312 statics, then do that conversion now. If the symbol is not being converted,
2313 just ignore it and it will be output during a later pass. */
2314 if (finfo->global_to_static)
2316 if (isym.n_sclass != C_EXT)
2320 isym.n_sclass = C_STAT;
2323 isym.n_numaux = h->numaux;
2325 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) finfo->outsyms);
2327 symesz = bfd_coff_symesz (output_bfd);
2329 if (bfd_seek (output_bfd,
2330 (obj_sym_filepos (output_bfd)
2331 + obj_raw_syment_count (output_bfd) * symesz),
2333 || bfd_write (finfo->outsyms, symesz, 1, output_bfd) != symesz)
2335 finfo->failed = true;
2339 h->indx = obj_raw_syment_count (output_bfd);
2341 ++obj_raw_syment_count (output_bfd);
2343 /* Write out any associated aux entries. There normally will be
2344 none. If there are any, I have no idea how to modify them. */
2345 for (i = 0; i < isym.n_numaux; i++)
2347 bfd_coff_swap_aux_out (output_bfd, (PTR) (h->aux + i), isym.n_type,
2348 isym.n_sclass, i, isym.n_numaux,
2349 (PTR) finfo->outsyms);
2350 if (bfd_write (finfo->outsyms, symesz, 1, output_bfd) != symesz)
2352 finfo->failed = true;
2355 ++obj_raw_syment_count (output_bfd);
2361 /* Write out task global symbols, converting them to statics. Called
2362 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2363 the dirty work, if the symbol we are processing needs conversion. */
2366 _bfd_coff_write_task_globals (h, data)
2367 struct coff_link_hash_entry *h;
2370 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2371 boolean rtnval = true;
2375 switch (h->root.type)
2377 case bfd_link_hash_defined:
2378 case bfd_link_hash_defweak:
2379 finfo->global_to_static = true;
2380 rtnval = _bfd_coff_write_global_sym (h, data);
2381 finfo->global_to_static = false;
2388 /* Handle a link order which is supposed to generate a reloc. */
2391 _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order)
2393 struct coff_final_link_info *finfo;
2394 asection *output_section;
2395 struct bfd_link_order *link_order;
2397 reloc_howto_type *howto;
2398 struct internal_reloc *irel;
2399 struct coff_link_hash_entry **rel_hash_ptr;
2401 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2404 bfd_set_error (bfd_error_bad_value);
2408 if (link_order->u.reloc.p->addend != 0)
2412 bfd_reloc_status_type rstat;
2415 size = bfd_get_reloc_size (howto);
2416 buf = (bfd_byte *) bfd_zmalloc (size);
2420 rstat = _bfd_relocate_contents (howto, output_bfd,
2421 link_order->u.reloc.p->addend, buf);
2427 case bfd_reloc_outofrange:
2429 case bfd_reloc_overflow:
2430 if (! ((*finfo->info->callbacks->reloc_overflow)
2432 (link_order->type == bfd_section_reloc_link_order
2433 ? bfd_section_name (output_bfd,
2434 link_order->u.reloc.p->u.section)
2435 : link_order->u.reloc.p->u.name),
2436 howto->name, link_order->u.reloc.p->addend,
2437 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2444 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
2445 (file_ptr) link_order->offset, size);
2451 /* Store the reloc information in the right place. It will get
2452 swapped and written out at the end of the final_link routine. */
2454 irel = (finfo->section_info[output_section->target_index].relocs
2455 + output_section->reloc_count);
2456 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2457 + output_section->reloc_count);
2459 memset (irel, 0, sizeof (struct internal_reloc));
2460 *rel_hash_ptr = NULL;
2462 irel->r_vaddr = output_section->vma + link_order->offset;
2464 if (link_order->type == bfd_section_reloc_link_order)
2466 /* We need to somehow locate a symbol in the right section. The
2467 symbol must either have a value of zero, or we must adjust
2468 the addend by the value of the symbol. FIXME: Write this
2469 when we need it. The old linker couldn't handle this anyhow. */
2471 *rel_hash_ptr = NULL;
2476 struct coff_link_hash_entry *h;
2478 h = ((struct coff_link_hash_entry *)
2479 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2480 link_order->u.reloc.p->u.name,
2481 false, false, true));
2485 irel->r_symndx = h->indx;
2488 /* Set the index to -2 to force this symbol to get
2497 if (! ((*finfo->info->callbacks->unattached_reloc)
2498 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2499 (asection *) NULL, (bfd_vma) 0)))
2505 /* FIXME: Is this always right? */
2506 irel->r_type = howto->type;
2508 /* r_size is only used on the RS/6000, which needs its own linker
2509 routines anyhow. r_extern is only used for ECOFF. */
2511 /* FIXME: What is the right value for r_offset? Is zero OK? */
2513 ++output_section->reloc_count;
2518 /* A basic reloc handling routine which may be used by processors with
2522 _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
2523 input_section, contents, relocs, syms,
2526 struct bfd_link_info *info;
2528 asection *input_section;
2530 struct internal_reloc *relocs;
2531 struct internal_syment *syms;
2532 asection **sections;
2534 struct internal_reloc *rel;
2535 struct internal_reloc *relend;
2538 relend = rel + input_section->reloc_count;
2539 for (; rel < relend; rel++)
2542 struct coff_link_hash_entry *h;
2543 struct internal_syment *sym;
2546 reloc_howto_type *howto;
2547 bfd_reloc_status_type rstat;
2549 symndx = rel->r_symndx;
2558 h = obj_coff_sym_hashes (input_bfd)[symndx];
2559 sym = syms + symndx;
2562 /* COFF treats common symbols in one of two ways. Either the
2563 size of the symbol is included in the section contents, or it
2564 is not. We assume that the size is not included, and force
2565 the rtype_to_howto function to adjust the addend as needed. */
2567 if (sym != NULL && sym->n_scnum != 0)
2568 addend = - sym->n_value;
2573 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2578 /* If we are doing a relocateable link, then we can just ignore
2579 a PC relative reloc that is pcrel_offset. It will already
2580 have the correct value. If this is not a relocateable link,
2581 then we should ignore the symbol value. */
2582 if (howto->pc_relative && howto->pcrel_offset)
2584 if (info->relocateable)
2586 if (sym != NULL && sym->n_scnum != 0)
2587 addend += sym->n_value;
2598 sec = bfd_abs_section_ptr;
2603 sec = sections[symndx];
2604 val = (sec->output_section->vma
2605 + sec->output_offset
2607 if (! obj_pe (output_bfd))
2613 if (h->root.type == bfd_link_hash_defined
2614 || h->root.type == bfd_link_hash_defweak)
2618 sec = h->root.u.def.section;
2619 val = (h->root.u.def.value
2620 + sec->output_section->vma
2621 + sec->output_offset);
2624 else if (! info->relocateable)
2626 if (! ((*info->callbacks->undefined_symbol)
2627 (info, h->root.root.string, input_bfd, input_section,
2628 rel->r_vaddr - input_section->vma)))
2633 if (info->base_file)
2635 /* Emit a reloc if the backend thinks it needs it. */
2636 if (sym && pe_data(output_bfd)->in_reloc_p(output_bfd, howto))
2638 /* relocation to a symbol in a section which
2639 isn't absolute - we output the address here
2641 bfd_vma addr = rel->r_vaddr
2642 - input_section->vma
2643 + input_section->output_offset
2644 + input_section->output_section->vma;
2645 if (coff_data(output_bfd)->pe)
2646 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
2647 /* FIXME: Shouldn't 4 be sizeof (addr)? */
2648 fwrite (&addr, 1,4, (FILE *) info->base_file);
2652 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
2654 rel->r_vaddr - input_section->vma,
2663 case bfd_reloc_outofrange:
2664 (*_bfd_error_handler)
2665 ("%s: bad reloc address 0x%lx in section `%s'",
2666 bfd_get_filename (input_bfd),
2667 (unsigned long) rel->r_vaddr,
2668 bfd_get_section_name (input_bfd, input_section));
2670 case bfd_reloc_overflow:
2673 char buf[SYMNMLEN + 1];
2678 name = h->root.root.string;
2681 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
2686 if (! ((*info->callbacks->reloc_overflow)
2687 (info, name, howto->name, (bfd_vma) 0, input_bfd,
2688 input_section, rel->r_vaddr - input_section->vma)))