1 /* Main program of GNU linker.
2 Copyright (C) 1991-2018 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"
43 #include "plugin-api.h"
44 #endif /* ENABLE_PLUGINS */
46 /* Somewhere above, sys/stat.h got included. */
47 #if !defined(S_ISDIR) && defined(S_IFDIR)
48 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
53 #ifndef TARGET_SYSTEM_ROOT
54 #define TARGET_SYSTEM_ROOT ""
59 FILE *saved_script_handle = NULL;
60 FILE *previous_script_handle = NULL;
61 bfd_boolean force_make_executable = FALSE;
64 const char *output_filename = "a.out";
66 /* Name this program was invoked by. */
69 /* The prefix for system library directories. */
70 const char *ld_sysroot;
72 /* The canonical representation of ld_sysroot. */
73 char *ld_canon_sysroot;
74 int ld_canon_sysroot_len;
76 /* Set by -G argument, for targets like MIPS ELF. */
77 int g_switch_value = 8;
79 /* Nonzero means print names of input files as processed. */
80 bfd_boolean trace_files;
82 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
85 /* Nonzero means version number was printed, so exit successfully
86 instead of complaining if no input files are given. */
87 bfd_boolean version_printed;
89 /* TRUE if we should demangle symbol names. */
90 bfd_boolean demangling;
92 args_type command_line;
94 ld_config_type config;
96 sort_type sort_section;
98 static const char *get_sysroot
100 static char *get_emulation
102 static bfd_boolean add_archive_element
103 (struct bfd_link_info *, bfd *, const char *, bfd **);
104 static void multiple_definition
105 (struct bfd_link_info *, struct bfd_link_hash_entry *,
106 bfd *, asection *, bfd_vma);
107 static void multiple_common
108 (struct bfd_link_info *, struct bfd_link_hash_entry *,
109 bfd *, enum bfd_link_hash_type, bfd_vma);
110 static void add_to_set
111 (struct bfd_link_info *, struct bfd_link_hash_entry *,
112 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
113 static void constructor_callback
114 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
115 asection *, bfd_vma);
116 static void warning_callback
117 (struct bfd_link_info *, const char *, const char *, bfd *,
118 asection *, bfd_vma);
119 static void warning_find_reloc
120 (bfd *, asection *, void *);
121 static void undefined_symbol
122 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
124 static void reloc_overflow
125 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
126 const char *, bfd_vma, bfd *, asection *, bfd_vma);
127 static void reloc_dangerous
128 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
129 static void unattached_reloc
130 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
131 static bfd_boolean notice
132 (struct bfd_link_info *, struct bfd_link_hash_entry *,
133 struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
135 static struct bfd_link_callbacks link_callbacks =
141 constructor_callback,
151 ldlang_override_segment_assignment
154 static bfd_assert_handler_type default_bfd_assert_handler;
155 static bfd_error_handler_type default_bfd_error_handler;
157 struct bfd_link_info link_info;
162 bfd_cache_close_all ();
163 #ifdef ENABLE_PLUGINS
164 plugin_call_cleanup ();
166 if (output_filename && delete_output_file_on_failure)
167 unlink_if_ordinary (output_filename);
170 /* Hook to notice BFD assertions. */
173 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
174 const char *file, int line)
176 config.make_executable = FALSE;
177 (*default_bfd_assert_handler) (fmt, bfdver, file, line);
180 /* Hook the bfd error/warning handler for --fatal-warnings. */
183 ld_bfd_error_handler (const char *fmt, va_list ap)
185 if (config.fatal_warnings)
186 config.make_executable = FALSE;
187 (*default_bfd_error_handler) (fmt, ap);
191 main (int argc, char **argv)
194 long start_time = get_run_time ();
196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
197 setlocale (LC_MESSAGES, "");
199 #if defined (HAVE_SETLOCALE)
200 setlocale (LC_CTYPE, "");
202 bindtextdomain (PACKAGE, LOCALEDIR);
203 textdomain (PACKAGE);
205 program_name = argv[0];
206 xmalloc_set_program_name (program_name);
208 START_PROGRESS (program_name, 0);
210 expandargv (&argc, &argv);
214 bfd_set_error_program_name (program_name);
216 /* We want to notice and fail on those nasty BFD assertions which are
217 likely to signal incorrect output being generated but otherwise may
219 default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
221 /* Also hook the bfd error/warning handler for --fatal-warnings. */
222 default_bfd_error_handler = bfd_set_error_handler (ld_bfd_error_handler);
224 xatexit (ld_cleanup);
226 /* Set up the sysroot directory. */
227 ld_sysroot = get_sysroot (argc, argv);
229 ld_canon_sysroot = lrealpath (ld_sysroot);
230 if (ld_canon_sysroot)
231 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
233 ld_canon_sysroot_len = -1;
235 /* Set the default BFD target based on the configured target. Doing
236 this permits the linker to be configured for a particular target,
237 and linked against a shared BFD library which was configured for
238 a different target. The macro TARGET is defined by Makefile. */
239 if (!bfd_set_default_target (TARGET))
241 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
252 config.build_constructors = TRUE;
253 config.rpath_separator = ':';
254 config.split_by_reloc = (unsigned) -1;
255 config.split_by_file = (bfd_size_type) -1;
256 config.make_executable = TRUE;
257 config.magic_demand_paged = TRUE;
258 config.text_read_only = TRUE;
259 link_info.disable_target_specific_optimizations = -1;
261 command_line.warn_mismatch = TRUE;
262 command_line.warn_search_mismatch = TRUE;
263 command_line.check_section_addresses = -1;
265 /* We initialize DEMANGLING based on the environment variable
266 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
267 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
268 environment. Acting the same way here lets us provide the same
269 interface by default. */
270 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
272 link_info.allow_undefined_version = TRUE;
273 link_info.keep_memory = TRUE;
274 link_info.combreloc = TRUE;
275 link_info.strip_discarded = TRUE;
276 link_info.emit_hash = DEFAULT_EMIT_SYSV_HASH;
277 link_info.emit_gnu_hash = DEFAULT_EMIT_GNU_HASH;
278 link_info.callbacks = &link_callbacks;
279 link_info.input_bfds_tail = &link_info.input_bfds;
280 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
281 and _fini symbols. We are compatible. */
282 link_info.init_function = "_init";
283 link_info.fini_function = "_fini";
284 link_info.relax_pass = 1;
285 link_info.extern_protected_data = -1;
286 link_info.dynamic_undefined_weak = -1;
287 link_info.pei386_auto_import = -1;
288 link_info.spare_dynamic_tags = 5;
289 link_info.path_separator = ':';
290 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
291 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
293 #ifdef DEFAULT_NEW_DTAGS
294 link_info.new_dtags = DEFAULT_NEW_DTAGS;
297 ldfile_add_arch ("");
298 emulation = get_emulation (argc, argv);
299 ldemul_choose_mode (emulation);
300 default_target = ldemul_choose_target (argc, argv);
301 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
302 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
305 ldemul_before_parse ();
306 lang_has_input_file = FALSE;
307 parse_args (argc, argv);
309 if (config.hash_table_size != 0)
310 bfd_hash_set_default_size (config.hash_table_size);
312 #ifdef ENABLE_PLUGINS
313 /* Now all the plugin arguments have been gathered, we can load them. */
314 plugin_load_plugins ();
315 #endif /* ENABLE_PLUGINS */
317 ldemul_set_symbols ();
319 /* If we have not already opened and parsed a linker script,
320 try the default script from command line first. */
321 if (saved_script_handle == NULL
322 && command_line.default_script != NULL)
324 ldfile_open_command_file (command_line.default_script);
325 parser_input = input_script;
329 /* If we have not already opened and parsed a linker script
330 read the emulation's appropriate default script. */
331 if (saved_script_handle == NULL)
334 char *s = ldemul_get_script (&isfile);
337 ldfile_open_default_command_file (s);
341 lex_redirect (s, _("built in linker script"), 1);
343 parser_input = input_script;
350 if (saved_script_handle)
351 info_msg (_("using external linker script:"));
353 info_msg (_("using internal linker script:"));
354 info_msg ("\n==================================================\n");
356 if (saved_script_handle)
358 static const int ld_bufsz = 8193;
360 char *buf = (char *) xmalloc (ld_bufsz);
362 rewind (saved_script_handle);
363 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
366 info_msg ("%s", buf);
368 rewind (saved_script_handle);
375 info_msg (ldemul_get_script (&isfile));
378 info_msg ("\n==================================================\n");
381 if (command_line.force_group_allocation
382 || !bfd_link_relocatable (&link_info))
383 link_info.resolve_section_groups = TRUE;
385 link_info.resolve_section_groups = FALSE;
387 if (command_line.print_output_format)
388 info_msg ("%s\n", lang_get_output_target ());
392 /* If the only command line argument has been -v or --version or --verbose
393 then ignore any input files provided by linker scripts and exit now.
394 We do not want to create an output file when the linker is just invoked
395 to provide version information. */
396 if (argc == 2 && version_printed)
399 if (link_info.inhibit_common_definition && !bfd_link_dll (&link_info))
400 einfo (_("%P%F: --no-define-common may not be used without -shared\n"));
402 if (!lang_has_input_file)
404 if (version_printed || command_line.print_output_format)
406 einfo (_("%P%F: no input files\n"));
410 info_msg (_("%P: mode %s\n"), emulation);
412 ldemul_after_parse ();
414 if (config.map_filename)
416 if (strcmp (config.map_filename, "-") == 0)
418 config.map_file = stdout;
422 config.map_file = fopen (config.map_filename, FOPEN_WT);
423 if (config.map_file == (FILE *) NULL)
425 bfd_set_error (bfd_error_system_call);
426 einfo (_("%P%F: cannot open map file %s: %E\n"),
427 config.map_filename);
434 /* Print error messages for any missing symbols, for any warning
435 symbols, and possibly multiple definitions. */
436 if (bfd_link_relocatable (&link_info))
437 link_info.output_bfd->flags &= ~EXEC_P;
439 link_info.output_bfd->flags |= EXEC_P;
441 if ((link_info.compress_debug & COMPRESS_DEBUG))
443 link_info.output_bfd->flags |= BFD_COMPRESS;
444 if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
445 link_info.output_bfd->flags |= BFD_COMPRESS_GABI;
450 if (config.map_file != NULL)
452 if (command_line.cref)
453 output_cref (config.map_file != NULL ? config.map_file : stdout);
454 if (nocrossref_list != NULL)
455 check_nocrossrefs ();
456 if (command_line.print_memory_usage)
457 lang_print_memory_usage ();
460 struct bfd_link_hash_entry *h;
462 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
463 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
469 /* Even if we're producing relocatable output, some non-fatal errors should
470 be reported in the exit status. (What non-fatal errors, if any, do we
471 want to ignore for relocatable output?) */
472 if (!config.make_executable && !force_make_executable)
475 einfo (_("%P: link errors found, deleting executable `%s'\n"),
478 /* The file will be removed by ld_cleanup. */
483 if (!bfd_close (link_info.output_bfd))
484 einfo (_("%F%pB: final close failed: %E\n"), link_info.output_bfd);
486 /* If the --force-exe-suffix is enabled, and we're making an
487 executable file and it doesn't end in .exe, copy it to one
489 if (!bfd_link_relocatable (&link_info)
490 && command_line.force_exe_suffix)
492 int len = strlen (output_filename);
495 || (strcasecmp (output_filename + len - 4, ".exe") != 0
496 && strcasecmp (output_filename + len - 4, ".dll") != 0))
500 const int bsize = 4096;
501 char *buf = (char *) xmalloc (bsize);
503 char *dst_name = (char *) xmalloc (len + 5);
505 strcpy (dst_name, output_filename);
506 strcat (dst_name, ".exe");
507 src = fopen (output_filename, FOPEN_RB);
508 dst = fopen (dst_name, FOPEN_WB);
511 einfo (_("%P%F: unable to open for source of copy `%s'\n"),
514 einfo (_("%P%F: unable to open for destination of copy `%s'\n"),
516 while ((l = fread (buf, 1, bsize, src)) > 0)
518 int done = fwrite (buf, 1, l, dst);
521 einfo (_("%P: Error writing file `%s'\n"), dst_name);
525 if (fclose (dst) == EOF)
526 einfo (_("%P: Error closing file `%s'\n"), dst_name);
533 END_PROGRESS (program_name);
537 long run_time = get_run_time () - start_time;
540 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
541 program_name, run_time / 1000000, run_time % 1000000);
545 /* Prevent ld_cleanup from doing anything, after a successful link. */
546 output_filename = NULL;
552 /* If the configured sysroot is relocatable, try relocating it based on
553 default prefix FROM. Return the relocated directory if it exists,
554 otherwise return null. */
557 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
559 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
563 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
566 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
574 /* Return the sysroot directory. Return "" if no sysroot is being used. */
577 get_sysroot (int argc, char **argv)
582 for (i = 1; i < argc; i++)
583 if (CONST_STRNEQ (argv[i], "--sysroot="))
584 return argv[i] + strlen ("--sysroot=");
586 path = get_relative_sysroot (BINDIR);
590 path = get_relative_sysroot (TOOLBINDIR);
594 return TARGET_SYSTEM_ROOT;
597 /* We need to find any explicitly given emulation in order to initialize the
598 state that's needed by the lex&yacc argument parser (parse_args). */
601 get_emulation (int argc, char **argv)
606 emulation = getenv (EMULATION_ENVIRON);
607 if (emulation == NULL)
608 emulation = DEFAULT_EMULATION;
610 for (i = 1; i < argc; i++)
612 if (CONST_STRNEQ (argv[i], "-m"))
614 if (argv[i][2] == '\0')
619 emulation = argv[i + 1];
623 einfo (_("%P%F: missing argument to -m\n"));
625 else if (strcmp (argv[i], "-mips1") == 0
626 || strcmp (argv[i], "-mips2") == 0
627 || strcmp (argv[i], "-mips3") == 0
628 || strcmp (argv[i], "-mips4") == 0
629 || strcmp (argv[i], "-mips5") == 0
630 || strcmp (argv[i], "-mips32") == 0
631 || strcmp (argv[i], "-mips32r2") == 0
632 || strcmp (argv[i], "-mips32r6") == 0
633 || strcmp (argv[i], "-mips64") == 0
634 || strcmp (argv[i], "-mips64r2") == 0
635 || strcmp (argv[i], "-mips64r6") == 0)
637 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
638 passed to the linker by some MIPS compilers. They
639 generally tell the linker to use a slightly different
640 library path. Perhaps someday these should be
641 implemented as emulations; until then, we just ignore
642 the arguments and hope that nobody ever creates
643 emulations named ips1, ips2 or ips3. */
645 else if (strcmp (argv[i], "-m486") == 0)
647 /* FIXME: The argument -m486 is passed to the linker on
648 some Linux systems. Hope that nobody creates an
649 emulation named 486. */
654 emulation = &argv[i][2];
663 add_ysym (const char *name)
665 if (link_info.notice_hash == NULL)
667 link_info.notice_hash
668 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
669 if (!bfd_hash_table_init_n (link_info.notice_hash,
671 sizeof (struct bfd_hash_entry),
673 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
676 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
677 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
681 add_ignoresym (struct bfd_link_info *info, const char *name)
683 if (info->ignore_hash == NULL)
685 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
686 if (!bfd_hash_table_init_n (info->ignore_hash,
688 sizeof (struct bfd_hash_entry),
690 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
693 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
694 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
697 /* Record a symbol to be wrapped, from the --wrap option. */
700 add_wrap (const char *name)
702 if (link_info.wrap_hash == NULL)
705 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
706 if (!bfd_hash_table_init_n (link_info.wrap_hash,
708 sizeof (struct bfd_hash_entry),
710 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
713 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
714 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
717 /* Handle the -retain-symbols-file option. */
720 add_keepsyms_file (const char *filename)
727 if (link_info.strip == strip_some)
728 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
730 file = fopen (filename, "r");
733 bfd_set_error (bfd_error_system_call);
734 einfo ("%X%P: %s: %E\n", filename);
738 link_info.keep_hash = (struct bfd_hash_table *)
739 xmalloc (sizeof (struct bfd_hash_table));
740 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
741 sizeof (struct bfd_hash_entry)))
742 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
745 buf = (char *) xmalloc (bufsize);
757 while (!ISSPACE (c) && c != EOF)
764 buf = (char *) xrealloc (buf, bufsize);
771 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
772 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
776 if (link_info.strip != strip_none)
777 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
780 link_info.strip = strip_some;
784 /* Callbacks from the BFD linker routines. */
786 /* This is called when BFD has decided to include an archive member in
790 add_archive_element (struct bfd_link_info *info,
793 bfd **subsbfd ATTRIBUTE_UNUSED)
795 lang_input_statement_type *input;
796 lang_input_statement_type *parent;
797 lang_input_statement_type orig_input;
799 input = (lang_input_statement_type *)
800 xcalloc (1, sizeof (lang_input_statement_type));
801 input->header.type = lang_input_statement_enum;
802 input->filename = abfd->filename;
803 input->local_sym_name = abfd->filename;
804 input->the_bfd = abfd;
806 parent = abfd->my_archive->usrdata;
807 if (parent != NULL && !parent->flags.reload)
808 parent->next = (lang_statement_union_type *) input;
810 /* Save the original data for trace files/tries below, as plugins
811 (if enabled) may possibly alter it to point to a replacement
812 BFD, but we still want to output the original BFD filename. */
814 #ifdef ENABLE_PLUGINS
815 if (link_info.lto_plugin_active)
817 /* We must offer this archive member to the plugins to claim. */
818 plugin_maybe_claim (input);
819 if (input->flags.claimed)
821 if (no_more_claiming)
823 /* Don't claim new IR symbols after all IR symbols have
825 if (trace_files || verbose)
826 info_msg ("%pI: no new IR symbols to claimi\n",
828 input->flags.claimed = 0;
831 input->flags.claim_archive = TRUE;
832 *subsbfd = input->the_bfd;
835 #endif /* ENABLE_PLUGINS */
837 ldlang_add_file (input);
839 if (config.map_file != NULL)
841 static bfd_boolean header_printed;
842 struct bfd_link_hash_entry *h;
846 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
858 case bfd_link_hash_defined:
859 case bfd_link_hash_defweak:
860 from = h->u.def.section->owner;
863 case bfd_link_hash_undefined:
864 case bfd_link_hash_undefweak:
865 from = h->u.undef.abfd;
868 case bfd_link_hash_common:
869 from = h->u.c.p->section->owner;
876 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
877 header_printed = TRUE;
880 if (abfd->my_archive == NULL
881 || bfd_is_thin_archive (abfd->my_archive))
883 minfo ("%s", bfd_get_filename (abfd));
884 len = strlen (bfd_get_filename (abfd));
888 minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
889 bfd_get_filename (abfd));
890 len = (strlen (bfd_get_filename (abfd->my_archive))
891 + strlen (bfd_get_filename (abfd))
907 minfo ("%pB ", from);
909 minfo ("(%pT)\n", h->root.string);
911 minfo ("(%s)\n", name);
914 if (trace_files || verbose)
915 info_msg ("%pI\n", &orig_input);
919 /* This is called when BFD has discovered a symbol which is defined
923 multiple_definition (struct bfd_link_info *info,
924 struct bfd_link_hash_entry *h,
934 if (info->allow_multiple_definition)
939 case bfd_link_hash_defined:
940 osec = h->u.def.section;
941 oval = h->u.def.value;
942 obfd = h->u.def.section->owner;
944 case bfd_link_hash_indirect:
945 osec = bfd_ind_section_ptr;
953 /* Ignore a redefinition of an absolute symbol to the
954 same value; it's harmless. */
955 if (h->type == bfd_link_hash_defined
956 && bfd_is_abs_section (osec)
957 && bfd_is_abs_section (nsec)
961 /* If either section has the output_section field set to
962 bfd_abs_section_ptr, it means that the section is being
963 discarded, and this is not really a multiple definition at all.
964 FIXME: It would be cleaner to somehow ignore symbols defined in
965 sections which are being discarded. */
966 if ((osec->output_section != NULL
967 && !bfd_is_abs_section (osec)
968 && bfd_is_abs_section (osec->output_section))
969 || (nsec->output_section != NULL
970 && !bfd_is_abs_section (nsec)
971 && bfd_is_abs_section (nsec->output_section)))
974 name = h->root.string;
982 einfo (_("%X%C: multiple definition of `%pT'\n"),
983 nbfd, nsec, nval, name);
985 einfo (_("%D: first defined here\n"), obfd, osec, oval);
987 if (RELAXATION_ENABLED_BY_USER)
989 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
994 /* This is called when there is a definition of a common symbol, or
995 when a common symbol is found for a symbol that is already defined,
996 or when two common symbols are found. We only do something if
997 -warn-common was used. */
1000 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1001 struct bfd_link_hash_entry *h,
1003 enum bfd_link_hash_type ntype,
1008 enum bfd_link_hash_type otype;
1011 if (!config.warn_common)
1014 name = h->root.string;
1016 if (otype == bfd_link_hash_common)
1018 obfd = h->u.c.p->section->owner;
1019 osize = h->u.c.size;
1021 else if (otype == bfd_link_hash_defined
1022 || otype == bfd_link_hash_defweak)
1024 obfd = h->u.def.section->owner;
1029 /* FIXME: It would nice if we could report the BFD which defined
1030 an indirect symbol, but we don't have anywhere to store the
1036 if (ntype == bfd_link_hash_defined
1037 || ntype == bfd_link_hash_defweak
1038 || ntype == bfd_link_hash_indirect)
1040 ASSERT (otype == bfd_link_hash_common);
1041 einfo (_("%pB: warning: definition of `%pT' overriding common\n"),
1044 einfo (_("%pB: warning: common is here\n"), obfd);
1046 else if (otype == bfd_link_hash_defined
1047 || otype == bfd_link_hash_defweak
1048 || otype == bfd_link_hash_indirect)
1050 ASSERT (ntype == bfd_link_hash_common);
1051 einfo (_("%pB: warning: common of `%pT' overridden by definition\n"),
1054 einfo (_("%pB: warning: defined here\n"), obfd);
1058 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1061 einfo (_("%pB: warning: common of `%pT' overridden by larger common\n"),
1064 einfo (_("%pB: warning: larger common is here\n"), obfd);
1066 else if (nsize > osize)
1068 einfo (_("%pB: warning: common of `%pT' overriding smaller common\n"),
1071 einfo (_("%pB: warning: smaller common is here\n"), obfd);
1075 einfo (_("%pB: warning: multiple common of `%pT'\n"), nbfd, name);
1077 einfo (_("%pB: warning: previous common is here\n"), obfd);
1082 /* This is called when BFD has discovered a set element. H is the
1083 entry in the linker hash table for the set. SECTION and VALUE
1084 represent a value which should be added to the set. */
1087 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1088 struct bfd_link_hash_entry *h,
1089 bfd_reloc_code_real_type reloc,
1094 if (config.warn_constructors)
1095 einfo (_("%P: warning: global constructor %s used\n"),
1098 if (!config.build_constructors)
1101 ldctor_add_set_entry (h, reloc, NULL, section, value);
1103 if (h->type == bfd_link_hash_new)
1105 h->type = bfd_link_hash_undefined;
1106 h->u.undef.abfd = abfd;
1107 /* We don't call bfd_link_add_undef to add this to the list of
1108 undefined symbols because we are going to define it
1113 /* This is called when BFD has discovered a constructor. This is only
1114 called for some object file formats--those which do not handle
1115 constructors in some more clever fashion. This is similar to
1116 adding an element to a set, but less general. */
1119 constructor_callback (struct bfd_link_info *info,
1120 bfd_boolean constructor,
1127 struct bfd_link_hash_entry *h;
1128 char set_name[1 + sizeof "__CTOR_LIST__"];
1130 if (config.warn_constructors)
1131 einfo (_("%P: warning: global constructor %s used\n"), name);
1133 if (!config.build_constructors)
1136 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1137 useful error message. */
1138 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1139 && (bfd_link_relocatable (info)
1140 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1141 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1144 if (bfd_get_symbol_leading_char (abfd) != '\0')
1145 *s++ = bfd_get_symbol_leading_char (abfd);
1147 strcpy (s, "__CTOR_LIST__");
1149 strcpy (s, "__DTOR_LIST__");
1151 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1152 if (h == (struct bfd_link_hash_entry *) NULL)
1153 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1154 if (h->type == bfd_link_hash_new)
1156 h->type = bfd_link_hash_undefined;
1157 h->u.undef.abfd = abfd;
1158 /* We don't call bfd_link_add_undef to add this to the list of
1159 undefined symbols because we are going to define it
1163 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1166 /* A structure used by warning_callback to pass information through
1167 bfd_map_over_sections. */
1169 struct warning_callback_info
1172 const char *warning;
1177 /* Look through the relocs to see if we can find a plausible address
1178 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1181 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1183 struct warning_callback_info cinfo;
1185 if (!bfd_generic_link_read_symbols (abfd))
1186 einfo (_("%pB%F: could not read symbols: %E\n"), abfd);
1188 cinfo.found = FALSE;
1189 cinfo.warning = warning;
1190 cinfo.symbol = symbol;
1191 cinfo.asymbols = bfd_get_outsymbols (abfd);
1192 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1196 /* This is called when there is a reference to a warning symbol. */
1199 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1200 const char *warning,
1206 /* This is a hack to support warn_multiple_gp. FIXME: This should
1207 have a cleaner interface, but what? */
1208 if (!config.warn_multiple_gp
1209 && strcmp (warning, "using multiple gp values") == 0)
1212 if (section != NULL)
1213 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1214 else if (abfd == NULL)
1215 einfo ("%P: %s%s\n", _("warning: "), warning);
1216 else if (symbol == NULL)
1217 einfo ("%pB: %s%s\n", abfd, _("warning: "), warning);
1218 else if (!symbol_warning (warning, symbol, abfd))
1221 /* Search all input files for a reference to SYMBOL. */
1222 for (b = info->input_bfds; b; b = b->link.next)
1223 if (b != abfd && symbol_warning (warning, symbol, b))
1225 einfo ("%pB: %s%s\n", abfd, _("warning: "), warning);
1229 /* This is called by warning_callback for each section. It checks the
1230 relocs of the section to see if it can find a reference to the
1231 symbol which triggered the warning. If it can, it uses the reloc
1232 to give an error message with a file and line number. */
1235 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1237 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1241 arelent **p, **pend;
1246 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1248 einfo (_("%pB%F: could not read relocs: %E\n"), abfd);
1252 relpp = (arelent **) xmalloc (relsize);
1253 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1255 einfo (_("%pB%F: could not read relocs: %E\n"), abfd);
1258 pend = p + relcount;
1259 for (; p < pend && *p != NULL; p++)
1263 if (q->sym_ptr_ptr != NULL
1264 && *q->sym_ptr_ptr != NULL
1265 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1267 /* We found a reloc for the symbol we are looking for. */
1268 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1278 /* This is called when an undefined symbol is found. */
1281 undefined_symbol (struct bfd_link_info *info,
1288 static char *error_name;
1289 static unsigned int error_count;
1291 #define MAX_ERRORS_IN_A_ROW 5
1293 if (info->ignore_hash != NULL
1294 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1297 if (config.warn_once)
1299 /* Only warn once about a particular undefined symbol. */
1300 add_ignoresym (info, name);
1303 /* We never print more than a reasonable number of errors in a row
1304 for a single symbol. */
1305 if (error_name != NULL
1306 && strcmp (name, error_name) == 0)
1311 if (error_name != NULL)
1313 error_name = xstrdup (name);
1316 if (section != NULL)
1318 if (error_count < MAX_ERRORS_IN_A_ROW)
1321 einfo (_("%X%C: undefined reference to `%pT'\n"),
1322 abfd, section, address, name);
1324 einfo (_("%C: warning: undefined reference to `%pT'\n"),
1325 abfd, section, address, name);
1327 else if (error_count == MAX_ERRORS_IN_A_ROW)
1330 einfo (_("%X%D: more undefined references to `%pT' follow\n"),
1331 abfd, section, address, name);
1333 einfo (_("%D: warning: more undefined references to `%pT' follow\n"),
1334 abfd, section, address, name);
1341 if (error_count < MAX_ERRORS_IN_A_ROW)
1344 einfo (_("%X%pB: undefined reference to `%pT'\n"),
1347 einfo (_("%pB: warning: undefined reference to `%pT'\n"),
1350 else if (error_count == MAX_ERRORS_IN_A_ROW)
1353 einfo (_("%X%pB: more undefined references to `%pT' follow\n"),
1356 einfo (_("%pB: warning: more undefined references to `%pT' follow\n"),
1364 /* Counter to limit the number of relocation overflow error messages
1365 to print. Errors are printed as it is decremented. When it's
1366 called and the counter is zero, a final message is printed
1367 indicating more relocations were omitted. When it gets to -1, no
1368 such errors are printed. If it's initially set to a value less
1369 than -1, all such errors will be printed (--verbose does this). */
1371 int overflow_cutoff_limit = 10;
1373 /* This is called when a reloc overflows. */
1376 reloc_overflow (struct bfd_link_info *info,
1377 struct bfd_link_hash_entry *entry,
1379 const char *reloc_name,
1385 if (overflow_cutoff_limit == -1)
1388 einfo ("%X%H:", abfd, section, address);
1390 if (overflow_cutoff_limit >= 0
1391 && overflow_cutoff_limit-- == 0)
1393 einfo (_(" additional relocation overflows omitted from the output\n"));
1399 while (entry->type == bfd_link_hash_indirect
1400 || entry->type == bfd_link_hash_warning)
1401 entry = entry->u.i.link;
1402 switch (entry->type)
1404 case bfd_link_hash_undefined:
1405 case bfd_link_hash_undefweak:
1406 einfo (_(" relocation truncated to fit: "
1407 "%s against undefined symbol `%pT'"),
1408 reloc_name, entry->root.string);
1410 case bfd_link_hash_defined:
1411 case bfd_link_hash_defweak:
1412 einfo (_(" relocation truncated to fit: "
1413 "%s against symbol `%pT' defined in %pA section in %pB"),
1414 reloc_name, entry->root.string,
1415 entry->u.def.section,
1416 entry->u.def.section == bfd_abs_section_ptr
1417 ? info->output_bfd : entry->u.def.section->owner);
1425 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1428 einfo ("+%v", addend);
1432 /* This is called when a dangerous relocation is made. */
1435 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1436 const char *message,
1441 einfo (_("%X%H: dangerous relocation: %s\n"),
1442 abfd, section, address, message);
1445 /* This is called when a reloc is being generated attached to a symbol
1446 that is not being output. */
1449 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1455 einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1456 abfd, section, address, name);
1459 /* This is called if link_info.notice_all is set, or when a symbol in
1460 link_info.notice_hash is found. Symbols are put in notice_hash
1461 using the -y option, while notice_all is set if the --cref option
1462 has been supplied, or if there are any NOCROSSREFS sections in the
1463 linker script; and if plugins are active, since they need to monitor
1464 all references from non-IR files. */
1467 notice (struct bfd_link_info *info,
1468 struct bfd_link_hash_entry *h,
1469 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1473 flagword flags ATTRIBUTE_UNUSED)
1479 if (command_line.cref || nocrossref_list != NULL)
1480 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1484 name = h->root.string;
1485 if (info->notice_hash != NULL
1486 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1488 if (bfd_is_und_section (section))
1489 einfo (_("%pB: reference to %s\n"), abfd, name);
1491 einfo (_("%pB: definition of %s\n"), abfd, name);
1494 if (command_line.cref || nocrossref_list != NULL)
1495 add_cref (name, abfd, section, value);