1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain steve@cygnus.com
7 This file is part of the GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
26 #include "safe-ctype.h"
27 #include "libiberty.h"
30 #include "filenames.h"
45 #include "plugin-api.h"
47 #endif /* ENABLE_PLUGINS */
49 /* Somewhere above, sys/stat.h got included. */
50 #if !defined(S_ISDIR) && defined(S_IFDIR)
51 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
62 #ifndef TARGET_SYSTEM_ROOT
63 #define TARGET_SYSTEM_ROOT ""
68 FILE *saved_script_handle = NULL;
69 FILE *previous_script_handle = NULL;
70 bfd_boolean force_make_executable = FALSE;
73 const char *output_filename = "a.out";
75 /* Name this program was invoked by. */
78 /* The prefix for system library directories. */
79 const char *ld_sysroot;
81 /* The canonical representation of ld_sysroot. */
82 char * ld_canon_sysroot;
83 int ld_canon_sysroot_len;
85 /* Set by -G argument, for MIPS ECOFF target. */
86 int g_switch_value = 8;
88 /* Nonzero means print names of input files as processed. */
89 bfd_boolean trace_files;
91 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
94 /* Nonzero means version number was printed, so exit successfully
95 instead of complaining if no input files are given. */
96 bfd_boolean version_printed;
98 /* TRUE if we should demangle symbol names. */
99 bfd_boolean demangling;
101 args_type command_line;
103 ld_config_type config;
105 sort_type sort_section;
107 static const char *get_sysroot
109 static char *get_emulation
111 static bfd_boolean add_archive_element
112 (struct bfd_link_info *, bfd *, const char *, bfd **);
113 static bfd_boolean multiple_definition
114 (struct bfd_link_info *, struct bfd_link_hash_entry *,
115 bfd *, asection *, bfd_vma);
116 static bfd_boolean multiple_common
117 (struct bfd_link_info *, struct bfd_link_hash_entry *,
118 bfd *, enum bfd_link_hash_type, bfd_vma);
119 static bfd_boolean add_to_set
120 (struct bfd_link_info *, struct bfd_link_hash_entry *,
121 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
122 static bfd_boolean constructor_callback
123 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
124 asection *, bfd_vma);
125 static bfd_boolean warning_callback
126 (struct bfd_link_info *, const char *, const char *, bfd *,
127 asection *, bfd_vma);
128 static void warning_find_reloc
129 (bfd *, asection *, void *);
130 static bfd_boolean undefined_symbol
131 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
133 static bfd_boolean reloc_overflow
134 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
135 const char *, bfd_vma, bfd *, asection *, bfd_vma);
136 static bfd_boolean reloc_dangerous
137 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
138 static bfd_boolean unattached_reloc
139 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
140 static bfd_boolean notice
141 (struct bfd_link_info *, struct bfd_link_hash_entry *,
142 bfd *, asection *, bfd_vma, flagword, const char *);
144 static struct bfd_link_callbacks link_callbacks =
150 constructor_callback,
160 ldlang_override_segment_assignment
163 static bfd_assert_handler_type default_bfd_assert_handler;
165 struct bfd_link_info link_info;
170 bfd_cache_close_all ();
171 #ifdef ENABLE_PLUGINS
172 plugin_call_cleanup ();
174 if (output_filename && delete_output_file_on_failure)
175 unlink_if_ordinary (output_filename);
178 /* If there's a BFD assertion, we'll notice and exit with an error
179 unless otherwise instructed. */
182 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
183 const char *file, int line)
185 (*default_bfd_assert_handler) (fmt, bfdver, file, line);
186 config.make_executable = FALSE;
190 main (int argc, char **argv)
193 long start_time = get_run_time ();
195 char *start_sbrk = (char *) sbrk (0);
198 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
199 setlocale (LC_MESSAGES, "");
201 #if defined (HAVE_SETLOCALE)
202 setlocale (LC_CTYPE, "");
204 bindtextdomain (PACKAGE, LOCALEDIR);
205 textdomain (PACKAGE);
207 program_name = argv[0];
208 xmalloc_set_program_name (program_name);
210 START_PROGRESS (program_name, 0);
212 expandargv (&argc, &argv);
216 bfd_set_error_program_name (program_name);
218 /* We want to notice and fail on those nasty BFD assertions which are
219 likely to signal incorrect output being generated but otherwise may
221 default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
223 xatexit (ld_cleanup);
225 /* Set up the sysroot directory. */
226 ld_sysroot = get_sysroot (argc, argv);
229 if (*TARGET_SYSTEM_ROOT == 0)
231 einfo ("%P%F: this linker was not configured to use sysroots\n");
235 ld_canon_sysroot = lrealpath (ld_sysroot);
237 if (ld_canon_sysroot)
238 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
240 ld_canon_sysroot_len = -1;
242 /* Set the default BFD target based on the configured target. Doing
243 this permits the linker to be configured for a particular target,
244 and linked against a shared BFD library which was configured for
245 a different target. The macro TARGET is defined by Makefile. */
246 if (! bfd_set_default_target (TARGET))
248 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
259 config.build_constructors = TRUE;
260 config.rpath_separator = ':';
261 config.split_by_reloc = (unsigned) -1;
262 config.split_by_file = (bfd_size_type) -1;
263 config.make_executable = TRUE;
264 config.magic_demand_paged = TRUE;
265 config.text_read_only = TRUE;
266 link_info.disable_target_specific_optimizations = -1;
268 command_line.warn_mismatch = TRUE;
269 command_line.warn_search_mismatch = TRUE;
270 command_line.check_section_addresses = -1;
272 /* We initialize DEMANGLING based on the environment variable
273 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
274 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
275 environment. Acting the same way here lets us provide the same
276 interface by default. */
277 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
279 link_info.allow_undefined_version = TRUE;
280 link_info.keep_memory = TRUE;
281 link_info.combreloc = TRUE;
282 link_info.strip_discarded = TRUE;
283 link_info.emit_hash = TRUE;
284 link_info.callbacks = &link_callbacks;
285 link_info.input_bfds_tail = &link_info.input_bfds;
286 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
287 and _fini symbols. We are compatible. */
288 link_info.init_function = "_init";
289 link_info.fini_function = "_fini";
290 link_info.relax_pass = 1;
291 link_info.pei386_auto_import = -1;
292 link_info.spare_dynamic_tags = 5;
293 link_info.path_separator = ':';
295 ldfile_add_arch ("");
296 emulation = get_emulation (argc, argv);
297 ldemul_choose_mode (emulation);
298 default_target = ldemul_choose_target (argc, argv);
299 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
300 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
302 ldemul_before_parse ();
303 lang_has_input_file = FALSE;
304 parse_args (argc, argv);
306 if (config.hash_table_size != 0)
307 bfd_hash_set_default_size (config.hash_table_size);
309 #ifdef ENABLE_PLUGINS
310 /* Now all the plugin arguments have been gathered, we can load them. */
311 if (plugin_load_plugins ())
312 einfo (_("%P%F: %s: error loading plugin\n"), plugin_error_plugin ());
313 #endif /* ENABLE_PLUGINS */
315 ldemul_set_symbols ();
317 /* If we have not already opened and parsed a linker script,
318 try the default script from command line first. */
319 if (saved_script_handle == NULL
320 && command_line.default_script != NULL)
322 ldfile_open_command_file (command_line.default_script);
323 parser_input = input_script;
327 /* If we have not already opened and parsed a linker script
328 read the emulation's appropriate default script. */
329 if (saved_script_handle == NULL)
332 char *s = ldemul_get_script (&isfile);
335 ldfile_open_default_command_file (s);
339 lex_redirect (s, _("built in linker script"), 1);
341 parser_input = input_script;
348 if (saved_script_handle)
349 info_msg (_("using external linker script:"));
351 info_msg (_("using internal linker script:"));
352 info_msg ("\n==================================================\n");
354 if (saved_script_handle)
356 static const int ld_bufsz = 8193;
358 char *buf = (char *) xmalloc (ld_bufsz);
360 rewind (saved_script_handle);
361 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
366 rewind (saved_script_handle);
373 info_msg (ldemul_get_script (&isfile));
376 info_msg ("\n==================================================\n");
379 if (command_line.print_output_format)
380 info_msg ("%s\n", lang_get_output_target ());
384 if (!lang_has_input_file)
386 if (version_printed || command_line.print_output_format)
388 einfo (_("%P%F: no input files\n"));
392 info_msg (_("%P: mode %s\n"), emulation);
394 ldemul_after_parse ();
396 if (config.map_filename)
398 if (strcmp (config.map_filename, "-") == 0)
400 config.map_file = stdout;
404 config.map_file = fopen (config.map_filename, FOPEN_WT);
405 if (config.map_file == (FILE *) NULL)
407 bfd_set_error (bfd_error_system_call);
408 einfo (_("%P%F: cannot open map file %s: %E\n"),
409 config.map_filename);
416 /* Print error messages for any missing symbols, for any warning
417 symbols, and possibly multiple definitions. */
418 if (link_info.relocatable)
419 link_info.output_bfd->flags &= ~EXEC_P;
421 link_info.output_bfd->flags |= EXEC_P;
425 if (config.map_file != NULL)
427 if (command_line.cref)
428 output_cref (config.map_file != NULL ? config.map_file : stdout);
429 if (nocrossref_list != NULL)
430 check_nocrossrefs ();
434 /* Even if we're producing relocatable output, some non-fatal errors should
435 be reported in the exit status. (What non-fatal errors, if any, do we
436 want to ignore for relocatable output?) */
437 if (!config.make_executable && !force_make_executable)
440 einfo (_("%P: link errors found, deleting executable `%s'\n"),
443 /* The file will be removed by ld_cleanup. */
448 if (! bfd_close (link_info.output_bfd))
449 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
451 /* If the --force-exe-suffix is enabled, and we're making an
452 executable file and it doesn't end in .exe, copy it to one
454 if (! link_info.relocatable && command_line.force_exe_suffix)
456 int len = strlen (output_filename);
459 || (strcasecmp (output_filename + len - 4, ".exe") != 0
460 && strcasecmp (output_filename + len - 4, ".dll") != 0))
464 const int bsize = 4096;
465 char *buf = (char *) xmalloc (bsize);
467 char *dst_name = (char *) xmalloc (len + 5);
469 strcpy (dst_name, output_filename);
470 strcat (dst_name, ".exe");
471 src = fopen (output_filename, FOPEN_RB);
472 dst = fopen (dst_name, FOPEN_WB);
475 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
478 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
480 while ((l = fread (buf, 1, bsize, src)) > 0)
482 int done = fwrite (buf, 1, l, dst);
485 einfo (_("%P: Error writing file `%s'\n"), dst_name);
489 if (fclose (dst) == EOF)
490 einfo (_("%P: Error closing file `%s'\n"), dst_name);
497 END_PROGRESS (program_name);
502 char *lim = (char *) sbrk (0);
504 long run_time = get_run_time () - start_time;
507 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
508 program_name, run_time / 1000000, run_time % 1000000);
510 fprintf (stderr, _("%s: data size %ld\n"), program_name,
511 (long) (lim - start_sbrk));
516 /* Prevent ld_cleanup from doing anything, after a successful link. */
517 output_filename = NULL;
523 /* If the configured sysroot is relocatable, try relocating it based on
524 default prefix FROM. Return the relocated directory if it exists,
525 otherwise return null. */
528 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
530 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
534 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
537 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
545 /* Return the sysroot directory. Return "" if no sysroot is being used. */
548 get_sysroot (int argc, char **argv)
553 for (i = 1; i < argc; i++)
554 if (CONST_STRNEQ (argv[i], "--sysroot="))
555 return argv[i] + strlen ("--sysroot=");
557 path = get_relative_sysroot (BINDIR);
561 path = get_relative_sysroot (TOOLBINDIR);
565 return TARGET_SYSTEM_ROOT;
568 /* We need to find any explicitly given emulation in order to initialize the
569 state that's needed by the lex&yacc argument parser (parse_args). */
572 get_emulation (int argc, char **argv)
577 emulation = getenv (EMULATION_ENVIRON);
578 if (emulation == NULL)
579 emulation = DEFAULT_EMULATION;
581 for (i = 1; i < argc; i++)
583 if (CONST_STRNEQ (argv[i], "-m"))
585 if (argv[i][2] == '\0')
590 emulation = argv[i + 1];
594 einfo (_("%P%F: missing argument to -m\n"));
596 else if (strcmp (argv[i], "-mips1") == 0
597 || strcmp (argv[i], "-mips2") == 0
598 || strcmp (argv[i], "-mips3") == 0
599 || strcmp (argv[i], "-mips4") == 0
600 || strcmp (argv[i], "-mips5") == 0
601 || strcmp (argv[i], "-mips32") == 0
602 || strcmp (argv[i], "-mips32r2") == 0
603 || strcmp (argv[i], "-mips64") == 0
604 || strcmp (argv[i], "-mips64r2") == 0)
606 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
607 passed to the linker by some MIPS compilers. They
608 generally tell the linker to use a slightly different
609 library path. Perhaps someday these should be
610 implemented as emulations; until then, we just ignore
611 the arguments and hope that nobody ever creates
612 emulations named ips1, ips2 or ips3. */
614 else if (strcmp (argv[i], "-m486") == 0)
616 /* FIXME: The argument -m486 is passed to the linker on
617 some Linux systems. Hope that nobody creates an
618 emulation named 486. */
623 emulation = &argv[i][2];
632 add_ysym (const char *name)
634 if (link_info.notice_hash == NULL)
636 link_info.notice_hash =
637 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
638 if (!bfd_hash_table_init_n (link_info.notice_hash,
640 sizeof (struct bfd_hash_entry),
642 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
645 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
646 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
650 add_ignoresym (struct bfd_link_info *info, const char *name)
652 if (info->ignore_hash == NULL)
654 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
655 if (! bfd_hash_table_init_n (info->ignore_hash,
657 sizeof (struct bfd_hash_entry),
659 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
662 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
663 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
666 /* Record a symbol to be wrapped, from the --wrap option. */
669 add_wrap (const char *name)
671 if (link_info.wrap_hash == NULL)
673 link_info.wrap_hash =
674 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
675 if (!bfd_hash_table_init_n (link_info.wrap_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.wrap_hash, name, TRUE, TRUE) == NULL)
683 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
686 /* Handle the -retain-symbols-file option. */
689 add_keepsyms_file (const char *filename)
696 if (link_info.strip == strip_some)
697 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
699 file = fopen (filename, "r");
702 bfd_set_error (bfd_error_system_call);
703 einfo ("%X%P: %s: %E\n", filename);
707 link_info.keep_hash = (struct bfd_hash_table *)
708 xmalloc (sizeof (struct bfd_hash_table));
709 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
710 sizeof (struct bfd_hash_entry)))
711 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
714 buf = (char *) xmalloc (bufsize);
726 while (! ISSPACE (c) && c != EOF)
733 buf = (char *) xrealloc (buf, bufsize);
740 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
741 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
745 if (link_info.strip != strip_none)
746 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
749 link_info.strip = strip_some;
752 /* Callbacks from the BFD linker routines. */
754 /* This is called when BFD has decided to include an archive member in
758 add_archive_element (struct bfd_link_info *info,
761 bfd **subsbfd ATTRIBUTE_UNUSED)
763 lang_input_statement_type *input;
764 lang_input_statement_type orig_input;
766 input = (lang_input_statement_type *)
767 xcalloc (1, sizeof (lang_input_statement_type));
768 input->filename = abfd->filename;
769 input->local_sym_name = abfd->filename;
770 input->the_bfd = abfd;
772 /* Save the original data for trace files/tries below, as plugins
773 (if enabled) may possibly alter it to point to a replacement
774 BFD, but we still want to output the original BFD filename. */
776 #ifdef ENABLE_PLUGINS
777 if (plugin_active_plugins_p () && !no_more_claiming)
779 /* We must offer this archive member to the plugins to claim. */
780 const char *filename = (bfd_my_archive (abfd) != NULL
781 ? bfd_my_archive (abfd)->filename : abfd->filename);
782 int fd = open (filename, O_RDONLY | O_BINARY);
785 struct ld_plugin_input_file file;
787 /* Offset and filesize must refer to the individual archive
788 member, not the whole file, and must exclude the header.
789 Fortunately for us, that is how the data is stored in the
790 origin field of the bfd and in the arelt_data. */
791 file.name = filename;
792 file.offset = abfd->origin;
793 file.filesize = arelt_size (abfd);
795 plugin_maybe_claim (&file, input);
796 if (input->flags.claimed)
798 input->flags.claim_archive = TRUE;
799 *subsbfd = input->the_bfd;
803 #endif /* ENABLE_PLUGINS */
805 ldlang_add_file (input);
807 if (config.map_file != NULL)
809 static bfd_boolean header_printed;
810 struct bfd_link_hash_entry *h;
814 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
826 case bfd_link_hash_defined:
827 case bfd_link_hash_defweak:
828 from = h->u.def.section->owner;
831 case bfd_link_hash_undefined:
832 case bfd_link_hash_undefweak:
833 from = h->u.undef.abfd;
836 case bfd_link_hash_common:
837 from = h->u.c.p->section->owner;
842 if (! header_printed)
846 sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
848 header_printed = TRUE;
851 if (bfd_my_archive (abfd) == NULL)
853 minfo ("%s", bfd_get_filename (abfd));
854 len = strlen (bfd_get_filename (abfd));
858 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
859 bfd_get_filename (abfd));
860 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
861 + strlen (bfd_get_filename (abfd))
879 minfo ("(%T)\n", h->root.string);
881 minfo ("(%s)\n", name);
884 if (trace_files || verbose)
885 info_msg ("%I\n", &orig_input);
889 /* This is called when BFD has discovered a symbol which is defined
893 multiple_definition (struct bfd_link_info *info,
894 struct bfd_link_hash_entry *h,
904 if (info->allow_multiple_definition)
909 case bfd_link_hash_defined:
910 osec = h->u.def.section;
911 oval = h->u.def.value;
912 obfd = h->u.def.section->owner;
914 case bfd_link_hash_indirect:
915 osec = bfd_ind_section_ptr;
923 /* Ignore a redefinition of an absolute symbol to the
924 same value; it's harmless. */
925 if (h->type == bfd_link_hash_defined
926 && bfd_is_abs_section (osec)
927 && bfd_is_abs_section (nsec)
931 /* If either section has the output_section field set to
932 bfd_abs_section_ptr, it means that the section is being
933 discarded, and this is not really a multiple definition at all.
934 FIXME: It would be cleaner to somehow ignore symbols defined in
935 sections which are being discarded. */
936 if ((osec->output_section != NULL
937 && ! bfd_is_abs_section (osec)
938 && bfd_is_abs_section (osec->output_section))
939 || (nsec->output_section != NULL
940 && ! bfd_is_abs_section (nsec)
941 && bfd_is_abs_section (nsec->output_section)))
944 name = h->root.string;
952 einfo (_("%X%C: multiple definition of `%T'\n"),
953 nbfd, nsec, nval, name);
955 einfo (_("%D: first defined here\n"), obfd, osec, oval);
957 if (RELAXATION_ENABLED)
959 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
960 link_info.disable_target_specific_optimizations = -1;
966 /* This is called when there is a definition of a common symbol, or
967 when a common symbol is found for a symbol that is already defined,
968 or when two common symbols are found. We only do something if
969 -warn-common was used. */
972 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
973 struct bfd_link_hash_entry *h,
975 enum bfd_link_hash_type ntype,
980 enum bfd_link_hash_type otype;
983 if (!config.warn_common)
986 name = h->root.string;
988 if (otype == bfd_link_hash_common)
990 obfd = h->u.c.p->section->owner;
993 else if (otype == bfd_link_hash_defined
994 || otype == bfd_link_hash_defweak)
996 obfd = h->u.def.section->owner;
1001 /* FIXME: It would nice if we could report the BFD which defined
1002 an indirect symbol, but we don't have anywhere to store the
1008 if (ntype == bfd_link_hash_defined
1009 || ntype == bfd_link_hash_defweak
1010 || ntype == bfd_link_hash_indirect)
1012 ASSERT (otype == bfd_link_hash_common);
1013 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1016 einfo (_("%B: warning: common is here\n"), obfd);
1018 else if (otype == bfd_link_hash_defined
1019 || otype == bfd_link_hash_defweak
1020 || otype == bfd_link_hash_indirect)
1022 ASSERT (ntype == bfd_link_hash_common);
1023 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1026 einfo (_("%B: warning: defined here\n"), obfd);
1030 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1033 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1036 einfo (_("%B: warning: larger common is here\n"), obfd);
1038 else if (nsize > osize)
1040 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1043 einfo (_("%B: warning: smaller common is here\n"), obfd);
1047 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1049 einfo (_("%B: warning: previous common is here\n"), obfd);
1056 /* This is called when BFD has discovered a set element. H is the
1057 entry in the linker hash table for the set. SECTION and VALUE
1058 represent a value which should be added to the set. */
1061 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1062 struct bfd_link_hash_entry *h,
1063 bfd_reloc_code_real_type reloc,
1068 if (config.warn_constructors)
1069 einfo (_("%P: warning: global constructor %s used\n"),
1072 if (! config.build_constructors)
1075 ldctor_add_set_entry (h, reloc, NULL, section, value);
1077 if (h->type == bfd_link_hash_new)
1079 h->type = bfd_link_hash_undefined;
1080 h->u.undef.abfd = abfd;
1081 /* We don't call bfd_link_add_undef to add this to the list of
1082 undefined symbols because we are going to define it
1089 /* This is called when BFD has discovered a constructor. This is only
1090 called for some object file formats--those which do not handle
1091 constructors in some more clever fashion. This is similar to
1092 adding an element to a set, but less general. */
1095 constructor_callback (struct bfd_link_info *info,
1096 bfd_boolean constructor,
1103 struct bfd_link_hash_entry *h;
1104 char set_name[1 + sizeof "__CTOR_LIST__"];
1106 if (config.warn_constructors)
1107 einfo (_("%P: warning: global constructor %s used\n"), name);
1109 if (! config.build_constructors)
1112 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1113 useful error message. */
1114 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1115 && (info->relocatable
1116 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1117 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1120 if (bfd_get_symbol_leading_char (abfd) != '\0')
1121 *s++ = bfd_get_symbol_leading_char (abfd);
1123 strcpy (s, "__CTOR_LIST__");
1125 strcpy (s, "__DTOR_LIST__");
1127 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1128 if (h == (struct bfd_link_hash_entry *) NULL)
1129 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1130 if (h->type == bfd_link_hash_new)
1132 h->type = bfd_link_hash_undefined;
1133 h->u.undef.abfd = abfd;
1134 /* We don't call bfd_link_add_undef to add this to the list of
1135 undefined symbols because we are going to define it
1139 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1143 /* A structure used by warning_callback to pass information through
1144 bfd_map_over_sections. */
1146 struct warning_callback_info
1149 const char *warning;
1154 /* This is called when there is a reference to a warning symbol. */
1157 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1158 const char *warning,
1164 /* This is a hack to support warn_multiple_gp. FIXME: This should
1165 have a cleaner interface, but what? */
1166 if (! config.warn_multiple_gp
1167 && strcmp (warning, "using multiple gp values") == 0)
1170 if (section != NULL)
1171 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1172 else if (abfd == NULL)
1173 einfo ("%P: %s%s\n", _("warning: "), warning);
1174 else if (symbol == NULL)
1175 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1178 struct warning_callback_info cinfo;
1180 /* Look through the relocs to see if we can find a plausible
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);
1193 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1199 /* This is called by warning_callback for each section. It checks the
1200 relocs of the section to see if it can find a reference to the
1201 symbol which triggered the warning. If it can, it uses the reloc
1202 to give an error message with a file and line number. */
1205 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1207 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1211 arelent **p, **pend;
1216 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1218 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1222 relpp = (arelent **) xmalloc (relsize);
1223 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1225 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1228 pend = p + relcount;
1229 for (; p < pend && *p != NULL; p++)
1233 if (q->sym_ptr_ptr != NULL
1234 && *q->sym_ptr_ptr != NULL
1235 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1237 /* We found a reloc for the symbol we are looking for. */
1238 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1248 /* This is called when an undefined symbol is found. */
1251 undefined_symbol (struct bfd_link_info *info,
1258 static char *error_name;
1259 static unsigned int error_count;
1261 #define MAX_ERRORS_IN_A_ROW 5
1263 if (info->ignore_hash != NULL
1264 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1267 if (config.warn_once)
1269 /* Only warn once about a particular undefined symbol. */
1270 add_ignoresym (info, name);
1273 /* We never print more than a reasonable number of errors in a row
1274 for a single symbol. */
1275 if (error_name != NULL
1276 && strcmp (name, error_name) == 0)
1281 if (error_name != NULL)
1283 error_name = xstrdup (name);
1286 if (section != NULL)
1288 if (error_count < MAX_ERRORS_IN_A_ROW)
1291 einfo (_("%X%C: undefined reference to `%T'\n"),
1292 abfd, section, address, name);
1294 einfo (_("%C: warning: undefined reference to `%T'\n"),
1295 abfd, section, address, name);
1297 else if (error_count == MAX_ERRORS_IN_A_ROW)
1300 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1301 abfd, section, address, name);
1303 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1304 abfd, section, address, name);
1311 if (error_count < MAX_ERRORS_IN_A_ROW)
1314 einfo (_("%X%B: undefined reference to `%T'\n"),
1317 einfo (_("%B: warning: undefined reference to `%T'\n"),
1320 else if (error_count == MAX_ERRORS_IN_A_ROW)
1323 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1326 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1336 /* Counter to limit the number of relocation overflow error messages
1337 to print. Errors are printed as it is decremented. When it's
1338 called and the counter is zero, a final message is printed
1339 indicating more relocations were omitted. When it gets to -1, no
1340 such errors are printed. If it's initially set to a value less
1341 than -1, all such errors will be printed (--verbose does this). */
1343 int overflow_cutoff_limit = 10;
1345 /* This is called when a reloc overflows. */
1348 reloc_overflow (struct bfd_link_info *info,
1349 struct bfd_link_hash_entry *entry,
1351 const char *reloc_name,
1357 if (overflow_cutoff_limit == -1)
1360 einfo ("%X%H:", abfd, section, address);
1362 if (overflow_cutoff_limit >= 0
1363 && overflow_cutoff_limit-- == 0)
1365 einfo (_(" additional relocation overflows omitted from the output\n"));
1371 while (entry->type == bfd_link_hash_indirect
1372 || entry->type == bfd_link_hash_warning)
1373 entry = entry->u.i.link;
1374 switch (entry->type)
1376 case bfd_link_hash_undefined:
1377 case bfd_link_hash_undefweak:
1378 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1379 reloc_name, entry->root.string);
1381 case bfd_link_hash_defined:
1382 case bfd_link_hash_defweak:
1383 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1384 reloc_name, entry->root.string,
1385 entry->u.def.section,
1386 entry->u.def.section == bfd_abs_section_ptr
1387 ? info->output_bfd : entry->u.def.section->owner);
1395 einfo (_(" relocation truncated to fit: %s against `%T'"),
1398 einfo ("+%v", addend);
1403 /* This is called when a dangerous relocation is made. */
1406 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1407 const char *message,
1412 einfo (_("%X%H: dangerous relocation: %s\n"),
1413 abfd, section, address, message);
1417 /* This is called when a reloc is being generated attached to a symbol
1418 that is not being output. */
1421 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1427 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1428 abfd, section, address, name);
1432 /* This is called if link_info.notice_all is set, or when a symbol in
1433 link_info.notice_hash is found. Symbols are put in notice_hash
1434 using the -y option, while notice_all is set if the --cref option
1435 has been supplied, or if there are any NOCROSSREFS sections in the
1436 linker script; and if plugins are active, since they need to monitor
1437 all references from non-IR files. */
1440 notice (struct bfd_link_info *info,
1441 struct bfd_link_hash_entry *h,
1445 flagword flags ATTRIBUTE_UNUSED,
1446 const char *string ATTRIBUTE_UNUSED)
1452 if (command_line.cref || nocrossref_list != NULL)
1453 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1457 name = h->root.string;
1458 if (info->notice_hash != NULL
1459 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1461 if (bfd_is_und_section (section))
1462 einfo ("%B: reference to %s\n", abfd, name);
1464 einfo ("%B: definition of %s\n", abfd, name);
1467 if (command_line.cref || nocrossref_list != NULL)
1468 add_cref (name, abfd, section, value);