1 /* Main program of GNU linker.
2 Copyright (C) 1991-2020 Free Software Foundation, Inc.
3 Written by Steve Chamberlain steve@cygnus.com
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
24 #include "safe-ctype.h"
25 #include "libiberty.h"
29 #include "filenames.h"
44 #include "plugin-api.h"
45 #endif /* ENABLE_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 bfd_boolean 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. */
88 bfd_boolean version_printed
;
90 /* TRUE if we should demangle symbol names. */
91 bfd_boolean demangling
;
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 bfd_boolean 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
*, bfd_boolean
, 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
);
132 static bfd_boolean notice
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_apply_strsym
,
154 ldlang_write_ctf_late
157 static bfd_assert_handler_type default_bfd_assert_handler
;
158 static bfd_error_handler_type default_bfd_error_handler
;
160 struct bfd_link_info link_info
;
165 bfd_cache_close_all ();
166 #ifdef ENABLE_PLUGINS
167 plugin_call_cleanup ();
169 if (output_filename
&& delete_output_file_on_failure
)
170 unlink_if_ordinary (output_filename
);
173 /* Hook to notice BFD assertions. */
176 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
177 const char *file
, int line
)
179 config
.make_executable
= FALSE
;
180 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
183 /* Hook the bfd error/warning handler for --fatal-warnings. */
186 ld_bfd_error_handler (const char *fmt
, va_list ap
)
188 if (config
.fatal_warnings
)
189 config
.make_executable
= FALSE
;
190 (*default_bfd_error_handler
) (fmt
, ap
);
194 main (int argc
, char **argv
)
197 long start_time
= get_run_time ();
199 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
200 setlocale (LC_MESSAGES
, "");
202 #if defined (HAVE_SETLOCALE)
203 setlocale (LC_CTYPE
, "");
205 bindtextdomain (PACKAGE
, LOCALEDIR
);
206 textdomain (PACKAGE
);
208 program_name
= argv
[0];
209 xmalloc_set_program_name (program_name
);
211 START_PROGRESS (program_name
, 0);
213 expandargv (&argc
, &argv
);
215 if (bfd_init () != BFD_INIT_MAGIC
)
216 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
218 bfd_set_error_program_name (program_name
);
220 /* We want to notice and fail on those nasty BFD assertions which are
221 likely to signal incorrect output being generated but otherwise may
223 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
225 /* Also hook the bfd error/warning handler for --fatal-warnings. */
226 default_bfd_error_handler
= bfd_set_error_handler (ld_bfd_error_handler
);
228 xatexit (ld_cleanup
);
230 /* Set up the sysroot directory. */
231 ld_sysroot
= get_sysroot (argc
, argv
);
233 ld_canon_sysroot
= lrealpath (ld_sysroot
);
234 if (ld_canon_sysroot
)
236 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
238 /* is_sysrooted_pathname() relies on no trailing dirsep. */
239 if (ld_canon_sysroot_len
> 0
240 && IS_DIR_SEPARATOR (ld_canon_sysroot
[ld_canon_sysroot_len
- 1]))
241 ld_canon_sysroot
[--ld_canon_sysroot_len
] = '\0';
244 ld_canon_sysroot_len
= -1;
246 /* Set the default BFD target based on the configured target. Doing
247 this permits the linker to be configured for a particular target,
248 and linked against a shared BFD library which was configured for
249 a different target. The macro TARGET is defined by Makefile. */
250 if (!bfd_set_default_target (TARGET
))
252 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
263 config
.build_constructors
= TRUE
;
264 config
.rpath_separator
= ':';
265 config
.split_by_reloc
= (unsigned) -1;
266 config
.split_by_file
= (bfd_size_type
) -1;
267 config
.make_executable
= TRUE
;
268 config
.magic_demand_paged
= TRUE
;
269 config
.text_read_only
= TRUE
;
270 config
.print_map_discarded
= TRUE
;
271 link_info
.disable_target_specific_optimizations
= -1;
273 command_line
.warn_mismatch
= TRUE
;
274 command_line
.warn_search_mismatch
= TRUE
;
275 command_line
.check_section_addresses
= -1;
277 /* We initialize DEMANGLING based on the environment variable
278 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
279 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
280 environment. Acting the same way here lets us provide the same
281 interface by default. */
282 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
284 link_info
.allow_undefined_version
= TRUE
;
285 link_info
.keep_memory
= TRUE
;
286 link_info
.combreloc
= TRUE
;
287 link_info
.strip_discarded
= TRUE
;
288 link_info
.prohibit_multiple_definition_absolute
= FALSE
;
289 link_info
.textrel_check
= DEFAULT_LD_TEXTREL_CHECK
;
290 link_info
.emit_hash
= DEFAULT_EMIT_SYSV_HASH
;
291 link_info
.emit_gnu_hash
= DEFAULT_EMIT_GNU_HASH
;
292 link_info
.callbacks
= &link_callbacks
;
293 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
294 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
295 and _fini symbols. We are compatible. */
296 link_info
.init_function
= "_init";
297 link_info
.fini_function
= "_fini";
298 link_info
.relax_pass
= 1;
299 link_info
.extern_protected_data
= -1;
300 link_info
.dynamic_undefined_weak
= -1;
301 link_info
.pei386_auto_import
= -1;
302 link_info
.spare_dynamic_tags
= 5;
303 link_info
.path_separator
= ':';
304 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
305 link_info
.compress_debug
= COMPRESS_DEBUG_GABI_ZLIB
;
307 #ifdef DEFAULT_NEW_DTAGS
308 link_info
.new_dtags
= DEFAULT_NEW_DTAGS
;
311 ldfile_add_arch ("");
312 emulation
= get_emulation (argc
, argv
);
313 ldemul_choose_mode (emulation
);
314 default_target
= ldemul_choose_target (argc
, argv
);
317 ldemul_before_parse ();
318 lang_has_input_file
= FALSE
;
319 parse_args (argc
, argv
);
321 if (config
.hash_table_size
!= 0)
322 bfd_hash_set_default_size (config
.hash_table_size
);
324 #ifdef ENABLE_PLUGINS
325 /* Now all the plugin arguments have been gathered, we can load them. */
326 plugin_load_plugins ();
327 #endif /* ENABLE_PLUGINS */
329 ldemul_set_symbols ();
331 /* If we have not already opened and parsed a linker script,
332 try the default script from command line first. */
333 if (saved_script_handle
== NULL
334 && command_line
.default_script
!= NULL
)
336 ldfile_open_script_file (command_line
.default_script
);
337 parser_input
= input_script
;
341 /* If we have not already opened and parsed a linker script
342 read the emulation's appropriate default script. */
343 if (saved_script_handle
== NULL
)
346 char *s
= ldemul_get_script (&isfile
);
349 ldfile_open_default_command_file (s
);
353 lex_redirect (s
, _("built in linker script"), 1);
355 parser_input
= input_script
;
362 if (saved_script_handle
)
363 info_msg (_("using external linker script:"));
365 info_msg (_("using internal linker script:"));
366 info_msg ("\n==================================================\n");
368 if (saved_script_handle
)
370 static const int ld_bufsz
= 8193;
372 char *buf
= (char *) xmalloc (ld_bufsz
);
374 rewind (saved_script_handle
);
375 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
378 info_msg ("%s", buf
);
380 rewind (saved_script_handle
);
387 info_msg (ldemul_get_script (&isfile
));
390 info_msg ("\n==================================================\n");
393 if (command_line
.force_group_allocation
394 || !bfd_link_relocatable (&link_info
))
395 link_info
.resolve_section_groups
= TRUE
;
397 link_info
.resolve_section_groups
= FALSE
;
399 if (command_line
.print_output_format
)
400 info_msg ("%s\n", lang_get_output_target ());
404 /* If the only command line argument has been -v or --version or --verbose
405 then ignore any input files provided by linker scripts and exit now.
406 We do not want to create an output file when the linker is just invoked
407 to provide version information. */
408 if (argc
== 2 && version_printed
)
411 if (link_info
.inhibit_common_definition
&& !bfd_link_dll (&link_info
))
412 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
414 if (!lang_has_input_file
)
416 if (version_printed
|| command_line
.print_output_format
)
418 einfo (_("%F%P: no input files\n"));
422 info_msg (_("%P: mode %s\n"), emulation
);
424 ldemul_after_parse ();
426 if (config
.map_filename
)
428 if (strcmp (config
.map_filename
, "-") == 0)
430 config
.map_file
= stdout
;
434 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
435 if (config
.map_file
== (FILE *) NULL
)
437 bfd_set_error (bfd_error_system_call
);
438 einfo (_("%F%P: cannot open map file %s: %E\n"),
439 config
.map_filename
);
442 link_info
.has_map_file
= TRUE
;
447 /* Print error messages for any missing symbols, for any warning
448 symbols, and possibly multiple definitions. */
449 if (bfd_link_relocatable (&link_info
))
450 link_info
.output_bfd
->flags
&= ~EXEC_P
;
452 link_info
.output_bfd
->flags
|= EXEC_P
;
454 if ((link_info
.compress_debug
& COMPRESS_DEBUG
))
456 link_info
.output_bfd
->flags
|= BFD_COMPRESS
;
457 if (link_info
.compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
458 link_info
.output_bfd
->flags
|= BFD_COMPRESS_GABI
;
463 if (config
.map_file
!= NULL
)
465 if (command_line
.cref
)
466 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
467 if (nocrossref_list
!= NULL
)
468 check_nocrossrefs ();
469 if (command_line
.print_memory_usage
)
470 lang_print_memory_usage ();
473 struct bfd_link_hash_entry
*h
;
475 h
= bfd_link_hash_lookup (link_info
.hash
, "__image_base__", 0,0,1);
476 fprintf (stderr
, "lookup = %p val %lx\n", h
, h
? h
->u
.def
.value
: 1);
482 /* Even if we're producing relocatable output, some non-fatal errors should
483 be reported in the exit status. (What non-fatal errors, if any, do we
484 want to ignore for relocatable output?) */
485 if (!config
.make_executable
&& !force_make_executable
)
488 einfo (_("%P: link errors found, deleting executable `%s'\n"),
491 /* The file will be removed by ld_cleanup. */
496 if (!bfd_close (link_info
.output_bfd
))
497 einfo (_("%F%P: %pB: final close failed: %E\n"), link_info
.output_bfd
);
499 /* If the --force-exe-suffix is enabled, and we're making an
500 executable file and it doesn't end in .exe, copy it to one
502 if (!bfd_link_relocatable (&link_info
)
503 && command_line
.force_exe_suffix
)
505 int len
= strlen (output_filename
);
508 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
509 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
513 const int bsize
= 4096;
514 char *buf
= (char *) xmalloc (bsize
);
516 char *dst_name
= (char *) xmalloc (len
+ 5);
518 strcpy (dst_name
, output_filename
);
519 strcat (dst_name
, ".exe");
520 src
= fopen (output_filename
, FOPEN_RB
);
521 dst
= fopen (dst_name
, FOPEN_WB
);
524 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
527 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
529 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
531 int done
= fwrite (buf
, 1, l
, dst
);
534 einfo (_("%P: error writing file `%s'\n"), dst_name
);
538 if (fclose (dst
) == EOF
)
539 einfo (_("%P: error closing file `%s'\n"), dst_name
);
546 END_PROGRESS (program_name
);
550 long run_time
= get_run_time () - start_time
;
553 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
554 program_name
, run_time
/ 1000000, run_time
% 1000000);
558 /* Prevent ld_cleanup from doing anything, after a successful link. */
559 output_filename
= NULL
;
565 /* If the configured sysroot is relocatable, try relocating it based on
566 default prefix FROM. Return the relocated directory if it exists,
567 otherwise return null. */
570 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
572 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
576 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
579 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
587 /* Return the sysroot directory. Return "" if no sysroot is being used. */
590 get_sysroot (int argc
, char **argv
)
593 const char *path
= NULL
;
595 for (i
= 1; i
< argc
; i
++)
596 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
597 path
= argv
[i
] + strlen ("--sysroot=");
600 path
= get_relative_sysroot (BINDIR
);
603 path
= get_relative_sysroot (TOOLBINDIR
);
606 path
= TARGET_SYSTEM_ROOT
;
608 if (IS_DIR_SEPARATOR (*path
) && path
[1] == 0)
614 /* We need to find any explicitly given emulation in order to initialize the
615 state that's needed by the lex&yacc argument parser (parse_args). */
618 get_emulation (int argc
, char **argv
)
623 emulation
= getenv (EMULATION_ENVIRON
);
624 if (emulation
== NULL
)
625 emulation
= DEFAULT_EMULATION
;
627 for (i
= 1; i
< argc
; i
++)
629 if (CONST_STRNEQ (argv
[i
], "-m"))
631 if (argv
[i
][2] == '\0')
636 emulation
= argv
[i
+ 1];
640 einfo (_("%F%P: missing argument to -m\n"));
642 else if (strcmp (argv
[i
], "-mips1") == 0
643 || strcmp (argv
[i
], "-mips2") == 0
644 || strcmp (argv
[i
], "-mips3") == 0
645 || strcmp (argv
[i
], "-mips4") == 0
646 || strcmp (argv
[i
], "-mips5") == 0
647 || strcmp (argv
[i
], "-mips32") == 0
648 || strcmp (argv
[i
], "-mips32r2") == 0
649 || strcmp (argv
[i
], "-mips32r6") == 0
650 || strcmp (argv
[i
], "-mips64") == 0
651 || strcmp (argv
[i
], "-mips64r2") == 0
652 || strcmp (argv
[i
], "-mips64r6") == 0)
654 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
655 passed to the linker by some MIPS compilers. They
656 generally tell the linker to use a slightly different
657 library path. Perhaps someday these should be
658 implemented as emulations; until then, we just ignore
659 the arguments and hope that nobody ever creates
660 emulations named ips1, ips2 or ips3. */
662 else if (strcmp (argv
[i
], "-m486") == 0)
664 /* FIXME: The argument -m486 is passed to the linker on
665 some Linux systems. Hope that nobody creates an
666 emulation named 486. */
671 emulation
= &argv
[i
][2];
680 add_ysym (const char *name
)
682 if (link_info
.notice_hash
== NULL
)
684 link_info
.notice_hash
685 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
686 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
688 sizeof (struct bfd_hash_entry
),
690 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
693 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
694 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
698 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
700 if (info
->ignore_hash
== NULL
)
702 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
703 if (!bfd_hash_table_init_n (info
->ignore_hash
,
705 sizeof (struct bfd_hash_entry
),
707 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
710 if (bfd_hash_lookup (info
->ignore_hash
, name
, TRUE
, TRUE
) == NULL
)
711 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
714 /* Record a symbol to be wrapped, from the --wrap option. */
717 add_wrap (const char *name
)
719 if (link_info
.wrap_hash
== NULL
)
722 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
723 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
725 sizeof (struct bfd_hash_entry
),
727 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
730 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
731 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
734 /* Handle the -retain-symbols-file option. */
737 add_keepsyms_file (const char *filename
)
744 if (link_info
.strip
== strip_some
)
745 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
747 file
= fopen (filename
, "r");
750 bfd_set_error (bfd_error_system_call
);
751 einfo ("%X%P: %s: %E\n", filename
);
755 link_info
.keep_hash
= (struct bfd_hash_table
*)
756 xmalloc (sizeof (struct bfd_hash_table
));
757 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
758 sizeof (struct bfd_hash_entry
)))
759 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
762 buf
= (char *) xmalloc (bufsize
);
774 while (!ISSPACE (c
) && c
!= EOF
)
781 buf
= (char *) xrealloc (buf
, bufsize
);
788 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
789 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
793 if (link_info
.strip
!= strip_none
)
794 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
797 link_info
.strip
= strip_some
;
801 /* Callbacks from the BFD linker routines. */
803 /* This is called when BFD has decided to include an archive member in
807 add_archive_element (struct bfd_link_info
*info
,
810 bfd
**subsbfd ATTRIBUTE_UNUSED
)
812 lang_input_statement_type
*input
;
813 lang_input_statement_type
*parent
;
814 lang_input_statement_type orig_input
;
816 input
= (lang_input_statement_type
*)
817 xcalloc (1, sizeof (lang_input_statement_type
));
818 input
->header
.type
= lang_input_statement_enum
;
819 input
->filename
= bfd_get_filename (abfd
);
820 input
->local_sym_name
= bfd_get_filename (abfd
);
821 input
->the_bfd
= abfd
;
823 parent
= bfd_usrdata (abfd
->my_archive
);
824 if (parent
!= NULL
&& !parent
->flags
.reload
)
825 parent
->next
= input
;
827 /* Save the original data for trace files/tries below, as plugins
828 (if enabled) may possibly alter it to point to a replacement
829 BFD, but we still want to output the original BFD filename. */
831 #ifdef ENABLE_PLUGINS
832 if (link_info
.lto_plugin_active
)
834 /* We must offer this archive member to the plugins to claim. */
835 plugin_maybe_claim (input
);
836 if (input
->flags
.claimed
)
838 if (no_more_claiming
)
840 /* Don't claim new IR symbols after all IR symbols have
843 info_msg ("%pI: no new IR symbols to claim\n",
845 input
->flags
.claimed
= 0;
848 input
->flags
.claim_archive
= TRUE
;
849 *subsbfd
= input
->the_bfd
;
852 #endif /* ENABLE_PLUGINS */
854 ldlang_add_file (input
);
856 if (config
.map_file
!= NULL
)
858 static bfd_boolean header_printed
;
859 struct bfd_link_hash_entry
*h
;
863 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
865 && info
->pei386_auto_import
866 && CONST_STRNEQ (name
, "__imp_"))
867 h
= bfd_link_hash_lookup (info
->hash
, name
+ 6, FALSE
, FALSE
, TRUE
);
879 case bfd_link_hash_defined
:
880 case bfd_link_hash_defweak
:
881 from
= h
->u
.def
.section
->owner
;
884 case bfd_link_hash_undefined
:
885 case bfd_link_hash_undefweak
:
886 from
= h
->u
.undef
.abfd
;
889 case bfd_link_hash_common
:
890 from
= h
->u
.c
.p
->section
->owner
;
897 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
898 header_printed
= TRUE
;
901 if (abfd
->my_archive
== NULL
902 || bfd_is_thin_archive (abfd
->my_archive
))
904 minfo ("%s", bfd_get_filename (abfd
));
905 len
= strlen (bfd_get_filename (abfd
));
909 minfo ("%s(%s)", bfd_get_filename (abfd
->my_archive
),
910 bfd_get_filename (abfd
));
911 len
= (strlen (bfd_get_filename (abfd
->my_archive
))
912 + strlen (bfd_get_filename (abfd
))
928 minfo ("%pB ", from
);
930 minfo ("(%pT)\n", h
->root
.string
);
932 minfo ("(%s)\n", name
);
937 || (trace_files
&& bfd_is_thin_archive (orig_input
.the_bfd
->my_archive
)))
938 info_msg ("%pI\n", &orig_input
);
942 /* This is called when BFD has discovered a symbol which is defined
946 multiple_definition (struct bfd_link_info
*info
,
947 struct bfd_link_hash_entry
*h
,
957 if (info
->allow_multiple_definition
)
962 case bfd_link_hash_defined
:
963 osec
= h
->u
.def
.section
;
964 oval
= h
->u
.def
.value
;
965 obfd
= h
->u
.def
.section
->owner
;
967 case bfd_link_hash_indirect
:
968 osec
= bfd_ind_section_ptr
;
976 /* Ignore a redefinition of an absolute symbol to the
977 same value; it's harmless. */
978 if (h
->type
== bfd_link_hash_defined
979 && bfd_is_abs_section (osec
)
980 && bfd_is_abs_section (nsec
)
984 /* If either section has the output_section field set to
985 bfd_abs_section_ptr, it means that the section is being
986 discarded, and this is not really a multiple definition at all.
987 FIXME: It would be cleaner to somehow ignore symbols defined in
988 sections which are being discarded. */
989 if (!info
->prohibit_multiple_definition_absolute
990 && ((osec
->output_section
!= NULL
991 && ! bfd_is_abs_section (osec
)
992 && bfd_is_abs_section (osec
->output_section
))
993 || (nsec
->output_section
!= NULL
994 && !bfd_is_abs_section (nsec
)
995 && bfd_is_abs_section (nsec
->output_section
))))
998 name
= h
->root
.string
;
1006 einfo (_("%X%P: %C: multiple definition of `%pT'"),
1007 nbfd
, nsec
, nval
, name
);
1009 einfo (_("; %D: first defined here"), obfd
, osec
, oval
);
1012 if (RELAXATION_ENABLED_BY_USER
)
1014 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1019 /* This is called when there is a definition of a common symbol, or
1020 when a common symbol is found for a symbol that is already defined,
1021 or when two common symbols are found. We only do something if
1022 -warn-common was used. */
1025 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1026 struct bfd_link_hash_entry
*h
,
1028 enum bfd_link_hash_type ntype
,
1033 enum bfd_link_hash_type otype
;
1036 if (!config
.warn_common
)
1039 name
= h
->root
.string
;
1041 if (otype
== bfd_link_hash_common
)
1043 obfd
= h
->u
.c
.p
->section
->owner
;
1044 osize
= h
->u
.c
.size
;
1046 else if (otype
== bfd_link_hash_defined
1047 || otype
== bfd_link_hash_defweak
)
1049 obfd
= h
->u
.def
.section
->owner
;
1054 /* FIXME: It would nice if we could report the BFD which defined
1055 an indirect symbol, but we don't have anywhere to store the
1061 if (ntype
== bfd_link_hash_defined
1062 || ntype
== bfd_link_hash_defweak
1063 || ntype
== bfd_link_hash_indirect
)
1065 ASSERT (otype
== bfd_link_hash_common
);
1067 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1071 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1074 else if (otype
== bfd_link_hash_defined
1075 || otype
== bfd_link_hash_defweak
1076 || otype
== bfd_link_hash_indirect
)
1078 ASSERT (ntype
== bfd_link_hash_common
);
1080 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1084 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1089 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1093 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1094 " by larger common from %pB\n"),
1097 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1098 " by larger common\n"),
1101 else if (nsize
> osize
)
1104 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1105 " smaller common from %pB\n"),
1108 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1109 " smaller common\n"),
1115 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1118 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1124 /* This is called when BFD has discovered a set element. H is the
1125 entry in the linker hash table for the set. SECTION and VALUE
1126 represent a value which should be added to the set. */
1129 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1130 struct bfd_link_hash_entry
*h
,
1131 bfd_reloc_code_real_type reloc
,
1136 if (config
.warn_constructors
)
1137 einfo (_("%P: warning: global constructor %s used\n"),
1140 if (!config
.build_constructors
)
1143 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1145 if (h
->type
== bfd_link_hash_new
)
1147 h
->type
= bfd_link_hash_undefined
;
1148 h
->u
.undef
.abfd
= abfd
;
1149 /* We don't call bfd_link_add_undef to add this to the list of
1150 undefined symbols because we are going to define it
1155 /* This is called when BFD has discovered a constructor. This is only
1156 called for some object file formats--those which do not handle
1157 constructors in some more clever fashion. This is similar to
1158 adding an element to a set, but less general. */
1161 constructor_callback (struct bfd_link_info
*info
,
1162 bfd_boolean constructor
,
1169 struct bfd_link_hash_entry
*h
;
1170 char set_name
[1 + sizeof "__CTOR_LIST__"];
1172 if (config
.warn_constructors
)
1173 einfo (_("%P: warning: global constructor %s used\n"), name
);
1175 if (!config
.build_constructors
)
1178 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1179 useful error message. */
1180 if (bfd_reloc_type_lookup (info
->output_bfd
, BFD_RELOC_CTOR
) == NULL
1181 && (bfd_link_relocatable (info
)
1182 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1183 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1186 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1187 *s
++ = bfd_get_symbol_leading_char (abfd
);
1189 strcpy (s
, "__CTOR_LIST__");
1191 strcpy (s
, "__DTOR_LIST__");
1193 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1194 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1195 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1196 if (h
->type
== bfd_link_hash_new
)
1198 h
->type
= bfd_link_hash_undefined
;
1199 h
->u
.undef
.abfd
= abfd
;
1200 /* We don't call bfd_link_add_undef to add this to the list of
1201 undefined symbols because we are going to define it
1205 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1208 /* A structure used by warning_callback to pass information through
1209 bfd_map_over_sections. */
1211 struct warning_callback_info
1214 const char *warning
;
1219 /* Look through the relocs to see if we can find a plausible address
1220 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1223 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1225 struct warning_callback_info cinfo
;
1227 if (!bfd_generic_link_read_symbols (abfd
))
1228 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd
);
1230 cinfo
.found
= FALSE
;
1231 cinfo
.warning
= warning
;
1232 cinfo
.symbol
= symbol
;
1233 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1234 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1238 /* This is called when there is a reference to a warning symbol. */
1241 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1242 const char *warning
,
1248 /* This is a hack to support warn_multiple_gp. FIXME: This should
1249 have a cleaner interface, but what? */
1250 if (!config
.warn_multiple_gp
1251 && strcmp (warning
, "using multiple gp values") == 0)
1254 if (section
!= NULL
)
1255 einfo ("%P: %C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1256 else if (abfd
== NULL
)
1257 einfo ("%P: %s%s\n", _("warning: "), warning
);
1258 else if (symbol
== NULL
)
1259 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1260 else if (!symbol_warning (warning
, symbol
, abfd
))
1263 /* Search all input files for a reference to SYMBOL. */
1264 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1265 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1267 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1271 /* This is called by warning_callback for each section. It checks the
1272 relocs of the section to see if it can find a reference to the
1273 symbol which triggered the warning. If it can, it uses the reloc
1274 to give an error message with a file and line number. */
1277 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1279 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1283 arelent
**p
, **pend
;
1288 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1290 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1294 relpp
= (arelent
**) xmalloc (relsize
);
1295 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1297 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1300 pend
= p
+ relcount
;
1301 for (; p
< pend
&& *p
!= NULL
; p
++)
1305 if (q
->sym_ptr_ptr
!= NULL
1306 && *q
->sym_ptr_ptr
!= NULL
1307 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1309 /* We found a reloc for the symbol we are looking for. */
1310 einfo ("%P: %C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1320 /* This is called when an undefined symbol is found. */
1323 undefined_symbol (struct bfd_link_info
*info
,
1330 static char *error_name
;
1331 static unsigned int error_count
;
1333 #define MAX_ERRORS_IN_A_ROW 5
1335 if (info
->ignore_hash
!= NULL
1336 && bfd_hash_lookup (info
->ignore_hash
, name
, FALSE
, FALSE
) != NULL
)
1339 if (config
.warn_once
)
1341 /* Only warn once about a particular undefined symbol. */
1342 add_ignoresym (info
, name
);
1345 /* We never print more than a reasonable number of errors in a row
1346 for a single symbol. */
1347 if (error_name
!= NULL
1348 && strcmp (name
, error_name
) == 0)
1354 error_name
= xstrdup (name
);
1357 if (section
!= NULL
)
1359 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1362 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1363 abfd
, section
, address
, name
);
1365 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1366 abfd
, section
, address
, name
);
1368 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1371 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1372 abfd
, section
, address
, name
);
1374 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1375 abfd
, section
, address
, name
);
1382 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1385 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1388 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1391 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1394 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1397 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1405 /* Counter to limit the number of relocation overflow error messages
1406 to print. Errors are printed as it is decremented. When it's
1407 called and the counter is zero, a final message is printed
1408 indicating more relocations were omitted. When it gets to -1, no
1409 such errors are printed. If it's initially set to a value less
1410 than -1, all such errors will be printed (--verbose does this). */
1412 int overflow_cutoff_limit
= 10;
1414 /* This is called when a reloc overflows. */
1417 reloc_overflow (struct bfd_link_info
*info
,
1418 struct bfd_link_hash_entry
*entry
,
1420 const char *reloc_name
,
1426 if (overflow_cutoff_limit
== -1)
1429 einfo ("%X%H:", abfd
, section
, address
);
1431 if (overflow_cutoff_limit
>= 0
1432 && overflow_cutoff_limit
-- == 0)
1434 einfo (_(" additional relocation overflows omitted from the output\n"));
1440 while (entry
->type
== bfd_link_hash_indirect
1441 || entry
->type
== bfd_link_hash_warning
)
1442 entry
= entry
->u
.i
.link
;
1443 switch (entry
->type
)
1445 case bfd_link_hash_undefined
:
1446 case bfd_link_hash_undefweak
:
1447 einfo (_(" relocation truncated to fit: "
1448 "%s against undefined symbol `%pT'"),
1449 reloc_name
, entry
->root
.string
);
1451 case bfd_link_hash_defined
:
1452 case bfd_link_hash_defweak
:
1453 einfo (_(" relocation truncated to fit: "
1454 "%s against symbol `%pT' defined in %pA section in %pB"),
1455 reloc_name
, entry
->root
.string
,
1456 entry
->u
.def
.section
,
1457 entry
->u
.def
.section
== bfd_abs_section_ptr
1458 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1466 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1469 einfo ("+%v", addend
);
1473 /* This is called when a dangerous relocation is made. */
1476 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1477 const char *message
,
1482 einfo (_("%X%H: dangerous relocation: %s\n"),
1483 abfd
, section
, address
, message
);
1486 /* This is called when a reloc is being generated attached to a symbol
1487 that is not being output. */
1490 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1496 einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1497 abfd
, section
, address
, name
);
1500 /* This is called if link_info.notice_all is set, or when a symbol in
1501 link_info.notice_hash is found. Symbols are put in notice_hash
1502 using the -y option, while notice_all is set if the --cref option
1503 has been supplied, or if there are any NOCROSSREFS sections in the
1504 linker script; and if plugins are active, since they need to monitor
1505 all references from non-IR files. */
1508 notice (struct bfd_link_info
*info
,
1509 struct bfd_link_hash_entry
*h
,
1510 struct bfd_link_hash_entry
*inh ATTRIBUTE_UNUSED
,
1514 flagword flags ATTRIBUTE_UNUSED
)
1520 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1521 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1525 name
= h
->root
.string
;
1526 if (info
->notice_hash
!= NULL
1527 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1529 if (bfd_is_und_section (section
))
1530 einfo (_("%P: %pB: reference to %s\n"), abfd
, name
);
1532 einfo (_("%P: %pB: definition of %s\n"), abfd
, name
);
1535 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1536 add_cref (name
, abfd
, section
, value
);