1 /* Main program of GNU linker.
2 Copyright (C) 1991-2021 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"
43 #if BFD_SUPPORTS_PLUGINS
45 #include "plugin-api.h"
46 #endif /* BFD_SUPPORTS_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_acquire_strings
,
156 ldlang_ctf_new_dynsym
,
157 ldlang_write_ctf_late
160 static bfd_assert_handler_type default_bfd_assert_handler
;
161 static bfd_error_handler_type default_bfd_error_handler
;
163 struct bfd_link_info link_info
;
165 struct dependency_file
167 struct dependency_file
*next
;
171 static struct dependency_file
*dependency_files
, *dependency_files_tail
;
174 track_dependency_files (const char *filename
)
176 struct dependency_file
*dep
177 = (struct dependency_file
*) xmalloc (sizeof (*dep
));
178 dep
->name
= xstrdup (filename
);
180 if (dependency_files
== NULL
)
181 dependency_files
= dep
;
183 dependency_files_tail
->next
= dep
;
184 dependency_files_tail
= dep
;
188 write_dependency_file (void)
191 struct dependency_file
*dep
;
193 out
= fopen (config
.dependency_file
, FOPEN_WT
);
196 einfo (_("%F%P: cannot open dependency file %s: %E\n"),
197 config
.dependency_file
);
200 fprintf (out
, "%s:", output_filename
);
202 for (dep
= dependency_files
; dep
!= NULL
; dep
= dep
->next
)
203 fprintf (out
, " \\\n %s", dep
->name
);
206 for (dep
= dependency_files
; dep
!= NULL
; dep
= dep
->next
)
207 fprintf (out
, "\n%s:\n", dep
->name
);
215 bfd_cache_close_all ();
216 #if BFD_SUPPORTS_PLUGINS
217 plugin_call_cleanup ();
219 if (output_filename
&& delete_output_file_on_failure
)
220 unlink_if_ordinary (output_filename
);
223 /* Hook to notice BFD assertions. */
226 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
227 const char *file
, int line
)
229 config
.make_executable
= FALSE
;
230 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
233 /* Hook the bfd error/warning handler for --fatal-warnings. */
236 ld_bfd_error_handler (const char *fmt
, va_list ap
)
238 if (config
.fatal_warnings
)
239 config
.make_executable
= FALSE
;
240 (*default_bfd_error_handler
) (fmt
, ap
);
244 main (int argc
, char **argv
)
247 long start_time
= get_run_time ();
249 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
250 setlocale (LC_MESSAGES
, "");
252 #if defined (HAVE_SETLOCALE)
253 setlocale (LC_CTYPE
, "");
255 bindtextdomain (PACKAGE
, LOCALEDIR
);
256 textdomain (PACKAGE
);
258 program_name
= argv
[0];
259 xmalloc_set_program_name (program_name
);
261 START_PROGRESS (program_name
, 0);
263 expandargv (&argc
, &argv
);
265 if (bfd_init () != BFD_INIT_MAGIC
)
266 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
268 bfd_set_error_program_name (program_name
);
270 /* We want to notice and fail on those nasty BFD assertions which are
271 likely to signal incorrect output being generated but otherwise may
273 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
275 /* Also hook the bfd error/warning handler for --fatal-warnings. */
276 default_bfd_error_handler
= bfd_set_error_handler (ld_bfd_error_handler
);
278 xatexit (ld_cleanup
);
280 /* Set up the sysroot directory. */
281 ld_sysroot
= get_sysroot (argc
, argv
);
283 ld_canon_sysroot
= lrealpath (ld_sysroot
);
284 if (ld_canon_sysroot
)
286 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
288 /* is_sysrooted_pathname() relies on no trailing dirsep. */
289 if (ld_canon_sysroot_len
> 0
290 && IS_DIR_SEPARATOR (ld_canon_sysroot
[ld_canon_sysroot_len
- 1]))
291 ld_canon_sysroot
[--ld_canon_sysroot_len
] = '\0';
294 ld_canon_sysroot_len
= -1;
296 /* Set the default BFD target based on the configured target. Doing
297 this permits the linker to be configured for a particular target,
298 and linked against a shared BFD library which was configured for
299 a different target. The macro TARGET is defined by Makefile. */
300 if (!bfd_set_default_target (TARGET
))
302 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
313 config
.build_constructors
= TRUE
;
314 config
.rpath_separator
= ':';
315 config
.split_by_reloc
= (unsigned) -1;
316 config
.split_by_file
= (bfd_size_type
) -1;
317 config
.make_executable
= TRUE
;
318 config
.magic_demand_paged
= TRUE
;
319 config
.text_read_only
= TRUE
;
320 config
.print_map_discarded
= TRUE
;
321 link_info
.disable_target_specific_optimizations
= -1;
323 command_line
.warn_mismatch
= TRUE
;
324 command_line
.warn_search_mismatch
= TRUE
;
325 command_line
.check_section_addresses
= -1;
327 /* We initialize DEMANGLING based on the environment variable
328 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
329 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
330 environment. Acting the same way here lets us provide the same
331 interface by default. */
332 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
334 link_info
.allow_undefined_version
= TRUE
;
335 link_info
.keep_memory
= TRUE
;
336 link_info
.combreloc
= TRUE
;
337 link_info
.strip_discarded
= TRUE
;
338 link_info
.prohibit_multiple_definition_absolute
= FALSE
;
339 link_info
.textrel_check
= DEFAULT_LD_TEXTREL_CHECK
;
340 link_info
.emit_hash
= DEFAULT_EMIT_SYSV_HASH
;
341 link_info
.emit_gnu_hash
= DEFAULT_EMIT_GNU_HASH
;
342 link_info
.callbacks
= &link_callbacks
;
343 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
344 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
345 and _fini symbols. We are compatible. */
346 link_info
.init_function
= "_init";
347 link_info
.fini_function
= "_fini";
348 link_info
.relax_pass
= 1;
349 link_info
.extern_protected_data
= -1;
350 link_info
.dynamic_undefined_weak
= -1;
351 link_info
.pei386_auto_import
= -1;
352 link_info
.spare_dynamic_tags
= 5;
353 link_info
.path_separator
= ':';
354 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
355 link_info
.compress_debug
= COMPRESS_DEBUG_GABI_ZLIB
;
357 #ifdef DEFAULT_NEW_DTAGS
358 link_info
.new_dtags
= DEFAULT_NEW_DTAGS
;
360 link_info
.start_stop_visibility
= STV_PROTECTED
;
362 ldfile_add_arch ("");
363 emulation
= get_emulation (argc
, argv
);
364 ldemul_choose_mode (emulation
);
365 default_target
= ldemul_choose_target (argc
, argv
);
368 ldemul_before_parse ();
369 lang_has_input_file
= FALSE
;
370 parse_args (argc
, argv
);
372 if (config
.hash_table_size
!= 0)
373 bfd_hash_set_default_size (config
.hash_table_size
);
375 #if BFD_SUPPORTS_PLUGINS
376 /* Now all the plugin arguments have been gathered, we can load them. */
377 plugin_load_plugins ();
378 #endif /* BFD_SUPPORTS_PLUGINS */
380 ldemul_set_symbols ();
382 /* If we have not already opened and parsed a linker script,
383 try the default script from command line first. */
384 if (saved_script_handle
== NULL
385 && command_line
.default_script
!= NULL
)
387 ldfile_open_script_file (command_line
.default_script
);
388 parser_input
= input_script
;
392 /* If we have not already opened and parsed a linker script
393 read the emulation's appropriate default script. */
394 if (saved_script_handle
== NULL
)
397 char *s
= ldemul_get_script (&isfile
);
400 ldfile_open_default_command_file (s
);
404 lex_redirect (s
, _("built in linker script"), 1);
406 parser_input
= input_script
;
413 if (saved_script_handle
)
414 info_msg (_("using external linker script:"));
416 info_msg (_("using internal linker script:"));
417 info_msg ("\n==================================================\n");
419 if (saved_script_handle
)
421 static const int ld_bufsz
= 8193;
423 char *buf
= (char *) xmalloc (ld_bufsz
);
425 rewind (saved_script_handle
);
426 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
429 info_msg ("%s", buf
);
431 rewind (saved_script_handle
);
438 info_msg (ldemul_get_script (&isfile
));
441 info_msg ("\n==================================================\n");
444 if (command_line
.force_group_allocation
445 || !bfd_link_relocatable (&link_info
))
446 link_info
.resolve_section_groups
= TRUE
;
448 link_info
.resolve_section_groups
= FALSE
;
450 if (command_line
.print_output_format
)
451 info_msg ("%s\n", lang_get_output_target ());
455 /* If the only command line argument has been -v or --version or --verbose
456 then ignore any input files provided by linker scripts and exit now.
457 We do not want to create an output file when the linker is just invoked
458 to provide version information. */
459 if (argc
== 2 && version_printed
)
462 if (link_info
.inhibit_common_definition
&& !bfd_link_dll (&link_info
))
463 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
465 if (!lang_has_input_file
)
467 if (version_printed
|| command_line
.print_output_format
)
469 einfo (_("%F%P: no input files\n"));
473 info_msg (_("%P: mode %s\n"), emulation
);
475 ldemul_after_parse ();
477 if (config
.map_filename
)
479 if (strcmp (config
.map_filename
, "-") == 0)
481 config
.map_file
= stdout
;
485 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
486 if (config
.map_file
== (FILE *) NULL
)
488 bfd_set_error (bfd_error_system_call
);
489 einfo (_("%F%P: cannot open map file %s: %E\n"),
490 config
.map_filename
);
493 link_info
.has_map_file
= TRUE
;
498 /* Print error messages for any missing symbols, for any warning
499 symbols, and possibly multiple definitions. */
500 if (bfd_link_relocatable (&link_info
))
501 link_info
.output_bfd
->flags
&= ~EXEC_P
;
503 link_info
.output_bfd
->flags
|= EXEC_P
;
505 if ((link_info
.compress_debug
& COMPRESS_DEBUG
))
507 link_info
.output_bfd
->flags
|= BFD_COMPRESS
;
508 if (link_info
.compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
509 link_info
.output_bfd
->flags
|= BFD_COMPRESS_GABI
;
514 if (config
.map_file
!= NULL
)
516 if (command_line
.cref
)
517 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
518 if (nocrossref_list
!= NULL
)
519 check_nocrossrefs ();
520 if (command_line
.print_memory_usage
)
521 lang_print_memory_usage ();
524 struct bfd_link_hash_entry
*h
;
526 h
= bfd_link_hash_lookup (link_info
.hash
, "__image_base__", 0,0,1);
527 fprintf (stderr
, "lookup = %p val %lx\n", h
, h
? h
->u
.def
.value
: 1);
533 if (config
.dependency_file
!= NULL
)
534 write_dependency_file ();
536 /* Even if we're producing relocatable output, some non-fatal errors should
537 be reported in the exit status. (What non-fatal errors, if any, do we
538 want to ignore for relocatable output?) */
539 if (!config
.make_executable
&& !force_make_executable
)
542 einfo (_("%P: link errors found, deleting executable `%s'\n"),
545 /* The file will be removed by ld_cleanup. */
550 if (!bfd_close (link_info
.output_bfd
))
551 einfo (_("%F%P: %pB: final close failed: %E\n"), link_info
.output_bfd
);
553 /* If the --force-exe-suffix is enabled, and we're making an
554 executable file and it doesn't end in .exe, copy it to one
556 if (!bfd_link_relocatable (&link_info
)
557 && command_line
.force_exe_suffix
)
559 int len
= strlen (output_filename
);
562 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
563 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
567 const int bsize
= 4096;
568 char *buf
= (char *) xmalloc (bsize
);
570 char *dst_name
= (char *) xmalloc (len
+ 5);
572 strcpy (dst_name
, output_filename
);
573 strcat (dst_name
, ".exe");
574 src
= fopen (output_filename
, FOPEN_RB
);
575 dst
= fopen (dst_name
, FOPEN_WB
);
578 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
581 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
583 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
585 int done
= fwrite (buf
, 1, l
, dst
);
588 einfo (_("%P: error writing file `%s'\n"), dst_name
);
592 if (fclose (dst
) == EOF
)
593 einfo (_("%P: error closing file `%s'\n"), dst_name
);
600 END_PROGRESS (program_name
);
604 long run_time
= get_run_time () - start_time
;
607 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
608 program_name
, run_time
/ 1000000, run_time
% 1000000);
612 /* Prevent ld_cleanup from doing anything, after a successful link. */
613 output_filename
= NULL
;
619 /* If the configured sysroot is relocatable, try relocating it based on
620 default prefix FROM. Return the relocated directory if it exists,
621 otherwise return null. */
624 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
626 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
630 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
633 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
641 /* Return the sysroot directory. Return "" if no sysroot is being used. */
644 get_sysroot (int argc
, char **argv
)
647 const char *path
= NULL
;
649 for (i
= 1; i
< argc
; i
++)
650 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
651 path
= argv
[i
] + strlen ("--sysroot=");
654 path
= get_relative_sysroot (BINDIR
);
657 path
= get_relative_sysroot (TOOLBINDIR
);
660 path
= TARGET_SYSTEM_ROOT
;
662 if (IS_DIR_SEPARATOR (*path
) && path
[1] == 0)
668 /* We need to find any explicitly given emulation in order to initialize the
669 state that's needed by the lex&yacc argument parser (parse_args). */
672 get_emulation (int argc
, char **argv
)
677 emulation
= getenv (EMULATION_ENVIRON
);
678 if (emulation
== NULL
)
679 emulation
= DEFAULT_EMULATION
;
681 for (i
= 1; i
< argc
; i
++)
683 if (CONST_STRNEQ (argv
[i
], "-m"))
685 if (argv
[i
][2] == '\0')
690 emulation
= argv
[i
+ 1];
694 einfo (_("%F%P: missing argument to -m\n"));
696 else if (strcmp (argv
[i
], "-mips1") == 0
697 || strcmp (argv
[i
], "-mips2") == 0
698 || strcmp (argv
[i
], "-mips3") == 0
699 || strcmp (argv
[i
], "-mips4") == 0
700 || strcmp (argv
[i
], "-mips5") == 0
701 || strcmp (argv
[i
], "-mips32") == 0
702 || strcmp (argv
[i
], "-mips32r2") == 0
703 || strcmp (argv
[i
], "-mips32r3") == 0
704 || strcmp (argv
[i
], "-mips32r5") == 0
705 || strcmp (argv
[i
], "-mips32r6") == 0
706 || strcmp (argv
[i
], "-mips64") == 0
707 || strcmp (argv
[i
], "-mips64r2") == 0
708 || strcmp (argv
[i
], "-mips64r3") == 0
709 || strcmp (argv
[i
], "-mips64r5") == 0
710 || strcmp (argv
[i
], "-mips64r6") == 0)
712 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
713 passed to the linker by some MIPS compilers. They
714 generally tell the linker to use a slightly different
715 library path. Perhaps someday these should be
716 implemented as emulations; until then, we just ignore
717 the arguments and hope that nobody ever creates
718 emulations named ips1, ips2 or ips3. */
720 else if (strcmp (argv
[i
], "-m486") == 0)
722 /* FIXME: The argument -m486 is passed to the linker on
723 some Linux systems. Hope that nobody creates an
724 emulation named 486. */
729 emulation
= &argv
[i
][2];
738 add_ysym (const char *name
)
740 if (link_info
.notice_hash
== NULL
)
742 link_info
.notice_hash
743 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
744 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
746 sizeof (struct bfd_hash_entry
),
748 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
751 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
752 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
756 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
758 if (info
->ignore_hash
== NULL
)
760 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
761 if (!bfd_hash_table_init_n (info
->ignore_hash
,
763 sizeof (struct bfd_hash_entry
),
765 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
768 if (bfd_hash_lookup (info
->ignore_hash
, name
, TRUE
, TRUE
) == NULL
)
769 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
772 /* Record a symbol to be wrapped, from the --wrap option. */
775 add_wrap (const char *name
)
777 if (link_info
.wrap_hash
== NULL
)
780 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
781 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
783 sizeof (struct bfd_hash_entry
),
785 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
788 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
789 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
792 /* Handle the -retain-symbols-file option. */
795 add_keepsyms_file (const char *filename
)
802 if (link_info
.strip
== strip_some
)
803 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
805 file
= fopen (filename
, "r");
808 bfd_set_error (bfd_error_system_call
);
809 einfo ("%X%P: %s: %E\n", filename
);
813 link_info
.keep_hash
= (struct bfd_hash_table
*)
814 xmalloc (sizeof (struct bfd_hash_table
));
815 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
816 sizeof (struct bfd_hash_entry
)))
817 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
820 buf
= (char *) xmalloc (bufsize
);
832 while (!ISSPACE (c
) && c
!= EOF
)
839 buf
= (char *) xrealloc (buf
, bufsize
);
846 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
847 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
851 if (link_info
.strip
!= strip_none
)
852 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
855 link_info
.strip
= strip_some
;
859 /* Callbacks from the BFD linker routines. */
861 /* This is called when BFD has decided to include an archive member in
865 add_archive_element (struct bfd_link_info
*info
,
868 bfd
**subsbfd ATTRIBUTE_UNUSED
)
870 lang_input_statement_type
*input
;
871 lang_input_statement_type
*parent
;
872 lang_input_statement_type orig_input
;
874 input
= (lang_input_statement_type
*)
875 xcalloc (1, sizeof (lang_input_statement_type
));
876 input
->header
.type
= lang_input_statement_enum
;
877 input
->filename
= bfd_get_filename (abfd
);
878 input
->local_sym_name
= bfd_get_filename (abfd
);
879 input
->the_bfd
= abfd
;
881 /* Save the original data for trace files/tries below, as plugins
882 (if enabled) may possibly alter it to point to a replacement
883 BFD, but we still want to output the original BFD filename. */
885 #if BFD_SUPPORTS_PLUGINS
886 if (link_info
.lto_plugin_active
)
888 /* We must offer this archive member to the plugins to claim. */
889 plugin_maybe_claim (input
);
890 if (input
->flags
.claimed
)
892 if (no_more_claiming
)
894 /* Don't claim new IR symbols after all IR symbols have
897 info_msg ("%pI: no new IR symbols to claim\n",
899 input
->flags
.claimed
= 0;
902 input
->flags
.claim_archive
= TRUE
;
903 *subsbfd
= input
->the_bfd
;
906 #endif /* BFD_SUPPORTS_PLUGINS */
908 if (link_info
.input_bfds_tail
== &input
->the_bfd
->link
.next
909 || input
->the_bfd
->link
.next
!= NULL
)
911 /* We have already loaded this element, and are attempting to
912 load it again. This can happen when the archive map doesn't
913 match actual symbols defined by the element. */
915 bfd_set_error (bfd_error_malformed_archive
);
919 /* Set the file_chain pointer of archives to the last element loaded
920 from the archive. See ldlang.c:find_rescan_insertion. */
921 parent
= bfd_usrdata (abfd
->my_archive
);
922 if (parent
!= NULL
&& !parent
->flags
.reload
)
923 parent
->next
= input
;
925 ldlang_add_file (input
);
927 if (config
.map_file
!= NULL
)
929 static bfd_boolean header_printed
;
930 struct bfd_link_hash_entry
*h
;
934 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
936 && info
->pei386_auto_import
937 && CONST_STRNEQ (name
, "__imp_"))
938 h
= bfd_link_hash_lookup (info
->hash
, name
+ 6, FALSE
, FALSE
, TRUE
);
950 case bfd_link_hash_defined
:
951 case bfd_link_hash_defweak
:
952 from
= h
->u
.def
.section
->owner
;
955 case bfd_link_hash_undefined
:
956 case bfd_link_hash_undefweak
:
957 from
= h
->u
.undef
.abfd
;
960 case bfd_link_hash_common
:
961 from
= h
->u
.c
.p
->section
->owner
;
968 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
969 header_printed
= TRUE
;
972 if (abfd
->my_archive
== NULL
973 || bfd_is_thin_archive (abfd
->my_archive
))
975 minfo ("%s", bfd_get_filename (abfd
));
976 len
= strlen (bfd_get_filename (abfd
));
980 minfo ("%s(%s)", bfd_get_filename (abfd
->my_archive
),
981 bfd_get_filename (abfd
));
982 len
= (strlen (bfd_get_filename (abfd
->my_archive
))
983 + strlen (bfd_get_filename (abfd
))
999 minfo ("%pB ", from
);
1001 minfo ("(%pT)\n", h
->root
.string
);
1003 minfo ("(%s)\n", name
);
1008 || (trace_files
&& bfd_is_thin_archive (orig_input
.the_bfd
->my_archive
)))
1009 info_msg ("%pI\n", &orig_input
);
1013 /* This is called when BFD has discovered a symbol which is defined
1017 multiple_definition (struct bfd_link_info
*info
,
1018 struct bfd_link_hash_entry
*h
,
1028 if (info
->allow_multiple_definition
)
1033 case bfd_link_hash_defined
:
1034 osec
= h
->u
.def
.section
;
1035 oval
= h
->u
.def
.value
;
1036 obfd
= h
->u
.def
.section
->owner
;
1038 case bfd_link_hash_indirect
:
1039 osec
= bfd_ind_section_ptr
;
1047 /* Ignore a redefinition of an absolute symbol to the
1048 same value; it's harmless. */
1049 if (h
->type
== bfd_link_hash_defined
1050 && bfd_is_abs_section (osec
)
1051 && bfd_is_abs_section (nsec
)
1055 /* If either section has the output_section field set to
1056 bfd_abs_section_ptr, it means that the section is being
1057 discarded, and this is not really a multiple definition at all.
1058 FIXME: It would be cleaner to somehow ignore symbols defined in
1059 sections which are being discarded. */
1060 if (!info
->prohibit_multiple_definition_absolute
1061 && ((osec
->output_section
!= NULL
1062 && ! bfd_is_abs_section (osec
)
1063 && bfd_is_abs_section (osec
->output_section
))
1064 || (nsec
->output_section
!= NULL
1065 && !bfd_is_abs_section (nsec
)
1066 && bfd_is_abs_section (nsec
->output_section
))))
1069 name
= h
->root
.string
;
1077 einfo (_("%X%P: %C: multiple definition of `%pT'"),
1078 nbfd
, nsec
, nval
, name
);
1080 einfo (_("; %D: first defined here"), obfd
, osec
, oval
);
1083 if (RELAXATION_ENABLED_BY_USER
)
1085 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1090 /* This is called when there is a definition of a common symbol, or
1091 when a common symbol is found for a symbol that is already defined,
1092 or when two common symbols are found. We only do something if
1093 -warn-common was used. */
1096 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1097 struct bfd_link_hash_entry
*h
,
1099 enum bfd_link_hash_type ntype
,
1104 enum bfd_link_hash_type otype
;
1107 if (!config
.warn_common
)
1110 name
= h
->root
.string
;
1112 if (otype
== bfd_link_hash_common
)
1114 obfd
= h
->u
.c
.p
->section
->owner
;
1115 osize
= h
->u
.c
.size
;
1117 else if (otype
== bfd_link_hash_defined
1118 || otype
== bfd_link_hash_defweak
)
1120 obfd
= h
->u
.def
.section
->owner
;
1125 /* FIXME: It would nice if we could report the BFD which defined
1126 an indirect symbol, but we don't have anywhere to store the
1132 if (ntype
== bfd_link_hash_defined
1133 || ntype
== bfd_link_hash_defweak
1134 || ntype
== bfd_link_hash_indirect
)
1136 ASSERT (otype
== bfd_link_hash_common
);
1138 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1142 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1145 else if (otype
== bfd_link_hash_defined
1146 || otype
== bfd_link_hash_defweak
1147 || otype
== bfd_link_hash_indirect
)
1149 ASSERT (ntype
== bfd_link_hash_common
);
1151 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1155 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1160 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1164 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1165 " by larger common from %pB\n"),
1168 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1169 " by larger common\n"),
1172 else if (nsize
> osize
)
1175 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1176 " smaller common from %pB\n"),
1179 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1180 " smaller common\n"),
1186 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1189 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1195 /* This is called when BFD has discovered a set element. H is the
1196 entry in the linker hash table for the set. SECTION and VALUE
1197 represent a value which should be added to the set. */
1200 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1201 struct bfd_link_hash_entry
*h
,
1202 bfd_reloc_code_real_type reloc
,
1207 if (config
.warn_constructors
)
1208 einfo (_("%P: warning: global constructor %s used\n"),
1211 if (!config
.build_constructors
)
1214 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1216 if (h
->type
== bfd_link_hash_new
)
1218 h
->type
= bfd_link_hash_undefined
;
1219 h
->u
.undef
.abfd
= abfd
;
1220 /* We don't call bfd_link_add_undef to add this to the list of
1221 undefined symbols because we are going to define it
1226 /* This is called when BFD has discovered a constructor. This is only
1227 called for some object file formats--those which do not handle
1228 constructors in some more clever fashion. This is similar to
1229 adding an element to a set, but less general. */
1232 constructor_callback (struct bfd_link_info
*info
,
1233 bfd_boolean constructor
,
1240 struct bfd_link_hash_entry
*h
;
1241 char set_name
[1 + sizeof "__CTOR_LIST__"];
1243 if (config
.warn_constructors
)
1244 einfo (_("%P: warning: global constructor %s used\n"), name
);
1246 if (!config
.build_constructors
)
1249 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1250 useful error message. */
1251 if (bfd_reloc_type_lookup (info
->output_bfd
, BFD_RELOC_CTOR
) == NULL
1252 && (bfd_link_relocatable (info
)
1253 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1254 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1257 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1258 *s
++ = bfd_get_symbol_leading_char (abfd
);
1260 strcpy (s
, "__CTOR_LIST__");
1262 strcpy (s
, "__DTOR_LIST__");
1264 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1265 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1266 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1267 if (h
->type
== bfd_link_hash_new
)
1269 h
->type
= bfd_link_hash_undefined
;
1270 h
->u
.undef
.abfd
= abfd
;
1271 /* We don't call bfd_link_add_undef to add this to the list of
1272 undefined symbols because we are going to define it
1276 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1279 /* A structure used by warning_callback to pass information through
1280 bfd_map_over_sections. */
1282 struct warning_callback_info
1285 const char *warning
;
1290 /* Look through the relocs to see if we can find a plausible address
1291 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1294 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1296 struct warning_callback_info cinfo
;
1298 if (!bfd_generic_link_read_symbols (abfd
))
1299 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd
);
1301 cinfo
.found
= FALSE
;
1302 cinfo
.warning
= warning
;
1303 cinfo
.symbol
= symbol
;
1304 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1305 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1309 /* This is called when there is a reference to a warning symbol. */
1312 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1313 const char *warning
,
1319 /* This is a hack to support warn_multiple_gp. FIXME: This should
1320 have a cleaner interface, but what? */
1321 if (!config
.warn_multiple_gp
1322 && strcmp (warning
, "using multiple gp values") == 0)
1325 if (section
!= NULL
)
1326 einfo ("%P: %C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1327 else if (abfd
== NULL
)
1328 einfo ("%P: %s%s\n", _("warning: "), warning
);
1329 else if (symbol
== NULL
)
1330 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1331 else if (!symbol_warning (warning
, symbol
, abfd
))
1334 /* Search all input files for a reference to SYMBOL. */
1335 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1336 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1338 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1342 /* This is called by warning_callback for each section. It checks the
1343 relocs of the section to see if it can find a reference to the
1344 symbol which triggered the warning. If it can, it uses the reloc
1345 to give an error message with a file and line number. */
1348 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1350 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1354 arelent
**p
, **pend
;
1359 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1361 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1365 relpp
= (arelent
**) xmalloc (relsize
);
1366 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1368 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1371 pend
= p
+ relcount
;
1372 for (; p
< pend
&& *p
!= NULL
; p
++)
1376 if (q
->sym_ptr_ptr
!= NULL
1377 && *q
->sym_ptr_ptr
!= NULL
1378 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1380 /* We found a reloc for the symbol we are looking for. */
1381 einfo ("%P: %C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1391 #if SUPPORT_ERROR_HANDLING_SCRIPT
1392 char * error_handling_script
= NULL
;
1395 /* This is called when an undefined symbol is found. */
1398 undefined_symbol (struct bfd_link_info
*info
,
1405 static char *error_name
;
1406 static unsigned int error_count
;
1408 #define MAX_ERRORS_IN_A_ROW 5
1410 if (info
->ignore_hash
!= NULL
1411 && bfd_hash_lookup (info
->ignore_hash
, name
, FALSE
, FALSE
) != NULL
)
1414 if (config
.warn_once
)
1416 /* Only warn once about a particular undefined symbol. */
1417 add_ignoresym (info
, name
);
1420 /* We never print more than a reasonable number of errors in a row
1421 for a single symbol. */
1422 if (error_name
!= NULL
1423 && strcmp (name
, error_name
) == 0)
1429 error_name
= xstrdup (name
);
1432 #if SUPPORT_ERROR_HANDLING_SCRIPT
1433 if (error_handling_script
!= NULL
1434 && error_count
< MAX_ERRORS_IN_A_ROW
)
1440 argv
[0] = error_handling_script
;
1441 argv
[1] = "undefined-symbol";
1442 argv
[2] = (char *) name
;
1446 einfo (_("%P: About to run error handling script '%s' with arguments: '%s' '%s'\n"),
1447 argv
[0], argv
[1], argv
[2]);
1449 res
= pex_one (PEX_SEARCH
, error_handling_script
, argv
,
1450 N_("error handling script"),
1451 NULL
/* Send stdout to random, temp file. */,
1452 NULL
/* Write to stderr. */,
1456 einfo (_("%P: Failed to run error handling script '%s', reason: "),
1457 error_handling_script
);
1458 /* FIXME: We assume here that errrno == err. */
1461 /* We ignore the return status of the script and
1462 carry on to issue the normal error message. */
1464 #endif /* SUPPORT_ERROR_HANDLING_SCRIPT */
1466 if (section
!= NULL
)
1468 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1471 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1472 abfd
, section
, address
, name
);
1474 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1475 abfd
, section
, address
, name
);
1477 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1480 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1481 abfd
, section
, address
, name
);
1483 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1484 abfd
, section
, address
, name
);
1491 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1494 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1497 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1500 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1503 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1506 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1514 /* Counter to limit the number of relocation overflow error messages
1515 to print. Errors are printed as it is decremented. When it's
1516 called and the counter is zero, a final message is printed
1517 indicating more relocations were omitted. When it gets to -1, no
1518 such errors are printed. If it's initially set to a value less
1519 than -1, all such errors will be printed (--verbose does this). */
1521 int overflow_cutoff_limit
= 10;
1523 /* This is called when a reloc overflows. */
1526 reloc_overflow (struct bfd_link_info
*info
,
1527 struct bfd_link_hash_entry
*entry
,
1529 const char *reloc_name
,
1535 if (overflow_cutoff_limit
== -1)
1538 einfo ("%X%H:", abfd
, section
, address
);
1540 if (overflow_cutoff_limit
>= 0
1541 && overflow_cutoff_limit
-- == 0)
1543 einfo (_(" additional relocation overflows omitted from the output\n"));
1549 while (entry
->type
== bfd_link_hash_indirect
1550 || entry
->type
== bfd_link_hash_warning
)
1551 entry
= entry
->u
.i
.link
;
1552 switch (entry
->type
)
1554 case bfd_link_hash_undefined
:
1555 case bfd_link_hash_undefweak
:
1556 einfo (_(" relocation truncated to fit: "
1557 "%s against undefined symbol `%pT'"),
1558 reloc_name
, entry
->root
.string
);
1560 case bfd_link_hash_defined
:
1561 case bfd_link_hash_defweak
:
1562 einfo (_(" relocation truncated to fit: "
1563 "%s against symbol `%pT' defined in %pA section in %pB"),
1564 reloc_name
, entry
->root
.string
,
1565 entry
->u
.def
.section
,
1566 entry
->u
.def
.section
== bfd_abs_section_ptr
1567 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1575 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1578 einfo ("+%v", addend
);
1582 /* This is called when a dangerous relocation is made. */
1585 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1586 const char *message
,
1591 einfo (_("%X%H: dangerous relocation: %s\n"),
1592 abfd
, section
, address
, message
);
1595 /* This is called when a reloc is being generated attached to a symbol
1596 that is not being output. */
1599 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1605 einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1606 abfd
, section
, address
, name
);
1609 /* This is called if link_info.notice_all is set, or when a symbol in
1610 link_info.notice_hash is found. Symbols are put in notice_hash
1611 using the -y option, while notice_all is set if the --cref option
1612 has been supplied, or if there are any NOCROSSREFS sections in the
1613 linker script; and if plugins are active, since they need to monitor
1614 all references from non-IR files. */
1617 notice (struct bfd_link_info
*info
,
1618 struct bfd_link_hash_entry
*h
,
1619 struct bfd_link_hash_entry
*inh ATTRIBUTE_UNUSED
,
1623 flagword flags ATTRIBUTE_UNUSED
)
1629 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1630 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1634 name
= h
->root
.string
;
1635 if (info
->notice_hash
!= NULL
1636 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1638 if (bfd_is_und_section (section
))
1639 einfo (_("%P: %pB: reference to %s\n"), abfd
, name
);
1641 einfo (_("%P: %pB: definition of %s\n"), abfd
, name
);
1644 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1645 add_cref (name
, abfd
, section
, value
);