1 /* Main program of GNU linker.
2 Copyright (C) 1991-2016 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;
162 struct bfd_link_info link_info;
167 bfd_cache_close_all ();
168 #ifdef ENABLE_PLUGINS
169 plugin_call_cleanup ();
171 if (output_filename && delete_output_file_on_failure)
172 unlink_if_ordinary (output_filename);
175 /* If there's a BFD assertion, we'll notice and exit with an error
176 unless otherwise instructed. */
179 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
180 const char *file, int line)
182 (*default_bfd_assert_handler) (fmt, bfdver, file, line);
183 config.make_executable = FALSE;
187 main (int argc, char **argv)
190 long start_time = get_run_time ();
192 char *start_sbrk = (char *) sbrk (0);
195 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
196 setlocale (LC_MESSAGES, "");
198 #if defined (HAVE_SETLOCALE)
199 setlocale (LC_CTYPE, "");
201 bindtextdomain (PACKAGE, LOCALEDIR);
202 textdomain (PACKAGE);
204 program_name = argv[0];
205 xmalloc_set_program_name (program_name);
207 START_PROGRESS (program_name, 0);
209 expandargv (&argc, &argv);
213 bfd_set_error_program_name (program_name);
215 /* We want to notice and fail on those nasty BFD assertions which are
216 likely to signal incorrect output being generated but otherwise may
218 default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
220 xatexit (ld_cleanup);
222 /* Set up the sysroot directory. */
223 ld_sysroot = get_sysroot (argc, argv);
225 ld_canon_sysroot = lrealpath (ld_sysroot);
226 if (ld_canon_sysroot)
227 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
229 ld_canon_sysroot_len = -1;
231 /* Set the default BFD target based on the configured target. Doing
232 this permits the linker to be configured for a particular target,
233 and linked against a shared BFD library which was configured for
234 a different target. The macro TARGET is defined by Makefile. */
235 if (! bfd_set_default_target (TARGET))
237 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
248 config.build_constructors = TRUE;
249 config.rpath_separator = ':';
250 config.split_by_reloc = (unsigned) -1;
251 config.split_by_file = (bfd_size_type) -1;
252 config.make_executable = TRUE;
253 config.magic_demand_paged = TRUE;
254 config.text_read_only = TRUE;
255 link_info.disable_target_specific_optimizations = -1;
257 command_line.warn_mismatch = TRUE;
258 command_line.warn_search_mismatch = TRUE;
259 command_line.check_section_addresses = -1;
261 /* We initialize DEMANGLING based on the environment variable
262 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
263 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
264 environment. Acting the same way here lets us provide the same
265 interface by default. */
266 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
268 link_info.allow_undefined_version = TRUE;
269 link_info.keep_memory = TRUE;
270 link_info.combreloc = TRUE;
271 link_info.strip_discarded = TRUE;
272 link_info.emit_hash = TRUE;
273 link_info.callbacks = &link_callbacks;
274 link_info.input_bfds_tail = &link_info.input_bfds;
275 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
276 and _fini symbols. We are compatible. */
277 link_info.init_function = "_init";
278 link_info.fini_function = "_fini";
279 link_info.relax_pass = 1;
280 link_info.extern_protected_data = -1;
281 link_info.dynamic_undefined_weak = -1;
282 link_info.pei386_auto_import = -1;
283 link_info.spare_dynamic_tags = 5;
284 link_info.path_separator = ':';
285 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
286 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
289 ldfile_add_arch ("");
290 emulation = get_emulation (argc, argv);
291 ldemul_choose_mode (emulation);
292 default_target = ldemul_choose_target (argc, argv);
293 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
294 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
297 ldemul_before_parse ();
298 lang_has_input_file = FALSE;
299 parse_args (argc, argv);
301 if (config.hash_table_size != 0)
302 bfd_hash_set_default_size (config.hash_table_size);
304 #ifdef ENABLE_PLUGINS
305 /* Now all the plugin arguments have been gathered, we can load them. */
306 plugin_load_plugins ();
307 #endif /* ENABLE_PLUGINS */
309 ldemul_set_symbols ();
311 /* If we have not already opened and parsed a linker script,
312 try the default script from command line first. */
313 if (saved_script_handle == NULL
314 && command_line.default_script != NULL)
316 ldfile_open_command_file (command_line.default_script);
317 parser_input = input_script;
321 /* If we have not already opened and parsed a linker script
322 read the emulation's appropriate default script. */
323 if (saved_script_handle == NULL)
326 char *s = ldemul_get_script (&isfile);
329 ldfile_open_default_command_file (s);
333 lex_redirect (s, _("built in linker script"), 1);
335 parser_input = input_script;
342 if (saved_script_handle)
343 info_msg (_("using external linker script:"));
345 info_msg (_("using internal linker script:"));
346 info_msg ("\n==================================================\n");
348 if (saved_script_handle)
350 static const int ld_bufsz = 8193;
352 char *buf = (char *) xmalloc (ld_bufsz);
354 rewind (saved_script_handle);
355 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
360 rewind (saved_script_handle);
367 info_msg (ldemul_get_script (&isfile));
370 info_msg ("\n==================================================\n");
373 if (command_line.print_output_format)
374 info_msg ("%s\n", lang_get_output_target ());
378 /* If the only command line argument has been -v or --version or --verbose
379 then ignore any input files provided by linker scripts and exit now.
380 We do not want to create an output file when the linker is just invoked
381 to provide version information. */
382 if (argc == 2 && version_printed)
385 if (!lang_has_input_file)
387 if (version_printed || command_line.print_output_format)
389 einfo (_("%P%F: no input files\n"));
393 info_msg (_("%P: mode %s\n"), emulation);
395 ldemul_after_parse ();
397 if (config.map_filename)
399 if (strcmp (config.map_filename, "-") == 0)
401 config.map_file = stdout;
405 config.map_file = fopen (config.map_filename, FOPEN_WT);
406 if (config.map_file == (FILE *) NULL)
408 bfd_set_error (bfd_error_system_call);
409 einfo (_("%P%F: cannot open map file %s: %E\n"),
410 config.map_filename);
417 /* Print error messages for any missing symbols, for any warning
418 symbols, and possibly multiple definitions. */
419 if (bfd_link_relocatable (&link_info))
420 link_info.output_bfd->flags &= ~EXEC_P;
422 link_info.output_bfd->flags |= EXEC_P;
424 if ((link_info.compress_debug & COMPRESS_DEBUG))
426 link_info.output_bfd->flags |= BFD_COMPRESS;
427 if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
428 link_info.output_bfd->flags |= BFD_COMPRESS_GABI;
433 if (config.map_file != NULL)
435 if (command_line.cref)
436 output_cref (config.map_file != NULL ? config.map_file : stdout);
437 if (nocrossref_list != NULL)
438 check_nocrossrefs ();
439 if (command_line.print_memory_usage)
440 lang_print_memory_usage ();
443 struct bfd_link_hash_entry * h;
445 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
446 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
452 /* Even if we're producing relocatable output, some non-fatal errors should
453 be reported in the exit status. (What non-fatal errors, if any, do we
454 want to ignore for relocatable output?) */
455 if (!config.make_executable && !force_make_executable)
458 einfo (_("%P: link errors found, deleting executable `%s'\n"),
461 /* The file will be removed by ld_cleanup. */
466 if (! bfd_close (link_info.output_bfd))
467 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
469 /* If the --force-exe-suffix is enabled, and we're making an
470 executable file and it doesn't end in .exe, copy it to one
472 if (!bfd_link_relocatable (&link_info)
473 && command_line.force_exe_suffix)
475 int len = strlen (output_filename);
478 || (strcasecmp (output_filename + len - 4, ".exe") != 0
479 && strcasecmp (output_filename + len - 4, ".dll") != 0))
483 const int bsize = 4096;
484 char *buf = (char *) xmalloc (bsize);
486 char *dst_name = (char *) xmalloc (len + 5);
488 strcpy (dst_name, output_filename);
489 strcat (dst_name, ".exe");
490 src = fopen (output_filename, FOPEN_RB);
491 dst = fopen (dst_name, FOPEN_WB);
494 einfo (_("%P%F: unable to open for source of copy `%s'\n"),
497 einfo (_("%P%F: unable to open for destination of copy `%s'\n"),
499 while ((l = fread (buf, 1, bsize, src)) > 0)
501 int done = fwrite (buf, 1, l, dst);
504 einfo (_("%P: Error writing file `%s'\n"), dst_name);
508 if (fclose (dst) == EOF)
509 einfo (_("%P: Error closing file `%s'\n"), dst_name);
516 END_PROGRESS (program_name);
521 char *lim = (char *) sbrk (0);
523 long run_time = get_run_time () - start_time;
526 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
527 program_name, run_time / 1000000, run_time % 1000000);
529 fprintf (stderr, _("%s: data size %ld\n"), program_name,
530 (long) (lim - start_sbrk));
535 /* Prevent ld_cleanup from doing anything, after a successful link. */
536 output_filename = NULL;
542 /* If the configured sysroot is relocatable, try relocating it based on
543 default prefix FROM. Return the relocated directory if it exists,
544 otherwise return null. */
547 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
549 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
553 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
556 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
564 /* Return the sysroot directory. Return "" if no sysroot is being used. */
567 get_sysroot (int argc, char **argv)
572 for (i = 1; i < argc; i++)
573 if (CONST_STRNEQ (argv[i], "--sysroot="))
574 return argv[i] + strlen ("--sysroot=");
576 path = get_relative_sysroot (BINDIR);
580 path = get_relative_sysroot (TOOLBINDIR);
584 return TARGET_SYSTEM_ROOT;
587 /* We need to find any explicitly given emulation in order to initialize the
588 state that's needed by the lex&yacc argument parser (parse_args). */
591 get_emulation (int argc, char **argv)
596 emulation = getenv (EMULATION_ENVIRON);
597 if (emulation == NULL)
598 emulation = DEFAULT_EMULATION;
600 for (i = 1; i < argc; i++)
602 if (CONST_STRNEQ (argv[i], "-m"))
604 if (argv[i][2] == '\0')
609 emulation = argv[i + 1];
613 einfo (_("%P%F: missing argument to -m\n"));
615 else if (strcmp (argv[i], "-mips1") == 0
616 || strcmp (argv[i], "-mips2") == 0
617 || strcmp (argv[i], "-mips3") == 0
618 || strcmp (argv[i], "-mips4") == 0
619 || strcmp (argv[i], "-mips5") == 0
620 || strcmp (argv[i], "-mips32") == 0
621 || strcmp (argv[i], "-mips32r2") == 0
622 || strcmp (argv[i], "-mips32r6") == 0
623 || strcmp (argv[i], "-mips64") == 0
624 || strcmp (argv[i], "-mips64r2") == 0
625 || strcmp (argv[i], "-mips64r6") == 0)
627 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
628 passed to the linker by some MIPS compilers. They
629 generally tell the linker to use a slightly different
630 library path. Perhaps someday these should be
631 implemented as emulations; until then, we just ignore
632 the arguments and hope that nobody ever creates
633 emulations named ips1, ips2 or ips3. */
635 else if (strcmp (argv[i], "-m486") == 0)
637 /* FIXME: The argument -m486 is passed to the linker on
638 some Linux systems. Hope that nobody creates an
639 emulation named 486. */
644 emulation = &argv[i][2];
653 add_ysym (const char *name)
655 if (link_info.notice_hash == NULL)
657 link_info.notice_hash =
658 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
659 if (!bfd_hash_table_init_n (link_info.notice_hash,
661 sizeof (struct bfd_hash_entry),
663 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
666 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
667 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
671 add_ignoresym (struct bfd_link_info *info, const char *name)
673 if (info->ignore_hash == NULL)
675 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
676 if (! bfd_hash_table_init_n (info->ignore_hash,
678 sizeof (struct bfd_hash_entry),
680 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
683 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
684 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
687 /* Record a symbol to be wrapped, from the --wrap option. */
690 add_wrap (const char *name)
692 if (link_info.wrap_hash == NULL)
694 link_info.wrap_hash =
695 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
696 if (!bfd_hash_table_init_n (link_info.wrap_hash,
698 sizeof (struct bfd_hash_entry),
700 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
703 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
704 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
707 /* Handle the -retain-symbols-file option. */
710 add_keepsyms_file (const char *filename)
717 if (link_info.strip == strip_some)
718 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
720 file = fopen (filename, "r");
723 bfd_set_error (bfd_error_system_call);
724 einfo ("%X%P: %s: %E\n", filename);
728 link_info.keep_hash = (struct bfd_hash_table *)
729 xmalloc (sizeof (struct bfd_hash_table));
730 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
731 sizeof (struct bfd_hash_entry)))
732 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
735 buf = (char *) xmalloc (bufsize);
747 while (! ISSPACE (c) && c != EOF)
754 buf = (char *) xrealloc (buf, bufsize);
761 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
762 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
766 if (link_info.strip != strip_none)
767 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
770 link_info.strip = strip_some;
774 /* Callbacks from the BFD linker routines. */
776 /* This is called when BFD has decided to include an archive member in
780 add_archive_element (struct bfd_link_info *info,
783 bfd **subsbfd ATTRIBUTE_UNUSED)
785 lang_input_statement_type *input;
786 lang_input_statement_type orig_input;
788 input = (lang_input_statement_type *)
789 xcalloc (1, sizeof (lang_input_statement_type));
790 input->filename = abfd->filename;
791 input->local_sym_name = abfd->filename;
792 input->the_bfd = abfd;
794 /* Save the original data for trace files/tries below, as plugins
795 (if enabled) may possibly alter it to point to a replacement
796 BFD, but we still want to output the original BFD filename. */
798 #ifdef ENABLE_PLUGINS
799 if (link_info.lto_plugin_active)
801 /* We must offer this archive member to the plugins to claim. */
802 plugin_maybe_claim (input);
803 if (input->flags.claimed)
805 if (no_more_claiming)
807 /* Don't claim new IR symbols after all IR symbols have
809 if (trace_files || verbose)
810 info_msg ("%I: no new IR symbols to claimi\n",
812 input->flags.claimed = 0;
815 input->flags.claim_archive = TRUE;
816 *subsbfd = input->the_bfd;
819 #endif /* ENABLE_PLUGINS */
821 ldlang_add_file (input);
823 if (config.map_file != NULL)
825 static bfd_boolean header_printed;
826 struct bfd_link_hash_entry *h;
830 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
842 case bfd_link_hash_defined:
843 case bfd_link_hash_defweak:
844 from = h->u.def.section->owner;
847 case bfd_link_hash_undefined:
848 case bfd_link_hash_undefweak:
849 from = h->u.undef.abfd;
852 case bfd_link_hash_common:
853 from = h->u.c.p->section->owner;
858 if (! header_printed)
862 sprintf (buf, _("Archive member included "
863 "to satisfy reference by file (symbol)\n\n"));
865 header_printed = TRUE;
868 if (bfd_my_archive (abfd) == NULL)
870 minfo ("%s", bfd_get_filename (abfd));
871 len = strlen (bfd_get_filename (abfd));
875 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
876 bfd_get_filename (abfd));
877 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
878 + strlen (bfd_get_filename (abfd))
896 minfo ("(%T)\n", h->root.string);
898 minfo ("(%s)\n", name);
901 if (trace_files || verbose)
902 info_msg ("%I\n", &orig_input);
906 /* This is called when BFD has discovered a symbol which is defined
910 multiple_definition (struct bfd_link_info *info,
911 struct bfd_link_hash_entry *h,
921 if (info->allow_multiple_definition)
926 case bfd_link_hash_defined:
927 osec = h->u.def.section;
928 oval = h->u.def.value;
929 obfd = h->u.def.section->owner;
931 case bfd_link_hash_indirect:
932 osec = bfd_ind_section_ptr;
940 /* Ignore a redefinition of an absolute symbol to the
941 same value; it's harmless. */
942 if (h->type == bfd_link_hash_defined
943 && bfd_is_abs_section (osec)
944 && bfd_is_abs_section (nsec)
948 /* If either section has the output_section field set to
949 bfd_abs_section_ptr, it means that the section is being
950 discarded, and this is not really a multiple definition at all.
951 FIXME: It would be cleaner to somehow ignore symbols defined in
952 sections which are being discarded. */
953 if ((osec->output_section != NULL
954 && ! bfd_is_abs_section (osec)
955 && bfd_is_abs_section (osec->output_section))
956 || (nsec->output_section != NULL
957 && ! bfd_is_abs_section (nsec)
958 && bfd_is_abs_section (nsec->output_section)))
961 name = h->root.string;
969 einfo (_("%X%C: multiple definition of `%T'\n"),
970 nbfd, nsec, nval, name);
972 einfo (_("%D: first defined here\n"), obfd, osec, oval);
974 if (RELAXATION_ENABLED_BY_USER)
976 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
981 /* This is called when there is a definition of a common symbol, or
982 when a common symbol is found for a symbol that is already defined,
983 or when two common symbols are found. We only do something if
984 -warn-common was used. */
987 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
988 struct bfd_link_hash_entry *h,
990 enum bfd_link_hash_type ntype,
995 enum bfd_link_hash_type otype;
998 if (!config.warn_common)
1001 name = h->root.string;
1003 if (otype == bfd_link_hash_common)
1005 obfd = h->u.c.p->section->owner;
1006 osize = h->u.c.size;
1008 else if (otype == bfd_link_hash_defined
1009 || otype == bfd_link_hash_defweak)
1011 obfd = h->u.def.section->owner;
1016 /* FIXME: It would nice if we could report the BFD which defined
1017 an indirect symbol, but we don't have anywhere to store the
1023 if (ntype == bfd_link_hash_defined
1024 || ntype == bfd_link_hash_defweak
1025 || ntype == bfd_link_hash_indirect)
1027 ASSERT (otype == bfd_link_hash_common);
1028 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1031 einfo (_("%B: warning: common is here\n"), obfd);
1033 else if (otype == bfd_link_hash_defined
1034 || otype == bfd_link_hash_defweak
1035 || otype == bfd_link_hash_indirect)
1037 ASSERT (ntype == bfd_link_hash_common);
1038 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1041 einfo (_("%B: warning: defined here\n"), obfd);
1045 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1048 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1051 einfo (_("%B: warning: larger common is here\n"), obfd);
1053 else if (nsize > osize)
1055 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1058 einfo (_("%B: warning: smaller common is here\n"), obfd);
1062 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1064 einfo (_("%B: warning: previous common is here\n"), obfd);
1069 /* This is called when BFD has discovered a set element. H is the
1070 entry in the linker hash table for the set. SECTION and VALUE
1071 represent a value which should be added to the set. */
1074 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1075 struct bfd_link_hash_entry *h,
1076 bfd_reloc_code_real_type reloc,
1081 if (config.warn_constructors)
1082 einfo (_("%P: warning: global constructor %s used\n"),
1085 if (! config.build_constructors)
1088 ldctor_add_set_entry (h, reloc, NULL, section, value);
1090 if (h->type == bfd_link_hash_new)
1092 h->type = bfd_link_hash_undefined;
1093 h->u.undef.abfd = abfd;
1094 /* We don't call bfd_link_add_undef to add this to the list of
1095 undefined symbols because we are going to define it
1100 /* This is called when BFD has discovered a constructor. This is only
1101 called for some object file formats--those which do not handle
1102 constructors in some more clever fashion. This is similar to
1103 adding an element to a set, but less general. */
1106 constructor_callback (struct bfd_link_info *info,
1107 bfd_boolean constructor,
1114 struct bfd_link_hash_entry *h;
1115 char set_name[1 + sizeof "__CTOR_LIST__"];
1117 if (config.warn_constructors)
1118 einfo (_("%P: warning: global constructor %s used\n"), name);
1120 if (! config.build_constructors)
1123 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1124 useful error message. */
1125 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1126 && (bfd_link_relocatable (info)
1127 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1128 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1131 if (bfd_get_symbol_leading_char (abfd) != '\0')
1132 *s++ = bfd_get_symbol_leading_char (abfd);
1134 strcpy (s, "__CTOR_LIST__");
1136 strcpy (s, "__DTOR_LIST__");
1138 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1139 if (h == (struct bfd_link_hash_entry *) NULL)
1140 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1141 if (h->type == bfd_link_hash_new)
1143 h->type = bfd_link_hash_undefined;
1144 h->u.undef.abfd = abfd;
1145 /* We don't call bfd_link_add_undef to add this to the list of
1146 undefined symbols because we are going to define it
1150 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1153 /* A structure used by warning_callback to pass information through
1154 bfd_map_over_sections. */
1156 struct warning_callback_info
1159 const char *warning;
1164 /* Look through the relocs to see if we can find a plausible address
1165 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1168 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1170 struct warning_callback_info cinfo;
1172 if (!bfd_generic_link_read_symbols (abfd))
1173 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1175 cinfo.found = FALSE;
1176 cinfo.warning = warning;
1177 cinfo.symbol = symbol;
1178 cinfo.asymbols = bfd_get_outsymbols (abfd);
1179 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1183 /* This is called when there is a reference to a warning symbol. */
1186 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1187 const char *warning,
1193 /* This is a hack to support warn_multiple_gp. FIXME: This should
1194 have a cleaner interface, but what? */
1195 if (! config.warn_multiple_gp
1196 && strcmp (warning, "using multiple gp values") == 0)
1199 if (section != NULL)
1200 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1201 else if (abfd == NULL)
1202 einfo ("%P: %s%s\n", _("warning: "), warning);
1203 else if (symbol == NULL)
1204 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1205 else if (! symbol_warning (warning, symbol, abfd))
1208 /* Search all input files for a reference to SYMBOL. */
1209 for (b = info->input_bfds; b; b = b->link.next)
1210 if (b != abfd && symbol_warning (warning, symbol, b))
1212 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1216 /* This is called by warning_callback for each section. It checks the
1217 relocs of the section to see if it can find a reference to the
1218 symbol which triggered the warning. If it can, it uses the reloc
1219 to give an error message with a file and line number. */
1222 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1224 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1228 arelent **p, **pend;
1233 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1235 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1239 relpp = (arelent **) xmalloc (relsize);
1240 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1242 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1245 pend = p + relcount;
1246 for (; p < pend && *p != NULL; p++)
1250 if (q->sym_ptr_ptr != NULL
1251 && *q->sym_ptr_ptr != NULL
1252 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1254 /* We found a reloc for the symbol we are looking for. */
1255 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1265 /* This is called when an undefined symbol is found. */
1268 undefined_symbol (struct bfd_link_info *info,
1275 static char *error_name;
1276 static unsigned int error_count;
1278 #define MAX_ERRORS_IN_A_ROW 5
1280 if (info->ignore_hash != NULL
1281 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1284 if (config.warn_once)
1286 /* Only warn once about a particular undefined symbol. */
1287 add_ignoresym (info, name);
1290 /* We never print more than a reasonable number of errors in a row
1291 for a single symbol. */
1292 if (error_name != NULL
1293 && strcmp (name, error_name) == 0)
1298 if (error_name != NULL)
1300 error_name = xstrdup (name);
1303 if (section != NULL)
1305 if (error_count < MAX_ERRORS_IN_A_ROW)
1308 einfo (_("%X%C: undefined reference to `%T'\n"),
1309 abfd, section, address, name);
1311 einfo (_("%C: warning: undefined reference to `%T'\n"),
1312 abfd, section, address, name);
1314 else if (error_count == MAX_ERRORS_IN_A_ROW)
1317 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1318 abfd, section, address, name);
1320 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1321 abfd, section, address, name);
1328 if (error_count < MAX_ERRORS_IN_A_ROW)
1331 einfo (_("%X%B: undefined reference to `%T'\n"),
1334 einfo (_("%B: warning: undefined reference to `%T'\n"),
1337 else if (error_count == MAX_ERRORS_IN_A_ROW)
1340 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1343 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1351 /* Counter to limit the number of relocation overflow error messages
1352 to print. Errors are printed as it is decremented. When it's
1353 called and the counter is zero, a final message is printed
1354 indicating more relocations were omitted. When it gets to -1, no
1355 such errors are printed. If it's initially set to a value less
1356 than -1, all such errors will be printed (--verbose does this). */
1358 int overflow_cutoff_limit = 10;
1360 /* This is called when a reloc overflows. */
1363 reloc_overflow (struct bfd_link_info *info,
1364 struct bfd_link_hash_entry *entry,
1366 const char *reloc_name,
1372 if (overflow_cutoff_limit == -1)
1375 einfo ("%X%H:", abfd, section, address);
1377 if (overflow_cutoff_limit >= 0
1378 && overflow_cutoff_limit-- == 0)
1380 einfo (_(" additional relocation overflows omitted from the output\n"));
1386 while (entry->type == bfd_link_hash_indirect
1387 || entry->type == bfd_link_hash_warning)
1388 entry = entry->u.i.link;
1389 switch (entry->type)
1391 case bfd_link_hash_undefined:
1392 case bfd_link_hash_undefweak:
1393 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1394 reloc_name, entry->root.string);
1396 case bfd_link_hash_defined:
1397 case bfd_link_hash_defweak:
1398 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1399 reloc_name, entry->root.string,
1400 entry->u.def.section,
1401 entry->u.def.section == bfd_abs_section_ptr
1402 ? info->output_bfd : entry->u.def.section->owner);
1410 einfo (_(" relocation truncated to fit: %s against `%T'"),
1413 einfo ("+%v", addend);
1417 /* This is called when a dangerous relocation is made. */
1420 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1421 const char *message,
1426 einfo (_("%X%H: dangerous relocation: %s\n"),
1427 abfd, section, address, message);
1430 /* This is called when a reloc is being generated attached to a symbol
1431 that is not being output. */
1434 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1440 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1441 abfd, section, address, name);
1444 /* This is called if link_info.notice_all is set, or when a symbol in
1445 link_info.notice_hash is found. Symbols are put in notice_hash
1446 using the -y option, while notice_all is set if the --cref option
1447 has been supplied, or if there are any NOCROSSREFS sections in the
1448 linker script; and if plugins are active, since they need to monitor
1449 all references from non-IR files. */
1452 notice (struct bfd_link_info *info,
1453 struct bfd_link_hash_entry *h,
1454 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1458 flagword flags ATTRIBUTE_UNUSED)
1464 if (command_line.cref || nocrossref_list != NULL)
1465 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1469 name = h->root.string;
1470 if (info->notice_hash != NULL
1471 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1473 if (bfd_is_und_section (section))
1474 einfo ("%B: reference to %s\n", abfd, name);
1476 einfo ("%B: definition of %s\n", abfd, name);
1479 if (command_line.cref || nocrossref_list != NULL)
1480 add_cref (name, abfd, section, value);