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 /* Write out the global symbols. */
842 finfo
.failed
= false;
843 coff_link_hash_traverse (coff_hash_table (info
), _bfd_coff_write_global_sym
,
848 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
849 if (finfo
.outsyms
!= NULL
)
851 free (finfo
.outsyms
);
852 finfo
.outsyms
= NULL
;
855 if (info
->relocateable
&& max_output_reloc_count
> 0)
857 /* Now that we have written out all the global symbols, we know
858 the symbol indices to use for relocs against them, and we can
859 finally write out the relocs. */
860 external_relocs
= ((bfd_byte
*)
861 bfd_malloc (max_output_reloc_count
* relsz
));
862 if (external_relocs
== NULL
)
865 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
867 struct internal_reloc
*irel
;
868 struct internal_reloc
*irelend
;
869 struct coff_link_hash_entry
**rel_hash
;
872 if (o
->reloc_count
== 0)
875 irel
= finfo
.section_info
[o
->target_index
].relocs
;
876 irelend
= irel
+ o
->reloc_count
;
877 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
878 erel
= external_relocs
;
879 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
881 if (*rel_hash
!= NULL
)
883 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
884 irel
->r_symndx
= (*rel_hash
)->indx
;
886 bfd_coff_swap_reloc_out (abfd
, (PTR
) irel
, (PTR
) erel
);
889 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0
890 || bfd_write ((PTR
) external_relocs
, relsz
, o
->reloc_count
,
891 abfd
) != relsz
* o
->reloc_count
)
895 free (external_relocs
);
896 external_relocs
= NULL
;
899 /* Free up the section information. */
900 if (finfo
.section_info
!= NULL
)
904 for (i
= 0; i
< abfd
->section_count
; i
++)
906 if (finfo
.section_info
[i
].relocs
!= NULL
)
907 free (finfo
.section_info
[i
].relocs
);
908 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
909 free (finfo
.section_info
[i
].rel_hashes
);
911 free (finfo
.section_info
);
912 finfo
.section_info
= NULL
;
915 /* If we have optimized stabs strings, output them. */
916 if (coff_hash_table (info
)->stab_info
!= NULL
)
918 if (! _bfd_write_stab_strings (abfd
, &coff_hash_table (info
)->stab_info
))
922 /* Write out the string table. */
923 if (obj_raw_syment_count (abfd
) != 0 || long_section_names
)
926 (obj_sym_filepos (abfd
)
927 + obj_raw_syment_count (abfd
) * symesz
),
931 #if STRING_SIZE_SIZE == 4
933 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
934 (bfd_byte
*) strbuf
);
936 #error Change bfd_h_put_32
939 if (bfd_write (strbuf
, 1, STRING_SIZE_SIZE
, abfd
) != STRING_SIZE_SIZE
)
942 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
946 _bfd_stringtab_free (finfo
.strtab
);
948 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
949 not try to write out the symbols. */
950 bfd_get_symcount (abfd
) = 0;
955 if (debug_merge_allocated
)
956 coff_debug_merge_hash_table_free (&finfo
.debug_merge
);
957 if (finfo
.strtab
!= NULL
)
958 _bfd_stringtab_free (finfo
.strtab
);
959 if (finfo
.section_info
!= NULL
)
963 for (i
= 0; i
< abfd
->section_count
; i
++)
965 if (finfo
.section_info
[i
].relocs
!= NULL
)
966 free (finfo
.section_info
[i
].relocs
);
967 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
968 free (finfo
.section_info
[i
].rel_hashes
);
970 free (finfo
.section_info
);
972 if (finfo
.internal_syms
!= NULL
)
973 free (finfo
.internal_syms
);
974 if (finfo
.sec_ptrs
!= NULL
)
975 free (finfo
.sec_ptrs
);
976 if (finfo
.sym_indices
!= NULL
)
977 free (finfo
.sym_indices
);
978 if (finfo
.outsyms
!= NULL
)
979 free (finfo
.outsyms
);
980 if (finfo
.linenos
!= NULL
)
981 free (finfo
.linenos
);
982 if (finfo
.contents
!= NULL
)
983 free (finfo
.contents
);
984 if (finfo
.external_relocs
!= NULL
)
985 free (finfo
.external_relocs
);
986 if (finfo
.internal_relocs
!= NULL
)
987 free (finfo
.internal_relocs
);
988 if (external_relocs
!= NULL
)
989 free (external_relocs
);
993 /* parse out a -heap <reserved>,<commit> line */
996 dores_com (ptr
, output_bfd
, heap
)
1001 if (coff_data(output_bfd
)->pe
)
1003 int val
= strtoul (ptr
, &ptr
, 0);
1005 pe_data(output_bfd
)->pe_opthdr
.SizeOfHeapReserve
=val
;
1007 pe_data(output_bfd
)->pe_opthdr
.SizeOfStackReserve
=val
;
1011 int val
= strtoul (ptr
+1, &ptr
, 0);
1013 pe_data(output_bfd
)->pe_opthdr
.SizeOfHeapCommit
=val
;
1015 pe_data(output_bfd
)->pe_opthdr
.SizeOfStackCommit
=val
;
1021 static char *get_name(ptr
, dst
)
1028 while (*ptr
&& *ptr
!= ' ')
1034 /* Process any magic embedded commands in a section called .drectve */
1037 process_embedded_commands (output_bfd
, info
, abfd
)
1039 struct bfd_link_info
*info
;
1042 asection
*sec
= bfd_get_section_by_name (abfd
, ".drectve");
1049 copy
= bfd_malloc ((size_t) sec
->_raw_size
);
1052 if (! bfd_get_section_contents(abfd
, sec
, copy
, 0, sec
->_raw_size
))
1057 e
= copy
+ sec
->_raw_size
;
1058 for (s
= copy
; s
< e
; )
1064 if (strncmp (s
,"-attr", 5) == 0)
1076 s
= get_name(s
, &name
);
1077 s
= get_name(s
, &attribs
);
1097 asec
= bfd_get_section_by_name (abfd
, name
);
1100 asec
->flags
|= SEC_CODE
;
1102 asec
->flags
|= SEC_READONLY
;
1105 else if (strncmp (s
,"-heap", 5) == 0)
1107 s
= dores_com (s
+5, output_bfd
, 1);
1109 else if (strncmp (s
,"-stack", 6) == 0)
1111 s
= dores_com (s
+6, output_bfd
, 0);
1120 /* Place a marker against all symbols which are used by relocations.
1121 This marker can be picked up by the 'do we skip this symbol ?'
1122 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1127 mark_relocs (finfo
, input_bfd
)
1128 struct coff_final_link_info
* finfo
;
1133 if ((bfd_get_file_flags (input_bfd
) & HAS_SYMS
) == 0)
1136 for (a
= input_bfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
1138 struct internal_reloc
* internal_relocs
;
1139 struct internal_reloc
* irel
;
1140 struct internal_reloc
* irelend
;
1143 if ((a
->flags
& SEC_RELOC
) == 0 || a
->reloc_count
< 1)
1146 /* Read in the relocs. */
1147 internal_relocs
= _bfd_coff_read_internal_relocs
1148 (input_bfd
, a
, false,
1149 finfo
->external_relocs
,
1150 finfo
->info
->relocateable
,
1151 (finfo
->info
->relocateable
1152 ? (finfo
->section_info
[ a
->output_section
->target_index
].relocs
+ a
->output_section
->reloc_count
)
1153 : finfo
->internal_relocs
)
1156 if (internal_relocs
== NULL
)
1159 irel
= internal_relocs
;
1160 irelend
= irel
+ a
->reloc_count
;
1162 /* Place a mark in the sym_indices array (whose entries have
1163 been initialised to 0) for all of the symbols that are used
1164 in the relocation table. This will then be picked up in the
1167 for (; irel
< irelend
; irel
++)
1169 finfo
->sym_indices
[ irel
->r_symndx
] = -1;
1174 /* Link an input file into the linker output file. This function
1175 handles all the sections and relocations of the input file at once. */
1178 _bfd_coff_link_input_bfd (finfo
, input_bfd
)
1179 struct coff_final_link_info
*finfo
;
1182 boolean (*sym_is_global
) PARAMS ((bfd
*, struct internal_syment
*));
1183 boolean (*adjust_symndx
) PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*,
1184 asection
*, struct internal_reloc
*,
1187 const char *strings
;
1188 bfd_size_type syment_base
;
1189 unsigned int n_tmask
;
1190 unsigned int n_btshft
;
1192 bfd_size_type isymesz
;
1193 bfd_size_type osymesz
;
1194 bfd_size_type linesz
;
1197 struct internal_syment
*isymp
;
1200 unsigned long output_index
;
1202 struct coff_link_hash_entry
**sym_hash
;
1205 /* Move all the symbols to the output file. */
1207 output_bfd
= finfo
->output_bfd
;
1208 sym_is_global
= coff_backend_info (input_bfd
)->_bfd_coff_sym_is_global
;
1210 syment_base
= obj_raw_syment_count (output_bfd
);
1211 isymesz
= bfd_coff_symesz (input_bfd
);
1212 osymesz
= bfd_coff_symesz (output_bfd
);
1213 linesz
= bfd_coff_linesz (input_bfd
);
1214 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
1216 n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
1217 n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
1219 /* Define macros so that ISFCN, et. al., macros work correctly. */
1220 #define N_TMASK n_tmask
1221 #define N_BTSHFT n_btshft
1224 if (! finfo
->info
->keep_memory
)
1227 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1230 if (! _bfd_coff_get_external_symbols (input_bfd
))
1233 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
1234 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
1235 isymp
= finfo
->internal_syms
;
1236 secpp
= finfo
->sec_ptrs
;
1237 indexp
= finfo
->sym_indices
;
1238 output_index
= syment_base
;
1239 outsym
= finfo
->outsyms
;
1241 if (coff_data (output_bfd
)->pe
)
1243 if (! process_embedded_commands (output_bfd
, finfo
->info
, input_bfd
))
1247 /* If we are going to perform relocations and also strip/discard some symbols
1248 then we must make sure that we do not strip/discard those symbols that are
1249 going to be involved in the relocations */
1250 if (( finfo
->info
->strip
!= strip_none
1251 || finfo
->info
->discard
!= discard_none
)
1252 && finfo
->info
->relocateable
)
1254 /* mark the symbol array as 'not-used' */
1255 memset (indexp
, 0, obj_raw_syment_count (input_bfd
) * sizeof * indexp
);
1257 mark_relocs (finfo
, input_bfd
);
1260 while (esym
< esym_end
)
1262 struct internal_syment isym
;
1265 boolean dont_skip_symbol
;
1268 bfd_coff_swap_sym_in (input_bfd
, (PTR
) esym
, (PTR
) isymp
);
1270 /* Make a copy of *isymp so that the relocate_section function
1271 always sees the original values. This is more reliable than
1272 always recomputing the symbol value even if we are stripping
1276 if (isym
.n_scnum
!= 0)
1277 *secpp
= coff_section_from_bfd_index (input_bfd
, isym
.n_scnum
);
1280 if (isym
.n_value
== 0)
1281 *secpp
= bfd_und_section_ptr
;
1283 *secpp
= bfd_com_section_ptr
;
1286 /* Extract the flag indicating if this symbol is used by a relocation */
1287 if (( finfo
->info
->strip
!= strip_none
1288 || finfo
->info
->discard
!= discard_none
)
1289 && finfo
->info
->relocateable
)
1290 dont_skip_symbol
= *indexp
;
1292 dont_skip_symbol
= false;
1298 add
= 1 + isym
.n_numaux
;
1300 /* If we are stripping all symbols, we want to skip this one. */
1301 if (finfo
->info
->strip
== strip_all
&& ! dont_skip_symbol
)
1306 if (isym
.n_sclass
== C_EXT
1307 || (sym_is_global
&& (*sym_is_global
) (input_bfd
, &isym
)))
1309 /* This is a global symbol. Global symbols come at the
1310 end of the symbol table, so skip them for now.
1311 Function symbols, however, are an exception, and are
1312 not moved to the end. */
1314 if (! ISFCN (isym
.n_type
))
1319 /* This is a local symbol. Skip it if we are discarding
1321 if (finfo
->info
->discard
== discard_all
&& ! dont_skip_symbol
)
1326 /* If we stripping debugging symbols, and this is a debugging
1327 symbol, then skip it. */
1329 && finfo
->info
->strip
== strip_debugger
1330 && ! dont_skip_symbol
1331 && isym
.n_scnum
== N_DEBUG
)
1334 /* If some symbols are stripped based on the name, work out the
1335 name and decide whether to skip this symbol. */
1337 && (finfo
->info
->strip
== strip_some
1338 || finfo
->info
->discard
== discard_l
))
1341 char buf
[SYMNMLEN
+ 1];
1343 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
1347 if (! dont_skip_symbol
1348 && ((finfo
->info
->strip
== strip_some
1349 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, false,
1352 && finfo
->info
->discard
== discard_l
1353 && bfd_is_local_label_name (input_bfd
, name
))))
1357 /* If this is an enum, struct, or union tag, see if we have
1358 already output an identical type. */
1360 && (finfo
->output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) == 0
1361 && (isym
.n_sclass
== C_ENTAG
1362 || isym
.n_sclass
== C_STRTAG
1363 || isym
.n_sclass
== C_UNTAG
)
1364 && isym
.n_numaux
== 1)
1367 char buf
[SYMNMLEN
+ 1];
1368 struct coff_debug_merge_hash_entry
*mh
;
1369 struct coff_debug_merge_type
*mt
;
1370 union internal_auxent aux
;
1371 struct coff_debug_merge_element
**epp
;
1372 bfd_byte
*esl
, *eslend
;
1373 struct internal_syment
*islp
;
1375 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
1379 /* Ignore fake names invented by compiler; treat them all as
1381 if (*name
== '~' || *name
== '.' || *name
== '$'
1382 || (*name
== bfd_get_symbol_leading_char (input_bfd
)
1383 && (name
[1] == '~' || name
[1] == '.' || name
[1] == '$')))
1386 mh
= coff_debug_merge_hash_lookup (&finfo
->debug_merge
, name
,
1391 /* Allocate memory to hold type information. If this turns
1392 out to be a duplicate, we pass this address to
1394 mt
= ((struct coff_debug_merge_type
*)
1395 bfd_alloc (input_bfd
,
1396 sizeof (struct coff_debug_merge_type
)));
1399 mt
->class = isym
.n_sclass
;
1401 /* Pick up the aux entry, which points to the end of the tag
1403 bfd_coff_swap_aux_in (input_bfd
, (PTR
) (esym
+ isymesz
),
1404 isym
.n_type
, isym
.n_sclass
, 0, isym
.n_numaux
,
1407 /* Gather the elements. */
1408 epp
= &mt
->elements
;
1409 mt
->elements
= NULL
;
1411 esl
= esym
+ 2 * isymesz
;
1412 eslend
= ((bfd_byte
*) obj_coff_external_syms (input_bfd
)
1413 + aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
* isymesz
);
1414 while (esl
< eslend
)
1416 const char *elename
;
1417 char elebuf
[SYMNMLEN
+ 1];
1420 bfd_coff_swap_sym_in (input_bfd
, (PTR
) esl
, (PTR
) islp
);
1422 *epp
= ((struct coff_debug_merge_element
*)
1423 bfd_alloc (input_bfd
,
1424 sizeof (struct coff_debug_merge_element
)));
1428 elename
= _bfd_coff_internal_syment_name (input_bfd
, islp
,
1430 if (elename
== NULL
)
1433 copy
= (char *) bfd_alloc (input_bfd
, strlen (elename
) + 1);
1436 strcpy (copy
, elename
);
1438 (*epp
)->name
= copy
;
1439 (*epp
)->type
= islp
->n_type
;
1441 if (islp
->n_numaux
>= 1
1442 && islp
->n_type
!= T_NULL
1443 && islp
->n_sclass
!= C_EOS
)
1445 union internal_auxent eleaux
;
1448 bfd_coff_swap_aux_in (input_bfd
, (PTR
) (esl
+ isymesz
),
1449 islp
->n_type
, islp
->n_sclass
, 0,
1450 islp
->n_numaux
, (PTR
) &eleaux
);
1451 indx
= eleaux
.x_sym
.x_tagndx
.l
;
1453 /* FIXME: If this tagndx entry refers to a symbol
1454 defined later in this file, we just ignore it.
1455 Handling this correctly would be tedious, and may
1461 (bfd_byte
*) obj_coff_external_syms (input_bfd
))
1464 (*epp
)->tagndx
= finfo
->sym_indices
[indx
];
1465 if ((*epp
)->tagndx
< 0)
1469 epp
= &(*epp
)->next
;
1472 esl
+= (islp
->n_numaux
+ 1) * isymesz
;
1473 islp
+= islp
->n_numaux
+ 1;
1476 /* See if we already have a definition which matches this
1477 type. We always output the type if it has no elements,
1479 if (mt
->elements
== NULL
)
1480 bfd_release (input_bfd
, (PTR
) mt
);
1483 struct coff_debug_merge_type
*mtl
;
1485 for (mtl
= mh
->types
; mtl
!= NULL
; mtl
= mtl
->next
)
1487 struct coff_debug_merge_element
*me
, *mel
;
1489 if (mtl
->class != mt
->class)
1492 for (me
= mt
->elements
, mel
= mtl
->elements
;
1493 me
!= NULL
&& mel
!= NULL
;
1494 me
= me
->next
, mel
= mel
->next
)
1496 if (strcmp (me
->name
, mel
->name
) != 0
1497 || me
->type
!= mel
->type
1498 || me
->tagndx
!= mel
->tagndx
)
1502 if (me
== NULL
&& mel
== NULL
)
1506 if (mtl
== NULL
|| (bfd_size_type
) mtl
->indx
>= syment_base
)
1508 /* This is the first definition of this type. */
1509 mt
->indx
= output_index
;
1510 mt
->next
= mh
->types
;
1515 /* This is a redefinition which can be merged. */
1516 bfd_release (input_bfd
, (PTR
) mt
);
1517 *indexp
= mtl
->indx
;
1518 add
= (eslend
- esym
) / isymesz
;
1524 /* We now know whether we are to skip this symbol or not. */
1527 /* Adjust the symbol in order to output it. */
1529 if (isym
._n
._n_n
._n_zeroes
== 0
1530 && isym
._n
._n_n
._n_offset
!= 0)
1535 /* This symbol has a long name. Enter it in the string
1536 table we are building. Note that we do not check
1537 bfd_coff_symname_in_debug. That is only true for
1538 XCOFF, and XCOFF requires different linking code
1540 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
,
1544 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
1545 if (indx
== (bfd_size_type
) -1)
1547 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
1550 if (isym
.n_scnum
> 0)
1552 isym
.n_scnum
= (*secpp
)->output_section
->target_index
;
1553 isym
.n_value
+= ((*secpp
)->output_section
->vma
1554 + (*secpp
)->output_offset
1558 /* The value of a C_FILE symbol is the symbol index of the
1559 next C_FILE symbol. The value of the last C_FILE symbol
1560 is the symbol index to the first external symbol
1561 (actually, coff_renumber_symbols does not get this
1562 right--it just sets the value of the last C_FILE symbol
1563 to zero--and nobody has ever complained about it). We
1564 try to get this right, below, just before we write the
1565 symbols out, but in the general case we may have to write
1566 the symbol out twice. */
1567 if (isym
.n_sclass
== C_FILE
)
1569 if (finfo
->last_file_index
!= -1
1570 && finfo
->last_file
.n_value
!= (long) output_index
)
1572 /* We must correct the value of the last C_FILE entry. */
1573 finfo
->last_file
.n_value
= output_index
;
1574 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
1576 /* The last C_FILE symbol is in this input file. */
1577 bfd_coff_swap_sym_out (output_bfd
,
1578 (PTR
) &finfo
->last_file
,
1579 (PTR
) (finfo
->outsyms
1580 + ((finfo
->last_file_index
1586 /* We have already written out the last C_FILE
1587 symbol. We need to write it out again. We
1588 borrow *outsym temporarily. */
1589 bfd_coff_swap_sym_out (output_bfd
,
1590 (PTR
) &finfo
->last_file
,
1592 if (bfd_seek (output_bfd
,
1593 (obj_sym_filepos (output_bfd
)
1594 + finfo
->last_file_index
* osymesz
),
1596 || (bfd_write (outsym
, osymesz
, 1, output_bfd
)
1602 finfo
->last_file_index
= output_index
;
1603 finfo
->last_file
= isym
;
1606 /* Output the symbol. */
1608 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) outsym
);
1610 *indexp
= output_index
;
1615 struct coff_link_hash_entry
*h
;
1617 indx
= ((esym
- (bfd_byte
*) obj_coff_external_syms (input_bfd
))
1619 h
= obj_coff_sym_hashes (input_bfd
)[indx
];
1622 /* This can happen if there were errors earlier in
1624 bfd_set_error (bfd_error_bad_value
);
1627 h
->indx
= output_index
;
1630 output_index
+= add
;
1631 outsym
+= add
* osymesz
;
1634 esym
+= add
* isymesz
;
1638 for (--add
; add
> 0; --add
)
1645 /* Fix up the aux entries. This must be done in a separate pass,
1646 because we don't know the correct symbol indices until we have
1647 already decided which symbols we are going to keep. */
1649 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
1650 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
1651 isymp
= finfo
->internal_syms
;
1652 indexp
= finfo
->sym_indices
;
1653 sym_hash
= obj_coff_sym_hashes (input_bfd
);
1654 outsym
= finfo
->outsyms
;
1655 while (esym
< esym_end
)
1659 add
= 1 + isymp
->n_numaux
;
1662 || (bfd_size_type
) *indexp
< syment_base
)
1663 && (*sym_hash
== NULL
1664 || (*sym_hash
)->auxbfd
!= input_bfd
))
1665 esym
+= add
* isymesz
;
1668 struct coff_link_hash_entry
*h
;
1676 /* The m68k-motorola-sysv assembler will sometimes
1677 generate two symbols with the same name, but only one
1678 will have aux entries. */
1679 BFD_ASSERT (isymp
->n_numaux
== 0
1680 || h
->numaux
== isymp
->n_numaux
);
1688 /* Handle the aux entries. This handling is based on
1689 coff_pointerize_aux. I don't know if it always correct. */
1690 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
1692 union internal_auxent aux
;
1693 union internal_auxent
*auxp
;
1699 bfd_coff_swap_aux_in (input_bfd
, (PTR
) esym
, isymp
->n_type
,
1700 isymp
->n_sclass
, i
, isymp
->n_numaux
,
1705 if (isymp
->n_sclass
== C_FILE
)
1707 /* If this is a long filename, we must put it in the
1709 if (auxp
->x_file
.x_n
.x_zeroes
== 0
1710 && auxp
->x_file
.x_n
.x_offset
!= 0)
1712 const char *filename
;
1715 BFD_ASSERT (auxp
->x_file
.x_n
.x_offset
1716 >= STRING_SIZE_SIZE
);
1717 if (strings
== NULL
)
1719 strings
= _bfd_coff_read_string_table (input_bfd
);
1720 if (strings
== NULL
)
1723 filename
= strings
+ auxp
->x_file
.x_n
.x_offset
;
1724 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
1726 if (indx
== (bfd_size_type
) -1)
1728 auxp
->x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
1731 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
1735 if (ISFCN (isymp
->n_type
)
1736 || ISTAG (isymp
->n_sclass
)
1737 || isymp
->n_sclass
== C_BLOCK
1738 || isymp
->n_sclass
== C_FCN
)
1740 indx
= auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1742 && indx
< obj_raw_syment_count (input_bfd
))
1744 /* We look forward through the symbol for
1745 the index of the next symbol we are going
1746 to include. I don't know if this is
1748 while ((finfo
->sym_indices
[indx
] < 0
1749 || ((bfd_size_type
) finfo
->sym_indices
[indx
]
1751 && indx
< obj_raw_syment_count (input_bfd
))
1753 if (indx
>= obj_raw_syment_count (input_bfd
))
1754 indx
= output_index
;
1756 indx
= finfo
->sym_indices
[indx
];
1757 auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
1761 indx
= auxp
->x_sym
.x_tagndx
.l
;
1762 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
1766 symindx
= finfo
->sym_indices
[indx
];
1768 auxp
->x_sym
.x_tagndx
.l
= 0;
1770 auxp
->x_sym
.x_tagndx
.l
= symindx
;
1773 /* The .bf symbols are supposed to be linked through
1774 the endndx field. We need to carry this list
1775 across object files. */
1778 && isymp
->n_sclass
== C_FCN
1779 && (isymp
->_n
._n_n
._n_zeroes
!= 0
1780 || isymp
->_n
._n_n
._n_offset
== 0)
1781 && isymp
->_n
._n_name
[0] == '.'
1782 && isymp
->_n
._n_name
[1] == 'b'
1783 && isymp
->_n
._n_name
[2] == 'f'
1784 && isymp
->_n
._n_name
[3] == '\0')
1786 if (finfo
->last_bf_index
!= -1)
1788 finfo
->last_bf
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1791 if ((bfd_size_type
) finfo
->last_bf_index
1796 /* The last .bf symbol is in this input
1797 file. This will only happen if the
1798 assembler did not set up the .bf
1799 endndx symbols correctly. */
1800 auxout
= (PTR
) (finfo
->outsyms
1801 + ((finfo
->last_bf_index
1804 bfd_coff_swap_aux_out (output_bfd
,
1805 (PTR
) &finfo
->last_bf
,
1813 /* We have already written out the last
1814 .bf aux entry. We need to write it
1815 out again. We borrow *outsym
1816 temporarily. FIXME: This case should
1818 bfd_coff_swap_aux_out (output_bfd
,
1819 (PTR
) &finfo
->last_bf
,
1824 if (bfd_seek (output_bfd
,
1825 (obj_sym_filepos (output_bfd
)
1826 + finfo
->last_bf_index
* osymesz
),
1828 || bfd_write (outsym
, osymesz
, 1,
1829 output_bfd
) != osymesz
)
1834 if (auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
!= 0)
1835 finfo
->last_bf_index
= -1;
1838 /* The endndx field of this aux entry must
1839 be updated with the symbol number of the
1841 finfo
->last_bf
= *auxp
;
1842 finfo
->last_bf_index
= (((outsym
- finfo
->outsyms
)
1851 bfd_coff_swap_aux_out (output_bfd
, (PTR
) auxp
, isymp
->n_type
,
1852 isymp
->n_sclass
, i
, isymp
->n_numaux
,
1866 /* Relocate the line numbers, unless we are stripping them. */
1867 if (finfo
->info
->strip
== strip_none
1868 || finfo
->info
->strip
== strip_some
)
1870 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
1876 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
1877 build_link_order in ldwrite.c will not have created a
1878 link order, which means that we will not have seen this
1879 input section in _bfd_coff_final_link, which means that
1880 we will not have allocated space for the line numbers of
1881 this section. I don't think line numbers can be
1882 meaningful for a section which does not have
1883 SEC_HAS_CONTENTS set, but, if they do, this must be
1885 if (o
->lineno_count
== 0
1886 || (o
->output_section
->flags
& SEC_HAS_CONTENTS
) == 0)
1889 if (bfd_seek (input_bfd
, o
->line_filepos
, SEEK_SET
) != 0
1890 || bfd_read (finfo
->linenos
, linesz
, o
->lineno_count
,
1891 input_bfd
) != linesz
* o
->lineno_count
)
1894 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
1895 eline
= finfo
->linenos
;
1896 elineend
= eline
+ linesz
* o
->lineno_count
;
1897 for (; eline
< elineend
; eline
+= linesz
)
1899 struct internal_lineno iline
;
1901 bfd_coff_swap_lineno_in (input_bfd
, (PTR
) eline
, (PTR
) &iline
);
1903 if (iline
.l_lnno
!= 0)
1904 iline
.l_addr
.l_paddr
+= offset
;
1905 else if (iline
.l_addr
.l_symndx
>= 0
1906 && ((unsigned long) iline
.l_addr
.l_symndx
1907 < obj_raw_syment_count (input_bfd
)))
1911 indx
= finfo
->sym_indices
[iline
.l_addr
.l_symndx
];
1915 /* These line numbers are attached to a symbol
1916 which we are stripping. We should really
1917 just discard the line numbers, but that would
1918 be a pain because we have already counted
1924 struct internal_syment is
;
1925 union internal_auxent ia
;
1927 /* Fix up the lnnoptr field in the aux entry of
1928 the symbol. It turns out that we can't do
1929 this when we modify the symbol aux entries,
1930 because gas sometimes screws up the lnnoptr
1931 field and makes it an offset from the start
1932 of the line numbers rather than an absolute
1934 bfd_coff_swap_sym_in (output_bfd
,
1935 (PTR
) (finfo
->outsyms
1936 + ((indx
- syment_base
)
1939 if ((ISFCN (is
.n_type
)
1940 || is
.n_sclass
== C_BLOCK
)
1941 && is
.n_numaux
>= 1)
1945 auxptr
= (PTR
) (finfo
->outsyms
1946 + ((indx
- syment_base
+ 1)
1948 bfd_coff_swap_aux_in (output_bfd
, auxptr
,
1949 is
.n_type
, is
.n_sclass
,
1950 0, is
.n_numaux
, (PTR
) &ia
);
1951 ia
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1952 (o
->output_section
->line_filepos
1953 + o
->output_section
->lineno_count
* linesz
1954 + eline
- finfo
->linenos
);
1955 bfd_coff_swap_aux_out (output_bfd
, (PTR
) &ia
,
1956 is
.n_type
, is
.n_sclass
, 0,
1957 is
.n_numaux
, auxptr
);
1961 iline
.l_addr
.l_symndx
= indx
;
1964 bfd_coff_swap_lineno_out (output_bfd
, (PTR
) &iline
, (PTR
) eline
);
1967 if (bfd_seek (output_bfd
,
1968 (o
->output_section
->line_filepos
1969 + o
->output_section
->lineno_count
* linesz
),
1971 || bfd_write (finfo
->linenos
, linesz
, o
->lineno_count
,
1972 output_bfd
) != linesz
* o
->lineno_count
)
1975 o
->output_section
->lineno_count
+= o
->lineno_count
;
1979 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
1980 symbol will be the first symbol in the next input file. In the
1981 normal case, this will save us from writing out the C_FILE symbol
1983 if (finfo
->last_file_index
!= -1
1984 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
1986 finfo
->last_file
.n_value
= output_index
;
1987 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &finfo
->last_file
,
1988 (PTR
) (finfo
->outsyms
1989 + ((finfo
->last_file_index
- syment_base
)
1993 /* Write the modified symbols to the output file. */
1994 if (outsym
> finfo
->outsyms
)
1996 if (bfd_seek (output_bfd
,
1997 obj_sym_filepos (output_bfd
) + syment_base
* osymesz
,
1999 || (bfd_write (finfo
->outsyms
, outsym
- finfo
->outsyms
, 1,
2001 != (bfd_size_type
) (outsym
- finfo
->outsyms
)))
2004 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
2005 + (outsym
- finfo
->outsyms
) / osymesz
)
2008 obj_raw_syment_count (output_bfd
) = output_index
;
2011 /* Relocate the contents of each section. */
2012 adjust_symndx
= coff_backend_info (input_bfd
)->_bfd_coff_adjust_symndx
;
2013 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2016 struct coff_section_tdata
*secdata
;
2018 if (! o
->linker_mark
)
2020 /* This section was omitted from the link. */
2024 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2025 || (o
->_raw_size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
2027 if ((o
->flags
& SEC_RELOC
) != 0
2028 && o
->reloc_count
!= 0)
2030 ((*_bfd_error_handler
)
2031 ("%s: relocs in section `%s', but it has no contents",
2032 bfd_get_filename (input_bfd
),
2033 bfd_get_section_name (input_bfd
, o
)));
2034 bfd_set_error (bfd_error_no_contents
);
2041 secdata
= coff_section_data (input_bfd
, o
);
2042 if (secdata
!= NULL
&& secdata
->contents
!= NULL
)
2043 contents
= secdata
->contents
;
2046 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
,
2047 (file_ptr
) 0, o
->_raw_size
))
2049 contents
= finfo
->contents
;
2052 if ((o
->flags
& SEC_RELOC
) != 0)
2055 struct internal_reloc
*internal_relocs
;
2056 struct internal_reloc
*irel
;
2058 /* Read in the relocs. */
2059 target_index
= o
->output_section
->target_index
;
2060 internal_relocs
= (_bfd_coff_read_internal_relocs
2061 (input_bfd
, o
, false, finfo
->external_relocs
,
2062 finfo
->info
->relocateable
,
2063 (finfo
->info
->relocateable
2064 ? (finfo
->section_info
[target_index
].relocs
2065 + o
->output_section
->reloc_count
)
2066 : finfo
->internal_relocs
)));
2067 if (internal_relocs
== NULL
)
2070 /* Call processor specific code to relocate the section
2072 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
2076 finfo
->internal_syms
,
2080 if (finfo
->info
->relocateable
)
2083 struct internal_reloc
*irelend
;
2084 struct coff_link_hash_entry
**rel_hash
;
2086 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
2087 irel
= internal_relocs
;
2088 irelend
= irel
+ o
->reloc_count
;
2089 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
2090 + o
->output_section
->reloc_count
);
2091 for (; irel
< irelend
; irel
++, rel_hash
++)
2093 struct coff_link_hash_entry
*h
;
2098 /* Adjust the reloc address and symbol index. */
2100 irel
->r_vaddr
+= offset
;
2102 if (irel
->r_symndx
== -1)
2107 if (! (*adjust_symndx
) (output_bfd
, finfo
->info
,
2115 h
= obj_coff_sym_hashes (input_bfd
)[irel
->r_symndx
];
2118 /* This is a global symbol. */
2120 irel
->r_symndx
= h
->indx
;
2123 /* This symbol is being written at the end
2124 of the file, and we do not yet know the
2125 symbol index. We save the pointer to the
2126 hash table entry in the rel_hash list.
2127 We set the indx field to -2 to indicate
2128 that this symbol must not be stripped. */
2137 indx
= finfo
->sym_indices
[irel
->r_symndx
];
2139 irel
->r_symndx
= indx
;
2142 struct internal_syment
*is
;
2144 char buf
[SYMNMLEN
+ 1];
2146 /* This reloc is against a symbol we are
2147 stripping. This should have been handled
2148 by the 'dont_skip_symbol' code in the while
2149 loop at the top of this function. */
2151 is
= finfo
->internal_syms
+ irel
->r_symndx
;
2153 name
= (_bfd_coff_internal_syment_name
2154 (input_bfd
, is
, buf
));
2158 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
2159 (finfo
->info
, name
, input_bfd
, o
,
2166 o
->output_section
->reloc_count
+= o
->reloc_count
;
2170 /* Write out the modified section contents. */
2171 if (secdata
== NULL
|| secdata
->stab_info
== NULL
)
2173 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2174 contents
, o
->output_offset
,
2175 (o
->_cooked_size
!= 0
2182 if (! (_bfd_write_section_stabs
2183 (output_bfd
, &coff_hash_table (finfo
->info
)->stab_info
,
2184 o
, &secdata
->stab_info
, contents
)))
2189 if (! finfo
->info
->keep_memory
)
2191 if (! _bfd_coff_free_symbols (input_bfd
))
2198 /* Write out a global symbol. Called via coff_link_hash_traverse. */
2201 _bfd_coff_write_global_sym (h
, data
)
2202 struct coff_link_hash_entry
*h
;
2205 struct coff_final_link_info
*finfo
= (struct coff_final_link_info
*) data
;
2207 struct internal_syment isym
;
2208 bfd_size_type symesz
;
2211 output_bfd
= finfo
->output_bfd
;
2217 && (finfo
->info
->strip
== strip_all
2218 || (finfo
->info
->strip
== strip_some
2219 && (bfd_hash_lookup (finfo
->info
->keep_hash
,
2220 h
->root
.root
.string
, false, false)
2224 switch (h
->root
.type
)
2227 case bfd_link_hash_new
:
2231 case bfd_link_hash_undefined
:
2232 case bfd_link_hash_undefweak
:
2233 isym
.n_scnum
= N_UNDEF
;
2237 case bfd_link_hash_defined
:
2238 case bfd_link_hash_defweak
:
2242 sec
= h
->root
.u
.def
.section
->output_section
;
2243 if (bfd_is_abs_section (sec
))
2244 isym
.n_scnum
= N_ABS
;
2246 isym
.n_scnum
= sec
->target_index
;
2247 isym
.n_value
= (h
->root
.u
.def
.value
2249 + h
->root
.u
.def
.section
->output_offset
);
2253 case bfd_link_hash_common
:
2254 isym
.n_scnum
= N_UNDEF
;
2255 isym
.n_value
= h
->root
.u
.c
.size
;
2258 case bfd_link_hash_indirect
:
2259 case bfd_link_hash_warning
:
2260 /* Just ignore these. They can't be handled anyhow. */
2264 if (strlen (h
->root
.root
.string
) <= SYMNMLEN
)
2265 strncpy (isym
._n
._n_name
, h
->root
.root
.string
, SYMNMLEN
);
2272 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
2274 indx
= _bfd_stringtab_add (finfo
->strtab
, h
->root
.root
.string
, hash
,
2276 if (indx
== (bfd_size_type
) -1)
2278 finfo
->failed
= true;
2281 isym
._n
._n_n
._n_zeroes
= 0;
2282 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
2285 isym
.n_sclass
= h
->class;
2286 isym
.n_type
= h
->type
;
2288 if (isym
.n_sclass
== C_NULL
)
2289 isym
.n_sclass
= C_EXT
;
2291 isym
.n_numaux
= h
->numaux
;
2293 bfd_coff_swap_sym_out (output_bfd
, (PTR
) &isym
, (PTR
) finfo
->outsyms
);
2295 symesz
= bfd_coff_symesz (output_bfd
);
2297 if (bfd_seek (output_bfd
,
2298 (obj_sym_filepos (output_bfd
)
2299 + obj_raw_syment_count (output_bfd
) * symesz
),
2301 || bfd_write (finfo
->outsyms
, symesz
, 1, output_bfd
) != symesz
)
2303 finfo
->failed
= true;
2307 h
->indx
= obj_raw_syment_count (output_bfd
);
2309 ++obj_raw_syment_count (output_bfd
);
2311 /* Write out any associated aux entries. There normally will be
2312 none. If there are any, I have no idea how to modify them. */
2313 for (i
= 0; i
< isym
.n_numaux
; i
++)
2315 bfd_coff_swap_aux_out (output_bfd
, (PTR
) (h
->aux
+ i
), isym
.n_type
,
2316 isym
.n_sclass
, i
, isym
.n_numaux
,
2317 (PTR
) finfo
->outsyms
);
2318 if (bfd_write (finfo
->outsyms
, symesz
, 1, output_bfd
) != symesz
)
2320 finfo
->failed
= true;
2323 ++obj_raw_syment_count (output_bfd
);
2329 /* Handle a link order which is supposed to generate a reloc. */
2332 _bfd_coff_reloc_link_order (output_bfd
, finfo
, output_section
, link_order
)
2334 struct coff_final_link_info
*finfo
;
2335 asection
*output_section
;
2336 struct bfd_link_order
*link_order
;
2338 reloc_howto_type
*howto
;
2339 struct internal_reloc
*irel
;
2340 struct coff_link_hash_entry
**rel_hash_ptr
;
2342 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
2345 bfd_set_error (bfd_error_bad_value
);
2349 if (link_order
->u
.reloc
.p
->addend
!= 0)
2353 bfd_reloc_status_type rstat
;
2356 size
= bfd_get_reloc_size (howto
);
2357 buf
= (bfd_byte
*) bfd_zmalloc (size
);
2361 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
2362 link_order
->u
.reloc
.p
->addend
, buf
);
2368 case bfd_reloc_outofrange
:
2370 case bfd_reloc_overflow
:
2371 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
2373 (link_order
->type
== bfd_section_reloc_link_order
2374 ? bfd_section_name (output_bfd
,
2375 link_order
->u
.reloc
.p
->u
.section
)
2376 : link_order
->u
.reloc
.p
->u
.name
),
2377 howto
->name
, link_order
->u
.reloc
.p
->addend
,
2378 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
2385 ok
= bfd_set_section_contents (output_bfd
, output_section
, (PTR
) buf
,
2386 (file_ptr
) link_order
->offset
, size
);
2392 /* Store the reloc information in the right place. It will get
2393 swapped and written out at the end of the final_link routine. */
2395 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
2396 + output_section
->reloc_count
);
2397 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
2398 + output_section
->reloc_count
);
2400 memset (irel
, 0, sizeof (struct internal_reloc
));
2401 *rel_hash_ptr
= NULL
;
2403 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
2405 if (link_order
->type
== bfd_section_reloc_link_order
)
2407 /* We need to somehow locate a symbol in the right section. The
2408 symbol must either have a value of zero, or we must adjust
2409 the addend by the value of the symbol. FIXME: Write this
2410 when we need it. The old linker couldn't handle this anyhow. */
2412 *rel_hash_ptr
= NULL
;
2417 struct coff_link_hash_entry
*h
;
2419 h
= ((struct coff_link_hash_entry
*)
2420 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
2421 link_order
->u
.reloc
.p
->u
.name
,
2422 false, false, true));
2426 irel
->r_symndx
= h
->indx
;
2429 /* Set the index to -2 to force this symbol to get
2438 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
2439 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
2440 (asection
*) NULL
, (bfd_vma
) 0)))
2446 /* FIXME: Is this always right? */
2447 irel
->r_type
= howto
->type
;
2449 /* r_size is only used on the RS/6000, which needs its own linker
2450 routines anyhow. r_extern is only used for ECOFF. */
2452 /* FIXME: What is the right value for r_offset? Is zero OK? */
2454 ++output_section
->reloc_count
;
2459 /* A basic reloc handling routine which may be used by processors with
2463 _bfd_coff_generic_relocate_section (output_bfd
, info
, input_bfd
,
2464 input_section
, contents
, relocs
, syms
,
2467 struct bfd_link_info
*info
;
2469 asection
*input_section
;
2471 struct internal_reloc
*relocs
;
2472 struct internal_syment
*syms
;
2473 asection
**sections
;
2475 struct internal_reloc
*rel
;
2476 struct internal_reloc
*relend
;
2479 relend
= rel
+ input_section
->reloc_count
;
2480 for (; rel
< relend
; rel
++)
2483 struct coff_link_hash_entry
*h
;
2484 struct internal_syment
*sym
;
2487 reloc_howto_type
*howto
;
2488 bfd_reloc_status_type rstat
;
2490 symndx
= rel
->r_symndx
;
2499 h
= obj_coff_sym_hashes (input_bfd
)[symndx
];
2500 sym
= syms
+ symndx
;
2503 /* COFF treats common symbols in one of two ways. Either the
2504 size of the symbol is included in the section contents, or it
2505 is not. We assume that the size is not included, and force
2506 the rtype_to_howto function to adjust the addend as needed. */
2508 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
2509 addend
= - sym
->n_value
;
2514 howto
= bfd_coff_rtype_to_howto (input_bfd
, input_section
, rel
, h
,
2519 /* If we are doing a relocateable link, then we can just ignore
2520 a PC relative reloc that is pcrel_offset. It will already
2521 have the correct value. If this is not a relocateable link,
2522 then we should ignore the symbol value. */
2523 if (howto
->pc_relative
&& howto
->pcrel_offset
)
2525 if (info
->relocateable
)
2527 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
2528 addend
+= sym
->n_value
;
2539 sec
= bfd_abs_section_ptr
;
2544 sec
= sections
[symndx
];
2545 val
= (sec
->output_section
->vma
2546 + sec
->output_offset
2553 if (h
->root
.type
== bfd_link_hash_defined
2554 || h
->root
.type
== bfd_link_hash_defweak
)
2558 sec
= h
->root
.u
.def
.section
;
2559 val
= (h
->root
.u
.def
.value
2560 + sec
->output_section
->vma
2561 + sec
->output_offset
);
2564 else if (! info
->relocateable
)
2566 if (! ((*info
->callbacks
->undefined_symbol
)
2567 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
2568 rel
->r_vaddr
- input_section
->vma
)))
2573 if (info
->base_file
)
2575 /* Emit a reloc if the backend thinks it needs it. */
2576 if (sym
&& pe_data(output_bfd
)->in_reloc_p(output_bfd
, howto
))
2578 /* relocation to a symbol in a section which
2579 isn't absolute - we output the address here
2581 bfd_vma addr
= rel
->r_vaddr
2582 - input_section
->vma
2583 + input_section
->output_offset
2584 + input_section
->output_section
->vma
;
2585 if (coff_data(output_bfd
)->pe
)
2586 addr
-= pe_data(output_bfd
)->pe_opthdr
.ImageBase
;
2587 /* FIXME: Shouldn't 4 be sizeof (addr)? */
2588 fwrite (&addr
, 1,4, (FILE *) info
->base_file
);
2592 rstat
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2594 rel
->r_vaddr
- input_section
->vma
,
2603 case bfd_reloc_outofrange
:
2604 (*_bfd_error_handler
)
2605 ("%s: bad reloc address 0x%lx in section `%s'",
2606 bfd_get_filename (input_bfd
),
2607 (unsigned long) rel
->r_vaddr
,
2608 bfd_get_section_name (input_bfd
, input_section
));
2610 case bfd_reloc_overflow
:
2613 char buf
[SYMNMLEN
+ 1];
2618 name
= h
->root
.root
.string
;
2621 name
= _bfd_coff_internal_syment_name (input_bfd
, sym
, buf
);
2626 if (! ((*info
->callbacks
->reloc_overflow
)
2627 (info
, name
, howto
->name
, (bfd_vma
) 0, input_bfd
,
2628 input_section
, rel
->r_vaddr
- input_section
->vma
)))