1 /* Main program of GNU linker.
2 Copyright (C) 1991-2017 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)
59 #ifndef TARGET_SYSTEM_ROOT
60 #define TARGET_SYSTEM_ROOT ""
65 FILE *saved_script_handle = NULL;
66 FILE *previous_script_handle = NULL;
67 bfd_boolean force_make_executable = FALSE;
70 const char *output_filename = "a.out";
72 /* Name this program was invoked by. */
75 /* The prefix for system library directories. */
76 const char *ld_sysroot;
78 /* The canonical representation of ld_sysroot. */
79 char *ld_canon_sysroot;
80 int ld_canon_sysroot_len;
82 /* Set by -G argument, for targets like MIPS ELF. */
83 int g_switch_value = 8;
85 /* Nonzero means print names of input files as processed. */
86 bfd_boolean trace_files;
88 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
91 /* Nonzero means version number was printed, so exit successfully
92 instead of complaining if no input files are given. */
93 bfd_boolean version_printed;
95 /* TRUE if we should demangle symbol names. */
96 bfd_boolean demangling;
98 args_type command_line;
100 ld_config_type config;
102 sort_type sort_section;
104 static const char *get_sysroot
106 static char *get_emulation
108 static bfd_boolean add_archive_element
109 (struct bfd_link_info *, bfd *, const char *, bfd **);
110 static void multiple_definition
111 (struct bfd_link_info *, struct bfd_link_hash_entry *,
112 bfd *, asection *, bfd_vma);
113 static void multiple_common
114 (struct bfd_link_info *, struct bfd_link_hash_entry *,
115 bfd *, enum bfd_link_hash_type, bfd_vma);
116 static void add_to_set
117 (struct bfd_link_info *, struct bfd_link_hash_entry *,
118 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
119 static void constructor_callback
120 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
121 asection *, bfd_vma);
122 static void warning_callback
123 (struct bfd_link_info *, const char *, const char *, bfd *,
124 asection *, bfd_vma);
125 static void warning_find_reloc
126 (bfd *, asection *, void *);
127 static void undefined_symbol
128 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
130 static void reloc_overflow
131 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
132 const char *, bfd_vma, bfd *, asection *, bfd_vma);
133 static void reloc_dangerous
134 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
135 static void unattached_reloc
136 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
137 static bfd_boolean notice
138 (struct bfd_link_info *, struct bfd_link_hash_entry *,
139 struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
141 static struct bfd_link_callbacks link_callbacks =
147 constructor_callback,
157 ldlang_override_segment_assignment
160 static bfd_assert_handler_type default_bfd_assert_handler;
161 static bfd_error_handler_type default_bfd_error_handler;
163 struct bfd_link_info link_info;
168 bfd_cache_close_all ();
169 #ifdef ENABLE_PLUGINS
170 plugin_call_cleanup ();
172 if (output_filename && delete_output_file_on_failure)
173 unlink_if_ordinary (output_filename);
176 /* Hook to notice BFD assertions. */
179 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
180 const char *file, int line)
182 config.make_executable = FALSE;
183 (*default_bfd_assert_handler) (fmt, bfdver, file, line);
186 /* Hook the bfd error/warning handler for --fatal-warnings. */
189 ld_bfd_error_handler (const char *fmt, va_list ap)
191 if (config.fatal_warnings)
192 config.make_executable = FALSE;
193 (*default_bfd_error_handler) (fmt, ap);
197 main (int argc, char **argv)
200 long start_time = get_run_time ();
202 char *start_sbrk = (char *) sbrk (0);
205 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
206 setlocale (LC_MESSAGES, "");
208 #if defined (HAVE_SETLOCALE)
209 setlocale (LC_CTYPE, "");
211 bindtextdomain (PACKAGE, LOCALEDIR);
212 textdomain (PACKAGE);
214 program_name = argv[0];
215 xmalloc_set_program_name (program_name);
217 START_PROGRESS (program_name, 0);
219 expandargv (&argc, &argv);
223 bfd_set_error_program_name (program_name);
225 /* We want to notice and fail on those nasty BFD assertions which are
226 likely to signal incorrect output being generated but otherwise may
228 default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
230 /* Also hook the bfd error/warning handler for --fatal-warnings. */
231 default_bfd_error_handler = bfd_set_error_handler (ld_bfd_error_handler);
233 xatexit (ld_cleanup);
235 /* Set up the sysroot directory. */
236 ld_sysroot = get_sysroot (argc, argv);
238 ld_canon_sysroot = lrealpath (ld_sysroot);
239 if (ld_canon_sysroot)
240 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
242 ld_canon_sysroot_len = -1;
244 /* Set the default BFD target based on the configured target. Doing
245 this permits the linker to be configured for a particular target,
246 and linked against a shared BFD library which was configured for
247 a different target. The macro TARGET is defined by Makefile. */
248 if (!bfd_set_default_target (TARGET))
250 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
261 config.build_constructors = TRUE;
262 config.rpath_separator = ':';
263 config.split_by_reloc = (unsigned) -1;
264 config.split_by_file = (bfd_size_type) -1;
265 config.make_executable = TRUE;
266 config.magic_demand_paged = TRUE;
267 config.text_read_only = TRUE;
268 link_info.disable_target_specific_optimizations = -1;
270 command_line.warn_mismatch = TRUE;
271 command_line.warn_search_mismatch = TRUE;
272 command_line.check_section_addresses = -1;
274 /* We initialize DEMANGLING based on the environment variable
275 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
276 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
277 environment. Acting the same way here lets us provide the same
278 interface by default. */
279 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
281 link_info.allow_undefined_version = TRUE;
282 link_info.keep_memory = TRUE;
283 link_info.combreloc = TRUE;
284 link_info.strip_discarded = TRUE;
285 link_info.emit_hash = TRUE;
286 link_info.callbacks = &link_callbacks;
287 link_info.input_bfds_tail = &link_info.input_bfds;
288 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
289 and _fini symbols. We are compatible. */
290 link_info.init_function = "_init";
291 link_info.fini_function = "_fini";
292 link_info.relax_pass = 1;
293 link_info.extern_protected_data = -1;
294 link_info.dynamic_undefined_weak = -1;
295 link_info.pei386_auto_import = -1;
296 link_info.spare_dynamic_tags = 5;
297 link_info.path_separator = ':';
298 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
299 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
302 ldfile_add_arch ("");
303 emulation = get_emulation (argc, argv);
304 ldemul_choose_mode (emulation);
305 default_target = ldemul_choose_target (argc, argv);
306 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
307 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
310 ldemul_before_parse ();
311 lang_has_input_file = FALSE;
312 parse_args (argc, argv);
314 if (config.hash_table_size != 0)
315 bfd_hash_set_default_size (config.hash_table_size);
317 #ifdef ENABLE_PLUGINS
318 /* Now all the plugin arguments have been gathered, we can load them. */
319 plugin_load_plugins ();
320 #endif /* ENABLE_PLUGINS */
322 ldemul_set_symbols ();
324 /* If we have not already opened and parsed a linker script,
325 try the default script from command line first. */
326 if (saved_script_handle == NULL
327 && command_line.default_script != NULL)
329 ldfile_open_command_file (command_line.default_script);
330 parser_input = input_script;
334 /* If we have not already opened and parsed a linker script
335 read the emulation's appropriate default script. */
336 if (saved_script_handle == NULL)
339 char *s = ldemul_get_script (&isfile);
342 ldfile_open_default_command_file (s);
346 lex_redirect (s, _("built in linker script"), 1);
348 parser_input = input_script;
355 if (saved_script_handle)
356 info_msg (_("using external linker script:"));
358 info_msg (_("using internal linker script:"));
359 info_msg ("\n==================================================\n");
361 if (saved_script_handle)
363 static const int ld_bufsz = 8193;
365 char *buf = (char *) xmalloc (ld_bufsz);
367 rewind (saved_script_handle);
368 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
371 info_msg ("%s", buf);
373 rewind (saved_script_handle);
380 info_msg (ldemul_get_script (&isfile));
383 info_msg ("\n==================================================\n");
386 if (command_line.print_output_format)
387 info_msg ("%s\n", lang_get_output_target ());
391 /* If the only command line argument has been -v or --version or --verbose
392 then ignore any input files provided by linker scripts and exit now.
393 We do not want to create an output file when the linker is just invoked
394 to provide version information. */
395 if (argc == 2 && version_printed)
398 if (!lang_has_input_file)
400 if (version_printed || command_line.print_output_format)
402 einfo (_("%P%F: no input files\n"));
406 info_msg (_("%P: mode %s\n"), emulation);
408 ldemul_after_parse ();
410 if (config.map_filename)
412 if (strcmp (config.map_filename, "-") == 0)
414 config.map_file = stdout;
418 config.map_file = fopen (config.map_filename, FOPEN_WT);
419 if (config.map_file == (FILE *) NULL)
421 bfd_set_error (bfd_error_system_call);
422 einfo (_("%P%F: cannot open map file %s: %E\n"),
423 config.map_filename);
430 /* Print error messages for any missing symbols, for any warning
431 symbols, and possibly multiple definitions. */
432 if (bfd_link_relocatable (&link_info))
433 link_info.output_bfd->flags &= ~EXEC_P;
435 link_info.output_bfd->flags |= EXEC_P;
437 if ((link_info.compress_debug & COMPRESS_DEBUG))
439 link_info.output_bfd->flags |= BFD_COMPRESS;
440 if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
441 link_info.output_bfd->flags |= BFD_COMPRESS_GABI;
446 if (config.map_file != NULL)
448 if (command_line.cref)
449 output_cref (config.map_file != NULL ? config.map_file : stdout);
450 if (nocrossref_list != NULL)
451 check_nocrossrefs ();
452 if (command_line.print_memory_usage)
453 lang_print_memory_usage ();
456 struct bfd_link_hash_entry *h;
458 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
459 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
465 /* Even if we're producing relocatable output, some non-fatal errors should
466 be reported in the exit status. (What non-fatal errors, if any, do we
467 want to ignore for relocatable output?) */
468 if (!config.make_executable && !force_make_executable)
471 einfo (_("%P: link errors found, deleting executable `%s'\n"),
474 /* The file will be removed by ld_cleanup. */
479 if (!bfd_close (link_info.output_bfd))
480 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
482 /* If the --force-exe-suffix is enabled, and we're making an
483 executable file and it doesn't end in .exe, copy it to one
485 if (!bfd_link_relocatable (&link_info)
486 && command_line.force_exe_suffix)
488 int len = strlen (output_filename);
491 || (strcasecmp (output_filename + len - 4, ".exe") != 0
492 && strcasecmp (output_filename + len - 4, ".dll") != 0))
496 const int bsize = 4096;
497 char *buf = (char *) xmalloc (bsize);
499 char *dst_name = (char *) xmalloc (len + 5);
501 strcpy (dst_name, output_filename);
502 strcat (dst_name, ".exe");
503 src = fopen (output_filename, FOPEN_RB);
504 dst = fopen (dst_name, FOPEN_WB);
507 einfo (_("%P%F: unable to open for source of copy `%s'\n"),
510 einfo (_("%P%F: unable to open for destination of copy `%s'\n"),
512 while ((l = fread (buf, 1, bsize, src)) > 0)
514 int done = fwrite (buf, 1, l, dst);
517 einfo (_("%P: Error writing file `%s'\n"), dst_name);
521 if (fclose (dst) == EOF)
522 einfo (_("%P: Error closing file `%s'\n"), dst_name);
529 END_PROGRESS (program_name);
534 char *lim = (char *) sbrk (0);
536 long run_time = get_run_time () - start_time;
539 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
540 program_name, run_time / 1000000, run_time % 1000000);
542 fprintf (stderr, _("%s: data size %ld\n"), program_name,
543 (long) (lim - start_sbrk));
548 /* Prevent ld_cleanup from doing anything, after a successful link. */
549 output_filename = NULL;
555 /* If the configured sysroot is relocatable, try relocating it based on
556 default prefix FROM. Return the relocated directory if it exists,
557 otherwise return null. */
560 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
562 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
566 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
569 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
577 /* Return the sysroot directory. Return "" if no sysroot is being used. */
580 get_sysroot (int argc, char **argv)
585 for (i = 1; i < argc; i++)
586 if (CONST_STRNEQ (argv[i], "--sysroot="))
587 return argv[i] + strlen ("--sysroot=");
589 path = get_relative_sysroot (BINDIR);
593 path = get_relative_sysroot (TOOLBINDIR);
597 return TARGET_SYSTEM_ROOT;
600 /* We need to find any explicitly given emulation in order to initialize the
601 state that's needed by the lex&yacc argument parser (parse_args). */
604 get_emulation (int argc, char **argv)
609 emulation = getenv (EMULATION_ENVIRON);
610 if (emulation == NULL)
611 emulation = DEFAULT_EMULATION;
613 for (i = 1; i < argc; i++)
615 if (CONST_STRNEQ (argv[i], "-m"))
617 if (argv[i][2] == '\0')
622 emulation = argv[i + 1];
626 einfo (_("%P%F: missing argument to -m\n"));
628 else if (strcmp (argv[i], "-mips1") == 0
629 || strcmp (argv[i], "-mips2") == 0
630 || strcmp (argv[i], "-mips3") == 0
631 || strcmp (argv[i], "-mips4") == 0
632 || strcmp (argv[i], "-mips5") == 0
633 || strcmp (argv[i], "-mips32") == 0
634 || strcmp (argv[i], "-mips32r2") == 0
635 || strcmp (argv[i], "-mips32r6") == 0
636 || strcmp (argv[i], "-mips64") == 0
637 || strcmp (argv[i], "-mips64r2") == 0
638 || strcmp (argv[i], "-mips64r6") == 0)
640 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
641 passed to the linker by some MIPS compilers. They
642 generally tell the linker to use a slightly different
643 library path. Perhaps someday these should be
644 implemented as emulations; until then, we just ignore
645 the arguments and hope that nobody ever creates
646 emulations named ips1, ips2 or ips3. */
648 else if (strcmp (argv[i], "-m486") == 0)
650 /* FIXME: The argument -m486 is passed to the linker on
651 some Linux systems. Hope that nobody creates an
652 emulation named 486. */
657 emulation = &argv[i][2];
666 add_ysym (const char *name)
668 if (link_info.notice_hash == NULL)
670 link_info.notice_hash
671 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
672 if (!bfd_hash_table_init_n (link_info.notice_hash,
674 sizeof (struct bfd_hash_entry),
676 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
679 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
680 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
684 add_ignoresym (struct bfd_link_info *info, const char *name)
686 if (info->ignore_hash == NULL)
688 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
689 if (!bfd_hash_table_init_n (info->ignore_hash,
691 sizeof (struct bfd_hash_entry),
693 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
696 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
697 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
700 /* Record a symbol to be wrapped, from the --wrap option. */
703 add_wrap (const char *name)
705 if (link_info.wrap_hash == NULL)
708 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
709 if (!bfd_hash_table_init_n (link_info.wrap_hash,
711 sizeof (struct bfd_hash_entry),
713 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
716 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
717 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
720 /* Handle the -retain-symbols-file option. */
723 add_keepsyms_file (const char *filename)
730 if (link_info.strip == strip_some)
731 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
733 file = fopen (filename, "r");
736 bfd_set_error (bfd_error_system_call);
737 einfo ("%X%P: %s: %E\n", filename);
741 link_info.keep_hash = (struct bfd_hash_table *)
742 xmalloc (sizeof (struct bfd_hash_table));
743 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
744 sizeof (struct bfd_hash_entry)))
745 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
748 buf = (char *) xmalloc (bufsize);
760 while (!ISSPACE (c) && c != EOF)
767 buf = (char *) xrealloc (buf, bufsize);
774 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
775 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
779 if (link_info.strip != strip_none)
780 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
783 link_info.strip = strip_some;
787 /* Callbacks from the BFD linker routines. */
789 /* This is called when BFD has decided to include an archive member in
793 add_archive_element (struct bfd_link_info *info,
796 bfd **subsbfd ATTRIBUTE_UNUSED)
798 lang_input_statement_type *input;
799 lang_input_statement_type orig_input;
801 input = (lang_input_statement_type *)
802 xcalloc (1, sizeof (lang_input_statement_type));
803 input->header.type = lang_input_statement_enum;
804 input->filename = abfd->filename;
805 input->local_sym_name = abfd->filename;
806 input->the_bfd = abfd;
808 /* Save the original data for trace files/tries below, as plugins
809 (if enabled) may possibly alter it to point to a replacement
810 BFD, but we still want to output the original BFD filename. */
812 #ifdef ENABLE_PLUGINS
813 if (link_info.lto_plugin_active)
815 /* We must offer this archive member to the plugins to claim. */
816 plugin_maybe_claim (input);
817 if (input->flags.claimed)
819 if (no_more_claiming)
821 /* Don't claim new IR symbols after all IR symbols have
823 if (trace_files || verbose)
824 info_msg ("%I: no new IR symbols to claimi\n",
826 input->flags.claimed = 0;
829 input->flags.claim_archive = TRUE;
830 *subsbfd = input->the_bfd;
833 #endif /* ENABLE_PLUGINS */
835 ldlang_add_file (input);
837 if (config.map_file != NULL)
839 static bfd_boolean header_printed;
840 struct bfd_link_hash_entry *h;
844 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
856 case bfd_link_hash_defined:
857 case bfd_link_hash_defweak:
858 from = h->u.def.section->owner;
861 case bfd_link_hash_undefined:
862 case bfd_link_hash_undefweak:
863 from = h->u.undef.abfd;
866 case bfd_link_hash_common:
867 from = h->u.c.p->section->owner;
874 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
875 header_printed = TRUE;
878 if (abfd->my_archive == NULL
879 || bfd_is_thin_archive (abfd->my_archive))
881 minfo ("%s", bfd_get_filename (abfd));
882 len = strlen (bfd_get_filename (abfd));
886 minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
887 bfd_get_filename (abfd));
888 len = (strlen (bfd_get_filename (abfd->my_archive))
889 + strlen (bfd_get_filename (abfd))
907 minfo ("(%T)\n", h->root.string);
909 minfo ("(%s)\n", name);
912 if (trace_files || verbose)
913 info_msg ("%I\n", &orig_input);
917 /* This is called when BFD has discovered a symbol which is defined
921 multiple_definition (struct bfd_link_info *info,
922 struct bfd_link_hash_entry *h,
932 if (info->allow_multiple_definition)
937 case bfd_link_hash_defined:
938 osec = h->u.def.section;
939 oval = h->u.def.value;
940 obfd = h->u.def.section->owner;
942 case bfd_link_hash_indirect:
943 osec = bfd_ind_section_ptr;
951 /* Ignore a redefinition of an absolute symbol to the
952 same value; it's harmless. */
953 if (h->type == bfd_link_hash_defined
954 && bfd_is_abs_section (osec)
955 && bfd_is_abs_section (nsec)
959 /* If either section has the output_section field set to
960 bfd_abs_section_ptr, it means that the section is being
961 discarded, and this is not really a multiple definition at all.
962 FIXME: It would be cleaner to somehow ignore symbols defined in
963 sections which are being discarded. */
964 if ((osec->output_section != NULL
965 && !bfd_is_abs_section (osec)
966 && bfd_is_abs_section (osec->output_section))
967 || (nsec->output_section != NULL
968 && !bfd_is_abs_section (nsec)
969 && bfd_is_abs_section (nsec->output_section)))
972 name = h->root.string;
980 einfo (_("%X%C: multiple definition of `%T'\n"),
981 nbfd, nsec, nval, name);
983 einfo (_("%D: first defined here\n"), obfd, osec, oval);
985 if (RELAXATION_ENABLED_BY_USER)
987 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
992 /* This is called when there is a definition of a common symbol, or
993 when a common symbol is found for a symbol that is already defined,
994 or when two common symbols are found. We only do something if
995 -warn-common was used. */
998 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
999 struct bfd_link_hash_entry *h,
1001 enum bfd_link_hash_type ntype,
1006 enum bfd_link_hash_type otype;
1009 if (!config.warn_common)
1012 name = h->root.string;
1014 if (otype == bfd_link_hash_common)
1016 obfd = h->u.c.p->section->owner;
1017 osize = h->u.c.size;
1019 else if (otype == bfd_link_hash_defined
1020 || otype == bfd_link_hash_defweak)
1022 obfd = h->u.def.section->owner;
1027 /* FIXME: It would nice if we could report the BFD which defined
1028 an indirect symbol, but we don't have anywhere to store the
1034 if (ntype == bfd_link_hash_defined
1035 || ntype == bfd_link_hash_defweak
1036 || ntype == bfd_link_hash_indirect)
1038 ASSERT (otype == bfd_link_hash_common);
1039 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1042 einfo (_("%B: warning: common is here\n"), obfd);
1044 else if (otype == bfd_link_hash_defined
1045 || otype == bfd_link_hash_defweak
1046 || otype == bfd_link_hash_indirect)
1048 ASSERT (ntype == bfd_link_hash_common);
1049 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1052 einfo (_("%B: warning: defined here\n"), obfd);
1056 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1059 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1062 einfo (_("%B: warning: larger common is here\n"), obfd);
1064 else if (nsize > osize)
1066 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1069 einfo (_("%B: warning: smaller common is here\n"), obfd);
1073 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1075 einfo (_("%B: warning: previous common is here\n"), obfd);
1080 /* This is called when BFD has discovered a set element. H is the
1081 entry in the linker hash table for the set. SECTION and VALUE
1082 represent a value which should be added to the set. */
1085 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1086 struct bfd_link_hash_entry *h,
1087 bfd_reloc_code_real_type reloc,
1092 if (config.warn_constructors)
1093 einfo (_("%P: warning: global constructor %s used\n"),
1096 if (!config.build_constructors)
1099 ldctor_add_set_entry (h, reloc, NULL, section, value);
1101 if (h->type == bfd_link_hash_new)
1103 h->type = bfd_link_hash_undefined;
1104 h->u.undef.abfd = abfd;
1105 /* We don't call bfd_link_add_undef to add this to the list of
1106 undefined symbols because we are going to define it
1111 /* This is called when BFD has discovered a constructor. This is only
1112 called for some object file formats--those which do not handle
1113 constructors in some more clever fashion. This is similar to
1114 adding an element to a set, but less general. */
1117 constructor_callback (struct bfd_link_info *info,
1118 bfd_boolean constructor,
1125 struct bfd_link_hash_entry *h;
1126 char set_name[1 + sizeof "__CTOR_LIST__"];
1128 if (config.warn_constructors)
1129 einfo (_("%P: warning: global constructor %s used\n"), name);
1131 if (!config.build_constructors)
1134 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1135 useful error message. */
1136 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1137 && (bfd_link_relocatable (info)
1138 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1139 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1142 if (bfd_get_symbol_leading_char (abfd) != '\0')
1143 *s++ = bfd_get_symbol_leading_char (abfd);
1145 strcpy (s, "__CTOR_LIST__");
1147 strcpy (s, "__DTOR_LIST__");
1149 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1150 if (h == (struct bfd_link_hash_entry *) NULL)
1151 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1152 if (h->type == bfd_link_hash_new)
1154 h->type = bfd_link_hash_undefined;
1155 h->u.undef.abfd = abfd;
1156 /* We don't call bfd_link_add_undef to add this to the list of
1157 undefined symbols because we are going to define it
1161 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1164 /* A structure used by warning_callback to pass information through
1165 bfd_map_over_sections. */
1167 struct warning_callback_info
1170 const char *warning;
1175 /* Look through the relocs to see if we can find a plausible address
1176 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1179 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1181 struct warning_callback_info cinfo;
1183 if (!bfd_generic_link_read_symbols (abfd))
1184 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1186 cinfo.found = FALSE;
1187 cinfo.warning = warning;
1188 cinfo.symbol = symbol;
1189 cinfo.asymbols = bfd_get_outsymbols (abfd);
1190 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1194 /* This is called when there is a reference to a warning symbol. */
1197 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1198 const char *warning,
1204 /* This is a hack to support warn_multiple_gp. FIXME: This should
1205 have a cleaner interface, but what? */
1206 if (!config.warn_multiple_gp
1207 && strcmp (warning, "using multiple gp values") == 0)
1210 if (section != NULL)
1211 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1212 else if (abfd == NULL)
1213 einfo ("%P: %s%s\n", _("warning: "), warning);
1214 else if (symbol == NULL)
1215 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1216 else if (!symbol_warning (warning, symbol, abfd))
1219 /* Search all input files for a reference to SYMBOL. */
1220 for (b = info->input_bfds; b; b = b->link.next)
1221 if (b != abfd && symbol_warning (warning, symbol, b))
1223 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1227 /* This is called by warning_callback for each section. It checks the
1228 relocs of the section to see if it can find a reference to the
1229 symbol which triggered the warning. If it can, it uses the reloc
1230 to give an error message with a file and line number. */
1233 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1235 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1239 arelent **p, **pend;
1244 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1246 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1250 relpp = (arelent **) xmalloc (relsize);
1251 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1253 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1256 pend = p + relcount;
1257 for (; p < pend && *p != NULL; p++)
1261 if (q->sym_ptr_ptr != NULL
1262 && *q->sym_ptr_ptr != NULL
1263 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1265 /* We found a reloc for the symbol we are looking for. */
1266 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1276 /* This is called when an undefined symbol is found. */
1279 undefined_symbol (struct bfd_link_info *info,
1286 static char *error_name;
1287 static unsigned int error_count;
1289 #define MAX_ERRORS_IN_A_ROW 5
1291 if (info->ignore_hash != NULL
1292 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1295 if (config.warn_once)
1297 /* Only warn once about a particular undefined symbol. */
1298 add_ignoresym (info, name);
1301 /* We never print more than a reasonable number of errors in a row
1302 for a single symbol. */
1303 if (error_name != NULL
1304 && strcmp (name, error_name) == 0)
1309 if (error_name != NULL)
1311 error_name = xstrdup (name);
1314 if (section != NULL)
1316 if (error_count < MAX_ERRORS_IN_A_ROW)
1319 einfo (_("%X%C: undefined reference to `%T'\n"),
1320 abfd, section, address, name);
1322 einfo (_("%C: warning: undefined reference to `%T'\n"),
1323 abfd, section, address, name);
1325 else if (error_count == MAX_ERRORS_IN_A_ROW)
1328 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1329 abfd, section, address, name);
1331 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1332 abfd, section, address, name);
1339 if (error_count < MAX_ERRORS_IN_A_ROW)
1342 einfo (_("%X%B: undefined reference to `%T'\n"),
1345 einfo (_("%B: warning: undefined reference to `%T'\n"),
1348 else if (error_count == MAX_ERRORS_IN_A_ROW)
1351 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1354 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1362 /* Counter to limit the number of relocation overflow error messages
1363 to print. Errors are printed as it is decremented. When it's
1364 called and the counter is zero, a final message is printed
1365 indicating more relocations were omitted. When it gets to -1, no
1366 such errors are printed. If it's initially set to a value less
1367 than -1, all such errors will be printed (--verbose does this). */
1369 int overflow_cutoff_limit = 10;
1371 /* This is called when a reloc overflows. */
1374 reloc_overflow (struct bfd_link_info *info,
1375 struct bfd_link_hash_entry *entry,
1377 const char *reloc_name,
1383 if (overflow_cutoff_limit == -1)
1386 einfo ("%X%H:", abfd, section, address);
1388 if (overflow_cutoff_limit >= 0
1389 && overflow_cutoff_limit-- == 0)
1391 einfo (_(" additional relocation overflows omitted from the output\n"));
1397 while (entry->type == bfd_link_hash_indirect
1398 || entry->type == bfd_link_hash_warning)
1399 entry = entry->u.i.link;
1400 switch (entry->type)
1402 case bfd_link_hash_undefined:
1403 case bfd_link_hash_undefweak:
1404 einfo (_(" relocation truncated to fit: "
1405 "%s against undefined symbol `%T'"),
1406 reloc_name, entry->root.string);
1408 case bfd_link_hash_defined:
1409 case bfd_link_hash_defweak:
1410 einfo (_(" relocation truncated to fit: "
1411 "%s against symbol `%T' defined in %A section in %B"),
1412 reloc_name, entry->root.string,
1413 entry->u.def.section,
1414 entry->u.def.section == bfd_abs_section_ptr
1415 ? info->output_bfd : entry->u.def.section->owner);
1423 einfo (_(" relocation truncated to fit: %s against `%T'"),
1426 einfo ("+%v", addend);
1430 /* This is called when a dangerous relocation is made. */
1433 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1434 const char *message,
1439 einfo (_("%X%H: dangerous relocation: %s\n"),
1440 abfd, section, address, message);
1443 /* This is called when a reloc is being generated attached to a symbol
1444 that is not being output. */
1447 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1453 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1454 abfd, section, address, name);
1457 /* This is called if link_info.notice_all is set, or when a symbol in
1458 link_info.notice_hash is found. Symbols are put in notice_hash
1459 using the -y option, while notice_all is set if the --cref option
1460 has been supplied, or if there are any NOCROSSREFS sections in the
1461 linker script; and if plugins are active, since they need to monitor
1462 all references from non-IR files. */
1465 notice (struct bfd_link_info *info,
1466 struct bfd_link_hash_entry *h,
1467 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1471 flagword flags ATTRIBUTE_UNUSED)
1477 if (command_line.cref || nocrossref_list != NULL)
1478 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1482 name = h->root.string;
1483 if (info->notice_hash != NULL
1484 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1486 if (bfd_is_und_section (section))
1487 einfo ("%B: reference to %s\n", abfd, name);
1489 einfo ("%B: definition of %s\n", abfd, name);
1492 if (command_line.cref || nocrossref_list != NULL)
1493 add_cref (name, abfd, section, value);