1 /* Main program of GNU linker.
2 Copyright (C) 1991-2022 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 bool 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. */
91 /* TRUE if we should demangle symbol names. */
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 bool 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
*, bool, 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
);
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 #ifdef HAVE_LC_MESSAGES
250 setlocale (LC_MESSAGES
, "");
252 setlocale (LC_CTYPE
, "");
253 bindtextdomain (PACKAGE
, LOCALEDIR
);
254 textdomain (PACKAGE
);
256 program_name
= argv
[0];
257 xmalloc_set_program_name (program_name
);
259 START_PROGRESS (program_name
, 0);
261 expandargv (&argc
, &argv
);
263 if (bfd_init () != BFD_INIT_MAGIC
)
264 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
266 bfd_set_error_program_name (program_name
);
268 /* We want to notice and fail on those nasty BFD assertions which are
269 likely to signal incorrect output being generated but otherwise may
271 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
273 /* Also hook the bfd error/warning handler for --fatal-warnings. */
274 default_bfd_error_handler
= bfd_set_error_handler (ld_bfd_error_handler
);
276 xatexit (ld_cleanup
);
278 /* Set up the sysroot directory. */
279 ld_sysroot
= get_sysroot (argc
, argv
);
281 ld_canon_sysroot
= lrealpath (ld_sysroot
);
282 if (ld_canon_sysroot
)
284 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
286 /* is_sysrooted_pathname() relies on no trailing dirsep. */
287 if (ld_canon_sysroot_len
> 0
288 && IS_DIR_SEPARATOR (ld_canon_sysroot
[ld_canon_sysroot_len
- 1]))
289 ld_canon_sysroot
[--ld_canon_sysroot_len
] = '\0';
292 ld_canon_sysroot_len
= -1;
294 /* Set the default BFD target based on the configured target. Doing
295 this permits the linker to be configured for a particular target,
296 and linked against a shared BFD library which was configured for
297 a different target. The macro TARGET is defined by Makefile. */
298 if (!bfd_set_default_target (TARGET
))
300 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
311 config
.build_constructors
= true;
312 config
.rpath_separator
= ':';
313 config
.split_by_reloc
= (unsigned) -1;
314 config
.split_by_file
= (bfd_size_type
) -1;
315 config
.make_executable
= true;
316 config
.magic_demand_paged
= true;
317 config
.text_read_only
= true;
318 config
.print_map_discarded
= true;
319 link_info
.disable_target_specific_optimizations
= -1;
321 command_line
.warn_mismatch
= true;
322 command_line
.warn_search_mismatch
= true;
323 command_line
.check_section_addresses
= -1;
325 /* We initialize DEMANGLING based on the environment variable
326 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
327 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
328 environment. Acting the same way here lets us provide the same
329 interface by default. */
330 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
332 link_info
.allow_undefined_version
= true;
333 link_info
.keep_memory
= true;
334 link_info
.max_cache_size
= (bfd_size_type
) -1;
335 link_info
.combreloc
= true;
336 link_info
.strip_discarded
= true;
337 link_info
.prohibit_multiple_definition_absolute
= false;
338 link_info
.textrel_check
= DEFAULT_LD_TEXTREL_CHECK
;
339 link_info
.emit_hash
= DEFAULT_EMIT_SYSV_HASH
;
340 link_info
.emit_gnu_hash
= DEFAULT_EMIT_GNU_HASH
;
341 link_info
.callbacks
= &link_callbacks
;
342 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
343 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
344 and _fini symbols. We are compatible. */
345 link_info
.init_function
= "_init";
346 link_info
.fini_function
= "_fini";
347 link_info
.relax_pass
= 1;
348 link_info
.extern_protected_data
= -1;
349 link_info
.dynamic_undefined_weak
= -1;
350 link_info
.indirect_extern_access
= -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_gc
= false;
361 link_info
.start_stop_visibility
= STV_PROTECTED
;
363 ldfile_add_arch ("");
364 emulation
= get_emulation (argc
, argv
);
365 ldemul_choose_mode (emulation
);
366 default_target
= ldemul_choose_target (argc
, argv
);
369 ldemul_before_parse ();
370 lang_has_input_file
= false;
371 parse_args (argc
, argv
);
373 if (config
.hash_table_size
!= 0)
374 bfd_hash_set_default_size (config
.hash_table_size
);
376 #if BFD_SUPPORTS_PLUGINS
377 /* Now all the plugin arguments have been gathered, we can load them. */
378 plugin_load_plugins ();
379 #endif /* BFD_SUPPORTS_PLUGINS */
381 ldemul_set_symbols ();
383 /* If we have not already opened and parsed a linker script,
384 try the default script from command line first. */
385 if (saved_script_handle
== NULL
386 && command_line
.default_script
!= NULL
)
388 ldfile_open_script_file (command_line
.default_script
);
389 parser_input
= input_script
;
393 /* If we have not already opened and parsed a linker script
394 read the emulation's appropriate default script. */
395 if (saved_script_handle
== NULL
)
398 char *s
= ldemul_get_script (&isfile
);
401 ldfile_open_default_command_file (s
);
405 lex_redirect (s
, _("built in linker script"), 1);
407 parser_input
= input_script
;
414 if (saved_script_handle
)
415 info_msg (_("using external linker script:"));
417 info_msg (_("using internal linker script:"));
418 info_msg ("\n==================================================\n");
420 if (saved_script_handle
)
422 static const int ld_bufsz
= 8193;
424 char *buf
= (char *) xmalloc (ld_bufsz
);
426 rewind (saved_script_handle
);
427 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
430 info_msg ("%s", buf
);
432 rewind (saved_script_handle
);
439 info_msg (ldemul_get_script (&isfile
));
442 info_msg ("\n==================================================\n");
445 if (command_line
.force_group_allocation
446 || !bfd_link_relocatable (&link_info
))
447 link_info
.resolve_section_groups
= true;
449 link_info
.resolve_section_groups
= false;
451 if (command_line
.print_output_format
)
452 info_msg ("%s\n", lang_get_output_target ());
456 /* If the only command line argument has been -v or --version or --verbose
457 then ignore any input files provided by linker scripts and exit now.
458 We do not want to create an output file when the linker is just invoked
459 to provide version information. */
460 if (argc
== 2 && version_printed
)
463 if (link_info
.inhibit_common_definition
&& !bfd_link_dll (&link_info
))
464 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
466 if (!lang_has_input_file
)
468 if (version_printed
|| command_line
.print_output_format
)
470 einfo (_("%F%P: no input files\n"));
474 info_msg (_("%P: mode %s\n"), emulation
);
476 ldemul_after_parse ();
478 if (config
.map_filename
)
480 if (strcmp (config
.map_filename
, "-") == 0)
482 config
.map_file
= stdout
;
486 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
487 if (config
.map_file
== (FILE *) NULL
)
489 bfd_set_error (bfd_error_system_call
);
490 einfo (_("%F%P: cannot open map file %s: %E\n"),
491 config
.map_filename
);
494 link_info
.has_map_file
= true;
499 /* Print error messages for any missing symbols, for any warning
500 symbols, and possibly multiple definitions. */
501 if (bfd_link_relocatable (&link_info
))
502 link_info
.output_bfd
->flags
&= ~EXEC_P
;
504 link_info
.output_bfd
->flags
|= EXEC_P
;
506 if ((link_info
.compress_debug
& COMPRESS_DEBUG
))
508 link_info
.output_bfd
->flags
|= BFD_COMPRESS
;
509 if (link_info
.compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
510 link_info
.output_bfd
->flags
|= BFD_COMPRESS_GABI
;
515 if (config
.map_file
!= NULL
)
517 if (command_line
.cref
)
518 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
519 if (nocrossref_list
!= NULL
)
520 check_nocrossrefs ();
521 if (command_line
.print_memory_usage
)
522 lang_print_memory_usage ();
525 struct bfd_link_hash_entry
*h
;
527 h
= bfd_link_hash_lookup (link_info
.hash
, "__image_base__", 0,0,1);
528 fprintf (stderr
, "lookup = %p val %lx\n", h
, h
? h
->u
.def
.value
: 1);
534 if (config
.dependency_file
!= NULL
)
535 write_dependency_file ();
537 /* Even if we're producing relocatable output, some non-fatal errors should
538 be reported in the exit status. (What non-fatal errors, if any, do we
539 want to ignore for relocatable output?) */
540 if (!config
.make_executable
&& !force_make_executable
)
543 einfo (_("%P: link errors found, deleting executable `%s'\n"),
546 /* The file will be removed by ld_cleanup. */
551 if (!bfd_close (link_info
.output_bfd
))
552 einfo (_("%F%P: %pB: final close failed: %E\n"), link_info
.output_bfd
);
554 /* If the --force-exe-suffix is enabled, and we're making an
555 executable file and it doesn't end in .exe, copy it to one
557 if (!bfd_link_relocatable (&link_info
)
558 && command_line
.force_exe_suffix
)
560 int len
= strlen (output_filename
);
563 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
564 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
568 const int bsize
= 4096;
569 char *buf
= (char *) xmalloc (bsize
);
571 char *dst_name
= (char *) xmalloc (len
+ 5);
573 strcpy (dst_name
, output_filename
);
574 strcat (dst_name
, ".exe");
575 src
= fopen (output_filename
, FOPEN_RB
);
576 dst
= fopen (dst_name
, FOPEN_WB
);
579 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
582 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
584 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
586 int done
= fwrite (buf
, 1, l
, dst
);
589 einfo (_("%P: error writing file `%s'\n"), dst_name
);
593 if (fclose (dst
) == EOF
)
594 einfo (_("%P: error closing file `%s'\n"), dst_name
);
601 END_PROGRESS (program_name
);
605 long run_time
= get_run_time () - start_time
;
608 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
609 program_name
, run_time
/ 1000000, run_time
% 1000000);
613 /* Prevent ld_cleanup from doing anything, after a successful link. */
614 output_filename
= NULL
;
620 /* If the configured sysroot is relocatable, try relocating it based on
621 default prefix FROM. Return the relocated directory if it exists,
622 otherwise return null. */
625 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
627 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
631 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
634 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
642 /* Return the sysroot directory. Return "" if no sysroot is being used. */
645 get_sysroot (int argc
, char **argv
)
648 const char *path
= NULL
;
650 for (i
= 1; i
< argc
; i
++)
651 if (startswith (argv
[i
], "--sysroot="))
652 path
= argv
[i
] + strlen ("--sysroot=");
655 path
= get_relative_sysroot (BINDIR
);
658 path
= get_relative_sysroot (TOOLBINDIR
);
661 path
= TARGET_SYSTEM_ROOT
;
663 if (IS_DIR_SEPARATOR (*path
) && path
[1] == 0)
669 /* We need to find any explicitly given emulation in order to initialize the
670 state that's needed by the lex&yacc argument parser (parse_args). */
673 get_emulation (int argc
, char **argv
)
678 emulation
= getenv (EMULATION_ENVIRON
);
679 if (emulation
== NULL
)
680 emulation
= DEFAULT_EMULATION
;
682 for (i
= 1; i
< argc
; i
++)
684 if (startswith (argv
[i
], "-m"))
686 if (argv
[i
][2] == '\0')
691 emulation
= argv
[i
+ 1];
695 einfo (_("%F%P: missing argument to -m\n"));
697 else if (strcmp (argv
[i
], "-mips1") == 0
698 || strcmp (argv
[i
], "-mips2") == 0
699 || strcmp (argv
[i
], "-mips3") == 0
700 || strcmp (argv
[i
], "-mips4") == 0
701 || strcmp (argv
[i
], "-mips5") == 0
702 || strcmp (argv
[i
], "-mips32") == 0
703 || strcmp (argv
[i
], "-mips32r2") == 0
704 || strcmp (argv
[i
], "-mips32r3") == 0
705 || strcmp (argv
[i
], "-mips32r5") == 0
706 || strcmp (argv
[i
], "-mips32r6") == 0
707 || strcmp (argv
[i
], "-mips64") == 0
708 || strcmp (argv
[i
], "-mips64r2") == 0
709 || strcmp (argv
[i
], "-mips64r3") == 0
710 || strcmp (argv
[i
], "-mips64r5") == 0
711 || strcmp (argv
[i
], "-mips64r6") == 0)
713 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
714 passed to the linker by some MIPS compilers. They
715 generally tell the linker to use a slightly different
716 library path. Perhaps someday these should be
717 implemented as emulations; until then, we just ignore
718 the arguments and hope that nobody ever creates
719 emulations named ips1, ips2 or ips3. */
721 else if (strcmp (argv
[i
], "-m486") == 0)
723 /* FIXME: The argument -m486 is passed to the linker on
724 some Linux systems. Hope that nobody creates an
725 emulation named 486. */
730 emulation
= &argv
[i
][2];
739 add_ysym (const char *name
)
741 if (link_info
.notice_hash
== NULL
)
743 link_info
.notice_hash
744 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
745 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
747 sizeof (struct bfd_hash_entry
),
749 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
752 if (bfd_hash_lookup (link_info
.notice_hash
, name
, true, true) == NULL
)
753 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
757 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
759 if (info
->ignore_hash
== NULL
)
761 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
762 if (!bfd_hash_table_init_n (info
->ignore_hash
,
764 sizeof (struct bfd_hash_entry
),
766 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
769 if (bfd_hash_lookup (info
->ignore_hash
, name
, true, true) == NULL
)
770 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
773 /* Record a symbol to be wrapped, from the --wrap option. */
776 add_wrap (const char *name
)
778 if (link_info
.wrap_hash
== NULL
)
781 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
782 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
784 sizeof (struct bfd_hash_entry
),
786 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
789 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, true, true) == NULL
)
790 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
793 /* Handle the -retain-symbols-file option. */
796 add_keepsyms_file (const char *filename
)
803 if (link_info
.strip
== strip_some
)
804 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
806 file
= fopen (filename
, "r");
809 bfd_set_error (bfd_error_system_call
);
810 einfo ("%X%P: %s: %E\n", filename
);
814 link_info
.keep_hash
= (struct bfd_hash_table
*)
815 xmalloc (sizeof (struct bfd_hash_table
));
816 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
817 sizeof (struct bfd_hash_entry
)))
818 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
821 buf
= (char *) xmalloc (bufsize
);
833 while (!ISSPACE (c
) && c
!= EOF
)
840 buf
= (char *) xrealloc (buf
, bufsize
);
847 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, true, true) == NULL
)
848 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
852 if (link_info
.strip
!= strip_none
)
853 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
856 link_info
.strip
= strip_some
;
860 /* Callbacks from the BFD linker routines. */
862 /* This is called when BFD has decided to include an archive member in
866 add_archive_element (struct bfd_link_info
*info
,
869 bfd
**subsbfd ATTRIBUTE_UNUSED
)
871 lang_input_statement_type
*input
;
872 lang_input_statement_type
*parent
;
873 lang_input_statement_type orig_input
;
875 input
= (lang_input_statement_type
*)
876 xcalloc (1, sizeof (lang_input_statement_type
));
877 input
->header
.type
= lang_input_statement_enum
;
878 input
->filename
= bfd_get_filename (abfd
);
879 input
->local_sym_name
= bfd_get_filename (abfd
);
880 input
->the_bfd
= abfd
;
882 /* Save the original data for trace files/tries below, as plugins
883 (if enabled) may possibly alter it to point to a replacement
884 BFD, but we still want to output the original BFD filename. */
886 #if BFD_SUPPORTS_PLUGINS
887 if (link_info
.lto_plugin_active
)
889 /* We must offer this archive member to the plugins to claim. */
890 plugin_maybe_claim (input
);
891 if (input
->flags
.claimed
)
893 if (no_more_claiming
)
895 /* Don't claim new IR symbols after all IR symbols have
898 info_msg ("%pI: no new IR symbols to claim\n",
900 input
->flags
.claimed
= 0;
903 input
->flags
.claim_archive
= true;
904 *subsbfd
= input
->the_bfd
;
907 #endif /* BFD_SUPPORTS_PLUGINS */
909 if (link_info
.input_bfds_tail
== &input
->the_bfd
->link
.next
910 || input
->the_bfd
->link
.next
!= NULL
)
912 /* We have already loaded this element, and are attempting to
913 load it again. This can happen when the archive map doesn't
914 match actual symbols defined by the element. */
916 bfd_set_error (bfd_error_malformed_archive
);
920 /* Set the file_chain pointer of archives to the last element loaded
921 from the archive. See ldlang.c:find_rescan_insertion. */
922 parent
= bfd_usrdata (abfd
->my_archive
);
923 if (parent
!= NULL
&& !parent
->flags
.reload
)
924 parent
->next
= input
;
926 ldlang_add_file (input
);
928 if (config
.map_file
!= NULL
)
930 static bool header_printed
;
931 struct bfd_link_hash_entry
*h
;
935 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
937 && info
->pei386_auto_import
938 && startswith (name
, "__imp_"))
939 h
= bfd_link_hash_lookup (info
->hash
, name
+ 6, false, false, true);
951 case bfd_link_hash_defined
:
952 case bfd_link_hash_defweak
:
953 from
= h
->u
.def
.section
->owner
;
956 case bfd_link_hash_undefined
:
957 case bfd_link_hash_undefweak
:
958 from
= h
->u
.undef
.abfd
;
961 case bfd_link_hash_common
:
962 from
= h
->u
.c
.p
->section
->owner
;
969 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
970 header_printed
= true;
973 if (abfd
->my_archive
== NULL
974 || bfd_is_thin_archive (abfd
->my_archive
))
976 minfo ("%s", bfd_get_filename (abfd
));
977 len
= strlen (bfd_get_filename (abfd
));
981 minfo ("%s(%s)", bfd_get_filename (abfd
->my_archive
),
982 bfd_get_filename (abfd
));
983 len
= (strlen (bfd_get_filename (abfd
->my_archive
))
984 + strlen (bfd_get_filename (abfd
))
993 print_spaces (30 - len
);
996 minfo ("%pB ", from
);
998 minfo ("(%pT)\n", h
->root
.string
);
1000 minfo ("(%s)\n", name
);
1005 || (trace_files
&& bfd_is_thin_archive (orig_input
.the_bfd
->my_archive
)))
1006 info_msg ("%pI\n", &orig_input
);
1010 /* This is called when BFD has discovered a symbol which is defined
1014 multiple_definition (struct bfd_link_info
*info
,
1015 struct bfd_link_hash_entry
*h
,
1025 if (info
->allow_multiple_definition
)
1030 case bfd_link_hash_defined
:
1031 osec
= h
->u
.def
.section
;
1032 oval
= h
->u
.def
.value
;
1033 obfd
= h
->u
.def
.section
->owner
;
1035 case bfd_link_hash_indirect
:
1036 osec
= bfd_ind_section_ptr
;
1044 /* Ignore a redefinition of an absolute symbol to the
1045 same value; it's harmless. */
1046 if (h
->type
== bfd_link_hash_defined
1047 && bfd_is_abs_section (osec
)
1048 && bfd_is_abs_section (nsec
)
1052 /* If either section has the output_section field set to
1053 bfd_abs_section_ptr, it means that the section is being
1054 discarded, and this is not really a multiple definition at all.
1055 FIXME: It would be cleaner to somehow ignore symbols defined in
1056 sections which are being discarded. */
1057 if (!info
->prohibit_multiple_definition_absolute
1058 && ((osec
->output_section
!= NULL
1059 && ! bfd_is_abs_section (osec
)
1060 && bfd_is_abs_section (osec
->output_section
))
1061 || (nsec
->output_section
!= NULL
1062 && !bfd_is_abs_section (nsec
)
1063 && bfd_is_abs_section (nsec
->output_section
))))
1066 name
= h
->root
.string
;
1074 if (info
->warn_multiple_definition
)
1075 einfo (_("%P: %C: warning: multiple definition of `%pT'"),
1076 nbfd
, nsec
, nval
, name
);
1078 einfo (_("%X%P: %C: multiple definition of `%pT'"),
1079 nbfd
, nsec
, nval
, name
);
1081 einfo (_("; %D: first defined here"), obfd
, osec
, oval
);
1084 if (RELAXATION_ENABLED_BY_USER
)
1086 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1091 /* This is called when there is a definition of a common symbol, or
1092 when a common symbol is found for a symbol that is already defined,
1093 or when two common symbols are found. We only do something if
1094 -warn-common was used. */
1097 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1098 struct bfd_link_hash_entry
*h
,
1100 enum bfd_link_hash_type ntype
,
1105 enum bfd_link_hash_type otype
;
1108 if (!config
.warn_common
)
1111 name
= h
->root
.string
;
1113 if (otype
== bfd_link_hash_common
)
1115 obfd
= h
->u
.c
.p
->section
->owner
;
1116 osize
= h
->u
.c
.size
;
1118 else if (otype
== bfd_link_hash_defined
1119 || otype
== bfd_link_hash_defweak
)
1121 obfd
= h
->u
.def
.section
->owner
;
1126 /* FIXME: It would nice if we could report the BFD which defined
1127 an indirect symbol, but we don't have anywhere to store the
1133 if (ntype
== bfd_link_hash_defined
1134 || ntype
== bfd_link_hash_defweak
1135 || ntype
== bfd_link_hash_indirect
)
1137 ASSERT (otype
== bfd_link_hash_common
);
1139 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1143 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1146 else if (otype
== bfd_link_hash_defined
1147 || otype
== bfd_link_hash_defweak
1148 || otype
== bfd_link_hash_indirect
)
1150 ASSERT (ntype
== bfd_link_hash_common
);
1152 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1156 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1161 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1165 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1166 " by larger common from %pB\n"),
1169 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1170 " by larger common\n"),
1173 else if (nsize
> osize
)
1176 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1177 " smaller common from %pB\n"),
1180 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1181 " smaller common\n"),
1187 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1190 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1196 /* This is called when BFD has discovered a set element. H is the
1197 entry in the linker hash table for the set. SECTION and VALUE
1198 represent a value which should be added to the set. */
1201 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1202 struct bfd_link_hash_entry
*h
,
1203 bfd_reloc_code_real_type reloc
,
1208 if (config
.warn_constructors
)
1209 einfo (_("%P: warning: global constructor %s used\n"),
1212 if (!config
.build_constructors
)
1215 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1217 if (h
->type
== bfd_link_hash_new
)
1219 h
->type
= bfd_link_hash_undefined
;
1220 h
->u
.undef
.abfd
= abfd
;
1221 /* We don't call bfd_link_add_undef to add this to the list of
1222 undefined symbols because we are going to define it
1227 /* This is called when BFD has discovered a constructor. This is only
1228 called for some object file formats--those which do not handle
1229 constructors in some more clever fashion. This is similar to
1230 adding an element to a set, but less general. */
1233 constructor_callback (struct bfd_link_info
*info
,
1241 struct bfd_link_hash_entry
*h
;
1242 char set_name
[1 + sizeof "__CTOR_LIST__"];
1244 if (config
.warn_constructors
)
1245 einfo (_("%P: warning: global constructor %s used\n"), name
);
1247 if (!config
.build_constructors
)
1250 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1251 useful error message. */
1252 if (bfd_reloc_type_lookup (info
->output_bfd
, BFD_RELOC_CTOR
) == NULL
1253 && (bfd_link_relocatable (info
)
1254 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1255 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1258 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1259 *s
++ = bfd_get_symbol_leading_char (abfd
);
1261 strcpy (s
, "__CTOR_LIST__");
1263 strcpy (s
, "__DTOR_LIST__");
1265 h
= bfd_link_hash_lookup (info
->hash
, set_name
, true, true, true);
1266 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1267 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1268 if (h
->type
== bfd_link_hash_new
)
1270 h
->type
= bfd_link_hash_undefined
;
1271 h
->u
.undef
.abfd
= abfd
;
1272 /* We don't call bfd_link_add_undef to add this to the list of
1273 undefined symbols because we are going to define it
1277 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1280 /* A structure used by warning_callback to pass information through
1281 bfd_map_over_sections. */
1283 struct warning_callback_info
1286 const char *warning
;
1291 /* Look through the relocs to see if we can find a plausible address
1292 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1295 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1297 struct warning_callback_info cinfo
;
1299 if (!bfd_generic_link_read_symbols (abfd
))
1300 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd
);
1302 cinfo
.found
= false;
1303 cinfo
.warning
= warning
;
1304 cinfo
.symbol
= symbol
;
1305 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1306 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1310 /* This is called when there is a reference to a warning symbol. */
1313 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1314 const char *warning
,
1320 /* This is a hack to support warn_multiple_gp. FIXME: This should
1321 have a cleaner interface, but what? */
1322 if (!config
.warn_multiple_gp
1323 && strcmp (warning
, "using multiple gp values") == 0)
1326 if (section
!= NULL
)
1327 einfo ("%P: %C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1328 else if (abfd
== NULL
)
1329 einfo ("%P: %s%s\n", _("warning: "), warning
);
1330 else if (symbol
== NULL
)
1331 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1332 else if (!symbol_warning (warning
, symbol
, abfd
))
1335 /* Search all input files for a reference to SYMBOL. */
1336 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1337 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1339 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1343 /* This is called by warning_callback for each section. It checks the
1344 relocs of the section to see if it can find a reference to the
1345 symbol which triggered the warning. If it can, it uses the reloc
1346 to give an error message with a file and line number. */
1349 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1351 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1355 arelent
**p
, **pend
;
1360 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1362 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1366 relpp
= (arelent
**) xmalloc (relsize
);
1367 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1369 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1372 pend
= p
+ relcount
;
1373 for (; p
< pend
&& *p
!= NULL
; p
++)
1377 if (q
->sym_ptr_ptr
!= NULL
1378 && *q
->sym_ptr_ptr
!= NULL
1379 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1381 /* We found a reloc for the symbol we are looking for. */
1382 einfo ("%P: %C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1392 #if SUPPORT_ERROR_HANDLING_SCRIPT
1393 char * error_handling_script
= NULL
;
1396 /* This is called when an undefined symbol is found. */
1399 undefined_symbol (struct bfd_link_info
*info
,
1406 static char *error_name
;
1407 static unsigned int error_count
;
1409 #define MAX_ERRORS_IN_A_ROW 5
1411 if (info
->ignore_hash
!= NULL
1412 && bfd_hash_lookup (info
->ignore_hash
, name
, false, false) != NULL
)
1415 if (config
.warn_once
)
1417 /* Only warn once about a particular undefined symbol. */
1418 add_ignoresym (info
, name
);
1421 /* We never print more than a reasonable number of errors in a row
1422 for a single symbol. */
1423 if (error_name
!= NULL
1424 && strcmp (name
, error_name
) == 0)
1430 error_name
= xstrdup (name
);
1433 #if SUPPORT_ERROR_HANDLING_SCRIPT
1434 if (error_handling_script
!= NULL
1435 && error_count
< MAX_ERRORS_IN_A_ROW
)
1441 argv
[0] = error_handling_script
;
1442 argv
[1] = "undefined-symbol";
1443 argv
[2] = (char *) name
;
1447 einfo (_("%P: About to run error handling script '%s' with arguments: '%s' '%s'\n"),
1448 argv
[0], argv
[1], argv
[2]);
1450 res
= pex_one (PEX_SEARCH
, error_handling_script
, argv
,
1451 N_("error handling script"),
1452 NULL
/* Send stdout to random, temp file. */,
1453 NULL
/* Write to stderr. */,
1457 einfo (_("%P: Failed to run error handling script '%s', reason: "),
1458 error_handling_script
);
1459 /* FIXME: We assume here that errrno == err. */
1462 /* We ignore the return status of the script and
1463 carry on to issue the normal error message. */
1465 #endif /* SUPPORT_ERROR_HANDLING_SCRIPT */
1467 if (section
!= NULL
)
1469 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1472 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1473 abfd
, section
, address
, name
);
1475 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1476 abfd
, section
, address
, name
);
1478 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1481 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1482 abfd
, section
, address
, name
);
1484 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1485 abfd
, section
, address
, name
);
1492 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1495 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1498 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1501 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1504 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1507 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1515 /* Counter to limit the number of relocation overflow error messages
1516 to print. Errors are printed as it is decremented. When it's
1517 called and the counter is zero, a final message is printed
1518 indicating more relocations were omitted. When it gets to -1, no
1519 such errors are printed. If it's initially set to a value less
1520 than -1, all such errors will be printed (--verbose does this). */
1522 int overflow_cutoff_limit
= 10;
1524 /* This is called when a reloc overflows. */
1527 reloc_overflow (struct bfd_link_info
*info
,
1528 struct bfd_link_hash_entry
*entry
,
1530 const char *reloc_name
,
1536 if (overflow_cutoff_limit
== -1)
1539 einfo ("%X%H:", abfd
, section
, address
);
1541 if (overflow_cutoff_limit
>= 0
1542 && overflow_cutoff_limit
-- == 0)
1544 einfo (_(" additional relocation overflows omitted from the output\n"));
1550 while (entry
->type
== bfd_link_hash_indirect
1551 || entry
->type
== bfd_link_hash_warning
)
1552 entry
= entry
->u
.i
.link
;
1553 switch (entry
->type
)
1555 case bfd_link_hash_undefined
:
1556 case bfd_link_hash_undefweak
:
1557 einfo (_(" relocation truncated to fit: "
1558 "%s against undefined symbol `%pT'"),
1559 reloc_name
, entry
->root
.string
);
1561 case bfd_link_hash_defined
:
1562 case bfd_link_hash_defweak
:
1563 einfo (_(" relocation truncated to fit: "
1564 "%s against symbol `%pT' defined in %pA section in %pB"),
1565 reloc_name
, entry
->root
.string
,
1566 entry
->u
.def
.section
,
1567 entry
->u
.def
.section
== bfd_abs_section_ptr
1568 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1576 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1579 einfo ("+%v", addend
);
1583 /* This is called when a dangerous relocation is made. */
1586 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1587 const char *message
,
1592 einfo (_("%X%H: dangerous relocation: %s\n"),
1593 abfd
, section
, address
, message
);
1596 /* This is called when a reloc is being generated attached to a symbol
1597 that is not being output. */
1600 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1606 einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1607 abfd
, section
, address
, name
);
1610 /* This is called if link_info.notice_all is set, or when a symbol in
1611 link_info.notice_hash is found. Symbols are put in notice_hash
1612 using the -y option, while notice_all is set if the --cref option
1613 has been supplied, or if there are any NOCROSSREFS sections in the
1614 linker script; and if plugins are active, since they need to monitor
1615 all references from non-IR files. */
1618 notice (struct bfd_link_info
*info
,
1619 struct bfd_link_hash_entry
*h
,
1620 struct bfd_link_hash_entry
*inh ATTRIBUTE_UNUSED
,
1624 flagword flags ATTRIBUTE_UNUSED
)
1630 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1631 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1635 name
= h
->root
.string
;
1636 if (info
->notice_hash
!= NULL
1637 && bfd_hash_lookup (info
->notice_hash
, name
, false, false) != NULL
)
1639 if (bfd_is_und_section (section
))
1640 einfo (_("%P: %pB: reference to %s\n"), abfd
, name
);
1642 einfo (_("%P: %pB: definition of %s\n"), abfd
, name
);
1645 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1646 add_cref (name
, abfd
, section
, value
);