1 /* Main program of GNU linker.
2 Copyright (C) 1991-2020 Free Software Foundation, Inc.
3 Written by Steve Chamberlain steve@cygnus.com
5 This file is part of the GNU Binutils.
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. */
24 #include "safe-ctype.h"
25 #include "libiberty.h"
29 #include "filenames.h"
30 #include "elf/common.h"
45 #include "plugin-api.h"
46 #endif /* ENABLE_PLUGINS */
48 /* Somewhere above, sys/stat.h got included. */
49 #if !defined(S_ISDIR) && defined(S_IFDIR)
50 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
55 #ifndef TARGET_SYSTEM_ROOT
56 #define TARGET_SYSTEM_ROOT ""
61 FILE *saved_script_handle
= NULL
;
62 FILE *previous_script_handle
= NULL
;
63 bfd_boolean force_make_executable
= FALSE
;
66 const char *output_filename
= "a.out";
68 /* Name this program was invoked by. */
71 /* The prefix for system library directories. */
72 const char *ld_sysroot
;
74 /* The canonical representation of ld_sysroot. */
75 char *ld_canon_sysroot
;
76 int ld_canon_sysroot_len
;
78 /* Set by -G argument, for targets like MIPS ELF. */
79 int g_switch_value
= 8;
81 /* Nonzero means print names of input files as processed. */
82 unsigned int trace_files
;
84 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
87 /* Nonzero means version number was printed, so exit successfully
88 instead of complaining if no input files are given. */
89 bfd_boolean version_printed
;
91 /* TRUE if we should demangle symbol names. */
92 bfd_boolean demangling
;
94 args_type command_line
;
96 ld_config_type config
;
98 sort_type sort_section
;
100 static const char *get_sysroot
102 static char *get_emulation
104 static bfd_boolean add_archive_element
105 (struct bfd_link_info
*, bfd
*, const char *, bfd
**);
106 static void multiple_definition
107 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
108 bfd
*, asection
*, bfd_vma
);
109 static void multiple_common
110 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
111 bfd
*, enum bfd_link_hash_type
, bfd_vma
);
112 static void add_to_set
113 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
114 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
115 static void constructor_callback
116 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
117 asection
*, bfd_vma
);
118 static void warning_callback
119 (struct bfd_link_info
*, const char *, const char *, bfd
*,
120 asection
*, bfd_vma
);
121 static void warning_find_reloc
122 (bfd
*, asection
*, void *);
123 static void undefined_symbol
124 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
126 static void reloc_overflow
127 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
128 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
129 static void reloc_dangerous
130 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
131 static void unattached_reloc
132 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
133 static bfd_boolean notice
134 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
135 struct bfd_link_hash_entry
*, bfd
*, asection
*, bfd_vma
, flagword
);
137 static struct bfd_link_callbacks link_callbacks
=
143 constructor_callback
,
153 ldlang_override_segment_assignment
,
154 ldlang_ctf_apply_strsym
,
155 ldlang_write_ctf_late
158 static bfd_assert_handler_type default_bfd_assert_handler
;
159 static bfd_error_handler_type default_bfd_error_handler
;
161 struct bfd_link_info link_info
;
166 bfd_cache_close_all ();
167 #ifdef ENABLE_PLUGINS
168 plugin_call_cleanup ();
170 if (output_filename
&& delete_output_file_on_failure
)
171 unlink_if_ordinary (output_filename
);
174 /* Hook to notice BFD assertions. */
177 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
178 const char *file
, int line
)
180 config
.make_executable
= FALSE
;
181 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
184 /* Hook the bfd error/warning handler for --fatal-warnings. */
187 ld_bfd_error_handler (const char *fmt
, va_list ap
)
189 if (config
.fatal_warnings
)
190 config
.make_executable
= FALSE
;
191 (*default_bfd_error_handler
) (fmt
, ap
);
195 main (int argc
, char **argv
)
198 long start_time
= get_run_time ();
200 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
201 setlocale (LC_MESSAGES
, "");
203 #if defined (HAVE_SETLOCALE)
204 setlocale (LC_CTYPE
, "");
206 bindtextdomain (PACKAGE
, LOCALEDIR
);
207 textdomain (PACKAGE
);
209 program_name
= argv
[0];
210 xmalloc_set_program_name (program_name
);
212 START_PROGRESS (program_name
, 0);
214 expandargv (&argc
, &argv
);
216 if (bfd_init () != BFD_INIT_MAGIC
)
217 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
219 bfd_set_error_program_name (program_name
);
221 /* We want to notice and fail on those nasty BFD assertions which are
222 likely to signal incorrect output being generated but otherwise may
224 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
226 /* Also hook the bfd error/warning handler for --fatal-warnings. */
227 default_bfd_error_handler
= bfd_set_error_handler (ld_bfd_error_handler
);
229 xatexit (ld_cleanup
);
231 /* Set up the sysroot directory. */
232 ld_sysroot
= get_sysroot (argc
, argv
);
234 ld_canon_sysroot
= lrealpath (ld_sysroot
);
235 if (ld_canon_sysroot
)
237 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
239 /* is_sysrooted_pathname() relies on no trailing dirsep. */
240 if (ld_canon_sysroot_len
> 0
241 && IS_DIR_SEPARATOR (ld_canon_sysroot
[ld_canon_sysroot_len
- 1]))
242 ld_canon_sysroot
[--ld_canon_sysroot_len
] = '\0';
245 ld_canon_sysroot_len
= -1;
247 /* Set the default BFD target based on the configured target. Doing
248 this permits the linker to be configured for a particular target,
249 and linked against a shared BFD library which was configured for
250 a different target. The macro TARGET is defined by Makefile. */
251 if (!bfd_set_default_target (TARGET
))
253 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
264 config
.build_constructors
= TRUE
;
265 config
.rpath_separator
= ':';
266 config
.split_by_reloc
= (unsigned) -1;
267 config
.split_by_file
= (bfd_size_type
) -1;
268 config
.make_executable
= TRUE
;
269 config
.magic_demand_paged
= TRUE
;
270 config
.text_read_only
= TRUE
;
271 config
.print_map_discarded
= TRUE
;
272 link_info
.disable_target_specific_optimizations
= -1;
274 command_line
.warn_mismatch
= TRUE
;
275 command_line
.warn_search_mismatch
= TRUE
;
276 command_line
.check_section_addresses
= -1;
278 /* We initialize DEMANGLING based on the environment variable
279 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
280 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
281 environment. Acting the same way here lets us provide the same
282 interface by default. */
283 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
285 link_info
.allow_undefined_version
= TRUE
;
286 link_info
.keep_memory
= TRUE
;
287 link_info
.combreloc
= TRUE
;
288 link_info
.strip_discarded
= TRUE
;
289 link_info
.prohibit_multiple_definition_absolute
= FALSE
;
290 link_info
.textrel_check
= DEFAULT_LD_TEXTREL_CHECK
;
291 link_info
.emit_hash
= DEFAULT_EMIT_SYSV_HASH
;
292 link_info
.emit_gnu_hash
= DEFAULT_EMIT_GNU_HASH
;
293 link_info
.callbacks
= &link_callbacks
;
294 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
295 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
296 and _fini symbols. We are compatible. */
297 link_info
.init_function
= "_init";
298 link_info
.fini_function
= "_fini";
299 link_info
.relax_pass
= 1;
300 link_info
.extern_protected_data
= -1;
301 link_info
.dynamic_undefined_weak
= -1;
302 link_info
.pei386_auto_import
= -1;
303 link_info
.spare_dynamic_tags
= 5;
304 link_info
.path_separator
= ':';
305 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
306 link_info
.compress_debug
= COMPRESS_DEBUG_GABI_ZLIB
;
308 #ifdef DEFAULT_NEW_DTAGS
309 link_info
.new_dtags
= DEFAULT_NEW_DTAGS
;
311 link_info
.start_stop_visibility
= STV_PROTECTED
;
313 ldfile_add_arch ("");
314 emulation
= get_emulation (argc
, argv
);
315 ldemul_choose_mode (emulation
);
316 default_target
= ldemul_choose_target (argc
, argv
);
319 ldemul_before_parse ();
320 lang_has_input_file
= FALSE
;
321 parse_args (argc
, argv
);
323 if (config
.hash_table_size
!= 0)
324 bfd_hash_set_default_size (config
.hash_table_size
);
326 #ifdef ENABLE_PLUGINS
327 /* Now all the plugin arguments have been gathered, we can load them. */
328 plugin_load_plugins ();
329 #endif /* ENABLE_PLUGINS */
331 ldemul_set_symbols ();
333 /* If we have not already opened and parsed a linker script,
334 try the default script from command line first. */
335 if (saved_script_handle
== NULL
336 && command_line
.default_script
!= NULL
)
338 ldfile_open_script_file (command_line
.default_script
);
339 parser_input
= input_script
;
343 /* If we have not already opened and parsed a linker script
344 read the emulation's appropriate default script. */
345 if (saved_script_handle
== NULL
)
348 char *s
= ldemul_get_script (&isfile
);
351 ldfile_open_default_command_file (s
);
355 lex_redirect (s
, _("built in linker script"), 1);
357 parser_input
= input_script
;
364 if (saved_script_handle
)
365 info_msg (_("using external linker script:"));
367 info_msg (_("using internal linker script:"));
368 info_msg ("\n==================================================\n");
370 if (saved_script_handle
)
372 static const int ld_bufsz
= 8193;
374 char *buf
= (char *) xmalloc (ld_bufsz
);
376 rewind (saved_script_handle
);
377 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
380 info_msg ("%s", buf
);
382 rewind (saved_script_handle
);
389 info_msg (ldemul_get_script (&isfile
));
392 info_msg ("\n==================================================\n");
395 if (command_line
.force_group_allocation
396 || !bfd_link_relocatable (&link_info
))
397 link_info
.resolve_section_groups
= TRUE
;
399 link_info
.resolve_section_groups
= FALSE
;
401 if (command_line
.print_output_format
)
402 info_msg ("%s\n", lang_get_output_target ());
406 /* If the only command line argument has been -v or --version or --verbose
407 then ignore any input files provided by linker scripts and exit now.
408 We do not want to create an output file when the linker is just invoked
409 to provide version information. */
410 if (argc
== 2 && version_printed
)
413 if (link_info
.inhibit_common_definition
&& !bfd_link_dll (&link_info
))
414 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
416 if (!lang_has_input_file
)
418 if (version_printed
|| command_line
.print_output_format
)
420 einfo (_("%F%P: no input files\n"));
424 info_msg (_("%P: mode %s\n"), emulation
);
426 ldemul_after_parse ();
428 if (config
.map_filename
)
430 if (strcmp (config
.map_filename
, "-") == 0)
432 config
.map_file
= stdout
;
436 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
437 if (config
.map_file
== (FILE *) NULL
)
439 bfd_set_error (bfd_error_system_call
);
440 einfo (_("%F%P: cannot open map file %s: %E\n"),
441 config
.map_filename
);
444 link_info
.has_map_file
= TRUE
;
449 /* Print error messages for any missing symbols, for any warning
450 symbols, and possibly multiple definitions. */
451 if (bfd_link_relocatable (&link_info
))
452 link_info
.output_bfd
->flags
&= ~EXEC_P
;
454 link_info
.output_bfd
->flags
|= EXEC_P
;
456 if ((link_info
.compress_debug
& COMPRESS_DEBUG
))
458 link_info
.output_bfd
->flags
|= BFD_COMPRESS
;
459 if (link_info
.compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
460 link_info
.output_bfd
->flags
|= BFD_COMPRESS_GABI
;
465 if (config
.map_file
!= NULL
)
467 if (command_line
.cref
)
468 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
469 if (nocrossref_list
!= NULL
)
470 check_nocrossrefs ();
471 if (command_line
.print_memory_usage
)
472 lang_print_memory_usage ();
475 struct bfd_link_hash_entry
*h
;
477 h
= bfd_link_hash_lookup (link_info
.hash
, "__image_base__", 0,0,1);
478 fprintf (stderr
, "lookup = %p val %lx\n", h
, h
? h
->u
.def
.value
: 1);
484 /* Even if we're producing relocatable output, some non-fatal errors should
485 be reported in the exit status. (What non-fatal errors, if any, do we
486 want to ignore for relocatable output?) */
487 if (!config
.make_executable
&& !force_make_executable
)
490 einfo (_("%P: link errors found, deleting executable `%s'\n"),
493 /* The file will be removed by ld_cleanup. */
498 if (!bfd_close (link_info
.output_bfd
))
499 einfo (_("%F%P: %pB: final close failed: %E\n"), link_info
.output_bfd
);
501 /* If the --force-exe-suffix is enabled, and we're making an
502 executable file and it doesn't end in .exe, copy it to one
504 if (!bfd_link_relocatable (&link_info
)
505 && command_line
.force_exe_suffix
)
507 int len
= strlen (output_filename
);
510 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
511 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
515 const int bsize
= 4096;
516 char *buf
= (char *) xmalloc (bsize
);
518 char *dst_name
= (char *) xmalloc (len
+ 5);
520 strcpy (dst_name
, output_filename
);
521 strcat (dst_name
, ".exe");
522 src
= fopen (output_filename
, FOPEN_RB
);
523 dst
= fopen (dst_name
, FOPEN_WB
);
526 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
529 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
531 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
533 int done
= fwrite (buf
, 1, l
, dst
);
536 einfo (_("%P: error writing file `%s'\n"), dst_name
);
540 if (fclose (dst
) == EOF
)
541 einfo (_("%P: error closing file `%s'\n"), dst_name
);
548 END_PROGRESS (program_name
);
552 long run_time
= get_run_time () - start_time
;
555 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
556 program_name
, run_time
/ 1000000, run_time
% 1000000);
560 /* Prevent ld_cleanup from doing anything, after a successful link. */
561 output_filename
= NULL
;
567 /* If the configured sysroot is relocatable, try relocating it based on
568 default prefix FROM. Return the relocated directory if it exists,
569 otherwise return null. */
572 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
574 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
578 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
581 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
589 /* Return the sysroot directory. Return "" if no sysroot is being used. */
592 get_sysroot (int argc
, char **argv
)
595 const char *path
= NULL
;
597 for (i
= 1; i
< argc
; i
++)
598 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
599 path
= argv
[i
] + strlen ("--sysroot=");
602 path
= get_relative_sysroot (BINDIR
);
605 path
= get_relative_sysroot (TOOLBINDIR
);
608 path
= TARGET_SYSTEM_ROOT
;
610 if (IS_DIR_SEPARATOR (*path
) && path
[1] == 0)
616 /* We need to find any explicitly given emulation in order to initialize the
617 state that's needed by the lex&yacc argument parser (parse_args). */
620 get_emulation (int argc
, char **argv
)
625 emulation
= getenv (EMULATION_ENVIRON
);
626 if (emulation
== NULL
)
627 emulation
= DEFAULT_EMULATION
;
629 for (i
= 1; i
< argc
; i
++)
631 if (CONST_STRNEQ (argv
[i
], "-m"))
633 if (argv
[i
][2] == '\0')
638 emulation
= argv
[i
+ 1];
642 einfo (_("%F%P: missing argument to -m\n"));
644 else if (strcmp (argv
[i
], "-mips1") == 0
645 || strcmp (argv
[i
], "-mips2") == 0
646 || strcmp (argv
[i
], "-mips3") == 0
647 || strcmp (argv
[i
], "-mips4") == 0
648 || strcmp (argv
[i
], "-mips5") == 0
649 || strcmp (argv
[i
], "-mips32") == 0
650 || strcmp (argv
[i
], "-mips32r2") == 0
651 || strcmp (argv
[i
], "-mips32r6") == 0
652 || strcmp (argv
[i
], "-mips64") == 0
653 || strcmp (argv
[i
], "-mips64r2") == 0
654 || strcmp (argv
[i
], "-mips64r6") == 0)
656 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
657 passed to the linker by some MIPS compilers. They
658 generally tell the linker to use a slightly different
659 library path. Perhaps someday these should be
660 implemented as emulations; until then, we just ignore
661 the arguments and hope that nobody ever creates
662 emulations named ips1, ips2 or ips3. */
664 else if (strcmp (argv
[i
], "-m486") == 0)
666 /* FIXME: The argument -m486 is passed to the linker on
667 some Linux systems. Hope that nobody creates an
668 emulation named 486. */
673 emulation
= &argv
[i
][2];
682 add_ysym (const char *name
)
684 if (link_info
.notice_hash
== NULL
)
686 link_info
.notice_hash
687 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
688 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
690 sizeof (struct bfd_hash_entry
),
692 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
695 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
696 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
700 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
702 if (info
->ignore_hash
== NULL
)
704 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
705 if (!bfd_hash_table_init_n (info
->ignore_hash
,
707 sizeof (struct bfd_hash_entry
),
709 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
712 if (bfd_hash_lookup (info
->ignore_hash
, name
, TRUE
, TRUE
) == NULL
)
713 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
716 /* Record a symbol to be wrapped, from the --wrap option. */
719 add_wrap (const char *name
)
721 if (link_info
.wrap_hash
== NULL
)
724 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
725 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
727 sizeof (struct bfd_hash_entry
),
729 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
732 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
733 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
736 /* Handle the -retain-symbols-file option. */
739 add_keepsyms_file (const char *filename
)
746 if (link_info
.strip
== strip_some
)
747 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
749 file
= fopen (filename
, "r");
752 bfd_set_error (bfd_error_system_call
);
753 einfo ("%X%P: %s: %E\n", filename
);
757 link_info
.keep_hash
= (struct bfd_hash_table
*)
758 xmalloc (sizeof (struct bfd_hash_table
));
759 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
760 sizeof (struct bfd_hash_entry
)))
761 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
764 buf
= (char *) xmalloc (bufsize
);
776 while (!ISSPACE (c
) && c
!= EOF
)
783 buf
= (char *) xrealloc (buf
, bufsize
);
790 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
791 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
795 if (link_info
.strip
!= strip_none
)
796 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
799 link_info
.strip
= strip_some
;
803 /* Callbacks from the BFD linker routines. */
805 /* This is called when BFD has decided to include an archive member in
809 add_archive_element (struct bfd_link_info
*info
,
812 bfd
**subsbfd ATTRIBUTE_UNUSED
)
814 lang_input_statement_type
*input
;
815 lang_input_statement_type
*parent
;
816 lang_input_statement_type orig_input
;
818 input
= (lang_input_statement_type
*)
819 xcalloc (1, sizeof (lang_input_statement_type
));
820 input
->header
.type
= lang_input_statement_enum
;
821 input
->filename
= bfd_get_filename (abfd
);
822 input
->local_sym_name
= bfd_get_filename (abfd
);
823 input
->the_bfd
= abfd
;
825 parent
= bfd_usrdata (abfd
->my_archive
);
826 if (parent
!= NULL
&& !parent
->flags
.reload
)
827 parent
->next
= input
;
829 /* Save the original data for trace files/tries below, as plugins
830 (if enabled) may possibly alter it to point to a replacement
831 BFD, but we still want to output the original BFD filename. */
833 #ifdef ENABLE_PLUGINS
834 if (link_info
.lto_plugin_active
)
836 /* We must offer this archive member to the plugins to claim. */
837 plugin_maybe_claim (input
);
838 if (input
->flags
.claimed
)
840 if (no_more_claiming
)
842 /* Don't claim new IR symbols after all IR symbols have
845 info_msg ("%pI: no new IR symbols to claim\n",
847 input
->flags
.claimed
= 0;
850 input
->flags
.claim_archive
= TRUE
;
851 *subsbfd
= input
->the_bfd
;
854 #endif /* ENABLE_PLUGINS */
856 ldlang_add_file (input
);
858 if (config
.map_file
!= NULL
)
860 static bfd_boolean header_printed
;
861 struct bfd_link_hash_entry
*h
;
865 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
867 && info
->pei386_auto_import
868 && CONST_STRNEQ (name
, "__imp_"))
869 h
= bfd_link_hash_lookup (info
->hash
, name
+ 6, FALSE
, FALSE
, TRUE
);
881 case bfd_link_hash_defined
:
882 case bfd_link_hash_defweak
:
883 from
= h
->u
.def
.section
->owner
;
886 case bfd_link_hash_undefined
:
887 case bfd_link_hash_undefweak
:
888 from
= h
->u
.undef
.abfd
;
891 case bfd_link_hash_common
:
892 from
= h
->u
.c
.p
->section
->owner
;
899 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
900 header_printed
= TRUE
;
903 if (abfd
->my_archive
== NULL
904 || bfd_is_thin_archive (abfd
->my_archive
))
906 minfo ("%s", bfd_get_filename (abfd
));
907 len
= strlen (bfd_get_filename (abfd
));
911 minfo ("%s(%s)", bfd_get_filename (abfd
->my_archive
),
912 bfd_get_filename (abfd
));
913 len
= (strlen (bfd_get_filename (abfd
->my_archive
))
914 + strlen (bfd_get_filename (abfd
))
930 minfo ("%pB ", from
);
932 minfo ("(%pT)\n", h
->root
.string
);
934 minfo ("(%s)\n", name
);
939 || (trace_files
&& bfd_is_thin_archive (orig_input
.the_bfd
->my_archive
)))
940 info_msg ("%pI\n", &orig_input
);
944 /* This is called when BFD has discovered a symbol which is defined
948 multiple_definition (struct bfd_link_info
*info
,
949 struct bfd_link_hash_entry
*h
,
959 if (info
->allow_multiple_definition
)
964 case bfd_link_hash_defined
:
965 osec
= h
->u
.def
.section
;
966 oval
= h
->u
.def
.value
;
967 obfd
= h
->u
.def
.section
->owner
;
969 case bfd_link_hash_indirect
:
970 osec
= bfd_ind_section_ptr
;
978 /* Ignore a redefinition of an absolute symbol to the
979 same value; it's harmless. */
980 if (h
->type
== bfd_link_hash_defined
981 && bfd_is_abs_section (osec
)
982 && bfd_is_abs_section (nsec
)
986 /* If either section has the output_section field set to
987 bfd_abs_section_ptr, it means that the section is being
988 discarded, and this is not really a multiple definition at all.
989 FIXME: It would be cleaner to somehow ignore symbols defined in
990 sections which are being discarded. */
991 if (!info
->prohibit_multiple_definition_absolute
992 && ((osec
->output_section
!= NULL
993 && ! bfd_is_abs_section (osec
)
994 && bfd_is_abs_section (osec
->output_section
))
995 || (nsec
->output_section
!= NULL
996 && !bfd_is_abs_section (nsec
)
997 && bfd_is_abs_section (nsec
->output_section
))))
1000 name
= h
->root
.string
;
1008 einfo (_("%X%P: %C: multiple definition of `%pT'"),
1009 nbfd
, nsec
, nval
, name
);
1011 einfo (_("; %D: first defined here"), obfd
, osec
, oval
);
1014 if (RELAXATION_ENABLED_BY_USER
)
1016 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1021 /* This is called when there is a definition of a common symbol, or
1022 when a common symbol is found for a symbol that is already defined,
1023 or when two common symbols are found. We only do something if
1024 -warn-common was used. */
1027 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1028 struct bfd_link_hash_entry
*h
,
1030 enum bfd_link_hash_type ntype
,
1035 enum bfd_link_hash_type otype
;
1038 if (!config
.warn_common
)
1041 name
= h
->root
.string
;
1043 if (otype
== bfd_link_hash_common
)
1045 obfd
= h
->u
.c
.p
->section
->owner
;
1046 osize
= h
->u
.c
.size
;
1048 else if (otype
== bfd_link_hash_defined
1049 || otype
== bfd_link_hash_defweak
)
1051 obfd
= h
->u
.def
.section
->owner
;
1056 /* FIXME: It would nice if we could report the BFD which defined
1057 an indirect symbol, but we don't have anywhere to store the
1063 if (ntype
== bfd_link_hash_defined
1064 || ntype
== bfd_link_hash_defweak
1065 || ntype
== bfd_link_hash_indirect
)
1067 ASSERT (otype
== bfd_link_hash_common
);
1069 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1073 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1076 else if (otype
== bfd_link_hash_defined
1077 || otype
== bfd_link_hash_defweak
1078 || otype
== bfd_link_hash_indirect
)
1080 ASSERT (ntype
== bfd_link_hash_common
);
1082 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1086 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1091 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1095 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1096 " by larger common from %pB\n"),
1099 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1100 " by larger common\n"),
1103 else if (nsize
> osize
)
1106 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1107 " smaller common from %pB\n"),
1110 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1111 " smaller common\n"),
1117 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1120 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1126 /* This is called when BFD has discovered a set element. H is the
1127 entry in the linker hash table for the set. SECTION and VALUE
1128 represent a value which should be added to the set. */
1131 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1132 struct bfd_link_hash_entry
*h
,
1133 bfd_reloc_code_real_type reloc
,
1138 if (config
.warn_constructors
)
1139 einfo (_("%P: warning: global constructor %s used\n"),
1142 if (!config
.build_constructors
)
1145 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1147 if (h
->type
== bfd_link_hash_new
)
1149 h
->type
= bfd_link_hash_undefined
;
1150 h
->u
.undef
.abfd
= abfd
;
1151 /* We don't call bfd_link_add_undef to add this to the list of
1152 undefined symbols because we are going to define it
1157 /* This is called when BFD has discovered a constructor. This is only
1158 called for some object file formats--those which do not handle
1159 constructors in some more clever fashion. This is similar to
1160 adding an element to a set, but less general. */
1163 constructor_callback (struct bfd_link_info
*info
,
1164 bfd_boolean constructor
,
1171 struct bfd_link_hash_entry
*h
;
1172 char set_name
[1 + sizeof "__CTOR_LIST__"];
1174 if (config
.warn_constructors
)
1175 einfo (_("%P: warning: global constructor %s used\n"), name
);
1177 if (!config
.build_constructors
)
1180 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1181 useful error message. */
1182 if (bfd_reloc_type_lookup (info
->output_bfd
, BFD_RELOC_CTOR
) == NULL
1183 && (bfd_link_relocatable (info
)
1184 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1185 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1188 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1189 *s
++ = bfd_get_symbol_leading_char (abfd
);
1191 strcpy (s
, "__CTOR_LIST__");
1193 strcpy (s
, "__DTOR_LIST__");
1195 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1196 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1197 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1198 if (h
->type
== bfd_link_hash_new
)
1200 h
->type
= bfd_link_hash_undefined
;
1201 h
->u
.undef
.abfd
= abfd
;
1202 /* We don't call bfd_link_add_undef to add this to the list of
1203 undefined symbols because we are going to define it
1207 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1210 /* A structure used by warning_callback to pass information through
1211 bfd_map_over_sections. */
1213 struct warning_callback_info
1216 const char *warning
;
1221 /* Look through the relocs to see if we can find a plausible address
1222 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1225 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1227 struct warning_callback_info cinfo
;
1229 if (!bfd_generic_link_read_symbols (abfd
))
1230 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd
);
1232 cinfo
.found
= FALSE
;
1233 cinfo
.warning
= warning
;
1234 cinfo
.symbol
= symbol
;
1235 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1236 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1240 /* This is called when there is a reference to a warning symbol. */
1243 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1244 const char *warning
,
1250 /* This is a hack to support warn_multiple_gp. FIXME: This should
1251 have a cleaner interface, but what? */
1252 if (!config
.warn_multiple_gp
1253 && strcmp (warning
, "using multiple gp values") == 0)
1256 if (section
!= NULL
)
1257 einfo ("%P: %C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1258 else if (abfd
== NULL
)
1259 einfo ("%P: %s%s\n", _("warning: "), warning
);
1260 else if (symbol
== NULL
)
1261 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1262 else if (!symbol_warning (warning
, symbol
, abfd
))
1265 /* Search all input files for a reference to SYMBOL. */
1266 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1267 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1269 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1273 /* This is called by warning_callback for each section. It checks the
1274 relocs of the section to see if it can find a reference to the
1275 symbol which triggered the warning. If it can, it uses the reloc
1276 to give an error message with a file and line number. */
1279 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1281 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1285 arelent
**p
, **pend
;
1290 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1292 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1296 relpp
= (arelent
**) xmalloc (relsize
);
1297 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1299 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1302 pend
= p
+ relcount
;
1303 for (; p
< pend
&& *p
!= NULL
; p
++)
1307 if (q
->sym_ptr_ptr
!= NULL
1308 && *q
->sym_ptr_ptr
!= NULL
1309 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1311 /* We found a reloc for the symbol we are looking for. */
1312 einfo ("%P: %C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1322 /* This is called when an undefined symbol is found. */
1325 undefined_symbol (struct bfd_link_info
*info
,
1332 static char *error_name
;
1333 static unsigned int error_count
;
1335 #define MAX_ERRORS_IN_A_ROW 5
1337 if (info
->ignore_hash
!= NULL
1338 && bfd_hash_lookup (info
->ignore_hash
, name
, FALSE
, FALSE
) != NULL
)
1341 if (config
.warn_once
)
1343 /* Only warn once about a particular undefined symbol. */
1344 add_ignoresym (info
, name
);
1347 /* We never print more than a reasonable number of errors in a row
1348 for a single symbol. */
1349 if (error_name
!= NULL
1350 && strcmp (name
, error_name
) == 0)
1356 error_name
= xstrdup (name
);
1359 if (section
!= NULL
)
1361 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1364 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1365 abfd
, section
, address
, name
);
1367 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1368 abfd
, section
, address
, name
);
1370 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1373 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1374 abfd
, section
, address
, name
);
1376 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1377 abfd
, section
, address
, name
);
1384 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1387 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1390 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1393 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1396 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1399 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1407 /* Counter to limit the number of relocation overflow error messages
1408 to print. Errors are printed as it is decremented. When it's
1409 called and the counter is zero, a final message is printed
1410 indicating more relocations were omitted. When it gets to -1, no
1411 such errors are printed. If it's initially set to a value less
1412 than -1, all such errors will be printed (--verbose does this). */
1414 int overflow_cutoff_limit
= 10;
1416 /* This is called when a reloc overflows. */
1419 reloc_overflow (struct bfd_link_info
*info
,
1420 struct bfd_link_hash_entry
*entry
,
1422 const char *reloc_name
,
1428 if (overflow_cutoff_limit
== -1)
1431 einfo ("%X%H:", abfd
, section
, address
);
1433 if (overflow_cutoff_limit
>= 0
1434 && overflow_cutoff_limit
-- == 0)
1436 einfo (_(" additional relocation overflows omitted from the output\n"));
1442 while (entry
->type
== bfd_link_hash_indirect
1443 || entry
->type
== bfd_link_hash_warning
)
1444 entry
= entry
->u
.i
.link
;
1445 switch (entry
->type
)
1447 case bfd_link_hash_undefined
:
1448 case bfd_link_hash_undefweak
:
1449 einfo (_(" relocation truncated to fit: "
1450 "%s against undefined symbol `%pT'"),
1451 reloc_name
, entry
->root
.string
);
1453 case bfd_link_hash_defined
:
1454 case bfd_link_hash_defweak
:
1455 einfo (_(" relocation truncated to fit: "
1456 "%s against symbol `%pT' defined in %pA section in %pB"),
1457 reloc_name
, entry
->root
.string
,
1458 entry
->u
.def
.section
,
1459 entry
->u
.def
.section
== bfd_abs_section_ptr
1460 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1468 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1471 einfo ("+%v", addend
);
1475 /* This is called when a dangerous relocation is made. */
1478 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1479 const char *message
,
1484 einfo (_("%X%H: dangerous relocation: %s\n"),
1485 abfd
, section
, address
, message
);
1488 /* This is called when a reloc is being generated attached to a symbol
1489 that is not being output. */
1492 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1498 einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1499 abfd
, section
, address
, name
);
1502 /* This is called if link_info.notice_all is set, or when a symbol in
1503 link_info.notice_hash is found. Symbols are put in notice_hash
1504 using the -y option, while notice_all is set if the --cref option
1505 has been supplied, or if there are any NOCROSSREFS sections in the
1506 linker script; and if plugins are active, since they need to monitor
1507 all references from non-IR files. */
1510 notice (struct bfd_link_info
*info
,
1511 struct bfd_link_hash_entry
*h
,
1512 struct bfd_link_hash_entry
*inh ATTRIBUTE_UNUSED
,
1516 flagword flags ATTRIBUTE_UNUSED
)
1522 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1523 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1527 name
= h
->root
.string
;
1528 if (info
->notice_hash
!= NULL
1529 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1531 if (bfd_is_und_section (section
))
1532 einfo (_("%P: %pB: reference to %s\n"), abfd
, name
);
1534 einfo (_("%P: %pB: definition of %s\n"), abfd
, name
);
1537 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1538 add_cref (name
, abfd
, section
, value
);