1 /* COFF specific linker code.
2 Copyright (C) 1994-2020 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* This file contains the COFF backend linker code. */
28 #include "coff/internal.h"
30 #include "safe-ctype.h"
32 static bfd_boolean
coff_link_add_object_symbols (bfd
*, struct bfd_link_info
*);
33 static bfd_boolean coff_link_check_archive_element
34 (bfd
*, struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
36 static bfd_boolean
coff_link_add_symbols (bfd
*, struct bfd_link_info
*);
38 /* Return TRUE if SYM is a weak, external symbol. */
39 #define IS_WEAK_EXTERNAL(abfd, sym) \
40 ((sym).n_sclass == C_WEAKEXT \
41 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
43 /* Return TRUE if SYM is an external symbol. */
44 #define IS_EXTERNAL(abfd, sym) \
45 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
47 /* Define macros so that the ISFCN, et. al., macros work correctly.
48 These macros are defined in include/coff/internal.h in terms of
49 N_TMASK, etc. These definitions require a user to define local
50 variables with the appropriate names, and with values from the
51 coff_data (abfd) structure. */
53 #define N_TMASK n_tmask
54 #define N_BTSHFT n_btshft
55 #define N_BTMASK n_btmask
57 /* Create an entry in a COFF linker hash table. */
59 struct bfd_hash_entry
*
60 _bfd_coff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
61 struct bfd_hash_table
*table
,
64 struct coff_link_hash_entry
*ret
= (struct coff_link_hash_entry
*) entry
;
66 /* Allocate the structure if it has not already been allocated by a
68 if (ret
== (struct coff_link_hash_entry
*) NULL
)
69 ret
= ((struct coff_link_hash_entry
*)
70 bfd_hash_allocate (table
, sizeof (struct coff_link_hash_entry
)));
71 if (ret
== (struct coff_link_hash_entry
*) NULL
)
72 return (struct bfd_hash_entry
*) ret
;
74 /* Call the allocation method of the superclass. */
75 ret
= ((struct coff_link_hash_entry
*)
76 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
78 if (ret
!= (struct coff_link_hash_entry
*) NULL
)
80 /* Set local fields. */
83 ret
->symbol_class
= C_NULL
;
89 return (struct bfd_hash_entry
*) ret
;
92 /* Initialize a COFF linker hash table. */
95 _bfd_coff_link_hash_table_init (struct coff_link_hash_table
*table
,
97 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
98 struct bfd_hash_table
*,
100 unsigned int entsize
)
102 memset (&table
->stab_info
, 0, sizeof (table
->stab_info
));
103 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
106 /* Create a COFF linker hash table. */
108 struct bfd_link_hash_table
*
109 _bfd_coff_link_hash_table_create (bfd
*abfd
)
111 struct coff_link_hash_table
*ret
;
112 size_t amt
= sizeof (struct coff_link_hash_table
);
114 ret
= (struct coff_link_hash_table
*) bfd_malloc (amt
);
118 if (! _bfd_coff_link_hash_table_init (ret
, abfd
,
119 _bfd_coff_link_hash_newfunc
,
120 sizeof (struct coff_link_hash_entry
)))
123 return (struct bfd_link_hash_table
*) NULL
;
128 /* Create an entry in a COFF debug merge hash table. */
130 struct bfd_hash_entry
*
131 _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry
*entry
,
132 struct bfd_hash_table
*table
,
135 struct coff_debug_merge_hash_entry
*ret
=
136 (struct coff_debug_merge_hash_entry
*) entry
;
138 /* Allocate the structure if it has not already been allocated by a
140 if (ret
== (struct coff_debug_merge_hash_entry
*) NULL
)
141 ret
= ((struct coff_debug_merge_hash_entry
*)
142 bfd_hash_allocate (table
,
143 sizeof (struct coff_debug_merge_hash_entry
)));
144 if (ret
== (struct coff_debug_merge_hash_entry
*) NULL
)
145 return (struct bfd_hash_entry
*) ret
;
147 /* Call the allocation method of the superclass. */
148 ret
= ((struct coff_debug_merge_hash_entry
*)
149 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
150 if (ret
!= (struct coff_debug_merge_hash_entry
*) NULL
)
152 /* Set local fields. */
156 return (struct bfd_hash_entry
*) ret
;
159 /* Given a COFF BFD, add symbols to the global hash table as
163 _bfd_coff_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
165 switch (bfd_get_format (abfd
))
168 return coff_link_add_object_symbols (abfd
, info
);
170 return _bfd_generic_link_add_archive_symbols
171 (abfd
, info
, coff_link_check_archive_element
);
173 bfd_set_error (bfd_error_wrong_format
);
178 /* Add symbols from a COFF object file. */
181 coff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
183 if (! _bfd_coff_get_external_symbols (abfd
))
185 if (! coff_link_add_symbols (abfd
, info
))
188 if (! info
->keep_memory
189 && ! _bfd_coff_free_symbols (abfd
))
195 /* Check a single archive element to see if we need to include it in
196 the link. *PNEEDED is set according to whether this element is
197 needed in the link or not. This is called via
198 _bfd_generic_link_add_archive_symbols. */
201 coff_link_check_archive_element (bfd
*abfd
,
202 struct bfd_link_info
*info
,
203 struct bfd_link_hash_entry
*h
,
205 bfd_boolean
*pneeded
)
209 /* We are only interested in symbols that are currently undefined.
210 If a symbol is currently known to be common, COFF linkers do not
211 bring in an object file which defines it. */
212 if (h
->type
!= bfd_link_hash_undefined
)
215 /* PR 22369 - Skip non COFF objects in the archive. */
216 if (! bfd_family_coff (abfd
))
219 /* Include this element? */
220 if (!(*info
->callbacks
->add_archive_element
) (info
, abfd
, name
, &abfd
))
224 return bfd_link_add_symbols (abfd
, info
);
227 /* Add all the symbols from an object file to the hash table. */
230 coff_link_add_symbols (bfd
*abfd
,
231 struct bfd_link_info
*info
)
233 unsigned int n_tmask
= coff_data (abfd
)->local_n_tmask
;
234 unsigned int n_btshft
= coff_data (abfd
)->local_n_btshft
;
235 unsigned int n_btmask
= coff_data (abfd
)->local_n_btmask
;
236 bfd_boolean keep_syms
;
237 bfd_boolean default_copy
;
238 bfd_size_type symcount
;
239 struct coff_link_hash_entry
**sym_hash
;
240 bfd_size_type symesz
;
245 symcount
= obj_raw_syment_count (abfd
);
248 return TRUE
; /* Nothing to do. */
250 /* Keep the symbols during this function, in case the linker needs
251 to read the generic symbols in order to report an error message. */
252 keep_syms
= obj_coff_keep_syms (abfd
);
253 obj_coff_keep_syms (abfd
) = TRUE
;
255 if (info
->keep_memory
)
256 default_copy
= FALSE
;
260 /* We keep a list of the linker hash table entries that correspond
261 to particular symbols. */
262 amt
= symcount
* sizeof (struct coff_link_hash_entry
*);
263 sym_hash
= (struct coff_link_hash_entry
**) bfd_zalloc (abfd
, amt
);
264 if (sym_hash
== NULL
)
266 obj_coff_sym_hashes (abfd
) = sym_hash
;
268 symesz
= bfd_coff_symesz (abfd
);
269 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
270 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
271 esym_end
= esym
+ symcount
* symesz
;
272 while (esym
< esym_end
)
274 struct internal_syment sym
;
275 enum coff_symbol_classification classification
;
278 bfd_coff_swap_sym_in (abfd
, esym
, &sym
);
280 classification
= bfd_coff_classify_symbol (abfd
, &sym
);
281 if (classification
!= COFF_SYMBOL_LOCAL
)
284 char buf
[SYMNMLEN
+ 1];
290 /* This symbol is externally visible. */
292 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
296 /* We must copy the name into memory if we got it from the
297 syment itself, rather than the string table. */
299 if (sym
._n
._n_n
._n_zeroes
!= 0
300 || sym
._n
._n_n
._n_offset
== 0)
305 switch (classification
)
310 case COFF_SYMBOL_GLOBAL
:
311 flags
= BSF_EXPORT
| BSF_GLOBAL
;
312 section
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
313 if (discarded_section (section
))
314 section
= bfd_und_section_ptr
;
315 else if (! obj_pe (abfd
))
316 value
-= section
->vma
;
319 case COFF_SYMBOL_UNDEFINED
:
321 section
= bfd_und_section_ptr
;
324 case COFF_SYMBOL_COMMON
:
326 section
= bfd_com_section_ptr
;
329 case COFF_SYMBOL_PE_SECTION
:
330 flags
= BSF_SECTION_SYM
| BSF_GLOBAL
;
331 section
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
332 if (discarded_section (section
))
333 section
= bfd_und_section_ptr
;
337 if (IS_WEAK_EXTERNAL (abfd
, sym
))
342 /* In the PE format, section symbols actually refer to the
343 start of the output section. We handle them specially
345 if (obj_pe (abfd
) && (flags
& BSF_SECTION_SYM
) != 0)
347 *sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
348 name
, FALSE
, copy
, FALSE
);
349 if (*sym_hash
!= NULL
)
351 if (((*sym_hash
)->coff_link_hash_flags
352 & COFF_LINK_HASH_PE_SECTION_SYMBOL
) == 0
353 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefined
354 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefweak
)
356 (_("warning: symbol `%s' is both section and non-section"),
363 /* The Microsoft Visual C compiler does string pooling by
364 hashing the constants to an internal symbol name, and
365 relying on the linker comdat support to discard
366 duplicate names. However, if one string is a literal and
367 one is a data initializer, one will end up in the .data
368 section and one will end up in the .rdata section. The
369 Microsoft linker will combine them into the .data
370 section, which seems to be wrong since it might cause the
373 As long as there are no external references to the
374 symbols, which there shouldn't be, we can treat the .data
375 and .rdata instances as separate symbols. The comdat
376 code in the linker will do the appropriate merging. Here
377 we avoid getting a multiple definition error for one of
378 these special symbols.
380 FIXME: I don't think this will work in the case where
381 there are two object files which use the constants as a
382 literal and two object files which use it as a data
383 initializer. One or the other of the second object files
384 is going to wind up with an inappropriate reference. */
386 && (classification
== COFF_SYMBOL_GLOBAL
387 || classification
== COFF_SYMBOL_PE_SECTION
)
388 && coff_section_data (abfd
, section
) != NULL
389 && coff_section_data (abfd
, section
)->comdat
!= NULL
390 && CONST_STRNEQ (name
, "??_")
391 && strcmp (name
, coff_section_data (abfd
, section
)->comdat
->name
) == 0)
393 if (*sym_hash
== NULL
)
394 *sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
395 name
, FALSE
, copy
, FALSE
);
396 if (*sym_hash
!= NULL
397 && (*sym_hash
)->root
.type
== bfd_link_hash_defined
398 && coff_section_data (abfd
, (*sym_hash
)->root
.u
.def
.section
)->comdat
!= NULL
399 && strcmp (coff_section_data (abfd
, (*sym_hash
)->root
.u
.def
.section
)->comdat
->name
,
400 coff_section_data (abfd
, section
)->comdat
->name
) == 0)
406 if (! (bfd_coff_link_add_one_symbol
407 (info
, abfd
, name
, flags
, section
, value
,
408 (const char *) NULL
, copy
, FALSE
,
409 (struct bfd_link_hash_entry
**) sym_hash
)))
413 if (obj_pe (abfd
) && (flags
& BSF_SECTION_SYM
) != 0)
414 (*sym_hash
)->coff_link_hash_flags
|=
415 COFF_LINK_HASH_PE_SECTION_SYMBOL
;
417 /* Limit the alignment of a common symbol to the possible
418 alignment of a section. There is no point to permitting
419 a higher alignment for a common symbol: we can not
420 guarantee it, and it may cause us to allocate extra space
421 in the common section. */
422 if (section
== bfd_com_section_ptr
423 && (*sym_hash
)->root
.type
== bfd_link_hash_common
424 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
425 > bfd_coff_default_section_alignment_power (abfd
)))
426 (*sym_hash
)->root
.u
.c
.p
->alignment_power
427 = bfd_coff_default_section_alignment_power (abfd
);
429 if (bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
))
431 /* If we don't have any symbol information currently in
432 the hash table, or if we are looking at a symbol
433 definition, then update the symbol class and type in
435 if (((*sym_hash
)->symbol_class
== C_NULL
436 && (*sym_hash
)->type
== T_NULL
)
439 && (*sym_hash
)->root
.type
!= bfd_link_hash_defined
440 && (*sym_hash
)->root
.type
!= bfd_link_hash_defweak
))
442 (*sym_hash
)->symbol_class
= sym
.n_sclass
;
443 if (sym
.n_type
!= T_NULL
)
445 /* We want to warn if the type changed, but not
446 if it changed from an unspecified type.
447 Testing the whole type byte may work, but the
448 change from (e.g.) a function of unspecified
449 type to function of known type also wants to
451 if ((*sym_hash
)->type
!= T_NULL
452 && (*sym_hash
)->type
!= sym
.n_type
453 && !(DTYPE ((*sym_hash
)->type
) == DTYPE (sym
.n_type
)
454 && (BTYPE ((*sym_hash
)->type
) == T_NULL
455 || BTYPE (sym
.n_type
) == T_NULL
)))
457 /* xgettext: c-format */
458 (_("warning: type of symbol `%s' changed"
459 " from %d to %d in %pB"),
460 name
, (*sym_hash
)->type
, sym
.n_type
, abfd
);
462 /* We don't want to change from a meaningful
463 base type to a null one, but if we know
464 nothing, take what little we might now know. */
465 if (BTYPE (sym
.n_type
) != T_NULL
466 || (*sym_hash
)->type
== T_NULL
)
467 (*sym_hash
)->type
= sym
.n_type
;
469 (*sym_hash
)->auxbfd
= abfd
;
470 if (sym
.n_numaux
!= 0)
472 union internal_auxent
*alloc
;
475 union internal_auxent
*iaux
;
477 (*sym_hash
)->numaux
= sym
.n_numaux
;
478 alloc
= ((union internal_auxent
*)
479 bfd_hash_allocate (&info
->hash
->table
,
481 * sizeof (*alloc
))));
484 for (i
= 0, eaux
= esym
+ symesz
, iaux
= alloc
;
486 i
++, eaux
+= symesz
, iaux
++)
487 bfd_coff_swap_aux_in (abfd
, eaux
, sym
.n_type
,
488 sym
.n_sclass
, (int) i
,
490 (*sym_hash
)->aux
= alloc
;
495 if (classification
== COFF_SYMBOL_PE_SECTION
496 && (*sym_hash
)->numaux
!= 0)
498 /* Some PE sections (such as .bss) have a zero size in
499 the section header, but a non-zero size in the AUX
500 record. Correct that here.
502 FIXME: This is not at all the right place to do this.
503 For example, it won't help objdump. This needs to be
504 done when we swap in the section header. */
505 BFD_ASSERT ((*sym_hash
)->numaux
== 1);
506 if (section
->size
== 0)
507 section
->size
= (*sym_hash
)->aux
[0].x_scn
.x_scnlen
;
509 /* FIXME: We could test whether the section sizes
510 matches the size in the aux entry, but apparently
511 that sometimes fails unexpectedly. */
515 esym
+= (sym
.n_numaux
+ 1) * symesz
;
516 sym_hash
+= sym
.n_numaux
+ 1;
519 /* If this is a non-traditional, non-relocatable link, try to
520 optimize the handling of any .stab/.stabstr sections. */
521 if (! bfd_link_relocatable (info
)
522 && ! info
->traditional_format
523 && bfd_get_flavour (info
->output_bfd
) == bfd_get_flavour (abfd
)
524 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
528 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
532 bfd_size_type string_offset
= 0;
535 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
536 if (CONST_STRNEQ (stab
->name
, ".stab")
538 || (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6]))))
540 struct coff_link_hash_table
*table
;
541 struct coff_section_tdata
*secdata
542 = coff_section_data (abfd
, stab
);
546 amt
= sizeof (struct coff_section_tdata
);
547 stab
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
548 if (stab
->used_by_bfd
== NULL
)
550 secdata
= coff_section_data (abfd
, stab
);
553 table
= coff_hash_table (info
);
555 if (! _bfd_link_section_stabs (abfd
, &table
->stab_info
,
564 obj_coff_keep_syms (abfd
) = keep_syms
;
569 obj_coff_keep_syms (abfd
) = keep_syms
;
573 /* Do the final link step. */
576 _bfd_coff_final_link (bfd
*abfd
,
577 struct bfd_link_info
*info
)
579 bfd_size_type symesz
;
580 struct coff_final_link_info flaginfo
;
581 bfd_boolean debug_merge_allocated
;
582 bfd_boolean long_section_names
;
584 struct bfd_link_order
*p
;
585 bfd_size_type max_sym_count
;
586 bfd_size_type max_lineno_count
;
587 bfd_size_type max_reloc_count
;
588 bfd_size_type max_output_reloc_count
;
589 bfd_size_type max_contents_size
;
590 file_ptr rel_filepos
;
592 file_ptr line_filepos
;
595 bfd_byte
*external_relocs
= NULL
;
596 char strbuf
[STRING_SIZE_SIZE
];
599 symesz
= bfd_coff_symesz (abfd
);
601 flaginfo
.info
= info
;
602 flaginfo
.output_bfd
= abfd
;
603 flaginfo
.strtab
= NULL
;
604 flaginfo
.section_info
= NULL
;
605 flaginfo
.last_file_index
= -1;
606 flaginfo
.last_bf_index
= -1;
607 flaginfo
.internal_syms
= NULL
;
608 flaginfo
.sec_ptrs
= NULL
;
609 flaginfo
.sym_indices
= NULL
;
610 flaginfo
.outsyms
= NULL
;
611 flaginfo
.linenos
= NULL
;
612 flaginfo
.contents
= NULL
;
613 flaginfo
.external_relocs
= NULL
;
614 flaginfo
.internal_relocs
= NULL
;
615 flaginfo
.global_to_static
= FALSE
;
616 debug_merge_allocated
= FALSE
;
618 coff_data (abfd
)->link_info
= info
;
620 flaginfo
.strtab
= _bfd_stringtab_init ();
621 if (flaginfo
.strtab
== NULL
)
624 if (! coff_debug_merge_hash_table_init (&flaginfo
.debug_merge
))
626 debug_merge_allocated
= TRUE
;
628 /* Compute the file positions for all the sections. */
629 if (! abfd
->output_has_begun
)
631 if (! bfd_coff_compute_section_file_positions (abfd
))
635 /* Count the line numbers and relocation entries required for the
636 output file. Set the file positions for the relocs. */
637 rel_filepos
= obj_relocbase (abfd
);
638 relsz
= bfd_coff_relsz (abfd
);
639 max_contents_size
= 0;
640 max_lineno_count
= 0;
643 long_section_names
= FALSE
;
644 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
648 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
650 if (p
->type
== bfd_indirect_link_order
)
654 sec
= p
->u
.indirect
.section
;
656 /* Mark all sections which are to be included in the
657 link. This will normally be every section. We need
658 to do this so that we can identify any sections which
659 the linker has decided to not include. */
660 sec
->linker_mark
= TRUE
;
662 if (info
->strip
== strip_none
663 || info
->strip
== strip_some
)
664 o
->lineno_count
+= sec
->lineno_count
;
666 if (bfd_link_relocatable (info
))
667 o
->reloc_count
+= sec
->reloc_count
;
669 if (sec
->rawsize
> max_contents_size
)
670 max_contents_size
= sec
->rawsize
;
671 if (sec
->size
> max_contents_size
)
672 max_contents_size
= sec
->size
;
673 if (sec
->lineno_count
> max_lineno_count
)
674 max_lineno_count
= sec
->lineno_count
;
675 if (sec
->reloc_count
> max_reloc_count
)
676 max_reloc_count
= sec
->reloc_count
;
678 else if (bfd_link_relocatable (info
)
679 && (p
->type
== bfd_section_reloc_link_order
680 || p
->type
== bfd_symbol_reloc_link_order
))
683 if (o
->reloc_count
== 0)
687 o
->flags
|= SEC_RELOC
;
688 o
->rel_filepos
= rel_filepos
;
689 rel_filepos
+= o
->reloc_count
* relsz
;
690 /* In PE COFF, if there are at least 0xffff relocations an
691 extra relocation will be written out to encode the count. */
692 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && o
->reloc_count
>= 0xffff)
693 rel_filepos
+= relsz
;
696 if (bfd_coff_long_section_names (abfd
)
697 && strlen (o
->name
) > SCNNMLEN
)
699 /* This section has a long name which must go in the string
700 table. This must correspond to the code in
701 coff_write_object_contents which puts the string index
702 into the s_name field of the section header. That is why
703 we pass hash as FALSE. */
704 if (_bfd_stringtab_add (flaginfo
.strtab
, o
->name
, FALSE
, FALSE
)
705 == (bfd_size_type
) -1)
707 long_section_names
= TRUE
;
711 /* If doing a relocatable link, allocate space for the pointers we
713 if (bfd_link_relocatable (info
))
717 /* We use section_count + 1, rather than section_count, because
718 the target_index fields are 1 based. */
719 amt
= abfd
->section_count
+ 1;
720 amt
*= sizeof (struct coff_link_section_info
);
721 flaginfo
.section_info
= (struct coff_link_section_info
*) bfd_malloc (amt
);
722 if (flaginfo
.section_info
== NULL
)
724 for (i
= 0; i
<= abfd
->section_count
; i
++)
726 flaginfo
.section_info
[i
].relocs
= NULL
;
727 flaginfo
.section_info
[i
].rel_hashes
= NULL
;
731 /* We now know the size of the relocs, so we can determine the file
732 positions of the line numbers. */
733 line_filepos
= rel_filepos
;
734 linesz
= bfd_coff_linesz (abfd
);
735 max_output_reloc_count
= 0;
736 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
738 if (o
->lineno_count
== 0)
742 o
->line_filepos
= line_filepos
;
743 line_filepos
+= o
->lineno_count
* linesz
;
746 if (o
->reloc_count
!= 0)
748 /* We don't know the indices of global symbols until we have
749 written out all the local symbols. For each section in
750 the output file, we keep an array of pointers to hash
751 table entries. Each entry in the array corresponds to a
752 reloc. When we find a reloc against a global symbol, we
753 set the corresponding entry in this array so that we can
754 fix up the symbol index after we have written out all the
757 Because of this problem, we also keep the relocs in
758 memory until the end of the link. This wastes memory,
759 but only when doing a relocatable link, which is not the
761 BFD_ASSERT (bfd_link_relocatable (info
));
762 amt
= o
->reloc_count
;
763 amt
*= sizeof (struct internal_reloc
);
764 flaginfo
.section_info
[o
->target_index
].relocs
=
765 (struct internal_reloc
*) bfd_malloc (amt
);
766 amt
= o
->reloc_count
;
767 amt
*= sizeof (struct coff_link_hash_entry
*);
768 flaginfo
.section_info
[o
->target_index
].rel_hashes
=
769 (struct coff_link_hash_entry
**) bfd_malloc (amt
);
770 if (flaginfo
.section_info
[o
->target_index
].relocs
== NULL
771 || flaginfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
774 if (o
->reloc_count
> max_output_reloc_count
)
775 max_output_reloc_count
= o
->reloc_count
;
778 /* Reset the reloc and lineno counts, so that we can use them to
779 count the number of entries we have output so far. */
784 obj_sym_filepos (abfd
) = line_filepos
;
786 /* Figure out the largest number of symbols in an input BFD. Take
787 the opportunity to clear the output_has_begun fields of all the
790 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
794 sub
->output_has_begun
= FALSE
;
795 sz
= bfd_family_coff (sub
) ? obj_raw_syment_count (sub
) : 2;
796 if (sz
> max_sym_count
)
800 /* Allocate some buffers used while linking. */
801 amt
= max_sym_count
* sizeof (struct internal_syment
);
802 flaginfo
.internal_syms
= (struct internal_syment
*) bfd_malloc (amt
);
803 amt
= max_sym_count
* sizeof (asection
*);
804 flaginfo
.sec_ptrs
= (asection
**) bfd_malloc (amt
);
805 amt
= max_sym_count
* sizeof (long);
806 flaginfo
.sym_indices
= (long int *) bfd_malloc (amt
);
807 flaginfo
.outsyms
= (bfd_byte
*) bfd_malloc ((max_sym_count
+ 1) * symesz
);
808 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
809 flaginfo
.linenos
= (bfd_byte
*) bfd_malloc (amt
);
810 flaginfo
.contents
= (bfd_byte
*) bfd_malloc (max_contents_size
);
811 amt
= max_reloc_count
* relsz
;
812 flaginfo
.external_relocs
= (bfd_byte
*) bfd_malloc (amt
);
813 if (! bfd_link_relocatable (info
))
815 amt
= max_reloc_count
* sizeof (struct internal_reloc
);
816 flaginfo
.internal_relocs
= (struct internal_reloc
*) bfd_malloc (amt
);
818 if ((flaginfo
.internal_syms
== NULL
&& max_sym_count
> 0)
819 || (flaginfo
.sec_ptrs
== NULL
&& max_sym_count
> 0)
820 || (flaginfo
.sym_indices
== NULL
&& max_sym_count
> 0)
821 || flaginfo
.outsyms
== NULL
822 || (flaginfo
.linenos
== NULL
&& max_lineno_count
> 0)
823 || (flaginfo
.contents
== NULL
&& max_contents_size
> 0)
824 || (flaginfo
.external_relocs
== NULL
&& max_reloc_count
> 0)
825 || (! bfd_link_relocatable (info
)
826 && flaginfo
.internal_relocs
== NULL
827 && max_reloc_count
> 0))
830 /* We now know the position of everything in the file, except that
831 we don't know the size of the symbol table and therefore we don't
832 know where the string table starts. We just build the string
833 table in memory as we go along. We process all the relocations
834 for a single input file at once. */
835 obj_raw_syment_count (abfd
) = 0;
837 if (coff_backend_info (abfd
)->_bfd_coff_start_final_link
)
839 if (! bfd_coff_start_final_link (abfd
, info
))
843 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
845 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
847 if (p
->type
== bfd_indirect_link_order
848 && bfd_family_coff (p
->u
.indirect
.section
->owner
))
850 sub
= p
->u
.indirect
.section
->owner
;
851 if (! bfd_coff_link_output_has_begun (sub
, & flaginfo
))
853 if (! _bfd_coff_link_input_bfd (&flaginfo
, sub
))
855 sub
->output_has_begun
= TRUE
;
858 else if (p
->type
== bfd_section_reloc_link_order
859 || p
->type
== bfd_symbol_reloc_link_order
)
861 if (! _bfd_coff_reloc_link_order (abfd
, &flaginfo
, o
, p
))
866 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
872 if (flaginfo
.info
->strip
!= strip_all
&& flaginfo
.info
->discard
!= discard_all
)
874 /* Add local symbols from foreign inputs. */
875 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
879 if (bfd_family_coff (sub
) || ! bfd_get_outsymbols (sub
))
881 for (i
= 0; i
< bfd_get_symcount (sub
); ++i
)
883 asymbol
*sym
= bfd_get_outsymbols (sub
) [i
];
885 struct internal_syment isym
;
886 union internal_auxent iaux
;
887 bfd_size_type string_size
= 0, indx
;
889 bfd_boolean rewrite
= FALSE
, hash
;
891 if (! (sym
->flags
& BSF_LOCAL
)
892 || (sym
->flags
& (BSF_SECTION_SYM
| BSF_DEBUGGING_RELOC
893 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
895 || ((sym
->flags
& BSF_DEBUGGING
)
896 && ! (sym
->flags
& BSF_FILE
)))
899 /* See if we are discarding symbols with this name. */
900 if ((flaginfo
.info
->strip
== strip_some
901 && (bfd_hash_lookup (flaginfo
.info
->keep_hash
,
902 bfd_asymbol_name(sym
), FALSE
, FALSE
)
904 || (((flaginfo
.info
->discard
== discard_sec_merge
905 && (bfd_asymbol_section (sym
)->flags
& SEC_MERGE
)
906 && ! bfd_link_relocatable (flaginfo
.info
))
907 || flaginfo
.info
->discard
== discard_l
)
908 && bfd_is_local_label_name (sub
, bfd_asymbol_name(sym
))))
911 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
)
913 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
915 if (! coff_write_alien_symbol(abfd
, sym
, &isym
, &iaux
, &written
,
916 &string_size
, NULL
, NULL
))
919 hash
= !flaginfo
.info
->traditional_format
;
921 if (string_size
>= 6 && isym
.n_sclass
== C_FILE
922 && ! isym
._n
._n_n
._n_zeroes
&& isym
.n_numaux
)
924 indx
= _bfd_stringtab_add (flaginfo
.strtab
, ".file", hash
,
926 if (indx
== (bfd_size_type
) -1)
928 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
929 bfd_coff_swap_sym_out (abfd
, &isym
, flaginfo
.outsyms
);
930 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
931 || bfd_bwrite (flaginfo
.outsyms
, symesz
,
939 indx
= _bfd_stringtab_add (flaginfo
.strtab
,
940 bfd_asymbol_name (sym
), hash
,
942 if (indx
== (bfd_size_type
) -1)
944 if (isym
.n_sclass
!= C_FILE
)
946 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
947 bfd_coff_swap_sym_out (abfd
, &isym
, flaginfo
.outsyms
);
952 BFD_ASSERT (isym
.n_numaux
== 1);
953 iaux
.x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
954 bfd_coff_swap_aux_out (abfd
, &iaux
, isym
.n_type
, C_FILE
,
955 0, 1, flaginfo
.outsyms
+ symesz
);
956 if (bfd_seek (abfd
, pos
+ symesz
, SEEK_SET
) != 0
957 || bfd_bwrite (flaginfo
.outsyms
+ symesz
, symesz
,
963 if (isym
.n_sclass
== C_FILE
)
965 if (flaginfo
.last_file_index
!= -1)
967 flaginfo
.last_file
.n_value
= obj_raw_syment_count (abfd
);
968 bfd_coff_swap_sym_out (abfd
, &flaginfo
.last_file
,
970 pos
= obj_sym_filepos (abfd
) + flaginfo
.last_file_index
974 flaginfo
.last_file_index
= obj_raw_syment_count (abfd
);
975 flaginfo
.last_file
= isym
;
979 && (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
980 || bfd_bwrite (flaginfo
.outsyms
, symesz
, abfd
) != symesz
))
983 obj_raw_syment_count (abfd
) += written
;
988 if (! bfd_coff_final_link_postscript (abfd
, & flaginfo
))
991 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
993 coff_debug_merge_hash_table_free (&flaginfo
.debug_merge
);
994 debug_merge_allocated
= FALSE
;
996 free (flaginfo
.internal_syms
);
997 flaginfo
.internal_syms
= NULL
;
998 free (flaginfo
.sec_ptrs
);
999 flaginfo
.sec_ptrs
= NULL
;
1000 free (flaginfo
.sym_indices
);
1001 flaginfo
.sym_indices
= NULL
;
1002 free (flaginfo
.linenos
);
1003 flaginfo
.linenos
= NULL
;
1004 free (flaginfo
.contents
);
1005 flaginfo
.contents
= NULL
;
1006 free (flaginfo
.external_relocs
);
1007 flaginfo
.external_relocs
= NULL
;
1008 free (flaginfo
.internal_relocs
);
1009 flaginfo
.internal_relocs
= NULL
;
1011 /* The value of the last C_FILE symbol is supposed to be the symbol
1012 index of the first external symbol. Write it out again if
1014 if (flaginfo
.last_file_index
!= -1
1015 && (unsigned int) flaginfo
.last_file
.n_value
!= obj_raw_syment_count (abfd
))
1019 flaginfo
.last_file
.n_value
= obj_raw_syment_count (abfd
);
1020 bfd_coff_swap_sym_out (abfd
, &flaginfo
.last_file
,
1023 pos
= obj_sym_filepos (abfd
) + flaginfo
.last_file_index
* symesz
;
1024 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1025 || bfd_bwrite (flaginfo
.outsyms
, symesz
, abfd
) != symesz
)
1029 /* If doing task linking (ld --task-link) then make a pass through the
1030 global symbols, writing out any that are defined, and making them
1032 if (info
->task_link
)
1034 flaginfo
.failed
= FALSE
;
1035 coff_link_hash_traverse (coff_hash_table (info
),
1036 _bfd_coff_write_task_globals
, &flaginfo
);
1037 if (flaginfo
.failed
)
1041 /* Write out the global symbols. */
1042 flaginfo
.failed
= FALSE
;
1043 bfd_hash_traverse (&info
->hash
->table
, _bfd_coff_write_global_sym
, &flaginfo
);
1044 if (flaginfo
.failed
)
1047 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
1048 free (flaginfo
.outsyms
);
1049 flaginfo
.outsyms
= NULL
;
1051 if (bfd_link_relocatable (info
) && max_output_reloc_count
> 0)
1053 /* Now that we have written out all the global symbols, we know
1054 the symbol indices to use for relocs against them, and we can
1055 finally write out the relocs. */
1056 amt
= max_output_reloc_count
* relsz
;
1057 external_relocs
= (bfd_byte
*) bfd_malloc (amt
);
1058 if (external_relocs
== NULL
)
1061 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1063 struct internal_reloc
*irel
;
1064 struct internal_reloc
*irelend
;
1065 struct coff_link_hash_entry
**rel_hash
;
1068 if (o
->reloc_count
== 0)
1071 irel
= flaginfo
.section_info
[o
->target_index
].relocs
;
1072 irelend
= irel
+ o
->reloc_count
;
1073 rel_hash
= flaginfo
.section_info
[o
->target_index
].rel_hashes
;
1074 erel
= external_relocs
;
1075 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
1077 if (*rel_hash
!= NULL
)
1079 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
1080 irel
->r_symndx
= (*rel_hash
)->indx
;
1082 bfd_coff_swap_reloc_out (abfd
, irel
, erel
);
1085 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0)
1087 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && o
->reloc_count
>= 0xffff)
1089 /* In PE COFF, write the count of relocs as the first
1090 reloc. The header overflow bit will be set
1092 struct internal_reloc incount
;
1093 bfd_byte
*excount
= (bfd_byte
*)bfd_malloc (relsz
);
1095 memset (&incount
, 0, sizeof (incount
));
1096 incount
.r_vaddr
= o
->reloc_count
+ 1;
1097 bfd_coff_swap_reloc_out (abfd
, &incount
, excount
);
1098 if (bfd_bwrite (excount
, relsz
, abfd
) != relsz
)
1099 /* We'll leak, but it's an error anyway. */
1103 if (bfd_bwrite (external_relocs
,
1104 (bfd_size_type
) relsz
* o
->reloc_count
, abfd
)
1105 != (bfd_size_type
) relsz
* o
->reloc_count
)
1109 free (external_relocs
);
1110 external_relocs
= NULL
;
1113 /* Free up the section information. */
1114 if (flaginfo
.section_info
!= NULL
)
1118 for (i
= 0; i
< abfd
->section_count
; i
++)
1120 free (flaginfo
.section_info
[i
].relocs
);
1121 free (flaginfo
.section_info
[i
].rel_hashes
);
1123 free (flaginfo
.section_info
);
1124 flaginfo
.section_info
= NULL
;
1127 /* If we have optimized stabs strings, output them. */
1128 if (coff_hash_table (info
)->stab_info
.stabstr
!= NULL
)
1130 if (! _bfd_write_stab_strings (abfd
, &coff_hash_table (info
)->stab_info
))
1134 /* Write out the string table. */
1135 if (obj_raw_syment_count (abfd
) != 0 || long_section_names
)
1139 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
1140 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1143 #if STRING_SIZE_SIZE == 4
1145 _bfd_stringtab_size (flaginfo
.strtab
) + STRING_SIZE_SIZE
,
1148 #error Change H_PUT_32 above
1151 if (bfd_bwrite (strbuf
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1152 != STRING_SIZE_SIZE
)
1155 if (! _bfd_stringtab_emit (abfd
, flaginfo
.strtab
))
1158 obj_coff_strings_written (abfd
) = TRUE
;
1161 _bfd_stringtab_free (flaginfo
.strtab
);
1163 /* Setting symcount to 0 will cause write_object_contents to
1164 not try to write out the symbols. */
1170 if (debug_merge_allocated
)
1171 coff_debug_merge_hash_table_free (&flaginfo
.debug_merge
);
1172 if (flaginfo
.strtab
!= NULL
)
1173 _bfd_stringtab_free (flaginfo
.strtab
);
1174 if (flaginfo
.section_info
!= NULL
)
1178 for (i
= 0; i
< abfd
->section_count
; i
++)
1180 free (flaginfo
.section_info
[i
].relocs
);
1181 free (flaginfo
.section_info
[i
].rel_hashes
);
1183 free (flaginfo
.section_info
);
1185 free (flaginfo
.internal_syms
);
1186 free (flaginfo
.sec_ptrs
);
1187 free (flaginfo
.sym_indices
);
1188 free (flaginfo
.outsyms
);
1189 free (flaginfo
.linenos
);
1190 free (flaginfo
.contents
);
1191 free (flaginfo
.external_relocs
);
1192 free (flaginfo
.internal_relocs
);
1193 free (external_relocs
);
1197 /* Parse out a -heap <reserved>,<commit> line. */
1200 dores_com (char *ptr
, bfd
*output_bfd
, int heap
)
1202 if (coff_data(output_bfd
)->pe
)
1204 int val
= strtoul (ptr
, &ptr
, 0);
1207 pe_data(output_bfd
)->pe_opthdr
.SizeOfHeapReserve
= val
;
1209 pe_data(output_bfd
)->pe_opthdr
.SizeOfStackReserve
= val
;
1213 val
= strtoul (ptr
+1, &ptr
, 0);
1215 pe_data(output_bfd
)->pe_opthdr
.SizeOfHeapCommit
= val
;
1217 pe_data(output_bfd
)->pe_opthdr
.SizeOfStackCommit
= val
;
1224 get_name (char *ptr
, char **dst
)
1229 while (*ptr
&& *ptr
!= ' ')
1235 /* Process any magic embedded commands in a section called .drectve. */
1238 process_embedded_commands (bfd
*output_bfd
,
1239 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1242 asection
*sec
= bfd_get_section_by_name (abfd
, ".drectve");
1250 if (!bfd_malloc_and_get_section (abfd
, sec
, ©
))
1255 e
= (char *) copy
+ sec
->size
;
1257 for (s
= (char *) copy
; s
< e
; )
1264 if (CONST_STRNEQ (s
, "-attr"))
1274 s
= get_name (s
, &name
);
1275 s
= get_name (s
, &attribs
);
1295 asec
= bfd_get_section_by_name (abfd
, name
);
1299 asec
->flags
|= SEC_CODE
;
1301 asec
->flags
|= SEC_READONLY
;
1304 else if (CONST_STRNEQ (s
, "-heap"))
1305 s
= dores_com (s
+ 5, output_bfd
, 1);
1307 else if (CONST_STRNEQ (s
, "-stack"))
1308 s
= dores_com (s
+ 6, output_bfd
, 0);
1310 /* GNU extension for aligned commons. */
1311 else if (CONST_STRNEQ (s
, "-aligncomm:"))
1313 /* Common symbols must be aligned on reading, as it
1314 is too late to do anything here, after they have
1315 already been allocated, so just skip the directive. */
1326 /* Place a marker against all symbols which are used by relocations.
1327 This marker can be picked up by the 'do we skip this symbol ?'
1328 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1332 mark_relocs (struct coff_final_link_info
*flaginfo
, bfd
*input_bfd
)
1336 if ((bfd_get_file_flags (input_bfd
) & HAS_SYMS
) == 0)
1339 for (a
= input_bfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
1341 struct internal_reloc
* internal_relocs
;
1342 struct internal_reloc
* irel
;
1343 struct internal_reloc
* irelend
;
1345 if ((a
->flags
& SEC_RELOC
) == 0 || a
->reloc_count
< 1
1346 || a
->linker_mark
== 0)
1348 /* Don't mark relocs in excluded sections. */
1349 if (a
->output_section
== bfd_abs_section_ptr
)
1352 /* Read in the relocs. */
1353 internal_relocs
= _bfd_coff_read_internal_relocs
1354 (input_bfd
, a
, FALSE
,
1355 flaginfo
->external_relocs
,
1356 bfd_link_relocatable (flaginfo
->info
),
1357 (bfd_link_relocatable (flaginfo
->info
)
1358 ? (flaginfo
->section_info
[ a
->output_section
->target_index
].relocs
+ a
->output_section
->reloc_count
)
1359 : flaginfo
->internal_relocs
)
1362 if (internal_relocs
== NULL
)
1365 irel
= internal_relocs
;
1366 irelend
= irel
+ a
->reloc_count
;
1368 /* Place a mark in the sym_indices array (whose entries have
1369 been initialised to 0) for all of the symbols that are used
1370 in the relocation table. This will then be picked up in the
1371 skip/don't-skip pass. */
1372 for (; irel
< irelend
; irel
++)
1373 if ((unsigned long) irel
->r_symndx
< obj_raw_syment_count (input_bfd
))
1374 flaginfo
->sym_indices
[irel
->r_symndx
] = -1;
1378 /* Link an input file into the linker output file. This function
1379 handles all the sections and relocations of the input file at once. */
1382 _bfd_coff_link_input_bfd (struct coff_final_link_info
*flaginfo
, bfd
*input_bfd
)
1384 unsigned int n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
1385 unsigned int n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
1386 bfd_boolean (*adjust_symndx
)
1387 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*,
1388 struct internal_reloc
*, bfd_boolean
*);
1390 const char *strings
;
1391 bfd_size_type syment_base
;
1392 bfd_boolean copy
, hash
;
1393 bfd_size_type isymesz
;
1394 bfd_size_type osymesz
;
1395 bfd_size_type linesz
;
1398 struct internal_syment
*isymp
;
1401 unsigned long output_index
;
1403 struct coff_link_hash_entry
**sym_hash
;
1406 /* Move all the symbols to the output file. */
1408 output_bfd
= flaginfo
->output_bfd
;
1410 syment_base
= obj_raw_syment_count (output_bfd
);
1411 isymesz
= bfd_coff_symesz (input_bfd
);
1412 osymesz
= bfd_coff_symesz (output_bfd
);
1413 linesz
= bfd_coff_linesz (input_bfd
);
1414 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
1417 if (! flaginfo
->info
->keep_memory
)
1420 if (flaginfo
->info
->traditional_format
)
1423 if (! _bfd_coff_get_external_symbols (input_bfd
))
1426 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
1427 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
1428 isymp
= flaginfo
->internal_syms
;
1429 secpp
= flaginfo
->sec_ptrs
;
1430 indexp
= flaginfo
->sym_indices
;
1431 output_index
= syment_base
;
1432 outsym
= flaginfo
->outsyms
;
1434 if (coff_data (output_bfd
)->pe
1435 && ! process_embedded_commands (output_bfd
, flaginfo
->info
, input_bfd
))
1438 /* If we are going to perform relocations and also strip/discard some
1439 symbols then we must make sure that we do not strip/discard those
1440 symbols that are going to be involved in the relocations. */
1441 if (( flaginfo
->info
->strip
!= strip_none
1442 || flaginfo
->info
->discard
!= discard_none
)
1443 && bfd_link_relocatable (flaginfo
->info
))
1445 /* Mark the symbol array as 'not-used'. */
1446 memset (indexp
, 0, obj_raw_syment_count (input_bfd
) * sizeof * indexp
);
1448 mark_relocs (flaginfo
, input_bfd
);
1451 while (esym
< esym_end
)
1453 struct internal_syment isym
;
1454 enum coff_symbol_classification classification
;
1457 bfd_boolean dont_skip_symbol
;
1460 bfd_coff_swap_sym_in (input_bfd
, esym
, isymp
);
1462 /* Make a copy of *isymp so that the relocate_section function
1463 always sees the original values. This is more reliable than
1464 always recomputing the symbol value even if we are stripping
1468 classification
= bfd_coff_classify_symbol (input_bfd
, &isym
);
1469 switch (classification
)
1473 case COFF_SYMBOL_GLOBAL
:
1474 case COFF_SYMBOL_PE_SECTION
:
1475 case COFF_SYMBOL_LOCAL
:
1476 *secpp
= coff_section_from_bfd_index (input_bfd
, isym
.n_scnum
);
1478 case COFF_SYMBOL_COMMON
:
1479 *secpp
= bfd_com_section_ptr
;
1481 case COFF_SYMBOL_UNDEFINED
:
1482 *secpp
= bfd_und_section_ptr
;
1486 /* Extract the flag indicating if this symbol is used by a
1488 if ((flaginfo
->info
->strip
!= strip_none
1489 || flaginfo
->info
->discard
!= discard_none
)
1490 && bfd_link_relocatable (flaginfo
->info
))
1491 dont_skip_symbol
= *indexp
;
1493 dont_skip_symbol
= FALSE
;
1499 add
= 1 + isym
.n_numaux
;
1501 /* If we are stripping all symbols, we want to skip this one. */
1502 if (flaginfo
->info
->strip
== strip_all
&& ! dont_skip_symbol
)
1507 switch (classification
)
1511 case COFF_SYMBOL_GLOBAL
:
1512 case COFF_SYMBOL_COMMON
:
1513 case COFF_SYMBOL_PE_SECTION
:
1514 /* This is a global symbol. Global symbols come at the
1515 end of the symbol table, so skip them for now.
1516 Locally defined function symbols, however, are an
1517 exception, and are not moved to the end. */
1519 if (! ISFCN (isym
.n_type
))
1523 case COFF_SYMBOL_UNDEFINED
:
1524 /* Undefined symbols are left for the end. */
1529 case COFF_SYMBOL_LOCAL
:
1530 /* This is a local symbol. Skip it if we are discarding
1532 if (flaginfo
->info
->discard
== discard_all
&& ! dont_skip_symbol
)
1538 #ifndef COFF_WITH_PE
1539 /* Skip section symbols for sections which are not going to be
1542 && !dont_skip_symbol
1543 && isym
.n_sclass
== C_STAT
1544 && isym
.n_type
== T_NULL
1545 && isym
.n_numaux
> 0
1546 && ((*secpp
)->output_section
== bfd_abs_section_ptr
1547 || bfd_section_removed_from_list (output_bfd
,
1548 (*secpp
)->output_section
)))
1552 /* If we stripping debugging symbols, and this is a debugging
1553 symbol, then skip it. FIXME: gas sets the section to N_ABS
1554 for some types of debugging symbols; I don't know if this is
1555 a bug or not. In any case, we handle it here. */
1557 && flaginfo
->info
->strip
== strip_debugger
1558 && ! dont_skip_symbol
1559 && (isym
.n_scnum
== N_DEBUG
1560 || (isym
.n_scnum
== N_ABS
1561 && (isym
.n_sclass
== C_AUTO
1562 || isym
.n_sclass
== C_REG
1563 || isym
.n_sclass
== C_MOS
1564 || isym
.n_sclass
== C_MOE
1565 || isym
.n_sclass
== C_MOU
1566 || isym
.n_sclass
== C_ARG
1567 || isym
.n_sclass
== C_REGPARM
1568 || isym
.n_sclass
== C_FIELD
1569 || isym
.n_sclass
== C_EOS
))))
1572 /* If some symbols are stripped based on the name, work out the
1573 name and decide whether to skip this symbol. */
1575 && (flaginfo
->info
->strip
== strip_some
1576 || flaginfo
->info
->discard
== discard_l
))
1579 char buf
[SYMNMLEN
+ 1];
1581 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
1585 if (! dont_skip_symbol
1586 && ((flaginfo
->info
->strip
== strip_some
1587 && (bfd_hash_lookup (flaginfo
->info
->keep_hash
, name
, FALSE
,
1590 && flaginfo
->info
->discard
== discard_l
1591 && bfd_is_local_label_name (input_bfd
, name
))))
1595 /* If this is an enum, struct, or union tag, see if we have
1596 already output an identical type. */
1598 && !flaginfo
->info
->traditional_format
1599 && (isym
.n_sclass
== C_ENTAG
1600 || isym
.n_sclass
== C_STRTAG
1601 || isym
.n_sclass
== C_UNTAG
)
1602 && isym
.n_numaux
== 1)
1605 char buf
[SYMNMLEN
+ 1];
1606 struct coff_debug_merge_hash_entry
*mh
;
1607 struct coff_debug_merge_type
*mt
;
1608 union internal_auxent aux
;
1609 struct coff_debug_merge_element
**epp
;
1610 bfd_byte
*esl
, *eslend
;
1611 struct internal_syment
*islp
;
1614 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
1618 /* Ignore fake names invented by compiler; treat them all as
1620 if (*name
== '~' || *name
== '.' || *name
== '$'
1621 || (*name
== bfd_get_symbol_leading_char (input_bfd
)
1622 && (name
[1] == '~' || name
[1] == '.' || name
[1] == '$')))
1625 mh
= coff_debug_merge_hash_lookup (&flaginfo
->debug_merge
, name
,
1630 /* Allocate memory to hold type information. If this turns
1631 out to be a duplicate, we pass this address to
1633 amt
= sizeof (struct coff_debug_merge_type
);
1634 mt
= (struct coff_debug_merge_type
*) bfd_alloc (input_bfd
, amt
);
1637 mt
->type_class
= isym
.n_sclass
;
1639 /* Pick up the aux entry, which points to the end of the tag
1641 bfd_coff_swap_aux_in (input_bfd
, (esym
+ isymesz
),
1642 isym
.n_type
, isym
.n_sclass
, 0, isym
.n_numaux
,
1645 /* Gather the elements. */
1646 epp
= &mt
->elements
;
1647 mt
->elements
= NULL
;
1649 esl
= esym
+ 2 * isymesz
;
1650 eslend
= ((bfd_byte
*) obj_coff_external_syms (input_bfd
)
1651 + aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
* isymesz
);
1652 while (esl
< eslend
)
1654 const char *elename
;
1655 char elebuf
[SYMNMLEN
+ 1];
1658 bfd_coff_swap_sym_in (input_bfd
, esl
, islp
);
1660 amt
= sizeof (struct coff_debug_merge_element
);
1661 *epp
= (struct coff_debug_merge_element
*)
1662 bfd_alloc (input_bfd
, amt
);
1666 elename
= _bfd_coff_internal_syment_name (input_bfd
, islp
,
1668 if (elename
== NULL
)
1671 amt
= strlen (elename
) + 1;
1672 name_copy
= (char *) bfd_alloc (input_bfd
, amt
);
1673 if (name_copy
== NULL
)
1675 strcpy (name_copy
, elename
);
1677 (*epp
)->name
= name_copy
;
1678 (*epp
)->type
= islp
->n_type
;
1680 if (islp
->n_numaux
>= 1
1681 && islp
->n_type
!= T_NULL
1682 && islp
->n_sclass
!= C_EOS
)
1684 union internal_auxent eleaux
;
1687 bfd_coff_swap_aux_in (input_bfd
, (esl
+ isymesz
),
1688 islp
->n_type
, islp
->n_sclass
, 0,
1689 islp
->n_numaux
, &eleaux
);
1690 indx
= eleaux
.x_sym
.x_tagndx
.l
;
1692 /* FIXME: If this tagndx entry refers to a symbol
1693 defined later in this file, we just ignore it.
1694 Handling this correctly would be tedious, and may
1699 (bfd_byte
*) obj_coff_external_syms (input_bfd
))
1702 (*epp
)->tagndx
= flaginfo
->sym_indices
[indx
];
1703 if ((*epp
)->tagndx
< 0)
1707 epp
= &(*epp
)->next
;
1710 esl
+= (islp
->n_numaux
+ 1) * isymesz
;
1711 islp
+= islp
->n_numaux
+ 1;
1714 /* See if we already have a definition which matches this
1715 type. We always output the type if it has no elements,
1717 if (mt
->elements
== NULL
)
1718 bfd_release (input_bfd
, mt
);
1721 struct coff_debug_merge_type
*mtl
;
1723 for (mtl
= mh
->types
; mtl
!= NULL
; mtl
= mtl
->next
)
1725 struct coff_debug_merge_element
*me
, *mel
;
1727 if (mtl
->type_class
!= mt
->type_class
)
1730 for (me
= mt
->elements
, mel
= mtl
->elements
;
1731 me
!= NULL
&& mel
!= NULL
;
1732 me
= me
->next
, mel
= mel
->next
)
1734 if (strcmp (me
->name
, mel
->name
) != 0
1735 || me
->type
!= mel
->type
1736 || me
->tagndx
!= mel
->tagndx
)
1740 if (me
== NULL
&& mel
== NULL
)
1744 if (mtl
== NULL
|| (bfd_size_type
) mtl
->indx
>= syment_base
)
1746 /* This is the first definition of this type. */
1747 mt
->indx
= output_index
;
1748 mt
->next
= mh
->types
;
1753 /* This is a redefinition which can be merged. */
1754 bfd_release (input_bfd
, mt
);
1755 *indexp
= mtl
->indx
;
1756 add
= (eslend
- esym
) / isymesz
;
1762 /* We now know whether we are to skip this symbol or not. */
1765 /* Adjust the symbol in order to output it. */
1767 if (isym
._n
._n_n
._n_zeroes
== 0
1768 && isym
._n
._n_n
._n_offset
!= 0)
1773 /* This symbol has a long name. Enter it in the string
1774 table we are building. Note that we do not check
1775 bfd_coff_symname_in_debug. That is only true for
1776 XCOFF, and XCOFF requires different linking code
1778 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, NULL
);
1781 indx
= _bfd_stringtab_add (flaginfo
->strtab
, name
, hash
, copy
);
1782 if (indx
== (bfd_size_type
) -1)
1784 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
1787 switch (isym
.n_sclass
)
1803 /* The symbol value should not be modified. */
1807 if (obj_pe (input_bfd
)
1808 && memcmp (isym
.n_name
, ".bf", sizeof ".bf") != 0
1809 && isym
.n_scnum
> 0)
1811 /* For PE, .lf and .ef get their value left alone,
1812 while .bf gets relocated. However, they all have
1813 "real" section numbers, and need to be moved into
1815 isym
.n_scnum
= (*secpp
)->output_section
->target_index
;
1820 case C_LABEL
: /* Not completely sure about these 2 */
1829 /* Compute new symbol location. */
1830 if (isym
.n_scnum
> 0)
1832 isym
.n_scnum
= (*secpp
)->output_section
->target_index
;
1833 isym
.n_value
+= (*secpp
)->output_offset
;
1834 if (! obj_pe (input_bfd
))
1835 isym
.n_value
-= (*secpp
)->vma
;
1836 if (! obj_pe (flaginfo
->output_bfd
))
1837 isym
.n_value
+= (*secpp
)->output_section
->vma
;
1842 /* The value of a C_FILE symbol is the symbol index of
1843 the next C_FILE symbol. The value of the last C_FILE
1844 symbol is the symbol index to the first external
1845 symbol (actually, coff_renumber_symbols does not get
1846 this right--it just sets the value of the last C_FILE
1847 symbol to zero--and nobody has ever complained about
1848 it). We try to get this right, below, just before we
1849 write the symbols out, but in the general case we may
1850 have to write the symbol out twice. */
1851 if (flaginfo
->last_file_index
!= -1
1852 && flaginfo
->last_file
.n_value
!= (bfd_vma
) output_index
)
1854 /* We must correct the value of the last C_FILE
1856 flaginfo
->last_file
.n_value
= output_index
;
1857 if ((bfd_size_type
) flaginfo
->last_file_index
>= syment_base
)
1859 /* The last C_FILE symbol is in this input file. */
1860 bfd_coff_swap_sym_out (output_bfd
,
1861 &flaginfo
->last_file
,
1863 + ((flaginfo
->last_file_index
1871 /* We have already written out the last C_FILE
1872 symbol. We need to write it out again. We
1873 borrow *outsym temporarily. */
1874 bfd_coff_swap_sym_out (output_bfd
,
1875 &flaginfo
->last_file
, outsym
);
1876 pos
= obj_sym_filepos (output_bfd
);
1877 pos
+= flaginfo
->last_file_index
* osymesz
;
1878 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
1879 || bfd_bwrite (outsym
, osymesz
, output_bfd
) != osymesz
)
1884 flaginfo
->last_file_index
= output_index
;
1885 flaginfo
->last_file
= isym
;
1889 /* If doing task linking, convert normal global function symbols to
1890 static functions. */
1891 if (flaginfo
->info
->task_link
&& IS_EXTERNAL (input_bfd
, isym
))
1892 isym
.n_sclass
= C_STAT
;
1894 /* Output the symbol. */
1895 bfd_coff_swap_sym_out (output_bfd
, &isym
, outsym
);
1897 *indexp
= output_index
;
1902 struct coff_link_hash_entry
*h
;
1904 indx
= ((esym
- (bfd_byte
*) obj_coff_external_syms (input_bfd
))
1906 h
= obj_coff_sym_hashes (input_bfd
)[indx
];
1909 /* This can happen if there were errors earlier in
1911 bfd_set_error (bfd_error_bad_value
);
1914 h
->indx
= output_index
;
1917 output_index
+= add
;
1918 outsym
+= add
* osymesz
;
1921 esym
+= add
* isymesz
;
1925 for (--add
; add
> 0; --add
)
1932 /* Fix up the aux entries. This must be done in a separate pass,
1933 because we don't know the correct symbol indices until we have
1934 already decided which symbols we are going to keep. */
1935 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
1936 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
1937 isymp
= flaginfo
->internal_syms
;
1938 indexp
= flaginfo
->sym_indices
;
1939 sym_hash
= obj_coff_sym_hashes (input_bfd
);
1940 outsym
= flaginfo
->outsyms
;
1942 while (esym
< esym_end
)
1946 add
= 1 + isymp
->n_numaux
;
1949 || (bfd_size_type
) *indexp
< syment_base
)
1950 && (*sym_hash
== NULL
1951 || (*sym_hash
)->auxbfd
!= input_bfd
))
1952 esym
+= add
* isymesz
;
1955 struct coff_link_hash_entry
*h
;
1963 /* The m68k-motorola-sysv assembler will sometimes
1964 generate two symbols with the same name, but only one
1965 will have aux entries. */
1966 BFD_ASSERT (isymp
->n_numaux
== 0
1968 || h
->numaux
== isymp
->n_numaux
);
1976 /* Handle the aux entries. This handling is based on
1977 coff_pointerize_aux. I don't know if it always correct. */
1978 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
1980 union internal_auxent aux
;
1981 union internal_auxent
*auxp
;
1983 if (h
!= NULL
&& h
->aux
!= NULL
&& (h
->numaux
> i
))
1987 bfd_coff_swap_aux_in (input_bfd
, esym
, isymp
->n_type
,
1988 isymp
->n_sclass
, i
, isymp
->n_numaux
, &aux
);
1992 if (isymp
->n_sclass
== C_FILE
)
1994 /* If this is a long filename, we must put it in the
1996 if (auxp
->x_file
.x_n
.x_zeroes
== 0
1997 && auxp
->x_file
.x_n
.x_offset
!= 0)
1999 const char *filename
;
2002 BFD_ASSERT (auxp
->x_file
.x_n
.x_offset
2003 >= STRING_SIZE_SIZE
);
2004 if (strings
== NULL
)
2006 strings
= _bfd_coff_read_string_table (input_bfd
);
2007 if (strings
== NULL
)
2010 if ((bfd_size_type
) auxp
->x_file
.x_n
.x_offset
>= obj_coff_strings_len (input_bfd
))
2011 filename
= _("<corrupt>");
2013 filename
= strings
+ auxp
->x_file
.x_n
.x_offset
;
2014 indx
= _bfd_stringtab_add (flaginfo
->strtab
, filename
,
2016 if (indx
== (bfd_size_type
) -1)
2018 auxp
->x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
2021 else if ((isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
2022 && isymp
->n_sclass
!= C_NT_WEAK
)
2026 if (ISFCN (isymp
->n_type
)
2027 || ISTAG (isymp
->n_sclass
)
2028 || isymp
->n_sclass
== C_BLOCK
2029 || isymp
->n_sclass
== C_FCN
)
2031 indx
= auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2033 && indx
< obj_raw_syment_count (input_bfd
))
2035 /* We look forward through the symbol for
2036 the index of the next symbol we are going
2037 to include. I don't know if this is
2039 while ((flaginfo
->sym_indices
[indx
] < 0
2040 || ((bfd_size_type
) flaginfo
->sym_indices
[indx
]
2042 && indx
< obj_raw_syment_count (input_bfd
))
2044 if (indx
>= obj_raw_syment_count (input_bfd
))
2045 indx
= output_index
;
2047 indx
= flaginfo
->sym_indices
[indx
];
2048 auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
2052 indx
= auxp
->x_sym
.x_tagndx
.l
;
2053 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
2057 symindx
= flaginfo
->sym_indices
[indx
];
2059 auxp
->x_sym
.x_tagndx
.l
= 0;
2061 auxp
->x_sym
.x_tagndx
.l
= symindx
;
2064 /* The .bf symbols are supposed to be linked through
2065 the endndx field. We need to carry this list
2066 across object files. */
2069 && isymp
->n_sclass
== C_FCN
2070 && (isymp
->_n
._n_n
._n_zeroes
!= 0
2071 || isymp
->_n
._n_n
._n_offset
== 0)
2072 && isymp
->_n
._n_name
[0] == '.'
2073 && isymp
->_n
._n_name
[1] == 'b'
2074 && isymp
->_n
._n_name
[2] == 'f'
2075 && isymp
->_n
._n_name
[3] == '\0')
2077 if (flaginfo
->last_bf_index
!= -1)
2079 flaginfo
->last_bf
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
2082 if ((bfd_size_type
) flaginfo
->last_bf_index
2087 /* The last .bf symbol is in this input
2088 file. This will only happen if the
2089 assembler did not set up the .bf
2090 endndx symbols correctly. */
2091 auxout
= (flaginfo
->outsyms
2092 + ((flaginfo
->last_bf_index
2096 bfd_coff_swap_aux_out (output_bfd
,
2107 /* We have already written out the last
2108 .bf aux entry. We need to write it
2109 out again. We borrow *outsym
2110 temporarily. FIXME: This case should
2112 bfd_coff_swap_aux_out (output_bfd
,
2118 pos
= obj_sym_filepos (output_bfd
);
2119 pos
+= flaginfo
->last_bf_index
* osymesz
;
2120 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
2121 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
2127 if (auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
!= 0)
2128 flaginfo
->last_bf_index
= -1;
2131 /* The endndx field of this aux entry must
2132 be updated with the symbol number of the
2134 flaginfo
->last_bf
= *auxp
;
2135 flaginfo
->last_bf_index
= (((outsym
- flaginfo
->outsyms
)
2144 bfd_coff_swap_aux_out (output_bfd
, auxp
, isymp
->n_type
,
2145 isymp
->n_sclass
, i
, isymp
->n_numaux
,
2159 /* Relocate the line numbers, unless we are stripping them. */
2160 if (flaginfo
->info
->strip
== strip_none
2161 || flaginfo
->info
->strip
== strip_some
)
2163 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2169 bfd_boolean skipping
;
2173 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2174 build_link_order in ldwrite.c will not have created a
2175 link order, which means that we will not have seen this
2176 input section in _bfd_coff_final_link, which means that
2177 we will not have allocated space for the line numbers of
2178 this section. I don't think line numbers can be
2179 meaningful for a section which does not have
2180 SEC_HAS_CONTENTS set, but, if they do, this must be
2182 if (o
->lineno_count
== 0
2183 || (o
->output_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2186 if (bfd_seek (input_bfd
, o
->line_filepos
, SEEK_SET
) != 0
2187 || bfd_bread (flaginfo
->linenos
, linesz
* o
->lineno_count
,
2188 input_bfd
) != linesz
* o
->lineno_count
)
2191 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
2192 eline
= flaginfo
->linenos
;
2193 oeline
= flaginfo
->linenos
;
2194 elineend
= eline
+ linesz
* o
->lineno_count
;
2196 for (; eline
< elineend
; eline
+= linesz
)
2198 struct internal_lineno iline
;
2200 bfd_coff_swap_lineno_in (input_bfd
, eline
, &iline
);
2202 if (iline
.l_lnno
!= 0)
2203 iline
.l_addr
.l_paddr
+= offset
;
2204 else if (iline
.l_addr
.l_symndx
>= 0
2205 && ((unsigned long) iline
.l_addr
.l_symndx
2206 < obj_raw_syment_count (input_bfd
)))
2210 indx
= flaginfo
->sym_indices
[iline
.l_addr
.l_symndx
];
2214 /* These line numbers are attached to a symbol
2215 which we are stripping. We must discard the
2216 line numbers because reading them back with
2217 no associated symbol (or associating them all
2218 with symbol #0) will fail. We can't regain
2219 the space in the output file, but at least
2225 struct internal_syment is
;
2226 union internal_auxent ia
;
2228 /* Fix up the lnnoptr field in the aux entry of
2229 the symbol. It turns out that we can't do
2230 this when we modify the symbol aux entries,
2231 because gas sometimes screws up the lnnoptr
2232 field and makes it an offset from the start
2233 of the line numbers rather than an absolute
2235 bfd_coff_swap_sym_in (output_bfd
,
2237 + ((indx
- syment_base
)
2239 if ((ISFCN (is
.n_type
)
2240 || is
.n_sclass
== C_BLOCK
)
2241 && is
.n_numaux
>= 1)
2245 auxptr
= (flaginfo
->outsyms
2246 + ((indx
- syment_base
+ 1)
2248 bfd_coff_swap_aux_in (output_bfd
, auxptr
,
2249 is
.n_type
, is
.n_sclass
,
2250 0, is
.n_numaux
, &ia
);
2251 ia
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
2252 (o
->output_section
->line_filepos
2253 + o
->output_section
->lineno_count
* linesz
2254 + eline
- flaginfo
->linenos
);
2255 bfd_coff_swap_aux_out (output_bfd
, &ia
,
2256 is
.n_type
, is
.n_sclass
, 0,
2257 is
.n_numaux
, auxptr
);
2263 iline
.l_addr
.l_symndx
= indx
;
2268 bfd_coff_swap_lineno_out (output_bfd
, &iline
, oeline
);
2273 pos
= o
->output_section
->line_filepos
;
2274 pos
+= o
->output_section
->lineno_count
* linesz
;
2275 amt
= oeline
- flaginfo
->linenos
;
2276 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
2277 || bfd_bwrite (flaginfo
->linenos
, amt
, output_bfd
) != amt
)
2280 o
->output_section
->lineno_count
+= amt
/ linesz
;
2284 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2285 symbol will be the first symbol in the next input file. In the
2286 normal case, this will save us from writing out the C_FILE symbol
2288 if (flaginfo
->last_file_index
!= -1
2289 && (bfd_size_type
) flaginfo
->last_file_index
>= syment_base
)
2291 flaginfo
->last_file
.n_value
= output_index
;
2292 bfd_coff_swap_sym_out (output_bfd
, &flaginfo
->last_file
,
2294 + ((flaginfo
->last_file_index
- syment_base
)
2298 /* Write the modified symbols to the output file. */
2299 if (outsym
> flaginfo
->outsyms
)
2304 pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
2305 amt
= outsym
- flaginfo
->outsyms
;
2306 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
2307 || bfd_bwrite (flaginfo
->outsyms
, amt
, output_bfd
) != amt
)
2310 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
2311 + (outsym
- flaginfo
->outsyms
) / osymesz
)
2314 obj_raw_syment_count (output_bfd
) = output_index
;
2317 /* Relocate the contents of each section. */
2318 adjust_symndx
= coff_backend_info (input_bfd
)->_bfd_coff_adjust_symndx
;
2319 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2322 struct coff_section_tdata
*secdata
;
2324 if (! o
->linker_mark
)
2325 /* This section was omitted from the link. */
2328 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
2331 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2332 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
2334 if ((o
->flags
& SEC_RELOC
) != 0
2335 && o
->reloc_count
!= 0)
2338 /* xgettext: c-format */
2339 (_("%pB: relocs in section `%pA', but it has no contents"),
2341 bfd_set_error (bfd_error_no_contents
);
2348 secdata
= coff_section_data (input_bfd
, o
);
2349 if (secdata
!= NULL
&& secdata
->contents
!= NULL
)
2350 contents
= secdata
->contents
;
2353 contents
= flaginfo
->contents
;
2354 if (! bfd_get_full_section_contents (input_bfd
, o
, &contents
))
2358 if ((o
->flags
& SEC_RELOC
) != 0)
2361 struct internal_reloc
*internal_relocs
;
2362 struct internal_reloc
*irel
;
2364 /* Read in the relocs. */
2365 target_index
= o
->output_section
->target_index
;
2366 internal_relocs
= (_bfd_coff_read_internal_relocs
2367 (input_bfd
, o
, FALSE
, flaginfo
->external_relocs
,
2368 bfd_link_relocatable (flaginfo
->info
),
2369 (bfd_link_relocatable (flaginfo
->info
)
2370 ? (flaginfo
->section_info
[target_index
].relocs
2371 + o
->output_section
->reloc_count
)
2372 : flaginfo
->internal_relocs
)));
2373 if (internal_relocs
== NULL
2374 && o
->reloc_count
> 0)
2377 /* Run through the relocs looking for relocs against symbols
2378 coming from discarded sections and complain about them. */
2379 irel
= internal_relocs
;
2380 for (; irel
< &internal_relocs
[o
->reloc_count
]; irel
++)
2382 struct coff_link_hash_entry
*h
;
2383 asection
*ps
= NULL
;
2384 long symndx
= irel
->r_symndx
;
2387 h
= obj_coff_sym_hashes (input_bfd
)[symndx
];
2390 while (h
->root
.type
== bfd_link_hash_indirect
2391 || h
->root
.type
== bfd_link_hash_warning
)
2392 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2393 if (h
->root
.type
== bfd_link_hash_defined
2394 || h
->root
.type
== bfd_link_hash_defweak
)
2395 ps
= h
->root
.u
.def
.section
;
2398 /* Complain if definition comes from an excluded section. */
2399 if (ps
->flags
& SEC_EXCLUDE
)
2400 (*flaginfo
->info
->callbacks
->einfo
)
2401 /* xgettext: c-format */
2402 (_("%X`%s' referenced in section `%pA' of %pB: "
2403 "defined in discarded section `%pA' of %pB\n"),
2404 h
->root
.root
.string
, o
, input_bfd
, ps
, ps
->owner
);
2407 /* Call processor specific code to relocate the section
2409 if (! bfd_coff_relocate_section (output_bfd
, flaginfo
->info
,
2413 flaginfo
->internal_syms
,
2414 flaginfo
->sec_ptrs
))
2417 if (bfd_link_relocatable (flaginfo
->info
))
2420 struct internal_reloc
*irelend
;
2421 struct coff_link_hash_entry
**rel_hash
;
2423 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
2424 irel
= internal_relocs
;
2425 irelend
= irel
+ o
->reloc_count
;
2426 rel_hash
= (flaginfo
->section_info
[target_index
].rel_hashes
2427 + o
->output_section
->reloc_count
);
2428 for (; irel
< irelend
; irel
++, rel_hash
++)
2430 struct coff_link_hash_entry
*h
;
2431 bfd_boolean adjusted
;
2435 /* Adjust the reloc address and symbol index. */
2436 irel
->r_vaddr
+= offset
;
2438 if (irel
->r_symndx
== -1)
2443 if (! (*adjust_symndx
) (output_bfd
, flaginfo
->info
,
2451 h
= obj_coff_sym_hashes (input_bfd
)[irel
->r_symndx
];
2454 /* This is a global symbol. */
2456 irel
->r_symndx
= h
->indx
;
2459 /* This symbol is being written at the end
2460 of the file, and we do not yet know the
2461 symbol index. We save the pointer to the
2462 hash table entry in the rel_hash list.
2463 We set the indx field to -2 to indicate
2464 that this symbol must not be stripped. */
2473 indx
= flaginfo
->sym_indices
[irel
->r_symndx
];
2475 irel
->r_symndx
= indx
;
2478 struct internal_syment
*is
;
2480 char buf
[SYMNMLEN
+ 1];
2482 /* This reloc is against a symbol we are
2483 stripping. This should have been handled
2484 by the 'dont_skip_symbol' code in the while
2485 loop at the top of this function. */
2486 is
= flaginfo
->internal_syms
+ irel
->r_symndx
;
2488 name
= (_bfd_coff_internal_syment_name
2489 (input_bfd
, is
, buf
));
2493 (*flaginfo
->info
->callbacks
->unattached_reloc
)
2494 (flaginfo
->info
, name
, input_bfd
, o
, irel
->r_vaddr
);
2499 o
->output_section
->reloc_count
+= o
->reloc_count
;
2503 /* Write out the modified section contents. */
2504 if (secdata
== NULL
|| secdata
->stab_info
== NULL
)
2506 file_ptr loc
= (o
->output_offset
2507 * bfd_octets_per_byte (output_bfd
, o
));
2508 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2509 contents
, loc
, o
->size
))
2514 if (! (_bfd_write_section_stabs
2515 (output_bfd
, &coff_hash_table (flaginfo
->info
)->stab_info
,
2516 o
, &secdata
->stab_info
, contents
)))
2521 if (! flaginfo
->info
->keep_memory
2522 && ! _bfd_coff_free_symbols (input_bfd
))
2528 /* Write out a global symbol. Called via bfd_hash_traverse. */
2531 _bfd_coff_write_global_sym (struct bfd_hash_entry
*bh
, void *data
)
2533 struct coff_link_hash_entry
*h
= (struct coff_link_hash_entry
*) bh
;
2534 struct coff_final_link_info
*flaginfo
= (struct coff_final_link_info
*) data
;
2536 struct internal_syment isym
;
2537 bfd_size_type symesz
;
2541 output_bfd
= flaginfo
->output_bfd
;
2543 if (h
->root
.type
== bfd_link_hash_warning
)
2545 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2546 if (h
->root
.type
== bfd_link_hash_new
)
2554 && (flaginfo
->info
->strip
== strip_all
2555 || (flaginfo
->info
->strip
== strip_some
2556 && (bfd_hash_lookup (flaginfo
->info
->keep_hash
,
2557 h
->root
.root
.string
, FALSE
, FALSE
)
2561 switch (h
->root
.type
)
2564 case bfd_link_hash_new
:
2565 case bfd_link_hash_warning
:
2569 case bfd_link_hash_undefined
:
2570 case bfd_link_hash_undefweak
:
2571 isym
.n_scnum
= N_UNDEF
;
2575 case bfd_link_hash_defined
:
2576 case bfd_link_hash_defweak
:
2580 sec
= h
->root
.u
.def
.section
->output_section
;
2581 if (bfd_is_abs_section (sec
))
2582 isym
.n_scnum
= N_ABS
;
2584 isym
.n_scnum
= sec
->target_index
;
2585 isym
.n_value
= (h
->root
.u
.def
.value
2586 + h
->root
.u
.def
.section
->output_offset
);
2587 if (! obj_pe (flaginfo
->output_bfd
))
2588 isym
.n_value
+= sec
->vma
;
2592 case bfd_link_hash_common
:
2593 isym
.n_scnum
= N_UNDEF
;
2594 isym
.n_value
= h
->root
.u
.c
.size
;
2597 case bfd_link_hash_indirect
:
2598 /* Just ignore these. They can't be handled anyhow. */
2602 if (strlen (h
->root
.root
.string
) <= SYMNMLEN
)
2603 strncpy (isym
._n
._n_name
, h
->root
.root
.string
, SYMNMLEN
);
2610 if (flaginfo
->info
->traditional_format
)
2612 indx
= _bfd_stringtab_add (flaginfo
->strtab
, h
->root
.root
.string
, hash
,
2614 if (indx
== (bfd_size_type
) -1)
2616 flaginfo
->failed
= TRUE
;
2619 isym
._n
._n_n
._n_zeroes
= 0;
2620 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
2623 isym
.n_sclass
= h
->symbol_class
;
2624 isym
.n_type
= h
->type
;
2626 if (isym
.n_sclass
== C_NULL
)
2627 isym
.n_sclass
= C_EXT
;
2629 /* If doing task linking and this is the pass where we convert
2630 defined globals to statics, then do that conversion now. If the
2631 symbol is not being converted, just ignore it and it will be
2632 output during a later pass. */
2633 if (flaginfo
->global_to_static
)
2635 if (! IS_EXTERNAL (output_bfd
, isym
))
2638 isym
.n_sclass
= C_STAT
;
2641 /* When a weak symbol is not overridden by a strong one,
2642 turn it into an external symbol when not building a
2643 shared or relocatable object. */
2644 if (! bfd_link_pic (flaginfo
->info
)
2645 && ! bfd_link_relocatable (flaginfo
->info
)
2646 && IS_WEAK_EXTERNAL (flaginfo
->output_bfd
, isym
))
2647 isym
.n_sclass
= C_EXT
;
2649 isym
.n_numaux
= h
->numaux
;
2651 bfd_coff_swap_sym_out (output_bfd
, &isym
, flaginfo
->outsyms
);
2653 symesz
= bfd_coff_symesz (output_bfd
);
2655 pos
= obj_sym_filepos (output_bfd
);
2656 pos
+= obj_raw_syment_count (output_bfd
) * symesz
;
2657 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
2658 || bfd_bwrite (flaginfo
->outsyms
, symesz
, output_bfd
) != symesz
)
2660 flaginfo
->failed
= TRUE
;
2664 h
->indx
= obj_raw_syment_count (output_bfd
);
2666 ++obj_raw_syment_count (output_bfd
);
2668 /* Write out any associated aux entries. Most of the aux entries
2669 will have been modified in _bfd_coff_link_input_bfd. We have to
2670 handle section aux entries here, now that we have the final
2671 relocation and line number counts. */
2672 for (i
= 0; i
< isym
.n_numaux
; i
++)
2674 union internal_auxent
*auxp
;
2678 /* Look for a section aux entry here using the same tests that
2679 coff_swap_aux_out uses. */
2681 && (isym
.n_sclass
== C_STAT
2682 || isym
.n_sclass
== C_HIDDEN
)
2683 && isym
.n_type
== T_NULL
2684 && (h
->root
.type
== bfd_link_hash_defined
2685 || h
->root
.type
== bfd_link_hash_defweak
))
2689 sec
= h
->root
.u
.def
.section
->output_section
;
2692 auxp
->x_scn
.x_scnlen
= sec
->size
;
2694 /* For PE, an overflow on the final link reportedly does
2695 not matter. FIXME: Why not? */
2696 if (sec
->reloc_count
> 0xffff
2697 && (! obj_pe (output_bfd
)
2698 || bfd_link_relocatable (flaginfo
->info
)))
2700 /* xgettext: c-format */
2701 (_("%pB: %pA: reloc overflow: %#x > 0xffff"),
2702 output_bfd
, sec
, sec
->reloc_count
);
2704 if (sec
->lineno_count
> 0xffff
2705 && (! obj_pe (output_bfd
)
2706 || bfd_link_relocatable (flaginfo
->info
)))
2708 /* xgettext: c-format */
2709 (_("%pB: warning: %pA: line number overflow: %#x > 0xffff"),
2710 output_bfd
, sec
, sec
->lineno_count
);
2712 auxp
->x_scn
.x_nreloc
= sec
->reloc_count
;
2713 auxp
->x_scn
.x_nlinno
= sec
->lineno_count
;
2714 auxp
->x_scn
.x_checksum
= 0;
2715 auxp
->x_scn
.x_associated
= 0;
2716 auxp
->x_scn
.x_comdat
= 0;
2720 bfd_coff_swap_aux_out (output_bfd
, auxp
, isym
.n_type
,
2721 isym
.n_sclass
, (int) i
, isym
.n_numaux
,
2723 if (bfd_bwrite (flaginfo
->outsyms
, symesz
, output_bfd
) != symesz
)
2725 flaginfo
->failed
= TRUE
;
2728 ++obj_raw_syment_count (output_bfd
);
2734 /* Write out task global symbols, converting them to statics. Called
2735 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2736 the dirty work, if the symbol we are processing needs conversion. */
2739 _bfd_coff_write_task_globals (struct coff_link_hash_entry
*h
, void *data
)
2741 struct coff_final_link_info
*flaginfo
= (struct coff_final_link_info
*) data
;
2742 bfd_boolean rtnval
= TRUE
;
2743 bfd_boolean save_global_to_static
;
2745 if (h
->root
.type
== bfd_link_hash_warning
)
2746 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2750 switch (h
->root
.type
)
2752 case bfd_link_hash_defined
:
2753 case bfd_link_hash_defweak
:
2754 save_global_to_static
= flaginfo
->global_to_static
;
2755 flaginfo
->global_to_static
= TRUE
;
2756 rtnval
= _bfd_coff_write_global_sym (&h
->root
.root
, data
);
2757 flaginfo
->global_to_static
= save_global_to_static
;
2766 /* Handle a link order which is supposed to generate a reloc. */
2769 _bfd_coff_reloc_link_order (bfd
*output_bfd
,
2770 struct coff_final_link_info
*flaginfo
,
2771 asection
*output_section
,
2772 struct bfd_link_order
*link_order
)
2774 reloc_howto_type
*howto
;
2775 struct internal_reloc
*irel
;
2776 struct coff_link_hash_entry
**rel_hash_ptr
;
2778 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
2781 bfd_set_error (bfd_error_bad_value
);
2785 if (link_order
->u
.reloc
.p
->addend
!= 0)
2789 bfd_reloc_status_type rstat
;
2793 size
= bfd_get_reloc_size (howto
);
2794 buf
= (bfd_byte
*) bfd_zmalloc (size
);
2795 if (buf
== NULL
&& size
!= 0)
2798 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
2799 (bfd_vma
) link_order
->u
.reloc
.p
->addend
,
2806 case bfd_reloc_outofrange
:
2808 case bfd_reloc_overflow
:
2809 (*flaginfo
->info
->callbacks
->reloc_overflow
)
2810 (flaginfo
->info
, NULL
,
2811 (link_order
->type
== bfd_section_reloc_link_order
2812 ? bfd_section_name (link_order
->u
.reloc
.p
->u
.section
)
2813 : link_order
->u
.reloc
.p
->u
.name
),
2814 howto
->name
, link_order
->u
.reloc
.p
->addend
,
2815 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0);
2818 loc
= link_order
->offset
* bfd_octets_per_byte (output_bfd
,
2820 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
2827 /* Store the reloc information in the right place. It will get
2828 swapped and written out at the end of the final_link routine. */
2829 irel
= (flaginfo
->section_info
[output_section
->target_index
].relocs
2830 + output_section
->reloc_count
);
2831 rel_hash_ptr
= (flaginfo
->section_info
[output_section
->target_index
].rel_hashes
2832 + output_section
->reloc_count
);
2834 memset (irel
, 0, sizeof (struct internal_reloc
));
2835 *rel_hash_ptr
= NULL
;
2837 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
2839 if (link_order
->type
== bfd_section_reloc_link_order
)
2841 /* We need to somehow locate a symbol in the right section. The
2842 symbol must either have a value of zero, or we must adjust
2843 the addend by the value of the symbol. FIXME: Write this
2844 when we need it. The old linker couldn't handle this anyhow. */
2846 *rel_hash_ptr
= NULL
;
2851 struct coff_link_hash_entry
*h
;
2853 h
= ((struct coff_link_hash_entry
*)
2854 bfd_wrapped_link_hash_lookup (output_bfd
, flaginfo
->info
,
2855 link_order
->u
.reloc
.p
->u
.name
,
2856 FALSE
, FALSE
, TRUE
));
2860 irel
->r_symndx
= h
->indx
;
2863 /* Set the index to -2 to force this symbol to get
2872 (*flaginfo
->info
->callbacks
->unattached_reloc
)
2873 (flaginfo
->info
, link_order
->u
.reloc
.p
->u
.name
,
2874 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0);
2879 /* FIXME: Is this always right? */
2880 irel
->r_type
= howto
->type
;
2882 /* r_size is only used on the RS/6000, which needs its own linker
2883 routines anyhow. r_extern is only used for ECOFF. */
2885 /* FIXME: What is the right value for r_offset? Is zero OK? */
2886 ++output_section
->reloc_count
;
2891 /* A basic reloc handling routine which may be used by processors with
2895 _bfd_coff_generic_relocate_section (bfd
*output_bfd
,
2896 struct bfd_link_info
*info
,
2898 asection
*input_section
,
2900 struct internal_reloc
*relocs
,
2901 struct internal_syment
*syms
,
2902 asection
**sections
)
2904 struct internal_reloc
*rel
;
2905 struct internal_reloc
*relend
;
2908 relend
= rel
+ input_section
->reloc_count
;
2909 for (; rel
< relend
; rel
++)
2912 struct coff_link_hash_entry
*h
;
2913 struct internal_syment
*sym
;
2917 reloc_howto_type
*howto
;
2918 bfd_reloc_status_type rstat
;
2920 symndx
= rel
->r_symndx
;
2928 || (unsigned long) symndx
>= obj_raw_syment_count (input_bfd
))
2931 /* xgettext: c-format */
2932 (_("%pB: illegal symbol index %ld in relocs"), input_bfd
, symndx
);
2937 h
= obj_coff_sym_hashes (input_bfd
)[symndx
];
2938 sym
= syms
+ symndx
;
2941 /* COFF treats common symbols in one of two ways. Either the
2942 size of the symbol is included in the section contents, or it
2943 is not. We assume that the size is not included, and force
2944 the rtype_to_howto function to adjust the addend as needed. */
2945 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
2946 addend
= - sym
->n_value
;
2950 howto
= bfd_coff_rtype_to_howto (input_bfd
, input_section
, rel
, h
,
2955 /* If we are doing a relocatable link, then we can just ignore
2956 a PC relative reloc that is pcrel_offset. It will already
2957 have the correct value. If this is not a relocatable link,
2958 then we should ignore the symbol value. */
2959 if (howto
->pc_relative
&& howto
->pcrel_offset
)
2961 if (bfd_link_relocatable (info
))
2963 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
2964 addend
+= sym
->n_value
;
2973 sec
= bfd_abs_section_ptr
;
2978 sec
= sections
[symndx
];
2980 /* PR 19623: Relocations against symbols in
2981 the absolute sections should ignored. */
2982 if (bfd_is_abs_section (sec
))
2985 val
= (sec
->output_section
->vma
2986 + sec
->output_offset
2988 if (! obj_pe (input_bfd
))
2994 if (h
->root
.type
== bfd_link_hash_defined
2995 || h
->root
.type
== bfd_link_hash_defweak
)
2997 /* Defined weak symbols are a GNU extension. */
2998 sec
= h
->root
.u
.def
.section
;
2999 val
= (h
->root
.u
.def
.value
3000 + sec
->output_section
->vma
3001 + sec
->output_offset
);
3004 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3006 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
3008 /* See _Microsoft Portable Executable and Common Object
3009 File Format Specification_, section 5.5.3.
3010 Note that weak symbols without aux records are a GNU
3012 FIXME: All weak externals are treated as having
3013 characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
3014 These behave as per SVR4 ABI: A library member
3015 will resolve a weak external only if a normal
3016 external causes the library member to be linked.
3017 See also linker.c: generic_link_check_archive_element. */
3018 struct coff_link_hash_entry
*h2
=
3019 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
3020 h
->aux
->x_sym
.x_tagndx
.l
];
3022 if (!h2
|| h2
->root
.type
== bfd_link_hash_undefined
)
3024 sec
= bfd_abs_section_ptr
;
3029 sec
= h2
->root
.u
.def
.section
;
3030 val
= h2
->root
.u
.def
.value
3031 + sec
->output_section
->vma
+ sec
->output_offset
;
3035 /* This is a GNU extension. */
3039 else if (! bfd_link_relocatable (info
))
3040 (*info
->callbacks
->undefined_symbol
)
3041 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
3042 rel
->r_vaddr
- input_section
->vma
, TRUE
);
3045 /* If the input section defining the symbol has been discarded
3046 then zero this reloc field. */
3047 if (sec
!= NULL
&& discarded_section (sec
))
3049 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3050 contents
, rel
->r_vaddr
- input_section
->vma
);
3054 if (info
->base_file
)
3056 /* Emit a reloc if the backend thinks it needs it. */
3057 if (sym
&& pe_data (output_bfd
)->in_reloc_p (output_bfd
, howto
))
3059 /* Relocation to a symbol in a section which isn't
3060 absolute. We output the address here to a file.
3061 This file is then read by dlltool when generating the
3062 reloc section. Note that the base file is not
3063 portable between systems. We write out a bfd_vma here,
3064 and dlltool reads in a bfd_vma. */
3065 bfd_vma addr
= (rel
->r_vaddr
3066 - input_section
->vma
3067 + input_section
->output_offset
3068 + input_section
->output_section
->vma
);
3069 if (coff_data (output_bfd
)->pe
)
3070 addr
-= pe_data(output_bfd
)->pe_opthdr
.ImageBase
;
3071 if (fwrite (&addr
, 1, sizeof (bfd_vma
), (FILE *) info
->base_file
)
3072 != sizeof (bfd_vma
))
3074 bfd_set_error (bfd_error_system_call
);
3080 rstat
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3082 rel
->r_vaddr
- input_section
->vma
,
3091 case bfd_reloc_outofrange
:
3093 /* xgettext: c-format */
3094 (_("%pB: bad reloc address %#" PRIx64
" in section `%pA'"),
3095 input_bfd
, (uint64_t) rel
->r_vaddr
, input_section
);
3097 case bfd_reloc_overflow
:
3100 char buf
[SYMNMLEN
+ 1];
3108 name
= _bfd_coff_internal_syment_name (input_bfd
, sym
, buf
);
3113 (*info
->callbacks
->reloc_overflow
)
3114 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3115 (bfd_vma
) 0, input_bfd
, input_section
,
3116 rel
->r_vaddr
- input_section
->vma
);