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;
301 #ifdef DEFAULT_NEW_DTAGS
302 link_info.new_dtags = TRUE;
305 ldfile_add_arch ("");
306 emulation = get_emulation (argc, argv);
307 ldemul_choose_mode (emulation);
308 default_target = ldemul_choose_target (argc, argv);
309 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
310 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
313 ldemul_before_parse ();
314 lang_has_input_file = FALSE;
315 parse_args (argc, argv);
317 if (config.hash_table_size != 0)
318 bfd_hash_set_default_size (config.hash_table_size);
320 #ifdef ENABLE_PLUGINS
321 /* Now all the plugin arguments have been gathered, we can load them. */
322 plugin_load_plugins ();
323 #endif /* ENABLE_PLUGINS */
325 ldemul_set_symbols ();
327 /* If we have not already opened and parsed a linker script,
328 try the default script from command line first. */
329 if (saved_script_handle == NULL
330 && command_line.default_script != NULL)
332 ldfile_open_command_file (command_line.default_script);
333 parser_input = input_script;
337 /* If we have not already opened and parsed a linker script
338 read the emulation's appropriate default script. */
339 if (saved_script_handle == NULL)
342 char *s = ldemul_get_script (&isfile);
345 ldfile_open_default_command_file (s);
349 lex_redirect (s, _("built in linker script"), 1);
351 parser_input = input_script;
358 if (saved_script_handle)
359 info_msg (_("using external linker script:"));
361 info_msg (_("using internal linker script:"));
362 info_msg ("\n==================================================\n");
364 if (saved_script_handle)
366 static const int ld_bufsz = 8193;
368 char *buf = (char *) xmalloc (ld_bufsz);
370 rewind (saved_script_handle);
371 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
374 info_msg ("%s", buf);
376 rewind (saved_script_handle);
383 info_msg (ldemul_get_script (&isfile));
386 info_msg ("\n==================================================\n");
389 if (command_line.print_output_format)
390 info_msg ("%s\n", lang_get_output_target ());
394 /* If the only command line argument has been -v or --version or --verbose
395 then ignore any input files provided by linker scripts and exit now.
396 We do not want to create an output file when the linker is just invoked
397 to provide version information. */
398 if (argc == 2 && version_printed)
401 if (!lang_has_input_file)
403 if (version_printed || command_line.print_output_format)
405 einfo (_("%P%F: no input files\n"));
409 info_msg (_("%P: mode %s\n"), emulation);
411 ldemul_after_parse ();
413 if (config.map_filename)
415 if (strcmp (config.map_filename, "-") == 0)
417 config.map_file = stdout;
421 config.map_file = fopen (config.map_filename, FOPEN_WT);
422 if (config.map_file == (FILE *) NULL)
424 bfd_set_error (bfd_error_system_call);
425 einfo (_("%P%F: cannot open map file %s: %E\n"),
426 config.map_filename);
433 /* Print error messages for any missing symbols, for any warning
434 symbols, and possibly multiple definitions. */
435 if (bfd_link_relocatable (&link_info))
436 link_info.output_bfd->flags &= ~EXEC_P;
438 link_info.output_bfd->flags |= EXEC_P;
440 if ((link_info.compress_debug & COMPRESS_DEBUG))
442 link_info.output_bfd->flags |= BFD_COMPRESS;
443 if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
444 link_info.output_bfd->flags |= BFD_COMPRESS_GABI;
449 if (config.map_file != NULL)
451 if (command_line.cref)
452 output_cref (config.map_file != NULL ? config.map_file : stdout);
453 if (nocrossref_list != NULL)
454 check_nocrossrefs ();
455 if (command_line.print_memory_usage)
456 lang_print_memory_usage ();
459 struct bfd_link_hash_entry *h;
461 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
462 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
468 /* Even if we're producing relocatable output, some non-fatal errors should
469 be reported in the exit status. (What non-fatal errors, if any, do we
470 want to ignore for relocatable output?) */
471 if (!config.make_executable && !force_make_executable)
474 einfo (_("%P: link errors found, deleting executable `%s'\n"),
477 /* The file will be removed by ld_cleanup. */
482 if (!bfd_close (link_info.output_bfd))
483 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
485 /* If the --force-exe-suffix is enabled, and we're making an
486 executable file and it doesn't end in .exe, copy it to one
488 if (!bfd_link_relocatable (&link_info)
489 && command_line.force_exe_suffix)
491 int len = strlen (output_filename);
494 || (strcasecmp (output_filename + len - 4, ".exe") != 0
495 && strcasecmp (output_filename + len - 4, ".dll") != 0))
499 const int bsize = 4096;
500 char *buf = (char *) xmalloc (bsize);
502 char *dst_name = (char *) xmalloc (len + 5);
504 strcpy (dst_name, output_filename);
505 strcat (dst_name, ".exe");
506 src = fopen (output_filename, FOPEN_RB);
507 dst = fopen (dst_name, FOPEN_WB);
510 einfo (_("%P%F: unable to open for source of copy `%s'\n"),
513 einfo (_("%P%F: unable to open for destination of copy `%s'\n"),
515 while ((l = fread (buf, 1, bsize, src)) > 0)
517 int done = fwrite (buf, 1, l, dst);
520 einfo (_("%P: Error writing file `%s'\n"), dst_name);
524 if (fclose (dst) == EOF)
525 einfo (_("%P: Error closing file `%s'\n"), dst_name);
532 END_PROGRESS (program_name);
537 char *lim = (char *) sbrk (0);
539 long run_time = get_run_time () - start_time;
542 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
543 program_name, run_time / 1000000, run_time % 1000000);
545 fprintf (stderr, _("%s: data size %ld\n"), program_name,
546 (long) (lim - start_sbrk));
551 /* Prevent ld_cleanup from doing anything, after a successful link. */
552 output_filename = NULL;
558 /* If the configured sysroot is relocatable, try relocating it based on
559 default prefix FROM. Return the relocated directory if it exists,
560 otherwise return null. */
563 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
565 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
569 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
572 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
580 /* Return the sysroot directory. Return "" if no sysroot is being used. */
583 get_sysroot (int argc, char **argv)
588 for (i = 1; i < argc; i++)
589 if (CONST_STRNEQ (argv[i], "--sysroot="))
590 return argv[i] + strlen ("--sysroot=");
592 path = get_relative_sysroot (BINDIR);
596 path = get_relative_sysroot (TOOLBINDIR);
600 return TARGET_SYSTEM_ROOT;
603 /* We need to find any explicitly given emulation in order to initialize the
604 state that's needed by the lex&yacc argument parser (parse_args). */
607 get_emulation (int argc, char **argv)
612 emulation = getenv (EMULATION_ENVIRON);
613 if (emulation == NULL)
614 emulation = DEFAULT_EMULATION;
616 for (i = 1; i < argc; i++)
618 if (CONST_STRNEQ (argv[i], "-m"))
620 if (argv[i][2] == '\0')
625 emulation = argv[i + 1];
629 einfo (_("%P%F: missing argument to -m\n"));
631 else if (strcmp (argv[i], "-mips1") == 0
632 || strcmp (argv[i], "-mips2") == 0
633 || strcmp (argv[i], "-mips3") == 0
634 || strcmp (argv[i], "-mips4") == 0
635 || strcmp (argv[i], "-mips5") == 0
636 || strcmp (argv[i], "-mips32") == 0
637 || strcmp (argv[i], "-mips32r2") == 0
638 || strcmp (argv[i], "-mips32r6") == 0
639 || strcmp (argv[i], "-mips64") == 0
640 || strcmp (argv[i], "-mips64r2") == 0
641 || strcmp (argv[i], "-mips64r6") == 0)
643 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
644 passed to the linker by some MIPS compilers. They
645 generally tell the linker to use a slightly different
646 library path. Perhaps someday these should be
647 implemented as emulations; until then, we just ignore
648 the arguments and hope that nobody ever creates
649 emulations named ips1, ips2 or ips3. */
651 else if (strcmp (argv[i], "-m486") == 0)
653 /* FIXME: The argument -m486 is passed to the linker on
654 some Linux systems. Hope that nobody creates an
655 emulation named 486. */
660 emulation = &argv[i][2];
669 add_ysym (const char *name)
671 if (link_info.notice_hash == NULL)
673 link_info.notice_hash
674 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
675 if (!bfd_hash_table_init_n (link_info.notice_hash,
677 sizeof (struct bfd_hash_entry),
679 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
682 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
683 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
687 add_ignoresym (struct bfd_link_info *info, const char *name)
689 if (info->ignore_hash == NULL)
691 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
692 if (!bfd_hash_table_init_n (info->ignore_hash,
694 sizeof (struct bfd_hash_entry),
696 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
699 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
700 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
703 /* Record a symbol to be wrapped, from the --wrap option. */
706 add_wrap (const char *name)
708 if (link_info.wrap_hash == NULL)
711 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
712 if (!bfd_hash_table_init_n (link_info.wrap_hash,
714 sizeof (struct bfd_hash_entry),
716 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
719 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
720 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
723 /* Handle the -retain-symbols-file option. */
726 add_keepsyms_file (const char *filename)
733 if (link_info.strip == strip_some)
734 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
736 file = fopen (filename, "r");
739 bfd_set_error (bfd_error_system_call);
740 einfo ("%X%P: %s: %E\n", filename);
744 link_info.keep_hash = (struct bfd_hash_table *)
745 xmalloc (sizeof (struct bfd_hash_table));
746 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
747 sizeof (struct bfd_hash_entry)))
748 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
751 buf = (char *) xmalloc (bufsize);
763 while (!ISSPACE (c) && c != EOF)
770 buf = (char *) xrealloc (buf, bufsize);
777 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
778 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
782 if (link_info.strip != strip_none)
783 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
786 link_info.strip = strip_some;
790 /* Callbacks from the BFD linker routines. */
792 /* This is called when BFD has decided to include an archive member in
796 add_archive_element (struct bfd_link_info *info,
799 bfd **subsbfd ATTRIBUTE_UNUSED)
801 lang_input_statement_type *input;
802 lang_input_statement_type orig_input;
804 input = (lang_input_statement_type *)
805 xcalloc (1, sizeof (lang_input_statement_type));
806 input->header.type = lang_input_statement_enum;
807 input->filename = abfd->filename;
808 input->local_sym_name = abfd->filename;
809 input->the_bfd = abfd;
811 /* Save the original data for trace files/tries below, as plugins
812 (if enabled) may possibly alter it to point to a replacement
813 BFD, but we still want to output the original BFD filename. */
815 #ifdef ENABLE_PLUGINS
816 if (link_info.lto_plugin_active)
818 /* We must offer this archive member to the plugins to claim. */
819 plugin_maybe_claim (input);
820 if (input->flags.claimed)
822 if (no_more_claiming)
824 /* Don't claim new IR symbols after all IR symbols have
826 if (trace_files || verbose)
827 info_msg ("%I: no new IR symbols to claimi\n",
829 input->flags.claimed = 0;
832 input->flags.claim_archive = TRUE;
833 *subsbfd = input->the_bfd;
836 #endif /* ENABLE_PLUGINS */
838 ldlang_add_file (input);
840 if (config.map_file != NULL)
842 static bfd_boolean header_printed;
843 struct bfd_link_hash_entry *h;
847 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
859 case bfd_link_hash_defined:
860 case bfd_link_hash_defweak:
861 from = h->u.def.section->owner;
864 case bfd_link_hash_undefined:
865 case bfd_link_hash_undefweak:
866 from = h->u.undef.abfd;
869 case bfd_link_hash_common:
870 from = h->u.c.p->section->owner;
877 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
878 header_printed = TRUE;
881 if (abfd->my_archive == NULL
882 || bfd_is_thin_archive (abfd->my_archive))
884 minfo ("%s", bfd_get_filename (abfd));
885 len = strlen (bfd_get_filename (abfd));
889 minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
890 bfd_get_filename (abfd));
891 len = (strlen (bfd_get_filename (abfd->my_archive))
892 + strlen (bfd_get_filename (abfd))
910 minfo ("(%T)\n", h->root.string);
912 minfo ("(%s)\n", name);
915 if (trace_files || verbose)
916 info_msg ("%I\n", &orig_input);
920 /* This is called when BFD has discovered a symbol which is defined
924 multiple_definition (struct bfd_link_info *info,
925 struct bfd_link_hash_entry *h,
935 if (info->allow_multiple_definition)
940 case bfd_link_hash_defined:
941 osec = h->u.def.section;
942 oval = h->u.def.value;
943 obfd = h->u.def.section->owner;
945 case bfd_link_hash_indirect:
946 osec = bfd_ind_section_ptr;
954 /* Ignore a redefinition of an absolute symbol to the
955 same value; it's harmless. */
956 if (h->type == bfd_link_hash_defined
957 && bfd_is_abs_section (osec)
958 && bfd_is_abs_section (nsec)
962 /* If either section has the output_section field set to
963 bfd_abs_section_ptr, it means that the section is being
964 discarded, and this is not really a multiple definition at all.
965 FIXME: It would be cleaner to somehow ignore symbols defined in
966 sections which are being discarded. */
967 if ((osec->output_section != NULL
968 && !bfd_is_abs_section (osec)
969 && bfd_is_abs_section (osec->output_section))
970 || (nsec->output_section != NULL
971 && !bfd_is_abs_section (nsec)
972 && bfd_is_abs_section (nsec->output_section)))
975 name = h->root.string;
983 einfo (_("%X%C: multiple definition of `%T'\n"),
984 nbfd, nsec, nval, name);
986 einfo (_("%D: first defined here\n"), obfd, osec, oval);
988 if (RELAXATION_ENABLED_BY_USER)
990 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
995 /* This is called when there is a definition of a common symbol, or
996 when a common symbol is found for a symbol that is already defined,
997 or when two common symbols are found. We only do something if
998 -warn-common was used. */
1001 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1002 struct bfd_link_hash_entry *h,
1004 enum bfd_link_hash_type ntype,
1009 enum bfd_link_hash_type otype;
1012 if (!config.warn_common)
1015 name = h->root.string;
1017 if (otype == bfd_link_hash_common)
1019 obfd = h->u.c.p->section->owner;
1020 osize = h->u.c.size;
1022 else if (otype == bfd_link_hash_defined
1023 || otype == bfd_link_hash_defweak)
1025 obfd = h->u.def.section->owner;
1030 /* FIXME: It would nice if we could report the BFD which defined
1031 an indirect symbol, but we don't have anywhere to store the
1037 if (ntype == bfd_link_hash_defined
1038 || ntype == bfd_link_hash_defweak
1039 || ntype == bfd_link_hash_indirect)
1041 ASSERT (otype == bfd_link_hash_common);
1042 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1045 einfo (_("%B: warning: common is here\n"), obfd);
1047 else if (otype == bfd_link_hash_defined
1048 || otype == bfd_link_hash_defweak
1049 || otype == bfd_link_hash_indirect)
1051 ASSERT (ntype == bfd_link_hash_common);
1052 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1055 einfo (_("%B: warning: defined here\n"), obfd);
1059 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1062 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1065 einfo (_("%B: warning: larger common is here\n"), obfd);
1067 else if (nsize > osize)
1069 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1072 einfo (_("%B: warning: smaller common is here\n"), obfd);
1076 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1078 einfo (_("%B: warning: previous common is here\n"), obfd);
1083 /* This is called when BFD has discovered a set element. H is the
1084 entry in the linker hash table for the set. SECTION and VALUE
1085 represent a value which should be added to the set. */
1088 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1089 struct bfd_link_hash_entry *h,
1090 bfd_reloc_code_real_type reloc,
1095 if (config.warn_constructors)
1096 einfo (_("%P: warning: global constructor %s used\n"),
1099 if (!config.build_constructors)
1102 ldctor_add_set_entry (h, reloc, NULL, section, value);
1104 if (h->type == bfd_link_hash_new)
1106 h->type = bfd_link_hash_undefined;
1107 h->u.undef.abfd = abfd;
1108 /* We don't call bfd_link_add_undef to add this to the list of
1109 undefined symbols because we are going to define it
1114 /* This is called when BFD has discovered a constructor. This is only
1115 called for some object file formats--those which do not handle
1116 constructors in some more clever fashion. This is similar to
1117 adding an element to a set, but less general. */
1120 constructor_callback (struct bfd_link_info *info,
1121 bfd_boolean constructor,
1128 struct bfd_link_hash_entry *h;
1129 char set_name[1 + sizeof "__CTOR_LIST__"];
1131 if (config.warn_constructors)
1132 einfo (_("%P: warning: global constructor %s used\n"), name);
1134 if (!config.build_constructors)
1137 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1138 useful error message. */
1139 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1140 && (bfd_link_relocatable (info)
1141 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1142 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1145 if (bfd_get_symbol_leading_char (abfd) != '\0')
1146 *s++ = bfd_get_symbol_leading_char (abfd);
1148 strcpy (s, "__CTOR_LIST__");
1150 strcpy (s, "__DTOR_LIST__");
1152 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1153 if (h == (struct bfd_link_hash_entry *) NULL)
1154 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1155 if (h->type == bfd_link_hash_new)
1157 h->type = bfd_link_hash_undefined;
1158 h->u.undef.abfd = abfd;
1159 /* We don't call bfd_link_add_undef to add this to the list of
1160 undefined symbols because we are going to define it
1164 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1167 /* A structure used by warning_callback to pass information through
1168 bfd_map_over_sections. */
1170 struct warning_callback_info
1173 const char *warning;
1178 /* Look through the relocs to see if we can find a plausible address
1179 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1182 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1184 struct warning_callback_info cinfo;
1186 if (!bfd_generic_link_read_symbols (abfd))
1187 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1189 cinfo.found = FALSE;
1190 cinfo.warning = warning;
1191 cinfo.symbol = symbol;
1192 cinfo.asymbols = bfd_get_outsymbols (abfd);
1193 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1197 /* This is called when there is a reference to a warning symbol. */
1200 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1201 const char *warning,
1207 /* This is a hack to support warn_multiple_gp. FIXME: This should
1208 have a cleaner interface, but what? */
1209 if (!config.warn_multiple_gp
1210 && strcmp (warning, "using multiple gp values") == 0)
1213 if (section != NULL)
1214 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1215 else if (abfd == NULL)
1216 einfo ("%P: %s%s\n", _("warning: "), warning);
1217 else if (symbol == NULL)
1218 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1219 else if (!symbol_warning (warning, symbol, abfd))
1222 /* Search all input files for a reference to SYMBOL. */
1223 for (b = info->input_bfds; b; b = b->link.next)
1224 if (b != abfd && symbol_warning (warning, symbol, b))
1226 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1230 /* This is called by warning_callback for each section. It checks the
1231 relocs of the section to see if it can find a reference to the
1232 symbol which triggered the warning. If it can, it uses the reloc
1233 to give an error message with a file and line number. */
1236 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1238 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1242 arelent **p, **pend;
1247 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1249 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1253 relpp = (arelent **) xmalloc (relsize);
1254 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1256 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1259 pend = p + relcount;
1260 for (; p < pend && *p != NULL; p++)
1264 if (q->sym_ptr_ptr != NULL
1265 && *q->sym_ptr_ptr != NULL
1266 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1268 /* We found a reloc for the symbol we are looking for. */
1269 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1279 /* This is called when an undefined symbol is found. */
1282 undefined_symbol (struct bfd_link_info *info,
1289 static char *error_name;
1290 static unsigned int error_count;
1292 #define MAX_ERRORS_IN_A_ROW 5
1294 if (info->ignore_hash != NULL
1295 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1298 if (config.warn_once)
1300 /* Only warn once about a particular undefined symbol. */
1301 add_ignoresym (info, name);
1304 /* We never print more than a reasonable number of errors in a row
1305 for a single symbol. */
1306 if (error_name != NULL
1307 && strcmp (name, error_name) == 0)
1312 if (error_name != NULL)
1314 error_name = xstrdup (name);
1317 if (section != NULL)
1319 if (error_count < MAX_ERRORS_IN_A_ROW)
1322 einfo (_("%X%C: undefined reference to `%T'\n"),
1323 abfd, section, address, name);
1325 einfo (_("%C: warning: undefined reference to `%T'\n"),
1326 abfd, section, address, name);
1328 else if (error_count == MAX_ERRORS_IN_A_ROW)
1331 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1332 abfd, section, address, name);
1334 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1335 abfd, section, address, name);
1342 if (error_count < MAX_ERRORS_IN_A_ROW)
1345 einfo (_("%X%B: undefined reference to `%T'\n"),
1348 einfo (_("%B: warning: undefined reference to `%T'\n"),
1351 else if (error_count == MAX_ERRORS_IN_A_ROW)
1354 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1357 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1365 /* Counter to limit the number of relocation overflow error messages
1366 to print. Errors are printed as it is decremented. When it's
1367 called and the counter is zero, a final message is printed
1368 indicating more relocations were omitted. When it gets to -1, no
1369 such errors are printed. If it's initially set to a value less
1370 than -1, all such errors will be printed (--verbose does this). */
1372 int overflow_cutoff_limit = 10;
1374 /* This is called when a reloc overflows. */
1377 reloc_overflow (struct bfd_link_info *info,
1378 struct bfd_link_hash_entry *entry,
1380 const char *reloc_name,
1386 if (overflow_cutoff_limit == -1)
1389 einfo ("%X%H:", abfd, section, address);
1391 if (overflow_cutoff_limit >= 0
1392 && overflow_cutoff_limit-- == 0)
1394 einfo (_(" additional relocation overflows omitted from the output\n"));
1400 while (entry->type == bfd_link_hash_indirect
1401 || entry->type == bfd_link_hash_warning)
1402 entry = entry->u.i.link;
1403 switch (entry->type)
1405 case bfd_link_hash_undefined:
1406 case bfd_link_hash_undefweak:
1407 einfo (_(" relocation truncated to fit: "
1408 "%s against undefined symbol `%T'"),
1409 reloc_name, entry->root.string);
1411 case bfd_link_hash_defined:
1412 case bfd_link_hash_defweak:
1413 einfo (_(" relocation truncated to fit: "
1414 "%s against symbol `%T' defined in %A section in %B"),
1415 reloc_name, entry->root.string,
1416 entry->u.def.section,
1417 entry->u.def.section == bfd_abs_section_ptr
1418 ? info->output_bfd : entry->u.def.section->owner);
1426 einfo (_(" relocation truncated to fit: %s against `%T'"),
1429 einfo ("+%v", addend);
1433 /* This is called when a dangerous relocation is made. */
1436 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1437 const char *message,
1442 einfo (_("%X%H: dangerous relocation: %s\n"),
1443 abfd, section, address, message);
1446 /* This is called when a reloc is being generated attached to a symbol
1447 that is not being output. */
1450 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1456 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1457 abfd, section, address, name);
1460 /* This is called if link_info.notice_all is set, or when a symbol in
1461 link_info.notice_hash is found. Symbols are put in notice_hash
1462 using the -y option, while notice_all is set if the --cref option
1463 has been supplied, or if there are any NOCROSSREFS sections in the
1464 linker script; and if plugins are active, since they need to monitor
1465 all references from non-IR files. */
1468 notice (struct bfd_link_info *info,
1469 struct bfd_link_hash_entry *h,
1470 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1474 flagword flags ATTRIBUTE_UNUSED)
1480 if (command_line.cref || nocrossref_list != NULL)
1481 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1485 name = h->root.string;
1486 if (info->notice_hash != NULL
1487 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1489 if (bfd_is_und_section (section))
1490 einfo ("%B: reference to %s\n", abfd, name);
1492 einfo ("%B: definition of %s\n", abfd, name);
1495 if (command_line.cref || nocrossref_list != NULL)
1496 add_cref (name, abfd, section, value);