1 /* COFF specific linker code.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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
*abfd
, struct bfd_link_info
*info
);
33 static bfd_boolean
coff_link_check_archive_element (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean
*pneeded
);
34 static bfd_boolean
coff_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
);
36 /* Return TRUE if SYM is a weak, external symbol. */
37 #define IS_WEAK_EXTERNAL(abfd, sym) \
38 ((sym).n_sclass == C_WEAKEXT \
39 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
41 /* Return TRUE if SYM is an external symbol. */
42 #define IS_EXTERNAL(abfd, sym) \
43 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
45 /* Define macros so that the ISFCN, et. al., macros work correctly.
46 These macros are defined in include/coff/internal.h in terms of
47 N_TMASK, etc. These definitions require a user to define local
48 variables with the appropriate names, and with values from the
49 coff_data (abfd) structure. */
51 #define N_TMASK n_tmask
52 #define N_BTSHFT n_btshft
53 #define N_BTMASK n_btmask
55 /* Create an entry in a COFF linker hash table. */
57 struct bfd_hash_entry
*
58 _bfd_coff_link_hash_newfunc (struct bfd_hash_entry
*entry
,
59 struct bfd_hash_table
*table
,
62 struct coff_link_hash_entry
*ret
= (struct coff_link_hash_entry
*) entry
;
64 /* Allocate the structure if it has not already been allocated by a
66 if (ret
== (struct coff_link_hash_entry
*) NULL
)
67 ret
= ((struct coff_link_hash_entry
*)
68 bfd_hash_allocate (table
, sizeof (struct coff_link_hash_entry
)));
69 if (ret
== (struct coff_link_hash_entry
*) NULL
)
70 return (struct bfd_hash_entry
*) ret
;
72 /* Call the allocation method of the superclass. */
73 ret
= ((struct coff_link_hash_entry
*)
74 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
76 if (ret
!= (struct coff_link_hash_entry
*) NULL
)
78 /* Set local fields. */
87 return (struct bfd_hash_entry
*) ret
;
90 /* Initialize a COFF linker hash table. */
93 _bfd_coff_link_hash_table_init (struct coff_link_hash_table
*table
,
95 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
96 struct bfd_hash_table
*,
99 memset (&table
->stab_info
, 0, sizeof (table
->stab_info
));
100 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
103 /* Create a COFF linker hash table. */
105 struct bfd_link_hash_table
*
106 _bfd_coff_link_hash_table_create (bfd
*abfd
)
108 struct coff_link_hash_table
*ret
;
109 bfd_size_type amt
= sizeof (struct coff_link_hash_table
);
111 ret
= bfd_malloc (amt
);
115 if (! _bfd_coff_link_hash_table_init (ret
, abfd
,
116 _bfd_coff_link_hash_newfunc
))
119 return (struct bfd_link_hash_table
*) NULL
;
124 /* Create an entry in a COFF debug merge hash table. */
126 struct bfd_hash_entry
*
127 _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry
*entry
,
128 struct bfd_hash_table
*table
,
131 struct coff_debug_merge_hash_entry
*ret
=
132 (struct coff_debug_merge_hash_entry
*) entry
;
134 /* Allocate the structure if it has not already been allocated by a
136 if (ret
== (struct coff_debug_merge_hash_entry
*) NULL
)
137 ret
= ((struct coff_debug_merge_hash_entry
*)
138 bfd_hash_allocate (table
,
139 sizeof (struct coff_debug_merge_hash_entry
)));
140 if (ret
== (struct coff_debug_merge_hash_entry
*) NULL
)
141 return (struct bfd_hash_entry
*) ret
;
143 /* Call the allocation method of the superclass. */
144 ret
= ((struct coff_debug_merge_hash_entry
*)
145 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
146 if (ret
!= (struct coff_debug_merge_hash_entry
*) NULL
)
148 /* Set local fields. */
152 return (struct bfd_hash_entry
*) ret
;
155 /* Given a COFF BFD, add symbols to the global hash table as
159 _bfd_coff_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
161 switch (bfd_get_format (abfd
))
164 return coff_link_add_object_symbols (abfd
, info
);
166 return _bfd_generic_link_add_archive_symbols
167 (abfd
, info
, coff_link_check_archive_element
);
169 bfd_set_error (bfd_error_wrong_format
);
174 /* Add symbols from a COFF object file. */
177 coff_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
179 if (! _bfd_coff_get_external_symbols (abfd
))
181 if (! coff_link_add_symbols (abfd
, info
))
184 if (! info
->keep_memory
185 && ! _bfd_coff_free_symbols (abfd
))
191 /* Look through the symbols to see if this object file should be
192 included in the link. */
195 coff_link_check_ar_symbols (bfd
*abfd
,
196 struct bfd_link_info
*info
,
197 bfd_boolean
*pneeded
)
199 bfd_size_type symesz
;
205 symesz
= bfd_coff_symesz (abfd
);
206 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
207 esym_end
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
208 while (esym
< esym_end
)
210 struct internal_syment sym
;
211 enum coff_symbol_classification classification
;
213 bfd_coff_swap_sym_in (abfd
, esym
, &sym
);
215 classification
= bfd_coff_classify_symbol (abfd
, &sym
);
216 if (classification
== COFF_SYMBOL_GLOBAL
217 || classification
== COFF_SYMBOL_COMMON
)
220 char buf
[SYMNMLEN
+ 1];
221 struct bfd_link_hash_entry
*h
;
223 /* This symbol is externally visible, and is defined by this
225 name
= _bfd_coff_internal_syment_name (abfd
, &sym
, buf
);
228 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
232 && info
->pei386_auto_import
233 && !strncmp (name
,"__imp_", 6))
234 h
= bfd_link_hash_lookup (info
->hash
, name
+ 6, FALSE
, FALSE
, TRUE
);
236 /* We are only interested in symbols that are currently
237 undefined. If a symbol is currently known to be common,
238 COFF linkers do not bring in an object file which defines
240 if (h
!= (struct bfd_link_hash_entry
*) NULL
241 && h
->type
== bfd_link_hash_undefined
)
243 if (! (*info
->callbacks
->add_archive_element
) (info
, abfd
, name
))
250 esym
+= (sym
.n_numaux
+ 1) * symesz
;
253 /* We do not need this object file. */
257 /* Check a single archive element to see if we need to include it in
258 the link. *PNEEDED is set according to whether this element is
259 needed in the link or not. This is called via
260 _bfd_generic_link_add_archive_symbols. */
263 coff_link_check_archive_element (bfd
*abfd
,
264 struct bfd_link_info
*info
,
265 bfd_boolean
*pneeded
)
267 if (! _bfd_coff_get_external_symbols (abfd
))
270 if (! coff_link_check_ar_symbols (abfd
, info
, pneeded
))
274 && ! coff_link_add_symbols (abfd
, info
))
277 if ((! info
->keep_memory
|| ! *pneeded
)
278 && ! _bfd_coff_free_symbols (abfd
))
284 /* Add all the symbols from an object file to the hash table. */
287 coff_link_add_symbols (bfd
*abfd
,
288 struct bfd_link_info
*info
)
290 unsigned int n_tmask
= coff_data (abfd
)->local_n_tmask
;
291 unsigned int n_btshft
= coff_data (abfd
)->local_n_btshft
;
292 unsigned int n_btmask
= coff_data (abfd
)->local_n_btmask
;
293 bfd_boolean keep_syms
;
294 bfd_boolean default_copy
;
295 bfd_size_type symcount
;
296 struct coff_link_hash_entry
**sym_hash
;
297 bfd_size_type symesz
;
302 /* Keep the symbols during this function, in case the linker needs
303 to read the generic symbols in order to report an error message. */
304 keep_syms
= obj_coff_keep_syms (abfd
);
305 obj_coff_keep_syms (abfd
) = TRUE
;
307 if (info
->keep_memory
)
308 default_copy
= FALSE
;
312 symcount
= obj_raw_syment_count (abfd
);
314 /* We keep a list of the linker hash table entries that correspond
315 to particular symbols. */
316 amt
= symcount
* sizeof (struct coff_link_hash_entry
*);
317 sym_hash
= bfd_zalloc (abfd
, amt
);
318 if (sym_hash
== NULL
&& symcount
!= 0)
320 obj_coff_sym_hashes (abfd
) = sym_hash
;
322 symesz
= bfd_coff_symesz (abfd
);
323 BFD_ASSERT (symesz
== bfd_coff_auxesz (abfd
));
324 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
325 esym_end
= esym
+ symcount
* symesz
;
326 while (esym
< esym_end
)
328 struct internal_syment sym
;
329 enum coff_symbol_classification classification
;
332 bfd_coff_swap_sym_in (abfd
, esym
, &sym
);
334 classification
= bfd_coff_classify_symbol (abfd
, &sym
);
335 if (classification
!= COFF_SYMBOL_LOCAL
)
338 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 switch (classification
)
364 case COFF_SYMBOL_GLOBAL
:
365 flags
= BSF_EXPORT
| BSF_GLOBAL
;
366 section
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
368 value
-= section
->vma
;
371 case COFF_SYMBOL_UNDEFINED
:
373 section
= bfd_und_section_ptr
;
376 case COFF_SYMBOL_COMMON
:
378 section
= bfd_com_section_ptr
;
381 case COFF_SYMBOL_PE_SECTION
:
382 flags
= BSF_SECTION_SYM
| BSF_GLOBAL
;
383 section
= coff_section_from_bfd_index (abfd
, sym
.n_scnum
);
387 if (IS_WEAK_EXTERNAL (abfd
, sym
))
392 /* In the PE format, section symbols actually refer to the
393 start of the output section. We handle them specially
395 if (obj_pe (abfd
) && (flags
& BSF_SECTION_SYM
) != 0)
397 *sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
398 name
, FALSE
, copy
, FALSE
);
399 if (*sym_hash
!= NULL
)
401 if (((*sym_hash
)->coff_link_hash_flags
402 & COFF_LINK_HASH_PE_SECTION_SYMBOL
) == 0
403 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefined
404 && (*sym_hash
)->root
.type
!= bfd_link_hash_undefweak
)
405 (*_bfd_error_handler
)
406 ("Warning: symbol `%s' is both section and non-section",
413 /* The Microsoft Visual C compiler does string pooling by
414 hashing the constants to an internal symbol name, and
415 relying on the linker comdat support to discard
416 duplicate names. However, if one string is a literal and
417 one is a data initializer, one will end up in the .data
418 section and one will end up in the .rdata section. The
419 Microsoft linker will combine them into the .data
420 section, which seems to be wrong since it might cause the
423 As long as there are no external references to the
424 symbols, which there shouldn't be, we can treat the .data
425 and .rdata instances as separate symbols. The comdat
426 code in the linker will do the appropriate merging. Here
427 we avoid getting a multiple definition error for one of
428 these special symbols.
430 FIXME: I don't think this will work in the case where
431 there are two object files which use the constants as a
432 literal and two object files which use it as a data
433 initializer. One or the other of the second object files
434 is going to wind up with an inappropriate reference. */
436 && (classification
== COFF_SYMBOL_GLOBAL
437 || classification
== COFF_SYMBOL_PE_SECTION
)
438 && coff_section_data (abfd
, section
)->comdat
!= NULL
439 && strncmp (name
, "??_", 3) == 0
440 && strcmp (name
, coff_section_data (abfd
, section
)->comdat
->name
) == 0)
442 if (*sym_hash
== NULL
)
443 *sym_hash
= coff_link_hash_lookup (coff_hash_table (info
),
444 name
, FALSE
, copy
, FALSE
);
445 if (*sym_hash
!= NULL
446 && (*sym_hash
)->root
.type
== bfd_link_hash_defined
447 && coff_section_data (abfd
, (*sym_hash
)->root
.u
.def
.section
)->comdat
!= NULL
448 && strcmp (coff_section_data (abfd
, (*sym_hash
)->root
.u
.def
.section
)->comdat
->name
,
449 coff_section_data (abfd
, section
)->comdat
->name
) == 0)
455 if (! (bfd_coff_link_add_one_symbol
456 (info
, abfd
, name
, flags
, section
, value
,
457 (const char *) NULL
, copy
, FALSE
,
458 (struct bfd_link_hash_entry
**) sym_hash
)))
462 if (obj_pe (abfd
) && (flags
& BSF_SECTION_SYM
) != 0)
463 (*sym_hash
)->coff_link_hash_flags
|=
464 COFF_LINK_HASH_PE_SECTION_SYMBOL
;
466 /* Limit the alignment of a common symbol to the possible
467 alignment of a section. There is no point to permitting
468 a higher alignment for a common symbol: we can not
469 guarantee it, and it may cause us to allocate extra space
470 in the common section. */
471 if (section
== bfd_com_section_ptr
472 && (*sym_hash
)->root
.type
== bfd_link_hash_common
473 && ((*sym_hash
)->root
.u
.c
.p
->alignment_power
474 > bfd_coff_default_section_alignment_power (abfd
)))
475 (*sym_hash
)->root
.u
.c
.p
->alignment_power
476 = bfd_coff_default_section_alignment_power (abfd
);
478 if (info
->hash
->creator
->flavour
== bfd_get_flavour (abfd
))
480 /* If we don't have any symbol information currently in
481 the hash table, or if we are looking at a symbol
482 definition, then update the symbol class and type in
484 if (((*sym_hash
)->class == C_NULL
485 && (*sym_hash
)->type
== T_NULL
)
488 && (*sym_hash
)->root
.type
!= bfd_link_hash_defined
489 && (*sym_hash
)->root
.type
!= bfd_link_hash_defweak
))
491 (*sym_hash
)->class = sym
.n_sclass
;
492 if (sym
.n_type
!= T_NULL
)
494 /* We want to warn if the type changed, but not
495 if it changed from an unspecified type.
496 Testing the whole type byte may work, but the
497 change from (e.g.) a function of unspecified
498 type to function of known type also wants to
500 if ((*sym_hash
)->type
!= T_NULL
501 && (*sym_hash
)->type
!= sym
.n_type
502 && !(DTYPE ((*sym_hash
)->type
) == DTYPE (sym
.n_type
)
503 && (BTYPE ((*sym_hash
)->type
) == T_NULL
504 || BTYPE (sym
.n_type
) == T_NULL
)))
505 (*_bfd_error_handler
)
506 (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
507 abfd
, name
, (*sym_hash
)->type
, sym
.n_type
);
509 /* We don't want to change from a meaningful
510 base type to a null one, but if we know
511 nothing, take what little we might now know. */
512 if (BTYPE (sym
.n_type
) != T_NULL
513 || (*sym_hash
)->type
== T_NULL
)
514 (*sym_hash
)->type
= sym
.n_type
;
516 (*sym_hash
)->auxbfd
= abfd
;
517 if (sym
.n_numaux
!= 0)
519 union internal_auxent
*alloc
;
522 union internal_auxent
*iaux
;
524 (*sym_hash
)->numaux
= sym
.n_numaux
;
525 alloc
= ((union internal_auxent
*)
526 bfd_hash_allocate (&info
->hash
->table
,
528 * sizeof (*alloc
))));
531 for (i
= 0, eaux
= esym
+ symesz
, iaux
= alloc
;
533 i
++, eaux
+= symesz
, iaux
++)
534 bfd_coff_swap_aux_in (abfd
, eaux
, sym
.n_type
,
535 sym
.n_sclass
, (int) i
,
537 (*sym_hash
)->aux
= alloc
;
542 if (classification
== COFF_SYMBOL_PE_SECTION
543 && (*sym_hash
)->numaux
!= 0)
545 /* Some PE sections (such as .bss) have a zero size in
546 the section header, but a non-zero size in the AUX
547 record. Correct that here.
549 FIXME: This is not at all the right place to do this.
550 For example, it won't help objdump. This needs to be
551 done when we swap in the section header. */
552 BFD_ASSERT ((*sym_hash
)->numaux
== 1);
553 if (section
->size
== 0)
554 section
->size
= (*sym_hash
)->aux
[0].x_scn
.x_scnlen
;
556 /* FIXME: We could test whether the section sizes
557 matches the size in the aux entry, but apparently
558 that sometimes fails unexpectedly. */
562 esym
+= (sym
.n_numaux
+ 1) * symesz
;
563 sym_hash
+= sym
.n_numaux
+ 1;
566 /* If this is a non-traditional, non-relocatable link, try to
567 optimize the handling of any .stab/.stabstr sections. */
568 if (! info
->relocatable
569 && ! info
->traditional_format
570 && info
->hash
->creator
->flavour
== bfd_get_flavour (abfd
)
571 && (info
->strip
!= strip_all
&& info
->strip
!= strip_debugger
))
575 stabstr
= bfd_get_section_by_name (abfd
, ".stabstr");
579 bfd_size_type string_offset
= 0;
582 for (stab
= abfd
->sections
; stab
; stab
= stab
->next
)
583 if (strncmp (".stab", stab
->name
, 5) == 0
585 || (stab
->name
[5] == '.' && ISDIGIT (stab
->name
[6]))))
587 struct coff_link_hash_table
*table
;
588 struct coff_section_tdata
*secdata
589 = coff_section_data (abfd
, stab
);
593 amt
= sizeof (struct coff_section_tdata
);
594 stab
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
595 if (stab
->used_by_bfd
== NULL
)
597 secdata
= coff_section_data (abfd
, stab
);
600 table
= coff_hash_table (info
);
602 if (! _bfd_link_section_stabs (abfd
, &table
->stab_info
,
611 obj_coff_keep_syms (abfd
) = keep_syms
;
616 obj_coff_keep_syms (abfd
) = keep_syms
;
620 /* Do the final link step. */
623 _bfd_coff_final_link (bfd
*abfd
,
624 struct bfd_link_info
*info
)
626 bfd_size_type symesz
;
627 struct coff_final_link_info finfo
;
628 bfd_boolean debug_merge_allocated
;
629 bfd_boolean long_section_names
;
631 struct bfd_link_order
*p
;
632 bfd_size_type max_sym_count
;
633 bfd_size_type max_lineno_count
;
634 bfd_size_type max_reloc_count
;
635 bfd_size_type max_output_reloc_count
;
636 bfd_size_type max_contents_size
;
637 file_ptr rel_filepos
;
639 file_ptr line_filepos
;
642 bfd_byte
*external_relocs
= NULL
;
643 char strbuf
[STRING_SIZE_SIZE
];
646 symesz
= bfd_coff_symesz (abfd
);
649 finfo
.output_bfd
= abfd
;
651 finfo
.section_info
= NULL
;
652 finfo
.last_file_index
= -1;
653 finfo
.last_bf_index
= -1;
654 finfo
.internal_syms
= NULL
;
655 finfo
.sec_ptrs
= NULL
;
656 finfo
.sym_indices
= NULL
;
657 finfo
.outsyms
= NULL
;
658 finfo
.linenos
= NULL
;
659 finfo
.contents
= NULL
;
660 finfo
.external_relocs
= NULL
;
661 finfo
.internal_relocs
= NULL
;
662 finfo
.global_to_static
= FALSE
;
663 debug_merge_allocated
= FALSE
;
665 coff_data (abfd
)->link_info
= info
;
667 finfo
.strtab
= _bfd_stringtab_init ();
668 if (finfo
.strtab
== NULL
)
671 if (! coff_debug_merge_hash_table_init (&finfo
.debug_merge
))
673 debug_merge_allocated
= TRUE
;
675 /* Compute the file positions for all the sections. */
676 if (! abfd
->output_has_begun
)
678 if (! bfd_coff_compute_section_file_positions (abfd
))
682 /* Count the line numbers and relocation entries required for the
683 output file. Set the file positions for the relocs. */
684 rel_filepos
= obj_relocbase (abfd
);
685 relsz
= bfd_coff_relsz (abfd
);
686 max_contents_size
= 0;
687 max_lineno_count
= 0;
690 long_section_names
= FALSE
;
691 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
695 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
697 if (p
->type
== bfd_indirect_link_order
)
701 sec
= p
->u
.indirect
.section
;
703 /* Mark all sections which are to be included in the
704 link. This will normally be every section. We need
705 to do this so that we can identify any sections which
706 the linker has decided to not include. */
707 sec
->linker_mark
= TRUE
;
709 if (info
->strip
== strip_none
710 || info
->strip
== strip_some
)
711 o
->lineno_count
+= sec
->lineno_count
;
713 if (info
->relocatable
)
714 o
->reloc_count
+= sec
->reloc_count
;
716 if (sec
->rawsize
> max_contents_size
)
717 max_contents_size
= sec
->rawsize
;
718 if (sec
->size
> max_contents_size
)
719 max_contents_size
= sec
->size
;
720 if (sec
->lineno_count
> max_lineno_count
)
721 max_lineno_count
= sec
->lineno_count
;
722 if (sec
->reloc_count
> max_reloc_count
)
723 max_reloc_count
= sec
->reloc_count
;
725 else if (info
->relocatable
726 && (p
->type
== bfd_section_reloc_link_order
727 || p
->type
== bfd_symbol_reloc_link_order
))
730 if (o
->reloc_count
== 0)
734 o
->flags
|= SEC_RELOC
;
735 o
->rel_filepos
= rel_filepos
;
736 rel_filepos
+= o
->reloc_count
* relsz
;
737 /* In PE COFF, if there are at least 0xffff relocations an
738 extra relocation will be written out to encode the count. */
739 if (obj_pe (abfd
) && o
->reloc_count
>= 0xffff)
740 rel_filepos
+= relsz
;
743 if (bfd_coff_long_section_names (abfd
)
744 && strlen (o
->name
) > SCNNMLEN
)
746 /* This section has a long name which must go in the string
747 table. This must correspond to the code in
748 coff_write_object_contents which puts the string index
749 into the s_name field of the section header. That is why
750 we pass hash as FALSE. */
751 if (_bfd_stringtab_add (finfo
.strtab
, o
->name
, FALSE
, FALSE
)
752 == (bfd_size_type
) -1)
754 long_section_names
= TRUE
;
758 /* If doing a relocatable link, allocate space for the pointers we
760 if (info
->relocatable
)
764 /* We use section_count + 1, rather than section_count, because
765 the target_index fields are 1 based. */
766 amt
= abfd
->section_count
+ 1;
767 amt
*= sizeof (struct coff_link_section_info
);
768 finfo
.section_info
= bfd_malloc (amt
);
769 if (finfo
.section_info
== NULL
)
771 for (i
= 0; i
<= abfd
->section_count
; i
++)
773 finfo
.section_info
[i
].relocs
= NULL
;
774 finfo
.section_info
[i
].rel_hashes
= NULL
;
778 /* We now know the size of the relocs, so we can determine the file
779 positions of the line numbers. */
780 line_filepos
= rel_filepos
;
781 linesz
= bfd_coff_linesz (abfd
);
782 max_output_reloc_count
= 0;
783 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
785 if (o
->lineno_count
== 0)
789 o
->line_filepos
= line_filepos
;
790 line_filepos
+= o
->lineno_count
* linesz
;
793 if (o
->reloc_count
!= 0)
795 /* We don't know the indices of global symbols until we have
796 written out all the local symbols. For each section in
797 the output file, we keep an array of pointers to hash
798 table entries. Each entry in the array corresponds to a
799 reloc. When we find a reloc against a global symbol, we
800 set the corresponding entry in this array so that we can
801 fix up the symbol index after we have written out all the
804 Because of this problem, we also keep the relocs in
805 memory until the end of the link. This wastes memory,
806 but only when doing a relocatable link, which is not the
808 BFD_ASSERT (info
->relocatable
);
809 amt
= o
->reloc_count
;
810 amt
*= sizeof (struct internal_reloc
);
811 finfo
.section_info
[o
->target_index
].relocs
= bfd_malloc (amt
);
812 amt
= o
->reloc_count
;
813 amt
*= sizeof (struct coff_link_hash_entry
*);
814 finfo
.section_info
[o
->target_index
].rel_hashes
= bfd_malloc (amt
);
815 if (finfo
.section_info
[o
->target_index
].relocs
== NULL
816 || finfo
.section_info
[o
->target_index
].rel_hashes
== NULL
)
819 if (o
->reloc_count
> max_output_reloc_count
)
820 max_output_reloc_count
= o
->reloc_count
;
823 /* Reset the reloc and lineno counts, so that we can use them to
824 count the number of entries we have output so far. */
829 obj_sym_filepos (abfd
) = line_filepos
;
831 /* Figure out the largest number of symbols in an input BFD. Take
832 the opportunity to clear the output_has_begun fields of all the
835 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link_next
)
839 sub
->output_has_begun
= FALSE
;
840 sz
= obj_raw_syment_count (sub
);
841 if (sz
> max_sym_count
)
845 /* Allocate some buffers used while linking. */
846 amt
= max_sym_count
* sizeof (struct internal_syment
);
847 finfo
.internal_syms
= bfd_malloc (amt
);
848 amt
= max_sym_count
* sizeof (asection
*);
849 finfo
.sec_ptrs
= bfd_malloc (amt
);
850 amt
= max_sym_count
* sizeof (long);
851 finfo
.sym_indices
= bfd_malloc (amt
);
852 finfo
.outsyms
= bfd_malloc ((max_sym_count
+ 1) * symesz
);
853 amt
= max_lineno_count
* bfd_coff_linesz (abfd
);
854 finfo
.linenos
= bfd_malloc (amt
);
855 finfo
.contents
= bfd_malloc (max_contents_size
);
856 amt
= max_reloc_count
* relsz
;
857 finfo
.external_relocs
= bfd_malloc (amt
);
858 if (! info
->relocatable
)
860 amt
= max_reloc_count
* sizeof (struct internal_reloc
);
861 finfo
.internal_relocs
= bfd_malloc (amt
);
863 if ((finfo
.internal_syms
== NULL
&& max_sym_count
> 0)
864 || (finfo
.sec_ptrs
== NULL
&& max_sym_count
> 0)
865 || (finfo
.sym_indices
== NULL
&& max_sym_count
> 0)
866 || finfo
.outsyms
== NULL
867 || (finfo
.linenos
== NULL
&& max_lineno_count
> 0)
868 || (finfo
.contents
== NULL
&& max_contents_size
> 0)
869 || (finfo
.external_relocs
== NULL
&& max_reloc_count
> 0)
870 || (! info
->relocatable
871 && finfo
.internal_relocs
== NULL
872 && max_reloc_count
> 0))
875 /* We now know the position of everything in the file, except that
876 we don't know the size of the symbol table and therefore we don't
877 know where the string table starts. We just build the string
878 table in memory as we go along. We process all the relocations
879 for a single input file at once. */
880 obj_raw_syment_count (abfd
) = 0;
882 if (coff_backend_info (abfd
)->_bfd_coff_start_final_link
)
884 if (! bfd_coff_start_final_link (abfd
, info
))
888 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
890 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
892 if (p
->type
== bfd_indirect_link_order
893 && bfd_family_coff (p
->u
.indirect
.section
->owner
))
895 sub
= p
->u
.indirect
.section
->owner
;
896 if (! bfd_coff_link_output_has_begun (sub
, & finfo
))
898 if (! _bfd_coff_link_input_bfd (&finfo
, sub
))
900 sub
->output_has_begun
= TRUE
;
903 else if (p
->type
== bfd_section_reloc_link_order
904 || p
->type
== bfd_symbol_reloc_link_order
)
906 if (! _bfd_coff_reloc_link_order (abfd
, &finfo
, o
, p
))
911 if (! _bfd_default_link_order (abfd
, info
, o
, p
))
917 if (! bfd_coff_final_link_postscript (abfd
, & finfo
))
920 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
922 coff_debug_merge_hash_table_free (&finfo
.debug_merge
);
923 debug_merge_allocated
= FALSE
;
925 if (finfo
.internal_syms
!= NULL
)
927 free (finfo
.internal_syms
);
928 finfo
.internal_syms
= NULL
;
930 if (finfo
.sec_ptrs
!= NULL
)
932 free (finfo
.sec_ptrs
);
933 finfo
.sec_ptrs
= NULL
;
935 if (finfo
.sym_indices
!= NULL
)
937 free (finfo
.sym_indices
);
938 finfo
.sym_indices
= NULL
;
940 if (finfo
.linenos
!= NULL
)
942 free (finfo
.linenos
);
943 finfo
.linenos
= NULL
;
945 if (finfo
.contents
!= NULL
)
947 free (finfo
.contents
);
948 finfo
.contents
= NULL
;
950 if (finfo
.external_relocs
!= NULL
)
952 free (finfo
.external_relocs
);
953 finfo
.external_relocs
= NULL
;
955 if (finfo
.internal_relocs
!= NULL
)
957 free (finfo
.internal_relocs
);
958 finfo
.internal_relocs
= NULL
;
961 /* The value of the last C_FILE symbol is supposed to be the symbol
962 index of the first external symbol. Write it out again if
964 if (finfo
.last_file_index
!= -1
965 && (unsigned int) finfo
.last_file
.n_value
!= obj_raw_syment_count (abfd
))
969 finfo
.last_file
.n_value
= obj_raw_syment_count (abfd
);
970 bfd_coff_swap_sym_out (abfd
, &finfo
.last_file
,
973 pos
= obj_sym_filepos (abfd
) + finfo
.last_file_index
* symesz
;
974 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
975 || bfd_bwrite (finfo
.outsyms
, symesz
, abfd
) != symesz
)
979 /* If doing task linking (ld --task-link) then make a pass through the
980 global symbols, writing out any that are defined, and making them
984 finfo
.failed
= FALSE
;
985 coff_link_hash_traverse (coff_hash_table (info
),
986 _bfd_coff_write_task_globals
, &finfo
);
991 /* Write out the global symbols. */
992 finfo
.failed
= FALSE
;
993 coff_link_hash_traverse (coff_hash_table (info
),
994 _bfd_coff_write_global_sym
, &finfo
);
998 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
999 if (finfo
.outsyms
!= NULL
)
1001 free (finfo
.outsyms
);
1002 finfo
.outsyms
= NULL
;
1005 if (info
->relocatable
&& max_output_reloc_count
> 0)
1007 /* Now that we have written out all the global symbols, we know
1008 the symbol indices to use for relocs against them, and we can
1009 finally write out the relocs. */
1010 amt
= max_output_reloc_count
* relsz
;
1011 external_relocs
= bfd_malloc (amt
);
1012 if (external_relocs
== NULL
)
1015 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1017 struct internal_reloc
*irel
;
1018 struct internal_reloc
*irelend
;
1019 struct coff_link_hash_entry
**rel_hash
;
1022 if (o
->reloc_count
== 0)
1025 irel
= finfo
.section_info
[o
->target_index
].relocs
;
1026 irelend
= irel
+ o
->reloc_count
;
1027 rel_hash
= finfo
.section_info
[o
->target_index
].rel_hashes
;
1028 erel
= external_relocs
;
1029 for (; irel
< irelend
; irel
++, rel_hash
++, erel
+= relsz
)
1031 if (*rel_hash
!= NULL
)
1033 BFD_ASSERT ((*rel_hash
)->indx
>= 0);
1034 irel
->r_symndx
= (*rel_hash
)->indx
;
1036 bfd_coff_swap_reloc_out (abfd
, irel
, erel
);
1039 if (bfd_seek (abfd
, o
->rel_filepos
, SEEK_SET
) != 0)
1041 if (obj_pe (abfd
) && o
->reloc_count
>= 0xffff)
1043 /* In PE COFF, write the count of relocs as the first
1044 reloc. The header overflow bit will be set
1046 struct internal_reloc incount
;
1047 bfd_byte
*excount
= (bfd_byte
*)bfd_malloc (relsz
);
1049 memset (&incount
, 0, sizeof (incount
));
1050 incount
.r_vaddr
= o
->reloc_count
+ 1;
1051 bfd_coff_swap_reloc_out (abfd
, (PTR
) &incount
, (PTR
) excount
);
1052 if (bfd_bwrite (excount
, relsz
, abfd
) != relsz
)
1053 /* We'll leak, but it's an error anyway. */
1057 if (bfd_bwrite (external_relocs
,
1058 (bfd_size_type
) relsz
* o
->reloc_count
, abfd
)
1059 != (bfd_size_type
) relsz
* o
->reloc_count
)
1063 free (external_relocs
);
1064 external_relocs
= NULL
;
1067 /* Free up the section information. */
1068 if (finfo
.section_info
!= NULL
)
1072 for (i
= 0; i
< abfd
->section_count
; i
++)
1074 if (finfo
.section_info
[i
].relocs
!= NULL
)
1075 free (finfo
.section_info
[i
].relocs
);
1076 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
1077 free (finfo
.section_info
[i
].rel_hashes
);
1079 free (finfo
.section_info
);
1080 finfo
.section_info
= NULL
;
1083 /* If we have optimized stabs strings, output them. */
1084 if (coff_hash_table (info
)->stab_info
.stabstr
!= NULL
)
1086 if (! _bfd_write_stab_strings (abfd
, &coff_hash_table (info
)->stab_info
))
1090 /* Write out the string table. */
1091 if (obj_raw_syment_count (abfd
) != 0 || long_section_names
)
1095 pos
= obj_sym_filepos (abfd
) + obj_raw_syment_count (abfd
) * symesz
;
1096 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1099 #if STRING_SIZE_SIZE == 4
1101 _bfd_stringtab_size (finfo
.strtab
) + STRING_SIZE_SIZE
,
1104 #error Change H_PUT_32 above
1107 if (bfd_bwrite (strbuf
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1108 != STRING_SIZE_SIZE
)
1111 if (! _bfd_stringtab_emit (abfd
, finfo
.strtab
))
1114 obj_coff_strings_written (abfd
) = TRUE
;
1117 _bfd_stringtab_free (finfo
.strtab
);
1119 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1120 not try to write out the symbols. */
1121 bfd_get_symcount (abfd
) = 0;
1126 if (debug_merge_allocated
)
1127 coff_debug_merge_hash_table_free (&finfo
.debug_merge
);
1128 if (finfo
.strtab
!= NULL
)
1129 _bfd_stringtab_free (finfo
.strtab
);
1130 if (finfo
.section_info
!= NULL
)
1134 for (i
= 0; i
< abfd
->section_count
; i
++)
1136 if (finfo
.section_info
[i
].relocs
!= NULL
)
1137 free (finfo
.section_info
[i
].relocs
);
1138 if (finfo
.section_info
[i
].rel_hashes
!= NULL
)
1139 free (finfo
.section_info
[i
].rel_hashes
);
1141 free (finfo
.section_info
);
1143 if (finfo
.internal_syms
!= NULL
)
1144 free (finfo
.internal_syms
);
1145 if (finfo
.sec_ptrs
!= NULL
)
1146 free (finfo
.sec_ptrs
);
1147 if (finfo
.sym_indices
!= NULL
)
1148 free (finfo
.sym_indices
);
1149 if (finfo
.outsyms
!= NULL
)
1150 free (finfo
.outsyms
);
1151 if (finfo
.linenos
!= NULL
)
1152 free (finfo
.linenos
);
1153 if (finfo
.contents
!= NULL
)
1154 free (finfo
.contents
);
1155 if (finfo
.external_relocs
!= NULL
)
1156 free (finfo
.external_relocs
);
1157 if (finfo
.internal_relocs
!= NULL
)
1158 free (finfo
.internal_relocs
);
1159 if (external_relocs
!= NULL
)
1160 free (external_relocs
);
1164 /* Parse out a -heap <reserved>,<commit> line. */
1167 dores_com (char *ptr
, bfd
*output_bfd
, int heap
)
1169 if (coff_data(output_bfd
)->pe
)
1171 int val
= strtoul (ptr
, &ptr
, 0);
1174 pe_data(output_bfd
)->pe_opthdr
.SizeOfHeapReserve
= val
;
1176 pe_data(output_bfd
)->pe_opthdr
.SizeOfStackReserve
= val
;
1180 val
= strtoul (ptr
+1, &ptr
, 0);
1182 pe_data(output_bfd
)->pe_opthdr
.SizeOfHeapCommit
= val
;
1184 pe_data(output_bfd
)->pe_opthdr
.SizeOfStackCommit
= val
;
1191 get_name (char *ptr
, char **dst
)
1196 while (*ptr
&& *ptr
!= ' ')
1202 /* Process any magic embedded commands in a section called .drectve. */
1205 process_embedded_commands (bfd
*output_bfd
,
1206 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1209 asection
*sec
= bfd_get_section_by_name (abfd
, ".drectve");
1217 if (!bfd_malloc_and_get_section (abfd
, sec
, ©
))
1223 e
= copy
+ sec
->size
;
1225 for (s
= copy
; s
< e
; )
1232 if (strncmp (s
,"-attr", 5) == 0)
1244 s
= get_name (s
, &name
);
1245 s
= get_name (s
, &attribs
);
1267 asec
= bfd_get_section_by_name (abfd
, name
);
1271 asec
->flags
|= SEC_CODE
;
1273 asec
->flags
|= SEC_READONLY
;
1276 else if (strncmp (s
,"-heap", 5) == 0)
1277 s
= dores_com (s
+5, output_bfd
, 1);
1279 else if (strncmp (s
,"-stack", 6) == 0)
1280 s
= dores_com (s
+6, output_bfd
, 0);
1289 /* Place a marker against all symbols which are used by relocations.
1290 This marker can be picked up by the 'do we skip this symbol ?'
1291 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1295 mark_relocs (struct coff_final_link_info
*finfo
, bfd
*input_bfd
)
1299 if ((bfd_get_file_flags (input_bfd
) & HAS_SYMS
) == 0)
1302 for (a
= input_bfd
->sections
; a
!= (asection
*) NULL
; a
= a
->next
)
1304 struct internal_reloc
* internal_relocs
;
1305 struct internal_reloc
* irel
;
1306 struct internal_reloc
* irelend
;
1308 if ((a
->flags
& SEC_RELOC
) == 0 || a
->reloc_count
< 1)
1310 /* Don't mark relocs in excluded sections. */
1311 if (a
->output_section
== bfd_abs_section_ptr
)
1314 /* Read in the relocs. */
1315 internal_relocs
= _bfd_coff_read_internal_relocs
1316 (input_bfd
, a
, FALSE
,
1317 finfo
->external_relocs
,
1318 finfo
->info
->relocatable
,
1319 (finfo
->info
->relocatable
1320 ? (finfo
->section_info
[ a
->output_section
->target_index
].relocs
+ a
->output_section
->reloc_count
)
1321 : finfo
->internal_relocs
)
1324 if (internal_relocs
== NULL
)
1327 irel
= internal_relocs
;
1328 irelend
= irel
+ a
->reloc_count
;
1330 /* Place a mark in the sym_indices array (whose entries have
1331 been initialised to 0) for all of the symbols that are used
1332 in the relocation table. This will then be picked up in the
1333 skip/don't-skip pass. */
1334 for (; irel
< irelend
; irel
++)
1335 finfo
->sym_indices
[ irel
->r_symndx
] = -1;
1339 /* Link an input file into the linker output file. This function
1340 handles all the sections and relocations of the input file at once. */
1343 _bfd_coff_link_input_bfd (struct coff_final_link_info
*finfo
, bfd
*input_bfd
)
1345 unsigned int n_tmask
= coff_data (input_bfd
)->local_n_tmask
;
1346 unsigned int n_btshft
= coff_data (input_bfd
)->local_n_btshft
;
1348 unsigned int n_btmask
= coff_data (input_bfd
)->local_n_btmask
;
1350 bfd_boolean (*adjust_symndx
)
1351 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*,
1352 struct internal_reloc
*, bfd_boolean
*);
1354 const char *strings
;
1355 bfd_size_type syment_base
;
1356 bfd_boolean copy
, hash
;
1357 bfd_size_type isymesz
;
1358 bfd_size_type osymesz
;
1359 bfd_size_type linesz
;
1362 struct internal_syment
*isymp
;
1365 unsigned long output_index
;
1367 struct coff_link_hash_entry
**sym_hash
;
1370 /* Move all the symbols to the output file. */
1372 output_bfd
= finfo
->output_bfd
;
1374 syment_base
= obj_raw_syment_count (output_bfd
);
1375 isymesz
= bfd_coff_symesz (input_bfd
);
1376 osymesz
= bfd_coff_symesz (output_bfd
);
1377 linesz
= bfd_coff_linesz (input_bfd
);
1378 BFD_ASSERT (linesz
== bfd_coff_linesz (output_bfd
));
1381 if (! finfo
->info
->keep_memory
)
1384 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
1387 if (! _bfd_coff_get_external_symbols (input_bfd
))
1390 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
1391 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
1392 isymp
= finfo
->internal_syms
;
1393 secpp
= finfo
->sec_ptrs
;
1394 indexp
= finfo
->sym_indices
;
1395 output_index
= syment_base
;
1396 outsym
= finfo
->outsyms
;
1398 if (coff_data (output_bfd
)->pe
1399 && ! process_embedded_commands (output_bfd
, finfo
->info
, input_bfd
))
1402 /* If we are going to perform relocations and also strip/discard some
1403 symbols then we must make sure that we do not strip/discard those
1404 symbols that are going to be involved in the relocations. */
1405 if (( finfo
->info
->strip
!= strip_none
1406 || finfo
->info
->discard
!= discard_none
)
1407 && finfo
->info
->relocatable
)
1409 /* Mark the symbol array as 'not-used'. */
1410 memset (indexp
, 0, obj_raw_syment_count (input_bfd
) * sizeof * indexp
);
1412 mark_relocs (finfo
, input_bfd
);
1415 while (esym
< esym_end
)
1417 struct internal_syment isym
;
1418 enum coff_symbol_classification classification
;
1421 bfd_boolean dont_skip_symbol
;
1424 bfd_coff_swap_sym_in (input_bfd
, esym
, isymp
);
1426 /* Make a copy of *isymp so that the relocate_section function
1427 always sees the original values. This is more reliable than
1428 always recomputing the symbol value even if we are stripping
1432 classification
= bfd_coff_classify_symbol (input_bfd
, &isym
);
1433 switch (classification
)
1437 case COFF_SYMBOL_GLOBAL
:
1438 case COFF_SYMBOL_PE_SECTION
:
1439 case COFF_SYMBOL_LOCAL
:
1440 *secpp
= coff_section_from_bfd_index (input_bfd
, isym
.n_scnum
);
1442 case COFF_SYMBOL_COMMON
:
1443 *secpp
= bfd_com_section_ptr
;
1445 case COFF_SYMBOL_UNDEFINED
:
1446 *secpp
= bfd_und_section_ptr
;
1450 /* Extract the flag indicating if this symbol is used by a
1452 if ((finfo
->info
->strip
!= strip_none
1453 || finfo
->info
->discard
!= discard_none
)
1454 && finfo
->info
->relocatable
)
1455 dont_skip_symbol
= *indexp
;
1457 dont_skip_symbol
= FALSE
;
1463 add
= 1 + isym
.n_numaux
;
1465 /* If we are stripping all symbols, we want to skip this one. */
1466 if (finfo
->info
->strip
== strip_all
&& ! dont_skip_symbol
)
1471 switch (classification
)
1475 case COFF_SYMBOL_GLOBAL
:
1476 case COFF_SYMBOL_COMMON
:
1477 case COFF_SYMBOL_PE_SECTION
:
1478 /* This is a global symbol. Global symbols come at the
1479 end of the symbol table, so skip them for now.
1480 Locally defined function symbols, however, are an
1481 exception, and are not moved to the end. */
1483 if (! ISFCN (isym
.n_type
))
1487 case COFF_SYMBOL_UNDEFINED
:
1488 /* Undefined symbols are left for the end. */
1493 case COFF_SYMBOL_LOCAL
:
1494 /* This is a local symbol. Skip it if we are discarding
1496 if (finfo
->info
->discard
== discard_all
&& ! dont_skip_symbol
)
1502 #ifndef COFF_WITH_PE
1503 /* Skip section symbols for sections which are not going to be
1506 && dont_skip_symbol
== 0
1507 && isym
.n_sclass
== C_STAT
1508 && isym
.n_type
== T_NULL
1509 && isym
.n_numaux
> 0
1510 && (*secpp
)->output_section
== bfd_abs_section_ptr
)
1514 /* If we stripping debugging symbols, and this is a debugging
1515 symbol, then skip it. FIXME: gas sets the section to N_ABS
1516 for some types of debugging symbols; I don't know if this is
1517 a bug or not. In any case, we handle it here. */
1519 && finfo
->info
->strip
== strip_debugger
1520 && ! dont_skip_symbol
1521 && (isym
.n_scnum
== N_DEBUG
1522 || (isym
.n_scnum
== N_ABS
1523 && (isym
.n_sclass
== C_AUTO
1524 || isym
.n_sclass
== C_REG
1525 || isym
.n_sclass
== C_MOS
1526 || isym
.n_sclass
== C_MOE
1527 || isym
.n_sclass
== C_MOU
1528 || isym
.n_sclass
== C_ARG
1529 || isym
.n_sclass
== C_REGPARM
1530 || isym
.n_sclass
== C_FIELD
1531 || isym
.n_sclass
== C_EOS
))))
1534 /* If some symbols are stripped based on the name, work out the
1535 name and decide whether to skip this symbol. */
1537 && (finfo
->info
->strip
== strip_some
1538 || finfo
->info
->discard
== discard_l
))
1541 char buf
[SYMNMLEN
+ 1];
1543 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
1547 if (! dont_skip_symbol
1548 && ((finfo
->info
->strip
== strip_some
1549 && (bfd_hash_lookup (finfo
->info
->keep_hash
, name
, FALSE
,
1552 && finfo
->info
->discard
== discard_l
1553 && bfd_is_local_label_name (input_bfd
, name
))))
1557 /* If this is an enum, struct, or union tag, see if we have
1558 already output an identical type. */
1560 && (finfo
->output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) == 0
1561 && (isym
.n_sclass
== C_ENTAG
1562 || isym
.n_sclass
== C_STRTAG
1563 || isym
.n_sclass
== C_UNTAG
)
1564 && isym
.n_numaux
== 1)
1567 char buf
[SYMNMLEN
+ 1];
1568 struct coff_debug_merge_hash_entry
*mh
;
1569 struct coff_debug_merge_type
*mt
;
1570 union internal_auxent aux
;
1571 struct coff_debug_merge_element
**epp
;
1572 bfd_byte
*esl
, *eslend
;
1573 struct internal_syment
*islp
;
1576 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, buf
);
1580 /* Ignore fake names invented by compiler; treat them all as
1582 if (*name
== '~' || *name
== '.' || *name
== '$'
1583 || (*name
== bfd_get_symbol_leading_char (input_bfd
)
1584 && (name
[1] == '~' || name
[1] == '.' || name
[1] == '$')))
1587 mh
= coff_debug_merge_hash_lookup (&finfo
->debug_merge
, name
,
1592 /* Allocate memory to hold type information. If this turns
1593 out to be a duplicate, we pass this address to
1595 amt
= sizeof (struct coff_debug_merge_type
);
1596 mt
= bfd_alloc (input_bfd
, amt
);
1599 mt
->class = isym
.n_sclass
;
1601 /* Pick up the aux entry, which points to the end of the tag
1603 bfd_coff_swap_aux_in (input_bfd
, (esym
+ isymesz
),
1604 isym
.n_type
, isym
.n_sclass
, 0, isym
.n_numaux
,
1607 /* Gather the elements. */
1608 epp
= &mt
->elements
;
1609 mt
->elements
= NULL
;
1611 esl
= esym
+ 2 * isymesz
;
1612 eslend
= ((bfd_byte
*) obj_coff_external_syms (input_bfd
)
1613 + aux
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
* isymesz
);
1614 while (esl
< eslend
)
1616 const char *elename
;
1617 char elebuf
[SYMNMLEN
+ 1];
1620 bfd_coff_swap_sym_in (input_bfd
, esl
, islp
);
1622 amt
= sizeof (struct coff_debug_merge_element
);
1623 *epp
= bfd_alloc (input_bfd
, amt
);
1627 elename
= _bfd_coff_internal_syment_name (input_bfd
, islp
,
1629 if (elename
== NULL
)
1632 amt
= strlen (elename
) + 1;
1633 name_copy
= bfd_alloc (input_bfd
, amt
);
1634 if (name_copy
== NULL
)
1636 strcpy (name_copy
, elename
);
1638 (*epp
)->name
= name_copy
;
1639 (*epp
)->type
= islp
->n_type
;
1641 if (islp
->n_numaux
>= 1
1642 && islp
->n_type
!= T_NULL
1643 && islp
->n_sclass
!= C_EOS
)
1645 union internal_auxent eleaux
;
1648 bfd_coff_swap_aux_in (input_bfd
, (esl
+ isymesz
),
1649 islp
->n_type
, islp
->n_sclass
, 0,
1650 islp
->n_numaux
, &eleaux
);
1651 indx
= eleaux
.x_sym
.x_tagndx
.l
;
1653 /* FIXME: If this tagndx entry refers to a symbol
1654 defined later in this file, we just ignore it.
1655 Handling this correctly would be tedious, and may
1660 (bfd_byte
*) obj_coff_external_syms (input_bfd
))
1663 (*epp
)->tagndx
= finfo
->sym_indices
[indx
];
1664 if ((*epp
)->tagndx
< 0)
1668 epp
= &(*epp
)->next
;
1671 esl
+= (islp
->n_numaux
+ 1) * isymesz
;
1672 islp
+= islp
->n_numaux
+ 1;
1675 /* See if we already have a definition which matches this
1676 type. We always output the type if it has no elements,
1678 if (mt
->elements
== NULL
)
1679 bfd_release (input_bfd
, mt
);
1682 struct coff_debug_merge_type
*mtl
;
1684 for (mtl
= mh
->types
; mtl
!= NULL
; mtl
= mtl
->next
)
1686 struct coff_debug_merge_element
*me
, *mel
;
1688 if (mtl
->class != mt
->class)
1691 for (me
= mt
->elements
, mel
= mtl
->elements
;
1692 me
!= NULL
&& mel
!= NULL
;
1693 me
= me
->next
, mel
= mel
->next
)
1695 if (strcmp (me
->name
, mel
->name
) != 0
1696 || me
->type
!= mel
->type
1697 || me
->tagndx
!= mel
->tagndx
)
1701 if (me
== NULL
&& mel
== NULL
)
1705 if (mtl
== NULL
|| (bfd_size_type
) mtl
->indx
>= syment_base
)
1707 /* This is the first definition of this type. */
1708 mt
->indx
= output_index
;
1709 mt
->next
= mh
->types
;
1714 /* This is a redefinition which can be merged. */
1715 bfd_release (input_bfd
, mt
);
1716 *indexp
= mtl
->indx
;
1717 add
= (eslend
- esym
) / isymesz
;
1723 /* We now know whether we are to skip this symbol or not. */
1726 /* Adjust the symbol in order to output it. */
1728 if (isym
._n
._n_n
._n_zeroes
== 0
1729 && isym
._n
._n_n
._n_offset
!= 0)
1734 /* This symbol has a long name. Enter it in the string
1735 table we are building. Note that we do not check
1736 bfd_coff_symname_in_debug. That is only true for
1737 XCOFF, and XCOFF requires different linking code
1739 name
= _bfd_coff_internal_syment_name (input_bfd
, &isym
, NULL
);
1742 indx
= _bfd_stringtab_add (finfo
->strtab
, name
, hash
, copy
);
1743 if (indx
== (bfd_size_type
) -1)
1745 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
1748 switch (isym
.n_sclass
)
1764 /* The symbol value should not be modified. */
1768 if (obj_pe (input_bfd
)
1769 && strcmp (isym
.n_name
, ".bf") != 0
1770 && isym
.n_scnum
> 0)
1772 /* For PE, .lf and .ef get their value left alone,
1773 while .bf gets relocated. However, they all have
1774 "real" section numbers, and need to be moved into
1776 isym
.n_scnum
= (*secpp
)->output_section
->target_index
;
1781 case C_LABEL
: /* Not completely sure about these 2 */
1790 /* Compute new symbol location. */
1791 if (isym
.n_scnum
> 0)
1793 isym
.n_scnum
= (*secpp
)->output_section
->target_index
;
1794 isym
.n_value
+= (*secpp
)->output_offset
;
1795 if (! obj_pe (input_bfd
))
1796 isym
.n_value
-= (*secpp
)->vma
;
1797 if (! obj_pe (finfo
->output_bfd
))
1798 isym
.n_value
+= (*secpp
)->output_section
->vma
;
1803 /* The value of a C_FILE symbol is the symbol index of
1804 the next C_FILE symbol. The value of the last C_FILE
1805 symbol is the symbol index to the first external
1806 symbol (actually, coff_renumber_symbols does not get
1807 this right--it just sets the value of the last C_FILE
1808 symbol to zero--and nobody has ever complained about
1809 it). We try to get this right, below, just before we
1810 write the symbols out, but in the general case we may
1811 have to write the symbol out twice. */
1812 if (finfo
->last_file_index
!= -1
1813 && finfo
->last_file
.n_value
!= (bfd_vma
) output_index
)
1815 /* We must correct the value of the last C_FILE
1817 finfo
->last_file
.n_value
= output_index
;
1818 if ((bfd_size_type
) finfo
->last_file_index
>= syment_base
)
1820 /* The last C_FILE symbol is in this input file. */
1821 bfd_coff_swap_sym_out (output_bfd
,
1824 + ((finfo
->last_file_index
1832 /* We have already written out the last C_FILE
1833 symbol. We need to write it out again. We
1834 borrow *outsym temporarily. */
1835 bfd_coff_swap_sym_out (output_bfd
,
1836 &finfo
->last_file
, outsym
);
1837 pos
= obj_sym_filepos (output_bfd
);
1838 pos
+= finfo
->last_file_index
* osymesz
;
1839 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
1840 || bfd_bwrite (outsym
, osymesz
, output_bfd
) != osymesz
)
1845 finfo
->last_file_index
= output_index
;
1846 finfo
->last_file
= isym
;
1850 /* If doing task linking, convert normal global function symbols to
1851 static functions. */
1852 if (finfo
->info
->task_link
&& IS_EXTERNAL (input_bfd
, isym
))
1853 isym
.n_sclass
= C_STAT
;
1855 /* Output the symbol. */
1856 bfd_coff_swap_sym_out (output_bfd
, &isym
, outsym
);
1858 *indexp
= output_index
;
1863 struct coff_link_hash_entry
*h
;
1865 indx
= ((esym
- (bfd_byte
*) obj_coff_external_syms (input_bfd
))
1867 h
= obj_coff_sym_hashes (input_bfd
)[indx
];
1870 /* This can happen if there were errors earlier in
1872 bfd_set_error (bfd_error_bad_value
);
1875 h
->indx
= output_index
;
1878 output_index
+= add
;
1879 outsym
+= add
* osymesz
;
1882 esym
+= add
* isymesz
;
1886 for (--add
; add
> 0; --add
)
1893 /* Fix up the aux entries. This must be done in a separate pass,
1894 because we don't know the correct symbol indices until we have
1895 already decided which symbols we are going to keep. */
1896 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
1897 esym_end
= esym
+ obj_raw_syment_count (input_bfd
) * isymesz
;
1898 isymp
= finfo
->internal_syms
;
1899 indexp
= finfo
->sym_indices
;
1900 sym_hash
= obj_coff_sym_hashes (input_bfd
);
1901 outsym
= finfo
->outsyms
;
1903 while (esym
< esym_end
)
1907 add
= 1 + isymp
->n_numaux
;
1910 || (bfd_size_type
) *indexp
< syment_base
)
1911 && (*sym_hash
== NULL
1912 || (*sym_hash
)->auxbfd
!= input_bfd
))
1913 esym
+= add
* isymesz
;
1916 struct coff_link_hash_entry
*h
;
1924 /* The m68k-motorola-sysv assembler will sometimes
1925 generate two symbols with the same name, but only one
1926 will have aux entries. */
1927 BFD_ASSERT (isymp
->n_numaux
== 0
1928 || h
->numaux
== isymp
->n_numaux
);
1936 /* Handle the aux entries. This handling is based on
1937 coff_pointerize_aux. I don't know if it always correct. */
1938 for (i
= 0; i
< isymp
->n_numaux
&& esym
< esym_end
; i
++)
1940 union internal_auxent aux
;
1941 union internal_auxent
*auxp
;
1947 bfd_coff_swap_aux_in (input_bfd
, esym
, isymp
->n_type
,
1948 isymp
->n_sclass
, i
, isymp
->n_numaux
, &aux
);
1952 if (isymp
->n_sclass
== C_FILE
)
1954 /* If this is a long filename, we must put it in the
1956 if (auxp
->x_file
.x_n
.x_zeroes
== 0
1957 && auxp
->x_file
.x_n
.x_offset
!= 0)
1959 const char *filename
;
1962 BFD_ASSERT (auxp
->x_file
.x_n
.x_offset
1963 >= STRING_SIZE_SIZE
);
1964 if (strings
== NULL
)
1966 strings
= _bfd_coff_read_string_table (input_bfd
);
1967 if (strings
== NULL
)
1970 filename
= strings
+ auxp
->x_file
.x_n
.x_offset
;
1971 indx
= _bfd_stringtab_add (finfo
->strtab
, filename
,
1973 if (indx
== (bfd_size_type
) -1)
1975 auxp
->x_file
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
1978 else if (isymp
->n_sclass
!= C_STAT
|| isymp
->n_type
!= T_NULL
)
1982 if (ISFCN (isymp
->n_type
)
1983 || ISTAG (isymp
->n_sclass
)
1984 || isymp
->n_sclass
== C_BLOCK
1985 || isymp
->n_sclass
== C_FCN
)
1987 indx
= auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1989 && indx
< obj_raw_syment_count (input_bfd
))
1991 /* We look forward through the symbol for
1992 the index of the next symbol we are going
1993 to include. I don't know if this is
1995 while ((finfo
->sym_indices
[indx
] < 0
1996 || ((bfd_size_type
) finfo
->sym_indices
[indx
]
1998 && indx
< obj_raw_syment_count (input_bfd
))
2000 if (indx
>= obj_raw_syment_count (input_bfd
))
2001 indx
= output_index
;
2003 indx
= finfo
->sym_indices
[indx
];
2004 auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= indx
;
2008 indx
= auxp
->x_sym
.x_tagndx
.l
;
2009 if (indx
> 0 && indx
< obj_raw_syment_count (input_bfd
))
2013 symindx
= finfo
->sym_indices
[indx
];
2015 auxp
->x_sym
.x_tagndx
.l
= 0;
2017 auxp
->x_sym
.x_tagndx
.l
= symindx
;
2020 /* The .bf symbols are supposed to be linked through
2021 the endndx field. We need to carry this list
2022 across object files. */
2025 && isymp
->n_sclass
== C_FCN
2026 && (isymp
->_n
._n_n
._n_zeroes
!= 0
2027 || isymp
->_n
._n_n
._n_offset
== 0)
2028 && isymp
->_n
._n_name
[0] == '.'
2029 && isymp
->_n
._n_name
[1] == 'b'
2030 && isymp
->_n
._n_name
[2] == 'f'
2031 && isymp
->_n
._n_name
[3] == '\0')
2033 if (finfo
->last_bf_index
!= -1)
2035 finfo
->last_bf
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
2038 if ((bfd_size_type
) finfo
->last_bf_index
2043 /* The last .bf symbol is in this input
2044 file. This will only happen if the
2045 assembler did not set up the .bf
2046 endndx symbols correctly. */
2047 auxout
= (finfo
->outsyms
2048 + ((finfo
->last_bf_index
2052 bfd_coff_swap_aux_out (output_bfd
,
2063 /* We have already written out the last
2064 .bf aux entry. We need to write it
2065 out again. We borrow *outsym
2066 temporarily. FIXME: This case should
2068 bfd_coff_swap_aux_out (output_bfd
,
2074 pos
= obj_sym_filepos (output_bfd
);
2075 pos
+= finfo
->last_bf_index
* osymesz
;
2076 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
2077 || (bfd_bwrite (outsym
, osymesz
, output_bfd
)
2083 if (auxp
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
!= 0)
2084 finfo
->last_bf_index
= -1;
2087 /* The endndx field of this aux entry must
2088 be updated with the symbol number of the
2090 finfo
->last_bf
= *auxp
;
2091 finfo
->last_bf_index
= (((outsym
- finfo
->outsyms
)
2100 bfd_coff_swap_aux_out (output_bfd
, auxp
, isymp
->n_type
,
2101 isymp
->n_sclass
, i
, isymp
->n_numaux
,
2115 /* Relocate the line numbers, unless we are stripping them. */
2116 if (finfo
->info
->strip
== strip_none
2117 || finfo
->info
->strip
== strip_some
)
2119 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2125 bfd_boolean skipping
;
2129 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2130 build_link_order in ldwrite.c will not have created a
2131 link order, which means that we will not have seen this
2132 input section in _bfd_coff_final_link, which means that
2133 we will not have allocated space for the line numbers of
2134 this section. I don't think line numbers can be
2135 meaningful for a section which does not have
2136 SEC_HAS_CONTENTS set, but, if they do, this must be
2138 if (o
->lineno_count
== 0
2139 || (o
->output_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2142 if (bfd_seek (input_bfd
, o
->line_filepos
, SEEK_SET
) != 0
2143 || bfd_bread (finfo
->linenos
, linesz
* o
->lineno_count
,
2144 input_bfd
) != linesz
* o
->lineno_count
)
2147 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
2148 eline
= finfo
->linenos
;
2149 oeline
= finfo
->linenos
;
2150 elineend
= eline
+ linesz
* o
->lineno_count
;
2152 for (; eline
< elineend
; eline
+= linesz
)
2154 struct internal_lineno iline
;
2156 bfd_coff_swap_lineno_in (input_bfd
, eline
, &iline
);
2158 if (iline
.l_lnno
!= 0)
2159 iline
.l_addr
.l_paddr
+= offset
;
2160 else if (iline
.l_addr
.l_symndx
>= 0
2161 && ((unsigned long) iline
.l_addr
.l_symndx
2162 < obj_raw_syment_count (input_bfd
)))
2166 indx
= finfo
->sym_indices
[iline
.l_addr
.l_symndx
];
2170 /* These line numbers are attached to a symbol
2171 which we are stripping. We must discard the
2172 line numbers because reading them back with
2173 no associated symbol (or associating them all
2174 with symbol #0) will fail. We can't regain
2175 the space in the output file, but at least
2181 struct internal_syment is
;
2182 union internal_auxent ia
;
2184 /* Fix up the lnnoptr field in the aux entry of
2185 the symbol. It turns out that we can't do
2186 this when we modify the symbol aux entries,
2187 because gas sometimes screws up the lnnoptr
2188 field and makes it an offset from the start
2189 of the line numbers rather than an absolute
2191 bfd_coff_swap_sym_in (output_bfd
,
2193 + ((indx
- syment_base
)
2195 if ((ISFCN (is
.n_type
)
2196 || is
.n_sclass
== C_BLOCK
)
2197 && is
.n_numaux
>= 1)
2201 auxptr
= (finfo
->outsyms
2202 + ((indx
- syment_base
+ 1)
2204 bfd_coff_swap_aux_in (output_bfd
, auxptr
,
2205 is
.n_type
, is
.n_sclass
,
2206 0, is
.n_numaux
, &ia
);
2207 ia
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
2208 (o
->output_section
->line_filepos
2209 + o
->output_section
->lineno_count
* linesz
2210 + eline
- finfo
->linenos
);
2211 bfd_coff_swap_aux_out (output_bfd
, &ia
,
2212 is
.n_type
, is
.n_sclass
, 0,
2213 is
.n_numaux
, auxptr
);
2219 iline
.l_addr
.l_symndx
= indx
;
2224 bfd_coff_swap_lineno_out (output_bfd
, &iline
, oeline
);
2229 pos
= o
->output_section
->line_filepos
;
2230 pos
+= o
->output_section
->lineno_count
* linesz
;
2231 amt
= oeline
- finfo
->linenos
;
2232 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
2233 || bfd_bwrite (finfo
->linenos
, amt
, output_bfd
) != amt
)
2236 o
->output_section
->lineno_count
+= amt
/ linesz
;
2240 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2241 symbol will be the first symbol in the next input file. In the
2242 normal case, this will save us from writing out the C_FILE symbol
2244 if (finfo
->last_file_index
!= -1
2245 && (bfd_size_type
) finfo
->last_file_index
>= syment_base
)
2247 finfo
->last_file
.n_value
= output_index
;
2248 bfd_coff_swap_sym_out (output_bfd
, &finfo
->last_file
,
2250 + ((finfo
->last_file_index
- syment_base
)
2254 /* Write the modified symbols to the output file. */
2255 if (outsym
> finfo
->outsyms
)
2260 pos
= obj_sym_filepos (output_bfd
) + syment_base
* osymesz
;
2261 amt
= outsym
- finfo
->outsyms
;
2262 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
2263 || bfd_bwrite (finfo
->outsyms
, amt
, output_bfd
) != amt
)
2266 BFD_ASSERT ((obj_raw_syment_count (output_bfd
)
2267 + (outsym
- finfo
->outsyms
) / osymesz
)
2270 obj_raw_syment_count (output_bfd
) = output_index
;
2273 /* Relocate the contents of each section. */
2274 adjust_symndx
= coff_backend_info (input_bfd
)->_bfd_coff_adjust_symndx
;
2275 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2278 struct coff_section_tdata
*secdata
;
2280 if (! o
->linker_mark
)
2281 /* This section was omitted from the link. */
2284 if ((o
->flags
& SEC_LINKER_CREATED
) != 0)
2287 if ((o
->flags
& SEC_HAS_CONTENTS
) == 0
2288 || (o
->size
== 0 && (o
->flags
& SEC_RELOC
) == 0))
2290 if ((o
->flags
& SEC_RELOC
) != 0
2291 && o
->reloc_count
!= 0)
2293 (*_bfd_error_handler
)
2294 (_("%B: relocs in section `%A', but it has no contents"),
2296 bfd_set_error (bfd_error_no_contents
);
2303 secdata
= coff_section_data (input_bfd
, o
);
2304 if (secdata
!= NULL
&& secdata
->contents
!= NULL
)
2305 contents
= secdata
->contents
;
2308 bfd_size_type x
= o
->rawsize
? o
->rawsize
: o
->size
;
2309 if (! bfd_get_section_contents (input_bfd
, o
, finfo
->contents
, 0, x
))
2311 contents
= finfo
->contents
;
2314 if ((o
->flags
& SEC_RELOC
) != 0)
2317 struct internal_reloc
*internal_relocs
;
2318 struct internal_reloc
*irel
;
2320 /* Read in the relocs. */
2321 target_index
= o
->output_section
->target_index
;
2322 internal_relocs
= (_bfd_coff_read_internal_relocs
2323 (input_bfd
, o
, FALSE
, finfo
->external_relocs
,
2324 finfo
->info
->relocatable
,
2325 (finfo
->info
->relocatable
2326 ? (finfo
->section_info
[target_index
].relocs
2327 + o
->output_section
->reloc_count
)
2328 : finfo
->internal_relocs
)));
2329 if (internal_relocs
== NULL
)
2332 /* Call processor specific code to relocate the section
2334 if (! bfd_coff_relocate_section (output_bfd
, finfo
->info
,
2338 finfo
->internal_syms
,
2342 if (finfo
->info
->relocatable
)
2345 struct internal_reloc
*irelend
;
2346 struct coff_link_hash_entry
**rel_hash
;
2348 offset
= o
->output_section
->vma
+ o
->output_offset
- o
->vma
;
2349 irel
= internal_relocs
;
2350 irelend
= irel
+ o
->reloc_count
;
2351 rel_hash
= (finfo
->section_info
[target_index
].rel_hashes
2352 + o
->output_section
->reloc_count
);
2353 for (; irel
< irelend
; irel
++, rel_hash
++)
2355 struct coff_link_hash_entry
*h
;
2356 bfd_boolean adjusted
;
2360 /* Adjust the reloc address and symbol index. */
2361 irel
->r_vaddr
+= offset
;
2363 if (irel
->r_symndx
== -1)
2368 if (! (*adjust_symndx
) (output_bfd
, finfo
->info
,
2376 h
= obj_coff_sym_hashes (input_bfd
)[irel
->r_symndx
];
2379 /* This is a global symbol. */
2381 irel
->r_symndx
= h
->indx
;
2384 /* This symbol is being written at the end
2385 of the file, and we do not yet know the
2386 symbol index. We save the pointer to the
2387 hash table entry in the rel_hash list.
2388 We set the indx field to -2 to indicate
2389 that this symbol must not be stripped. */
2398 indx
= finfo
->sym_indices
[irel
->r_symndx
];
2400 irel
->r_symndx
= indx
;
2403 struct internal_syment
*is
;
2405 char buf
[SYMNMLEN
+ 1];
2407 /* This reloc is against a symbol we are
2408 stripping. This should have been handled
2409 by the 'dont_skip_symbol' code in the while
2410 loop at the top of this function. */
2411 is
= finfo
->internal_syms
+ irel
->r_symndx
;
2413 name
= (_bfd_coff_internal_syment_name
2414 (input_bfd
, is
, buf
));
2418 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
2419 (finfo
->info
, name
, input_bfd
, o
,
2426 o
->output_section
->reloc_count
+= o
->reloc_count
;
2430 /* Write out the modified section contents. */
2431 if (secdata
== NULL
|| secdata
->stab_info
== NULL
)
2433 file_ptr loc
= o
->output_offset
* bfd_octets_per_byte (output_bfd
);
2434 if (! bfd_set_section_contents (output_bfd
, o
->output_section
,
2435 contents
, loc
, o
->size
))
2440 if (! (_bfd_write_section_stabs
2441 (output_bfd
, &coff_hash_table (finfo
->info
)->stab_info
,
2442 o
, &secdata
->stab_info
, contents
)))
2447 if (! finfo
->info
->keep_memory
2448 && ! _bfd_coff_free_symbols (input_bfd
))
2454 /* Write out a global symbol. Called via coff_link_hash_traverse. */
2457 _bfd_coff_write_global_sym (struct coff_link_hash_entry
*h
, void *data
)
2459 struct coff_final_link_info
*finfo
= (struct coff_final_link_info
*) data
;
2461 struct internal_syment isym
;
2462 bfd_size_type symesz
;
2466 output_bfd
= finfo
->output_bfd
;
2468 if (h
->root
.type
== bfd_link_hash_warning
)
2470 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2471 if (h
->root
.type
== bfd_link_hash_new
)
2479 && (finfo
->info
->strip
== strip_all
2480 || (finfo
->info
->strip
== strip_some
2481 && (bfd_hash_lookup (finfo
->info
->keep_hash
,
2482 h
->root
.root
.string
, FALSE
, FALSE
)
2486 switch (h
->root
.type
)
2489 case bfd_link_hash_new
:
2490 case bfd_link_hash_warning
:
2494 case bfd_link_hash_undefined
:
2495 case bfd_link_hash_undefweak
:
2496 isym
.n_scnum
= N_UNDEF
;
2500 case bfd_link_hash_defined
:
2501 case bfd_link_hash_defweak
:
2505 sec
= h
->root
.u
.def
.section
->output_section
;
2506 if (bfd_is_abs_section (sec
))
2507 isym
.n_scnum
= N_ABS
;
2509 isym
.n_scnum
= sec
->target_index
;
2510 isym
.n_value
= (h
->root
.u
.def
.value
2511 + h
->root
.u
.def
.section
->output_offset
);
2512 if (! obj_pe (finfo
->output_bfd
))
2513 isym
.n_value
+= sec
->vma
;
2517 case bfd_link_hash_common
:
2518 isym
.n_scnum
= N_UNDEF
;
2519 isym
.n_value
= h
->root
.u
.c
.size
;
2522 case bfd_link_hash_indirect
:
2523 /* Just ignore these. They can't be handled anyhow. */
2527 if (strlen (h
->root
.root
.string
) <= SYMNMLEN
)
2528 strncpy (isym
._n
._n_name
, h
->root
.root
.string
, SYMNMLEN
);
2535 if ((output_bfd
->flags
& BFD_TRADITIONAL_FORMAT
) != 0)
2537 indx
= _bfd_stringtab_add (finfo
->strtab
, h
->root
.root
.string
, hash
,
2539 if (indx
== (bfd_size_type
) -1)
2541 finfo
->failed
= TRUE
;
2544 isym
._n
._n_n
._n_zeroes
= 0;
2545 isym
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
2548 isym
.n_sclass
= h
->class;
2549 isym
.n_type
= h
->type
;
2551 if (isym
.n_sclass
== C_NULL
)
2552 isym
.n_sclass
= C_EXT
;
2554 /* If doing task linking and this is the pass where we convert
2555 defined globals to statics, then do that conversion now. If the
2556 symbol is not being converted, just ignore it and it will be
2557 output during a later pass. */
2558 if (finfo
->global_to_static
)
2560 if (! IS_EXTERNAL (output_bfd
, isym
))
2563 isym
.n_sclass
= C_STAT
;
2566 /* When a weak symbol is not overridden by a strong one,
2567 turn it into an external symbol when not building a
2568 shared or relocatable object. */
2569 if (! finfo
->info
->shared
2570 && ! finfo
->info
->relocatable
2571 && IS_WEAK_EXTERNAL (finfo
->output_bfd
, isym
))
2572 isym
.n_sclass
= C_EXT
;
2574 isym
.n_numaux
= h
->numaux
;
2576 bfd_coff_swap_sym_out (output_bfd
, &isym
, finfo
->outsyms
);
2578 symesz
= bfd_coff_symesz (output_bfd
);
2580 pos
= obj_sym_filepos (output_bfd
);
2581 pos
+= obj_raw_syment_count (output_bfd
) * symesz
;
2582 if (bfd_seek (output_bfd
, pos
, SEEK_SET
) != 0
2583 || bfd_bwrite (finfo
->outsyms
, symesz
, output_bfd
) != symesz
)
2585 finfo
->failed
= TRUE
;
2589 h
->indx
= obj_raw_syment_count (output_bfd
);
2591 ++obj_raw_syment_count (output_bfd
);
2593 /* Write out any associated aux entries. Most of the aux entries
2594 will have been modified in _bfd_coff_link_input_bfd. We have to
2595 handle section aux entries here, now that we have the final
2596 relocation and line number counts. */
2597 for (i
= 0; i
< isym
.n_numaux
; i
++)
2599 union internal_auxent
*auxp
;
2603 /* Look for a section aux entry here using the same tests that
2604 coff_swap_aux_out uses. */
2606 && (isym
.n_sclass
== C_STAT
2607 || isym
.n_sclass
== C_HIDDEN
)
2608 && isym
.n_type
== T_NULL
2609 && (h
->root
.type
== bfd_link_hash_defined
2610 || h
->root
.type
== bfd_link_hash_defweak
))
2614 sec
= h
->root
.u
.def
.section
->output_section
;
2617 auxp
->x_scn
.x_scnlen
= sec
->size
;
2619 /* For PE, an overflow on the final link reportedly does
2620 not matter. FIXME: Why not? */
2621 if (sec
->reloc_count
> 0xffff
2622 && (! obj_pe (output_bfd
)
2623 || finfo
->info
->relocatable
))
2624 (*_bfd_error_handler
)
2625 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2626 bfd_get_filename (output_bfd
),
2627 bfd_get_section_name (output_bfd
, sec
),
2630 if (sec
->lineno_count
> 0xffff
2631 && (! obj_pe (output_bfd
)
2632 || finfo
->info
->relocatable
))
2633 (*_bfd_error_handler
)
2634 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2635 bfd_get_filename (output_bfd
),
2636 bfd_get_section_name (output_bfd
, sec
),
2639 auxp
->x_scn
.x_nreloc
= sec
->reloc_count
;
2640 auxp
->x_scn
.x_nlinno
= sec
->lineno_count
;
2641 auxp
->x_scn
.x_checksum
= 0;
2642 auxp
->x_scn
.x_associated
= 0;
2643 auxp
->x_scn
.x_comdat
= 0;
2647 bfd_coff_swap_aux_out (output_bfd
, auxp
, isym
.n_type
,
2648 isym
.n_sclass
, (int) i
, isym
.n_numaux
,
2650 if (bfd_bwrite (finfo
->outsyms
, symesz
, output_bfd
) != symesz
)
2652 finfo
->failed
= TRUE
;
2655 ++obj_raw_syment_count (output_bfd
);
2661 /* Write out task global symbols, converting them to statics. Called
2662 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2663 the dirty work, if the symbol we are processing needs conversion. */
2666 _bfd_coff_write_task_globals (struct coff_link_hash_entry
*h
, void *data
)
2668 struct coff_final_link_info
*finfo
= (struct coff_final_link_info
*) data
;
2669 bfd_boolean rtnval
= TRUE
;
2670 bfd_boolean save_global_to_static
;
2672 if (h
->root
.type
== bfd_link_hash_warning
)
2673 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2677 switch (h
->root
.type
)
2679 case bfd_link_hash_defined
:
2680 case bfd_link_hash_defweak
:
2681 save_global_to_static
= finfo
->global_to_static
;
2682 finfo
->global_to_static
= TRUE
;
2683 rtnval
= _bfd_coff_write_global_sym (h
, data
);
2684 finfo
->global_to_static
= save_global_to_static
;
2693 /* Handle a link order which is supposed to generate a reloc. */
2696 _bfd_coff_reloc_link_order (bfd
*output_bfd
,
2697 struct coff_final_link_info
*finfo
,
2698 asection
*output_section
,
2699 struct bfd_link_order
*link_order
)
2701 reloc_howto_type
*howto
;
2702 struct internal_reloc
*irel
;
2703 struct coff_link_hash_entry
**rel_hash_ptr
;
2705 howto
= bfd_reloc_type_lookup (output_bfd
, link_order
->u
.reloc
.p
->reloc
);
2708 bfd_set_error (bfd_error_bad_value
);
2712 if (link_order
->u
.reloc
.p
->addend
!= 0)
2716 bfd_reloc_status_type rstat
;
2720 size
= bfd_get_reloc_size (howto
);
2721 buf
= bfd_zmalloc (size
);
2725 rstat
= _bfd_relocate_contents (howto
, output_bfd
,
2726 (bfd_vma
) link_order
->u
.reloc
.p
->addend
,\
2733 case bfd_reloc_outofrange
:
2735 case bfd_reloc_overflow
:
2736 if (! ((*finfo
->info
->callbacks
->reloc_overflow
)
2738 (link_order
->type
== bfd_section_reloc_link_order
2739 ? bfd_section_name (output_bfd
,
2740 link_order
->u
.reloc
.p
->u
.section
)
2741 : link_order
->u
.reloc
.p
->u
.name
),
2742 howto
->name
, link_order
->u
.reloc
.p
->addend
,
2743 (bfd
*) NULL
, (asection
*) NULL
, (bfd_vma
) 0)))
2750 loc
= link_order
->offset
* bfd_octets_per_byte (output_bfd
);
2751 ok
= bfd_set_section_contents (output_bfd
, output_section
, buf
,
2758 /* Store the reloc information in the right place. It will get
2759 swapped and written out at the end of the final_link routine. */
2760 irel
= (finfo
->section_info
[output_section
->target_index
].relocs
2761 + output_section
->reloc_count
);
2762 rel_hash_ptr
= (finfo
->section_info
[output_section
->target_index
].rel_hashes
2763 + output_section
->reloc_count
);
2765 memset (irel
, 0, sizeof (struct internal_reloc
));
2766 *rel_hash_ptr
= NULL
;
2768 irel
->r_vaddr
= output_section
->vma
+ link_order
->offset
;
2770 if (link_order
->type
== bfd_section_reloc_link_order
)
2772 /* We need to somehow locate a symbol in the right section. The
2773 symbol must either have a value of zero, or we must adjust
2774 the addend by the value of the symbol. FIXME: Write this
2775 when we need it. The old linker couldn't handle this anyhow. */
2777 *rel_hash_ptr
= NULL
;
2782 struct coff_link_hash_entry
*h
;
2784 h
= ((struct coff_link_hash_entry
*)
2785 bfd_wrapped_link_hash_lookup (output_bfd
, finfo
->info
,
2786 link_order
->u
.reloc
.p
->u
.name
,
2787 FALSE
, FALSE
, TRUE
));
2791 irel
->r_symndx
= h
->indx
;
2794 /* Set the index to -2 to force this symbol to get
2803 if (! ((*finfo
->info
->callbacks
->unattached_reloc
)
2804 (finfo
->info
, link_order
->u
.reloc
.p
->u
.name
, (bfd
*) NULL
,
2805 (asection
*) NULL
, (bfd_vma
) 0)))
2811 /* FIXME: Is this always right? */
2812 irel
->r_type
= howto
->type
;
2814 /* r_size is only used on the RS/6000, which needs its own linker
2815 routines anyhow. r_extern is only used for ECOFF. */
2817 /* FIXME: What is the right value for r_offset? Is zero OK? */
2818 ++output_section
->reloc_count
;
2823 /* A basic reloc handling routine which may be used by processors with
2827 _bfd_coff_generic_relocate_section (bfd
*output_bfd
,
2828 struct bfd_link_info
*info
,
2830 asection
*input_section
,
2832 struct internal_reloc
*relocs
,
2833 struct internal_syment
*syms
,
2834 asection
**sections
)
2836 struct internal_reloc
*rel
;
2837 struct internal_reloc
*relend
;
2840 relend
= rel
+ input_section
->reloc_count
;
2841 for (; rel
< relend
; rel
++)
2844 struct coff_link_hash_entry
*h
;
2845 struct internal_syment
*sym
;
2848 reloc_howto_type
*howto
;
2849 bfd_reloc_status_type rstat
;
2851 symndx
= rel
->r_symndx
;
2859 || (unsigned long) symndx
>= obj_raw_syment_count (input_bfd
))
2861 (*_bfd_error_handler
)
2862 ("%B: illegal symbol index %ld in relocs", input_bfd
, symndx
);
2867 h
= obj_coff_sym_hashes (input_bfd
)[symndx
];
2868 sym
= syms
+ symndx
;
2871 /* COFF treats common symbols in one of two ways. Either the
2872 size of the symbol is included in the section contents, or it
2873 is not. We assume that the size is not included, and force
2874 the rtype_to_howto function to adjust the addend as needed. */
2875 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
2876 addend
= - sym
->n_value
;
2880 howto
= bfd_coff_rtype_to_howto (input_bfd
, input_section
, rel
, h
,
2885 /* If we are doing a relocatable link, then we can just ignore
2886 a PC relative reloc that is pcrel_offset. It will already
2887 have the correct value. If this is not a relocatable link,
2888 then we should ignore the symbol value. */
2889 if (howto
->pc_relative
&& howto
->pcrel_offset
)
2891 if (info
->relocatable
)
2893 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
2894 addend
+= sym
->n_value
;
2905 sec
= bfd_abs_section_ptr
;
2910 sec
= sections
[symndx
];
2911 val
= (sec
->output_section
->vma
2912 + sec
->output_offset
2914 if (! obj_pe (input_bfd
))
2920 if (h
->root
.type
== bfd_link_hash_defined
2921 || h
->root
.type
== bfd_link_hash_defweak
)
2923 /* Defined weak symbols are a GNU extension. */
2926 sec
= h
->root
.u
.def
.section
;
2927 val
= (h
->root
.u
.def
.value
2928 + sec
->output_section
->vma
2929 + sec
->output_offset
);
2932 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2934 if (h
->class == C_NT_WEAK
&& h
->numaux
== 1)
2936 /* See _Microsoft Portable Executable and Common Object
2937 * File Format Specification_, section 5.5.3.
2938 * Note that weak symbols without aux records are a GNU
2940 * FIXME: All weak externals are treated as having
2941 * characteristics IMAGE_WEAK_EXTERN_SEARCH_LIBRARY (2).
2942 * There are no known uses of the other two types of
2946 struct coff_link_hash_entry
*h2
=
2947 input_bfd
->tdata
.coff_obj_data
->sym_hashes
[
2948 h
->aux
->x_sym
.x_tagndx
.l
];
2950 sec
= h2
->root
.u
.def
.section
;
2951 val
= h2
->root
.u
.def
.value
+ sec
->output_section
->vma
2952 + sec
->output_offset
;
2955 /* This is a GNU extension. */
2959 else if (! info
->relocatable
)
2961 if (! ((*info
->callbacks
->undefined_symbol
)
2962 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
2963 rel
->r_vaddr
- input_section
->vma
, TRUE
)))
2968 if (info
->base_file
)
2970 /* Emit a reloc if the backend thinks it needs it. */
2971 if (sym
&& pe_data (output_bfd
)->in_reloc_p (output_bfd
, howto
))
2973 /* Relocation to a symbol in a section which isn't
2974 absolute. We output the address here to a file.
2975 This file is then read by dlltool when generating the
2976 reloc section. Note that the base file is not
2977 portable between systems. We write out a long here,
2978 and dlltool reads in a long. */
2979 long addr
= (rel
->r_vaddr
2980 - input_section
->vma
2981 + input_section
->output_offset
2982 + input_section
->output_section
->vma
);
2983 if (coff_data (output_bfd
)->pe
)
2984 addr
-= pe_data(output_bfd
)->pe_opthdr
.ImageBase
;
2985 if (fwrite (&addr
, 1, sizeof (long), (FILE *) info
->base_file
)
2988 bfd_set_error (bfd_error_system_call
);
2994 rstat
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2996 rel
->r_vaddr
- input_section
->vma
,
3005 case bfd_reloc_outofrange
:
3006 (*_bfd_error_handler
)
3007 (_("%B: bad reloc address 0x%lx in section `%A'"),
3008 input_bfd
, input_section
, (unsigned long) rel
->r_vaddr
);
3010 case bfd_reloc_overflow
:
3013 char buf
[SYMNMLEN
+ 1];
3018 name
= h
->root
.root
.string
;
3021 name
= _bfd_coff_internal_syment_name (input_bfd
, sym
, buf
);
3026 if (! ((*info
->callbacks
->reloc_overflow
)
3027 (info
, name
, howto
->name
, (bfd_vma
) 0, input_bfd
,
3028 input_section
, rel
->r_vaddr
- input_section
->vma
)))