1 /* Main program of GNU linker.
2 Copyright (C) 1991-2023 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"
28 #include "filenames.h"
29 #include "elf/common.h"
42 #if BFD_SUPPORTS_PLUGINS
44 #include "plugin-api.h"
45 #endif /* BFD_SUPPORTS_PLUGINS */
47 /* Somewhere above, sys/stat.h got included. */
48 #if !defined(S_ISDIR) && defined(S_IFDIR)
49 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
54 #ifndef TARGET_SYSTEM_ROOT
55 #define TARGET_SYSTEM_ROOT ""
60 FILE *saved_script_handle
= NULL
;
61 FILE *previous_script_handle
= NULL
;
62 bool force_make_executable
= false;
65 const char *output_filename
= "a.out";
67 /* Name this program was invoked by. */
70 /* The prefix for system library directories. */
71 const char *ld_sysroot
;
73 /* The canonical representation of ld_sysroot. */
74 char *ld_canon_sysroot
;
75 int ld_canon_sysroot_len
;
77 /* Set by -G argument, for targets like MIPS ELF. */
78 int g_switch_value
= 8;
80 /* Nonzero means print names of input files as processed. */
81 unsigned int trace_files
;
83 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
86 /* Nonzero means version number was printed, so exit successfully
87 instead of complaining if no input files are given. */
90 /* TRUE if we should demangle symbol names. */
93 args_type command_line
;
95 ld_config_type config
;
97 sort_type sort_section
;
99 static const char *get_sysroot
101 static char *get_emulation
103 static bool add_archive_element
104 (struct bfd_link_info
*, bfd
*, const char *, bfd
**);
105 static void multiple_definition
106 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
107 bfd
*, asection
*, bfd_vma
);
108 static void multiple_common
109 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
110 bfd
*, enum bfd_link_hash_type
, bfd_vma
);
111 static void add_to_set
112 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
113 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
114 static void constructor_callback
115 (struct bfd_link_info
*, bool, const char *, bfd
*,
116 asection
*, bfd_vma
);
117 static void warning_callback
118 (struct bfd_link_info
*, const char *, const char *, bfd
*,
119 asection
*, bfd_vma
);
120 static void warning_find_reloc
121 (bfd
*, asection
*, void *);
122 static void undefined_symbol
123 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
125 static void reloc_overflow
126 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
127 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
128 static void reloc_dangerous
129 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
130 static void unattached_reloc
131 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
133 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
134 struct bfd_link_hash_entry
*, bfd
*, asection
*, bfd_vma
, flagword
);
136 static struct bfd_link_callbacks link_callbacks
=
142 constructor_callback
,
152 ldlang_override_segment_assignment
,
153 ldlang_ctf_acquire_strings
,
155 ldlang_ctf_new_dynsym
,
156 ldlang_write_ctf_late
159 static bfd_assert_handler_type default_bfd_assert_handler
;
160 static bfd_error_handler_type default_bfd_error_handler
;
162 struct bfd_link_info link_info
;
164 struct dependency_file
166 struct dependency_file
*next
;
170 static struct dependency_file
*dependency_files
, *dependency_files_tail
;
173 track_dependency_files (const char *filename
)
175 struct dependency_file
*dep
176 = (struct dependency_file
*) xmalloc (sizeof (*dep
));
177 dep
->name
= xstrdup (filename
);
179 if (dependency_files
== NULL
)
180 dependency_files
= dep
;
182 dependency_files_tail
->next
= dep
;
183 dependency_files_tail
= dep
;
187 write_dependency_file (void)
190 struct dependency_file
*dep
;
192 out
= fopen (config
.dependency_file
, FOPEN_WT
);
195 einfo (_("%F%P: cannot open dependency file %s: %E\n"),
196 config
.dependency_file
);
199 fprintf (out
, "%s:", output_filename
);
201 for (dep
= dependency_files
; dep
!= NULL
; dep
= dep
->next
)
202 fprintf (out
, " \\\n %s", dep
->name
);
205 for (dep
= dependency_files
; dep
!= NULL
; dep
= dep
->next
)
206 fprintf (out
, "\n%s:\n", dep
->name
);
215 if (link_info
.output_bfd
)
216 bfd_close_all_done (link_info
.output_bfd
);
217 for (ibfd
= link_info
.input_bfds
; ibfd
; ibfd
= inext
)
219 inext
= ibfd
->link
.next
;
220 bfd_close_all_done (ibfd
);
222 #if BFD_SUPPORTS_PLUGINS
223 plugin_call_cleanup ();
225 if (output_filename
&& delete_output_file_on_failure
)
226 unlink_if_ordinary (output_filename
);
229 /* Hook to notice BFD assertions. */
232 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
233 const char *file
, int line
)
235 config
.make_executable
= false;
236 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
239 /* Hook the bfd error/warning handler for --fatal-warnings. */
242 ld_bfd_error_handler (const char *fmt
, va_list ap
)
244 if (config
.fatal_warnings
)
245 config
.make_executable
= false;
246 (*default_bfd_error_handler
) (fmt
, ap
);
250 main (int argc
, char **argv
)
253 long start_time
= get_run_time ();
255 #ifdef HAVE_LC_MESSAGES
256 setlocale (LC_MESSAGES
, "");
258 setlocale (LC_CTYPE
, "");
259 bindtextdomain (PACKAGE
, LOCALEDIR
);
260 textdomain (PACKAGE
);
262 program_name
= argv
[0];
263 xmalloc_set_program_name (program_name
);
265 expandargv (&argc
, &argv
);
267 if (bfd_init () != BFD_INIT_MAGIC
)
268 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
270 bfd_set_error_program_name (program_name
);
272 /* We want to notice and fail on those nasty BFD assertions which are
273 likely to signal incorrect output being generated but otherwise may
275 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
277 /* Also hook the bfd error/warning handler for --fatal-warnings. */
278 default_bfd_error_handler
= bfd_set_error_handler (ld_bfd_error_handler
);
280 xatexit (ld_cleanup
);
282 /* Set up the sysroot directory. */
283 ld_sysroot
= get_sysroot (argc
, argv
);
285 ld_canon_sysroot
= lrealpath (ld_sysroot
);
286 if (ld_canon_sysroot
)
288 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
290 /* is_sysrooted_pathname() relies on no trailing dirsep. */
291 if (ld_canon_sysroot_len
> 0
292 && IS_DIR_SEPARATOR (ld_canon_sysroot
[ld_canon_sysroot_len
- 1]))
293 ld_canon_sysroot
[--ld_canon_sysroot_len
] = '\0';
296 ld_canon_sysroot_len
= -1;
298 /* Set the default BFD target based on the configured target. Doing
299 this permits the linker to be configured for a particular target,
300 and linked against a shared BFD library which was configured for
301 a different target. The macro TARGET is defined by Makefile. */
302 if (!bfd_set_default_target (TARGET
))
304 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
315 config
.build_constructors
= true;
316 config
.rpath_separator
= ':';
317 config
.split_by_reloc
= (unsigned) -1;
318 config
.split_by_file
= (bfd_size_type
) -1;
319 config
.make_executable
= true;
320 config
.magic_demand_paged
= true;
321 config
.text_read_only
= true;
322 config
.print_map_discarded
= true;
323 link_info
.disable_target_specific_optimizations
= -1;
325 command_line
.warn_mismatch
= true;
326 command_line
.warn_search_mismatch
= true;
327 command_line
.check_section_addresses
= -1;
329 /* We initialize DEMANGLING based on the environment variable
330 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
331 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
332 environment. Acting the same way here lets us provide the same
333 interface by default. */
334 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
336 link_info
.allow_undefined_version
= true;
337 link_info
.keep_memory
= true;
338 link_info
.max_cache_size
= (bfd_size_type
) -1;
339 link_info
.combreloc
= true;
340 link_info
.strip_discarded
= true;
341 link_info
.prohibit_multiple_definition_absolute
= false;
342 link_info
.textrel_check
= DEFAULT_LD_TEXTREL_CHECK
;
343 link_info
.emit_hash
= DEFAULT_EMIT_SYSV_HASH
;
344 link_info
.emit_gnu_hash
= DEFAULT_EMIT_GNU_HASH
;
345 link_info
.callbacks
= &link_callbacks
;
346 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
347 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
348 and _fini symbols. We are compatible. */
349 link_info
.init_function
= "_init";
350 link_info
.fini_function
= "_fini";
351 link_info
.relax_pass
= 1;
352 link_info
.extern_protected_data
= -1;
353 link_info
.dynamic_undefined_weak
= -1;
354 link_info
.indirect_extern_access
= -1;
355 link_info
.pei386_auto_import
= -1;
356 link_info
.spare_dynamic_tags
= 5;
357 link_info
.path_separator
= ':';
358 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
359 config
.compress_debug
= DEFAULT_COMPRESSED_DEBUG_ALGORITHM
;
361 #ifdef DEFAULT_NEW_DTAGS
362 link_info
.new_dtags
= DEFAULT_NEW_DTAGS
;
364 link_info
.start_stop_gc
= false;
365 link_info
.start_stop_visibility
= STV_PROTECTED
;
367 ldfile_add_arch ("");
368 emulation
= get_emulation (argc
, argv
);
369 ldemul_choose_mode (emulation
);
370 default_target
= ldemul_choose_target (argc
, argv
);
373 ldemul_before_parse ();
374 lang_has_input_file
= false;
375 parse_args (argc
, argv
);
377 if (config
.hash_table_size
!= 0)
378 bfd_hash_set_default_size (config
.hash_table_size
);
380 #if BFD_SUPPORTS_PLUGINS
381 /* Now all the plugin arguments have been gathered, we can load them. */
382 plugin_load_plugins ();
383 #endif /* BFD_SUPPORTS_PLUGINS */
385 ldemul_set_symbols ();
387 /* If we have not already opened and parsed a linker script,
388 try the default script from command line first. */
389 if (saved_script_handle
== NULL
390 && command_line
.default_script
!= NULL
)
392 ldfile_open_script_file (command_line
.default_script
);
393 parser_input
= input_script
;
397 /* If we have not already opened and parsed a linker script
398 read the emulation's appropriate default script. */
399 if (saved_script_handle
== NULL
)
402 char *s
= ldemul_get_script (&isfile
);
405 ldfile_open_default_command_file (s
);
409 lex_redirect (s
, _("built in linker script"), 1);
411 parser_input
= input_script
;
418 if (saved_script_handle
)
419 info_msg (_("using external linker script:"));
421 info_msg (_("using internal linker script:"));
422 info_msg ("\n==================================================\n");
424 if (saved_script_handle
)
426 static const int ld_bufsz
= 8193;
428 char *buf
= (char *) xmalloc (ld_bufsz
);
430 rewind (saved_script_handle
);
431 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
434 info_msg ("%s", buf
);
436 rewind (saved_script_handle
);
443 info_msg (ldemul_get_script (&isfile
));
446 info_msg ("\n==================================================\n");
449 if (command_line
.force_group_allocation
450 || !bfd_link_relocatable (&link_info
))
451 link_info
.resolve_section_groups
= true;
453 link_info
.resolve_section_groups
= false;
455 if (command_line
.print_output_format
)
456 info_msg ("%s\n", lang_get_output_target ());
460 /* If the only command line argument has been -v or --version or --verbose
461 then ignore any input files provided by linker scripts and exit now.
462 We do not want to create an output file when the linker is just invoked
463 to provide version information. */
464 if (argc
== 2 && version_printed
)
467 if (link_info
.inhibit_common_definition
&& !bfd_link_dll (&link_info
))
468 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
470 if (!lang_has_input_file
)
472 if (version_printed
|| command_line
.print_output_format
)
474 einfo (_("%F%P: no input files\n"));
478 info_msg (_("%P: mode %s\n"), emulation
);
480 ldemul_after_parse ();
482 if (config
.map_filename
)
484 if (strcmp (config
.map_filename
, "-") == 0)
486 config
.map_file
= stdout
;
490 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
491 if (config
.map_file
== (FILE *) NULL
)
493 bfd_set_error (bfd_error_system_call
);
494 einfo (_("%F%P: cannot open map file %s: %E\n"),
495 config
.map_filename
);
498 link_info
.has_map_file
= true;
503 /* Print error messages for any missing symbols, for any warning
504 symbols, and possibly multiple definitions. */
505 if (bfd_link_relocatable (&link_info
))
506 link_info
.output_bfd
->flags
&= ~EXEC_P
;
508 link_info
.output_bfd
->flags
|= EXEC_P
;
511 switch (config
.compress_debug
)
513 case COMPRESS_DEBUG_GNU_ZLIB
:
514 flags
= BFD_COMPRESS
;
516 case COMPRESS_DEBUG_GABI_ZLIB
:
517 flags
= BFD_COMPRESS
| BFD_COMPRESS_GABI
;
519 case COMPRESS_DEBUG_ZSTD
:
520 flags
= BFD_COMPRESS
| BFD_COMPRESS_GABI
| BFD_COMPRESS_ZSTD
;
525 link_info
.output_bfd
->flags
526 |= flags
& bfd_applicable_file_flags (link_info
.output_bfd
);
530 if (config
.map_file
!= NULL
)
532 if (command_line
.cref
)
533 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
534 if (nocrossref_list
!= NULL
)
535 check_nocrossrefs ();
536 if (command_line
.print_memory_usage
)
537 lang_print_memory_usage ();
540 struct bfd_link_hash_entry
*h
;
542 h
= bfd_link_hash_lookup (link_info
.hash
, "__image_base__", 0,0,1);
543 fprintf (stderr
, "lookup = %p val %lx\n", h
, h
? h
->u
.def
.value
: 1);
549 if (config
.dependency_file
!= NULL
)
550 write_dependency_file ();
552 /* Even if we're producing relocatable output, some non-fatal errors should
553 be reported in the exit status. (What non-fatal errors, if any, do we
554 want to ignore for relocatable output?) */
555 if (!config
.make_executable
&& !force_make_executable
)
558 einfo (_("%P: link errors found, deleting executable `%s'\n"),
561 /* The file will be removed by ld_cleanup. */
566 bfd
*obfd
= link_info
.output_bfd
;
567 link_info
.output_bfd
= NULL
;
568 if (!bfd_close (obfd
))
569 einfo (_("%F%P: %s: final close failed: %E\n"), output_filename
);
571 /* If the --force-exe-suffix is enabled, and we're making an
572 executable file and it doesn't end in .exe, copy it to one
574 if (!bfd_link_relocatable (&link_info
)
575 && command_line
.force_exe_suffix
)
577 int len
= strlen (output_filename
);
580 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
581 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
585 const int bsize
= 4096;
586 char *buf
= (char *) xmalloc (bsize
);
588 char *dst_name
= (char *) xmalloc (len
+ 5);
590 strcpy (dst_name
, output_filename
);
591 strcat (dst_name
, ".exe");
592 src
= fopen (output_filename
, FOPEN_RB
);
593 dst
= fopen (dst_name
, FOPEN_WB
);
596 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
599 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
601 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
603 int done
= fwrite (buf
, 1, l
, dst
);
606 einfo (_("%P: error writing file `%s'\n"), dst_name
);
610 if (fclose (dst
) == EOF
)
611 einfo (_("%P: error closing file `%s'\n"), dst_name
);
620 long run_time
= get_run_time () - start_time
;
623 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
624 program_name
, run_time
/ 1000000, run_time
% 1000000);
628 /* Prevent ld_cleanup from deleting the output file. */
629 output_filename
= NULL
;
635 /* If the configured sysroot is relocatable, try relocating it based on
636 default prefix FROM. Return the relocated directory if it exists,
637 otherwise return null. */
640 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
642 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
646 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
649 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
657 /* Return the sysroot directory. Return "" if no sysroot is being used. */
660 get_sysroot (int argc
, char **argv
)
663 const char *path
= NULL
;
665 for (i
= 1; i
< argc
; i
++)
666 if (startswith (argv
[i
], "--sysroot="))
667 path
= argv
[i
] + strlen ("--sysroot=");
670 path
= get_relative_sysroot (BINDIR
);
673 path
= get_relative_sysroot (TOOLBINDIR
);
676 path
= TARGET_SYSTEM_ROOT
;
678 if (IS_DIR_SEPARATOR (*path
) && path
[1] == 0)
684 /* We need to find any explicitly given emulation in order to initialize the
685 state that's needed by the lex&yacc argument parser (parse_args). */
688 get_emulation (int argc
, char **argv
)
693 emulation
= getenv (EMULATION_ENVIRON
);
694 if (emulation
== NULL
)
695 emulation
= DEFAULT_EMULATION
;
697 for (i
= 1; i
< argc
; i
++)
699 if (startswith (argv
[i
], "-m"))
701 if (argv
[i
][2] == '\0')
706 emulation
= argv
[i
+ 1];
710 einfo (_("%F%P: missing argument to -m\n"));
712 else if (strcmp (argv
[i
], "-mips1") == 0
713 || strcmp (argv
[i
], "-mips2") == 0
714 || strcmp (argv
[i
], "-mips3") == 0
715 || strcmp (argv
[i
], "-mips4") == 0
716 || strcmp (argv
[i
], "-mips5") == 0
717 || strcmp (argv
[i
], "-mips32") == 0
718 || strcmp (argv
[i
], "-mips32r2") == 0
719 || strcmp (argv
[i
], "-mips32r3") == 0
720 || strcmp (argv
[i
], "-mips32r5") == 0
721 || strcmp (argv
[i
], "-mips32r6") == 0
722 || strcmp (argv
[i
], "-mips64") == 0
723 || strcmp (argv
[i
], "-mips64r2") == 0
724 || strcmp (argv
[i
], "-mips64r3") == 0
725 || strcmp (argv
[i
], "-mips64r5") == 0
726 || strcmp (argv
[i
], "-mips64r6") == 0)
728 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
729 passed to the linker by some MIPS compilers. They
730 generally tell the linker to use a slightly different
731 library path. Perhaps someday these should be
732 implemented as emulations; until then, we just ignore
733 the arguments and hope that nobody ever creates
734 emulations named ips1, ips2 or ips3. */
736 else if (strcmp (argv
[i
], "-m486") == 0)
738 /* FIXME: The argument -m486 is passed to the linker on
739 some Linux systems. Hope that nobody creates an
740 emulation named 486. */
745 emulation
= &argv
[i
][2];
754 add_ysym (const char *name
)
756 if (link_info
.notice_hash
== NULL
)
758 link_info
.notice_hash
759 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
760 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
762 sizeof (struct bfd_hash_entry
),
764 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
767 if (bfd_hash_lookup (link_info
.notice_hash
, name
, true, true) == NULL
)
768 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
772 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
774 if (info
->ignore_hash
== NULL
)
776 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
777 if (!bfd_hash_table_init_n (info
->ignore_hash
,
779 sizeof (struct bfd_hash_entry
),
781 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
784 if (bfd_hash_lookup (info
->ignore_hash
, name
, true, true) == NULL
)
785 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
788 /* Record a symbol to be wrapped, from the --wrap option. */
791 add_wrap (const char *name
)
793 if (link_info
.wrap_hash
== NULL
)
796 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
797 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
799 sizeof (struct bfd_hash_entry
),
801 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
804 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, true, true) == NULL
)
805 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
808 /* Handle the -retain-symbols-file option. */
811 add_keepsyms_file (const char *filename
)
818 if (link_info
.strip
== strip_some
)
819 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
821 file
= fopen (filename
, "r");
824 bfd_set_error (bfd_error_system_call
);
825 einfo ("%X%P: %s: %E\n", filename
);
829 link_info
.keep_hash
= (struct bfd_hash_table
*)
830 xmalloc (sizeof (struct bfd_hash_table
));
831 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
832 sizeof (struct bfd_hash_entry
)))
833 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
836 buf
= (char *) xmalloc (bufsize
);
848 while (!ISSPACE (c
) && c
!= EOF
)
855 buf
= (char *) xrealloc (buf
, bufsize
);
862 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, true, true) == NULL
)
863 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
867 if (link_info
.strip
!= strip_none
)
868 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
871 link_info
.strip
= strip_some
;
875 /* Callbacks from the BFD linker routines. */
877 /* This is called when BFD has decided to include an archive member in
881 add_archive_element (struct bfd_link_info
*info
,
884 bfd
**subsbfd ATTRIBUTE_UNUSED
)
886 lang_input_statement_type
*input
;
887 lang_input_statement_type
*parent
;
888 lang_input_statement_type orig_input
;
890 input
= (lang_input_statement_type
*)
891 xcalloc (1, sizeof (lang_input_statement_type
));
892 input
->header
.type
= lang_input_statement_enum
;
893 input
->filename
= bfd_get_filename (abfd
);
894 input
->local_sym_name
= bfd_get_filename (abfd
);
895 input
->the_bfd
= abfd
;
897 /* Save the original data for trace files/tries below, as plugins
898 (if enabled) may possibly alter it to point to a replacement
899 BFD, but we still want to output the original BFD filename. */
901 #if BFD_SUPPORTS_PLUGINS
902 if (link_info
.lto_plugin_active
)
904 /* We must offer this archive member to the plugins to claim. */
905 plugin_maybe_claim (input
);
906 if (input
->flags
.claimed
)
908 if (no_more_claiming
)
910 /* Don't claim new IR symbols after all IR symbols have
913 info_msg ("%pI: no new IR symbols to claim\n",
915 input
->flags
.claimed
= 0;
918 input
->flags
.claim_archive
= true;
919 *subsbfd
= input
->the_bfd
;
922 #endif /* BFD_SUPPORTS_PLUGINS */
924 if (link_info
.input_bfds_tail
== &input
->the_bfd
->link
.next
925 || input
->the_bfd
->link
.next
!= NULL
)
927 /* We have already loaded this element, and are attempting to
928 load it again. This can happen when the archive map doesn't
929 match actual symbols defined by the element. */
931 bfd_set_error (bfd_error_malformed_archive
);
935 /* Set the file_chain pointer of archives to the last element loaded
936 from the archive. See ldlang.c:find_rescan_insertion. */
937 parent
= bfd_usrdata (abfd
->my_archive
);
938 if (parent
!= NULL
&& !parent
->flags
.reload
)
939 parent
->next
= input
;
941 ldlang_add_file (input
);
943 if (config
.map_file
!= NULL
)
945 static bool header_printed
;
946 struct bfd_link_hash_entry
*h
;
950 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
952 && info
->pei386_auto_import
953 && startswith (name
, "__imp_"))
954 h
= bfd_link_hash_lookup (info
->hash
, name
+ 6, false, false, true);
966 case bfd_link_hash_defined
:
967 case bfd_link_hash_defweak
:
968 from
= h
->u
.def
.section
->owner
;
971 case bfd_link_hash_undefined
:
972 case bfd_link_hash_undefweak
:
973 from
= h
->u
.undef
.abfd
;
976 case bfd_link_hash_common
:
977 from
= h
->u
.c
.p
->section
->owner
;
984 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
985 header_printed
= true;
988 if (abfd
->my_archive
== NULL
989 || bfd_is_thin_archive (abfd
->my_archive
))
991 minfo ("%s", bfd_get_filename (abfd
));
992 len
= strlen (bfd_get_filename (abfd
));
996 minfo ("%s(%s)", bfd_get_filename (abfd
->my_archive
),
997 bfd_get_filename (abfd
));
998 len
= (strlen (bfd_get_filename (abfd
->my_archive
))
999 + strlen (bfd_get_filename (abfd
))
1008 print_spaces (30 - len
);
1011 minfo ("%pB ", from
);
1013 minfo ("(%pT)\n", h
->root
.string
);
1015 minfo ("(%s)\n", name
);
1020 || (trace_files
&& bfd_is_thin_archive (orig_input
.the_bfd
->my_archive
)))
1021 info_msg ("%pI\n", &orig_input
);
1025 /* This is called when BFD has discovered a symbol which is defined
1029 multiple_definition (struct bfd_link_info
*info
,
1030 struct bfd_link_hash_entry
*h
,
1040 if (info
->allow_multiple_definition
)
1045 case bfd_link_hash_defined
:
1046 osec
= h
->u
.def
.section
;
1047 oval
= h
->u
.def
.value
;
1048 obfd
= h
->u
.def
.section
->owner
;
1050 case bfd_link_hash_indirect
:
1051 osec
= bfd_ind_section_ptr
;
1059 /* Ignore a redefinition of an absolute symbol to the
1060 same value; it's harmless. */
1061 if (h
->type
== bfd_link_hash_defined
1062 && bfd_is_abs_section (osec
)
1063 && bfd_is_abs_section (nsec
)
1067 /* If either section has the output_section field set to
1068 bfd_abs_section_ptr, it means that the section is being
1069 discarded, and this is not really a multiple definition at all.
1070 FIXME: It would be cleaner to somehow ignore symbols defined in
1071 sections which are being discarded. */
1072 if (!info
->prohibit_multiple_definition_absolute
1073 && ((osec
->output_section
!= NULL
1074 && ! bfd_is_abs_section (osec
)
1075 && bfd_is_abs_section (osec
->output_section
))
1076 || (nsec
->output_section
!= NULL
1077 && !bfd_is_abs_section (nsec
)
1078 && bfd_is_abs_section (nsec
->output_section
))))
1081 name
= h
->root
.string
;
1089 if (info
->warn_multiple_definition
)
1090 einfo (_("%P: %C: warning: multiple definition of `%pT'"),
1091 nbfd
, nsec
, nval
, name
);
1093 einfo (_("%X%P: %C: multiple definition of `%pT'"),
1094 nbfd
, nsec
, nval
, name
);
1096 einfo (_("; %D: first defined here"), obfd
, osec
, oval
);
1099 if (RELAXATION_ENABLED_BY_USER
)
1101 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1106 /* This is called when there is a definition of a common symbol, or
1107 when a common symbol is found for a symbol that is already defined,
1108 or when two common symbols are found. We only do something if
1109 -warn-common was used. */
1112 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1113 struct bfd_link_hash_entry
*h
,
1115 enum bfd_link_hash_type ntype
,
1120 enum bfd_link_hash_type otype
;
1123 if (!config
.warn_common
)
1126 name
= h
->root
.string
;
1128 if (otype
== bfd_link_hash_common
)
1130 obfd
= h
->u
.c
.p
->section
->owner
;
1131 osize
= h
->u
.c
.size
;
1133 else if (otype
== bfd_link_hash_defined
1134 || otype
== bfd_link_hash_defweak
)
1136 obfd
= h
->u
.def
.section
->owner
;
1141 /* FIXME: It would nice if we could report the BFD which defined
1142 an indirect symbol, but we don't have anywhere to store the
1148 if (ntype
== bfd_link_hash_defined
1149 || ntype
== bfd_link_hash_defweak
1150 || ntype
== bfd_link_hash_indirect
)
1152 ASSERT (otype
== bfd_link_hash_common
);
1154 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1158 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1161 else if (otype
== bfd_link_hash_defined
1162 || otype
== bfd_link_hash_defweak
1163 || otype
== bfd_link_hash_indirect
)
1165 ASSERT (ntype
== bfd_link_hash_common
);
1167 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1171 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1176 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1180 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1181 " by larger common from %pB\n"),
1184 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1185 " by larger common\n"),
1188 else if (nsize
> osize
)
1191 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1192 " smaller common from %pB\n"),
1195 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1196 " smaller common\n"),
1202 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1205 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1211 /* This is called when BFD has discovered a set element. H is the
1212 entry in the linker hash table for the set. SECTION and VALUE
1213 represent a value which should be added to the set. */
1216 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1217 struct bfd_link_hash_entry
*h
,
1218 bfd_reloc_code_real_type reloc
,
1223 if (config
.warn_constructors
)
1224 einfo (_("%P: warning: global constructor %s used\n"),
1227 if (!config
.build_constructors
)
1230 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1232 if (h
->type
== bfd_link_hash_new
)
1234 h
->type
= bfd_link_hash_undefined
;
1235 h
->u
.undef
.abfd
= abfd
;
1236 /* We don't call bfd_link_add_undef to add this to the list of
1237 undefined symbols because we are going to define it
1242 /* This is called when BFD has discovered a constructor. This is only
1243 called for some object file formats--those which do not handle
1244 constructors in some more clever fashion. This is similar to
1245 adding an element to a set, but less general. */
1248 constructor_callback (struct bfd_link_info
*info
,
1256 struct bfd_link_hash_entry
*h
;
1257 char set_name
[1 + sizeof "__CTOR_LIST__"];
1259 if (config
.warn_constructors
)
1260 einfo (_("%P: warning: global constructor %s used\n"), name
);
1262 if (!config
.build_constructors
)
1265 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1266 useful error message. */
1267 if (bfd_reloc_type_lookup (info
->output_bfd
, BFD_RELOC_CTOR
) == NULL
1268 && (bfd_link_relocatable (info
)
1269 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1270 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1273 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1274 *s
++ = bfd_get_symbol_leading_char (abfd
);
1276 strcpy (s
, "__CTOR_LIST__");
1278 strcpy (s
, "__DTOR_LIST__");
1280 h
= bfd_link_hash_lookup (info
->hash
, set_name
, true, true, true);
1281 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1282 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1283 if (h
->type
== bfd_link_hash_new
)
1285 h
->type
= bfd_link_hash_undefined
;
1286 h
->u
.undef
.abfd
= abfd
;
1287 /* We don't call bfd_link_add_undef to add this to the list of
1288 undefined symbols because we are going to define it
1292 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1295 /* A structure used by warning_callback to pass information through
1296 bfd_map_over_sections. */
1298 struct warning_callback_info
1301 const char *warning
;
1306 /* Look through the relocs to see if we can find a plausible address
1307 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1310 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1312 struct warning_callback_info cinfo
;
1314 if (!bfd_generic_link_read_symbols (abfd
))
1315 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd
);
1317 cinfo
.found
= false;
1318 cinfo
.warning
= warning
;
1319 cinfo
.symbol
= symbol
;
1320 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1321 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1325 /* This is called when there is a reference to a warning symbol. */
1328 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1329 const char *warning
,
1335 /* This is a hack to support warn_multiple_gp. FIXME: This should
1336 have a cleaner interface, but what? */
1337 if (!config
.warn_multiple_gp
1338 && strcmp (warning
, "using multiple gp values") == 0)
1341 if (section
!= NULL
)
1342 einfo ("%P: %C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1343 else if (abfd
== NULL
)
1344 einfo ("%P: %s%s\n", _("warning: "), warning
);
1345 else if (symbol
== NULL
)
1346 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1347 else if (!symbol_warning (warning
, symbol
, abfd
))
1350 /* Search all input files for a reference to SYMBOL. */
1351 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1352 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1354 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1358 /* This is called by warning_callback for each section. It checks the
1359 relocs of the section to see if it can find a reference to the
1360 symbol which triggered the warning. If it can, it uses the reloc
1361 to give an error message with a file and line number. */
1364 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1366 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1370 arelent
**p
, **pend
;
1375 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1377 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1381 relpp
= (arelent
**) xmalloc (relsize
);
1382 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1384 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1387 pend
= p
+ relcount
;
1388 for (; p
< pend
&& *p
!= NULL
; p
++)
1392 if (q
->sym_ptr_ptr
!= NULL
1393 && *q
->sym_ptr_ptr
!= NULL
1394 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1396 /* We found a reloc for the symbol we are looking for. */
1397 einfo ("%P: %C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1407 #if SUPPORT_ERROR_HANDLING_SCRIPT
1408 char * error_handling_script
= NULL
;
1411 /* This is called when an undefined symbol is found. */
1414 undefined_symbol (struct bfd_link_info
*info
,
1421 static char *error_name
;
1422 static unsigned int error_count
;
1424 #define MAX_ERRORS_IN_A_ROW 5
1426 if (info
->ignore_hash
!= NULL
1427 && bfd_hash_lookup (info
->ignore_hash
, name
, false, false) != NULL
)
1430 if (config
.warn_once
)
1432 /* Only warn once about a particular undefined symbol. */
1433 add_ignoresym (info
, name
);
1436 /* We never print more than a reasonable number of errors in a row
1437 for a single symbol. */
1438 if (error_name
!= NULL
1439 && strcmp (name
, error_name
) == 0)
1445 error_name
= xstrdup (name
);
1448 #if SUPPORT_ERROR_HANDLING_SCRIPT
1449 if (error_handling_script
!= NULL
1450 && error_count
< MAX_ERRORS_IN_A_ROW
)
1456 argv
[0] = error_handling_script
;
1457 argv
[1] = "undefined-symbol";
1458 argv
[2] = (char *) name
;
1462 einfo (_("%P: About to run error handling script '%s' with arguments: '%s' '%s'\n"),
1463 argv
[0], argv
[1], argv
[2]);
1465 res
= pex_one (PEX_SEARCH
, error_handling_script
, argv
,
1466 N_("error handling script"),
1467 NULL
/* Send stdout to random, temp file. */,
1468 NULL
/* Write to stderr. */,
1472 einfo (_("%P: Failed to run error handling script '%s', reason: "),
1473 error_handling_script
);
1474 /* FIXME: We assume here that errrno == err. */
1477 /* We ignore the return status of the script and
1478 carry on to issue the normal error message. */
1480 #endif /* SUPPORT_ERROR_HANDLING_SCRIPT */
1482 if (section
!= NULL
)
1484 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1487 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1488 abfd
, section
, address
, name
);
1490 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1491 abfd
, section
, address
, name
);
1493 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1496 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1497 abfd
, section
, address
, name
);
1499 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1500 abfd
, section
, address
, name
);
1507 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1510 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1513 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1516 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1519 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1522 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1530 /* Counter to limit the number of relocation overflow error messages
1531 to print. Errors are printed as it is decremented. When it's
1532 called and the counter is zero, a final message is printed
1533 indicating more relocations were omitted. When it gets to -1, no
1534 such errors are printed. If it's initially set to a value less
1535 than -1, all such errors will be printed (--verbose does this). */
1537 int overflow_cutoff_limit
= 10;
1539 /* This is called when a reloc overflows. */
1542 reloc_overflow (struct bfd_link_info
*info
,
1543 struct bfd_link_hash_entry
*entry
,
1545 const char *reloc_name
,
1551 if (overflow_cutoff_limit
== -1)
1554 einfo ("%X%H:", abfd
, section
, address
);
1556 if (overflow_cutoff_limit
>= 0
1557 && overflow_cutoff_limit
-- == 0)
1559 einfo (_(" additional relocation overflows omitted from the output\n"));
1565 while (entry
->type
== bfd_link_hash_indirect
1566 || entry
->type
== bfd_link_hash_warning
)
1567 entry
= entry
->u
.i
.link
;
1568 switch (entry
->type
)
1570 case bfd_link_hash_undefined
:
1571 case bfd_link_hash_undefweak
:
1572 einfo (_(" relocation truncated to fit: "
1573 "%s against undefined symbol `%pT'"),
1574 reloc_name
, entry
->root
.string
);
1576 case bfd_link_hash_defined
:
1577 case bfd_link_hash_defweak
:
1578 einfo (_(" relocation truncated to fit: "
1579 "%s against symbol `%pT' defined in %pA section in %pB"),
1580 reloc_name
, entry
->root
.string
,
1581 entry
->u
.def
.section
,
1582 entry
->u
.def
.section
== bfd_abs_section_ptr
1583 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1591 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1594 einfo ("+%v", addend
);
1598 /* This is called when a dangerous relocation is made. */
1601 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1602 const char *message
,
1607 einfo (_("%X%H: dangerous relocation: %s\n"),
1608 abfd
, section
, address
, message
);
1611 /* This is called when a reloc is being generated attached to a symbol
1612 that is not being output. */
1615 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1621 einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1622 abfd
, section
, address
, name
);
1625 /* This is called if link_info.notice_all is set, or when a symbol in
1626 link_info.notice_hash is found. Symbols are put in notice_hash
1627 using the -y option, while notice_all is set if the --cref option
1628 has been supplied, or if there are any NOCROSSREFS sections in the
1629 linker script; and if plugins are active, since they need to monitor
1630 all references from non-IR files. */
1633 notice (struct bfd_link_info
*info
,
1634 struct bfd_link_hash_entry
*h
,
1635 struct bfd_link_hash_entry
*inh ATTRIBUTE_UNUSED
,
1639 flagword flags ATTRIBUTE_UNUSED
)
1645 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1646 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1650 name
= h
->root
.string
;
1651 if (info
->notice_hash
!= NULL
1652 && bfd_hash_lookup (info
->notice_hash
, name
, false, false) != NULL
)
1654 if (bfd_is_und_section (section
))
1655 einfo (_("%P: %pB: reference to %s\n"), abfd
, name
);
1657 einfo (_("%P: %pB: definition of %s\n"), abfd
, name
);
1660 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1661 add_cref (name
, abfd
, section
, value
);