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
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 same, but note open failures, too. */
92 bfd_boolean trace_file_tries;
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 /* Nonzero means link in every member of an archive. */
99 bfd_boolean whole_archive;
101 /* True means only create DT_NEEDED entries for dynamic libraries
102 if they actually satisfy some reference in a regular object. */
103 bfd_boolean add_DT_NEEDED_for_regular;
105 /* True means create DT_NEEDED entries for dynamic libraries that
106 are DT_NEEDED by dynamic libraries specifically mentioned on
108 bfd_boolean add_DT_NEEDED_for_dynamic = TRUE;
110 /* TRUE if we should demangle symbol names. */
111 bfd_boolean demangling;
113 args_type command_line;
115 ld_config_type config;
117 sort_type sort_section;
119 static const char *get_sysroot
121 static char *get_emulation
123 static bfd_boolean add_archive_element
124 (struct bfd_link_info *, bfd *, const char *, bfd **);
125 static bfd_boolean multiple_definition
126 (struct bfd_link_info *, struct bfd_link_hash_entry *,
127 bfd *, asection *, bfd_vma);
128 static bfd_boolean multiple_common
129 (struct bfd_link_info *, struct bfd_link_hash_entry *,
130 bfd *, enum bfd_link_hash_type, bfd_vma);
131 static bfd_boolean add_to_set
132 (struct bfd_link_info *, struct bfd_link_hash_entry *,
133 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
134 static bfd_boolean constructor_callback
135 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
136 asection *, bfd_vma);
137 static bfd_boolean warning_callback
138 (struct bfd_link_info *, const char *, const char *, bfd *,
139 asection *, bfd_vma);
140 static void warning_find_reloc
141 (bfd *, asection *, void *);
142 static bfd_boolean undefined_symbol
143 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
145 static bfd_boolean reloc_overflow
146 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
147 const char *, bfd_vma, bfd *, asection *, bfd_vma);
148 static bfd_boolean reloc_dangerous
149 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
150 static bfd_boolean unattached_reloc
151 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
152 static bfd_boolean notice
153 (struct bfd_link_info *, struct bfd_link_hash_entry *,
154 bfd *, asection *, bfd_vma);
156 static struct bfd_link_callbacks link_callbacks =
162 constructor_callback,
172 ldlang_override_segment_assignment
175 struct bfd_link_info link_info;
180 bfd_cache_close_all ();
181 #ifdef ENABLE_PLUGINS
182 plugin_call_cleanup ();
184 if (output_filename && delete_output_file_on_failure)
185 unlink_if_ordinary (output_filename);
189 main (int argc, char **argv)
192 long start_time = get_run_time ();
194 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
195 setlocale (LC_MESSAGES, "");
197 #if defined (HAVE_SETLOCALE)
198 setlocale (LC_CTYPE, "");
200 bindtextdomain (PACKAGE, LOCALEDIR);
201 textdomain (PACKAGE);
203 program_name = argv[0];
204 xmalloc_set_program_name (program_name);
206 START_PROGRESS (program_name, 0);
208 expandargv (&argc, &argv);
212 bfd_set_error_program_name (program_name);
214 xatexit (ld_cleanup);
216 /* Set up the sysroot directory. */
217 ld_sysroot = get_sysroot (argc, argv);
220 if (*TARGET_SYSTEM_ROOT == 0)
222 einfo ("%P%F: this linker was not configured to use sysroots\n");
226 ld_canon_sysroot = lrealpath (ld_sysroot);
228 if (ld_canon_sysroot)
229 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
231 ld_canon_sysroot_len = -1;
233 /* Set the default BFD target based on the configured target. Doing
234 this permits the linker to be configured for a particular target,
235 and linked against a shared BFD library which was configured for
236 a different target. The macro TARGET is defined by Makefile. */
237 if (! bfd_set_default_target (TARGET))
239 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
250 config.build_constructors = TRUE;
251 config.rpath_separator = ':';
252 config.split_by_reloc = (unsigned) -1;
253 config.split_by_file = (bfd_size_type) -1;
254 config.make_executable = TRUE;
255 config.magic_demand_paged = TRUE;
256 config.text_read_only = TRUE;
258 command_line.warn_mismatch = TRUE;
259 command_line.warn_search_mismatch = TRUE;
260 command_line.check_section_addresses = -1;
261 command_line.disable_target_specific_optimizations = -1;
263 /* We initialize DEMANGLING based on the environment variable
264 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
265 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
266 environment. Acting the same way here lets us provide the same
267 interface by default. */
268 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
270 link_info.allow_undefined_version = TRUE;
271 link_info.keep_memory = TRUE;
272 link_info.combreloc = TRUE;
273 link_info.strip_discarded = TRUE;
274 link_info.emit_hash = TRUE;
275 link_info.callbacks = &link_callbacks;
276 link_info.input_bfds_tail = &link_info.input_bfds;
277 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
278 and _fini symbols. We are compatible. */
279 link_info.init_function = "_init";
280 link_info.fini_function = "_fini";
281 link_info.relax_pass = 1;
282 link_info.pei386_auto_import = -1;
283 link_info.spare_dynamic_tags = 5;
284 link_info.path_separator = ':';
286 ldfile_add_arch ("");
287 emulation = get_emulation (argc, argv);
288 ldemul_choose_mode (emulation);
289 default_target = ldemul_choose_target (argc, argv);
290 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
291 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
293 ldemul_before_parse ();
294 lang_has_input_file = FALSE;
295 parse_args (argc, argv);
297 if (config.hash_table_size != 0)
298 bfd_hash_set_default_size (config.hash_table_size);
300 ldemul_set_symbols ();
302 if (link_info.relocatable)
304 if (command_line.check_section_addresses < 0)
305 command_line.check_section_addresses = 0;
306 if (link_info.shared)
307 einfo (_("%P%F: -r and -shared may not be used together\n"));
310 /* We may have -Bsymbolic, -Bsymbolic-functions, --dynamic-list-data,
311 --dynamic-list-cpp-new, --dynamic-list-cpp-typeinfo and
312 --dynamic-list FILE. -Bsymbolic and -Bsymbolic-functions are
313 for shared libraries. -Bsymbolic overrides all others and vice
315 switch (command_line.symbolic)
320 /* -Bsymbolic is for shared library only. */
321 if (link_info.shared)
323 link_info.symbolic = TRUE;
324 /* Should we free the unused memory? */
325 link_info.dynamic_list = NULL;
326 command_line.dynamic_list = dynamic_list_unset;
329 case symbolic_functions:
330 /* -Bsymbolic-functions is for shared library only. */
331 if (link_info.shared)
332 command_line.dynamic_list = dynamic_list_data;
336 switch (command_line.dynamic_list)
338 case dynamic_list_unset:
340 case dynamic_list_data:
341 link_info.dynamic_data = TRUE;
343 link_info.dynamic = TRUE;
347 if (! link_info.shared)
349 if (command_line.filter_shlib)
350 einfo (_("%P%F: -F may not be used without -shared\n"));
351 if (command_line.auxiliary_filters)
352 einfo (_("%P%F: -f may not be used without -shared\n"));
355 if (! link_info.shared || link_info.pie)
356 link_info.executable = TRUE;
358 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
359 don't see how else this can be handled, since in this case we
360 must preserve all externally visible symbols. */
361 if (link_info.relocatable && link_info.strip == strip_all)
363 link_info.strip = strip_debugger;
364 if (link_info.discard == discard_sec_merge)
365 link_info.discard = discard_all;
368 /* If we have not already opened and parsed a linker script,
369 try the default script from command line first. */
370 if (saved_script_handle == NULL
371 && command_line.default_script != NULL)
373 ldfile_open_command_file (command_line.default_script);
374 parser_input = input_script;
378 /* If we have not already opened and parsed a linker script
379 read the emulation's appropriate default script. */
380 if (saved_script_handle == NULL)
383 char *s = ldemul_get_script (&isfile);
386 ldfile_open_default_command_file (s);
392 parser_input = input_script;
397 if (trace_file_tries)
399 if (saved_script_handle)
400 info_msg (_("using external linker script:"));
402 info_msg (_("using internal linker script:"));
403 info_msg ("\n==================================================\n");
405 if (saved_script_handle)
407 static const int ld_bufsz = 8193;
409 char *buf = (char *) xmalloc (ld_bufsz);
411 rewind (saved_script_handle);
412 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
417 rewind (saved_script_handle);
424 info_msg (ldemul_get_script (&isfile));
427 info_msg ("\n==================================================\n");
432 if (!lang_has_input_file)
436 einfo (_("%P%F: no input files\n"));
440 info_msg (_("%P: mode %s\n"), emulation);
442 ldemul_after_parse ();
444 if (config.map_filename)
446 if (strcmp (config.map_filename, "-") == 0)
448 config.map_file = stdout;
452 config.map_file = fopen (config.map_filename, FOPEN_WT);
453 if (config.map_file == (FILE *) NULL)
455 bfd_set_error (bfd_error_system_call);
456 einfo (_("%P%F: cannot open map file %s: %E\n"),
457 config.map_filename);
464 /* Print error messages for any missing symbols, for any warning
465 symbols, and possibly multiple definitions. */
466 if (link_info.relocatable)
467 link_info.output_bfd->flags &= ~EXEC_P;
469 link_info.output_bfd->flags |= EXEC_P;
473 if (config.map_file != NULL)
475 if (command_line.cref)
476 output_cref (config.map_file != NULL ? config.map_file : stdout);
477 if (nocrossref_list != NULL)
478 check_nocrossrefs ();
482 /* Even if we're producing relocatable output, some non-fatal errors should
483 be reported in the exit status. (What non-fatal errors, if any, do we
484 want to ignore for relocatable output?) */
485 if (!config.make_executable && !force_make_executable)
488 einfo (_("%P: link errors found, deleting executable `%s'\n"),
491 /* The file will be removed by remove_output. */
496 if (! bfd_close (link_info.output_bfd))
497 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
499 /* If the --force-exe-suffix is enabled, and we're making an
500 executable file and it doesn't end in .exe, copy it to one
502 if (! link_info.relocatable && command_line.force_exe_suffix)
504 int len = strlen (output_filename);
507 || (strcasecmp (output_filename + len - 4, ".exe") != 0
508 && strcasecmp (output_filename + len - 4, ".dll") != 0))
512 const int bsize = 4096;
513 char *buf = (char *) xmalloc (bsize);
515 char *dst_name = (char *) xmalloc (len + 5);
517 strcpy (dst_name, output_filename);
518 strcat (dst_name, ".exe");
519 src = fopen (output_filename, FOPEN_RB);
520 dst = fopen (dst_name, FOPEN_WB);
523 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
526 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
528 while ((l = fread (buf, 1, bsize, src)) > 0)
530 int done = fwrite (buf, 1, l, dst);
533 einfo (_("%P: Error writing file `%s'\n"), dst_name);
537 if (fclose (dst) == EOF)
538 einfo (_("%P: Error closing file `%s'\n"), dst_name);
545 END_PROGRESS (program_name);
550 char *lim = (char *) sbrk (0);
552 long run_time = get_run_time () - start_time;
555 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
556 program_name, run_time / 1000000, run_time % 1000000);
558 fprintf (stderr, _("%s: data size %ld\n"), program_name,
559 (long) (lim - (char *) &environ));
564 /* Prevent remove_output from doing anything, after a successful link. */
565 output_filename = NULL;
571 /* If the configured sysroot is relocatable, try relocating it based on
572 default prefix FROM. Return the relocated directory if it exists,
573 otherwise return null. */
576 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
578 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
582 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
585 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
593 /* Return the sysroot directory. Return "" if no sysroot is being used. */
596 get_sysroot (int argc, char **argv)
601 for (i = 1; i < argc; i++)
602 if (CONST_STRNEQ (argv[i], "--sysroot="))
603 return argv[i] + strlen ("--sysroot=");
605 path = get_relative_sysroot (BINDIR);
609 path = get_relative_sysroot (TOOLBINDIR);
613 return TARGET_SYSTEM_ROOT;
616 /* We need to find any explicitly given emulation in order to initialize the
617 state that's needed by the lex&yacc argument parser (parse_args). */
620 get_emulation (int argc, char **argv)
625 emulation = getenv (EMULATION_ENVIRON);
626 if (emulation == NULL)
627 emulation = DEFAULT_EMULATION;
629 for (i = 1; i < argc; i++)
631 if (CONST_STRNEQ (argv[i], "-m"))
633 if (argv[i][2] == '\0')
638 emulation = argv[i + 1];
642 einfo (_("%P%F: missing argument to -m\n"));
644 else if (strcmp (argv[i], "-mips1") == 0
645 || strcmp (argv[i], "-mips2") == 0
646 || strcmp (argv[i], "-mips3") == 0
647 || strcmp (argv[i], "-mips4") == 0
648 || strcmp (argv[i], "-mips5") == 0
649 || strcmp (argv[i], "-mips32") == 0
650 || strcmp (argv[i], "-mips32r2") == 0
651 || strcmp (argv[i], "-mips64") == 0
652 || strcmp (argv[i], "-mips64r2") == 0)
654 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
655 passed to the linker by some MIPS compilers. They
656 generally tell the linker to use a slightly different
657 library path. Perhaps someday these should be
658 implemented as emulations; until then, we just ignore
659 the arguments and hope that nobody ever creates
660 emulations named ips1, ips2 or ips3. */
662 else if (strcmp (argv[i], "-m486") == 0)
664 /* FIXME: The argument -m486 is passed to the linker on
665 some Linux systems. Hope that nobody creates an
666 emulation named 486. */
671 emulation = &argv[i][2];
680 add_ysym (const char *name)
682 if (link_info.notice_hash == NULL)
684 link_info.notice_hash =
685 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
686 if (!bfd_hash_table_init_n (link_info.notice_hash,
688 sizeof (struct bfd_hash_entry),
690 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
693 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
694 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
697 /* Record a symbol to be wrapped, from the --wrap option. */
700 add_wrap (const char *name)
702 if (link_info.wrap_hash == NULL)
704 link_info.wrap_hash =
705 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
706 if (!bfd_hash_table_init_n (link_info.wrap_hash,
708 sizeof (struct bfd_hash_entry),
710 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
713 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
714 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
717 /* Handle the -retain-symbols-file option. */
720 add_keepsyms_file (const char *filename)
727 if (link_info.strip == strip_some)
728 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
730 file = fopen (filename, "r");
733 bfd_set_error (bfd_error_system_call);
734 einfo ("%X%P: %s: %E\n", filename);
738 link_info.keep_hash = (struct bfd_hash_table *)
739 xmalloc (sizeof (struct bfd_hash_table));
740 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
741 sizeof (struct bfd_hash_entry)))
742 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
745 buf = (char *) xmalloc (bufsize);
757 while (! ISSPACE (c) && c != EOF)
764 buf = (char *) xrealloc (buf, bufsize);
771 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
772 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
776 if (link_info.strip != strip_none)
777 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
780 link_info.strip = strip_some;
783 /* Callbacks from the BFD linker routines. */
785 /* This is called when BFD has decided to include an archive member in
789 add_archive_element (struct bfd_link_info *info,
792 bfd **subsbfd ATTRIBUTE_UNUSED)
794 lang_input_statement_type *input;
795 lang_input_statement_type orig_input;
797 input = (lang_input_statement_type *)
798 xcalloc (1, sizeof (lang_input_statement_type));
799 input->filename = abfd->filename;
800 input->local_sym_name = abfd->filename;
801 input->the_bfd = abfd;
803 /* Save the original data for trace files/tries below, as plugins
804 (if enabled) may possibly alter it to point to a replacement
805 BFD, but we still want to output the original BFD filename. */
807 #ifdef ENABLE_PLUGINS
808 if (bfd_my_archive (abfd) != NULL
809 && plugin_active_plugins_p ()
810 && !no_more_claiming)
812 /* We must offer this archive member to the plugins to claim. */
813 int fd = open (bfd_my_archive (abfd)->filename, O_RDONLY | O_BINARY);
816 struct ld_plugin_input_file file;
818 /* Offset and filesize must refer to the individual archive
819 member, not the whole file, and must exclude the header.
820 Fortunately for us, that is how the data is stored in the
821 origin field of the bfd and in the arelt_data. */
822 file.name = bfd_my_archive (abfd)->filename;
823 file.offset = abfd->origin;
824 file.filesize = arelt_size (abfd);
826 plugin_maybe_claim (&file, input);
829 input->claim_archive = TRUE;
830 *subsbfd = input->the_bfd;
834 #endif /* ENABLE_PLUGINS */
836 ldlang_add_file (input);
838 if (config.map_file != NULL)
840 static bfd_boolean header_printed;
841 struct bfd_link_hash_entry *h;
845 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
857 case bfd_link_hash_defined:
858 case bfd_link_hash_defweak:
859 from = h->u.def.section->owner;
862 case bfd_link_hash_undefined:
863 case bfd_link_hash_undefweak:
864 from = h->u.undef.abfd;
867 case bfd_link_hash_common:
868 from = h->u.c.p->section->owner;
873 if (! header_printed)
877 sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
879 header_printed = TRUE;
882 if (bfd_my_archive (abfd) == NULL)
884 minfo ("%s", bfd_get_filename (abfd));
885 len = strlen (bfd_get_filename (abfd));
889 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
890 bfd_get_filename (abfd));
891 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
892 + strlen (bfd_get_filename (abfd))
910 minfo ("(%T)\n", h->root.string);
912 minfo ("(%s)\n", name);
915 if (trace_files || trace_file_tries)
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)
990 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
991 command_line.disable_target_specific_optimizations = -1;
997 /* This is called when there is a definition of a common symbol, or
998 when a common symbol is found for a symbol that is already defined,
999 or when two common symbols are found. We only do something if
1000 -warn-common was used. */
1003 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1004 struct bfd_link_hash_entry *h,
1006 enum bfd_link_hash_type ntype,
1011 enum bfd_link_hash_type otype;
1014 if (!config.warn_common)
1017 name = h->root.string;
1019 if (otype == bfd_link_hash_common)
1021 obfd = h->u.c.p->section->owner;
1022 osize = h->u.c.size;
1024 else if (otype == bfd_link_hash_defined
1025 || otype == bfd_link_hash_defweak)
1027 obfd = h->u.def.section->owner;
1032 /* FIXME: It would nice if we could report the BFD which defined
1033 an indirect symbol, but we don't have anywhere to store the
1039 if (ntype == bfd_link_hash_defined
1040 || ntype == bfd_link_hash_defweak
1041 || ntype == bfd_link_hash_indirect)
1043 ASSERT (otype == bfd_link_hash_common);
1044 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1047 einfo (_("%B: warning: common is here\n"), obfd);
1049 else if (otype == bfd_link_hash_defined
1050 || otype == bfd_link_hash_defweak
1051 || otype == bfd_link_hash_indirect)
1053 ASSERT (ntype == bfd_link_hash_common);
1054 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1057 einfo (_("%B: warning: defined here\n"), obfd);
1061 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1064 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1067 einfo (_("%B: warning: larger common is here\n"), obfd);
1069 else if (nsize > osize)
1071 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1074 einfo (_("%B: warning: smaller common is here\n"), obfd);
1078 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1080 einfo (_("%B: warning: previous common is here\n"), obfd);
1087 /* This is called when BFD has discovered a set element. H is the
1088 entry in the linker hash table for the set. SECTION and VALUE
1089 represent a value which should be added to the set. */
1092 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1093 struct bfd_link_hash_entry *h,
1094 bfd_reloc_code_real_type reloc,
1099 if (config.warn_constructors)
1100 einfo (_("%P: warning: global constructor %s used\n"),
1103 if (! config.build_constructors)
1106 ldctor_add_set_entry (h, reloc, NULL, section, value);
1108 if (h->type == bfd_link_hash_new)
1110 h->type = bfd_link_hash_undefined;
1111 h->u.undef.abfd = abfd;
1112 /* We don't call bfd_link_add_undef to add this to the list of
1113 undefined symbols because we are going to define it
1120 /* This is called when BFD has discovered a constructor. This is only
1121 called for some object file formats--those which do not handle
1122 constructors in some more clever fashion. This is similar to
1123 adding an element to a set, but less general. */
1126 constructor_callback (struct bfd_link_info *info,
1127 bfd_boolean constructor,
1134 struct bfd_link_hash_entry *h;
1135 char set_name[1 + sizeof "__CTOR_LIST__"];
1137 if (config.warn_constructors)
1138 einfo (_("%P: warning: global constructor %s used\n"), name);
1140 if (! config.build_constructors)
1143 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1144 useful error message. */
1145 if (bfd_reloc_type_lookup (link_info.output_bfd, BFD_RELOC_CTOR) == NULL
1146 && (info->relocatable
1147 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1148 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1151 if (bfd_get_symbol_leading_char (abfd) != '\0')
1152 *s++ = bfd_get_symbol_leading_char (abfd);
1154 strcpy (s, "__CTOR_LIST__");
1156 strcpy (s, "__DTOR_LIST__");
1158 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1159 if (h == (struct bfd_link_hash_entry *) NULL)
1160 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1161 if (h->type == bfd_link_hash_new)
1163 h->type = bfd_link_hash_undefined;
1164 h->u.undef.abfd = abfd;
1165 /* We don't call bfd_link_add_undef to add this to the list of
1166 undefined symbols because we are going to define it
1170 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1174 /* A structure used by warning_callback to pass information through
1175 bfd_map_over_sections. */
1177 struct warning_callback_info
1180 const char *warning;
1185 /* This is called when there is a reference to a warning symbol. */
1188 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1189 const char *warning,
1195 /* This is a hack to support warn_multiple_gp. FIXME: This should
1196 have a cleaner interface, but what? */
1197 if (! config.warn_multiple_gp
1198 && strcmp (warning, "using multiple gp values") == 0)
1201 if (section != NULL)
1202 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1203 else if (abfd == NULL)
1204 einfo ("%P: %s%s\n", _("warning: "), warning);
1205 else if (symbol == NULL)
1206 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1209 struct warning_callback_info cinfo;
1211 /* Look through the relocs to see if we can find a plausible
1214 if (!bfd_generic_link_read_symbols (abfd))
1215 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1217 cinfo.found = FALSE;
1218 cinfo.warning = warning;
1219 cinfo.symbol = symbol;
1220 cinfo.asymbols = bfd_get_outsymbols (abfd);
1221 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1224 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 ATTRIBUTE_UNUSED,
1289 static char *error_name;
1290 static unsigned int error_count;
1292 #define MAX_ERRORS_IN_A_ROW 5
1294 if (config.warn_once)
1296 static struct bfd_hash_table *hash;
1298 /* Only warn once about a particular undefined symbol. */
1301 hash = (struct bfd_hash_table *)
1302 xmalloc (sizeof (struct bfd_hash_table));
1303 if (!bfd_hash_table_init (hash, bfd_hash_newfunc,
1304 sizeof (struct bfd_hash_entry)))
1305 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1308 if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1311 if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1312 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1315 /* We never print more than a reasonable number of errors in a row
1316 for a single symbol. */
1317 if (error_name != NULL
1318 && strcmp (name, error_name) == 0)
1323 if (error_name != NULL)
1325 error_name = xstrdup (name);
1328 if (section != NULL)
1330 if (error_count < MAX_ERRORS_IN_A_ROW)
1333 einfo (_("%X%C: undefined reference to `%T'\n"),
1334 abfd, section, address, name);
1336 einfo (_("%C: warning: undefined reference to `%T'\n"),
1337 abfd, section, address, name);
1339 else if (error_count == MAX_ERRORS_IN_A_ROW)
1342 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1343 abfd, section, address, name);
1345 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1346 abfd, section, address, name);
1353 if (error_count < MAX_ERRORS_IN_A_ROW)
1356 einfo (_("%X%B: undefined reference to `%T'\n"),
1359 einfo (_("%B: warning: undefined reference to `%T'\n"),
1362 else if (error_count == MAX_ERRORS_IN_A_ROW)
1365 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1368 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1378 /* Counter to limit the number of relocation overflow error messages
1379 to print. Errors are printed as it is decremented. When it's
1380 called and the counter is zero, a final message is printed
1381 indicating more relocations were omitted. When it gets to -1, no
1382 such errors are printed. If it's initially set to a value less
1383 than -1, all such errors will be printed (--verbose does this). */
1385 int overflow_cutoff_limit = 10;
1387 /* This is called when a reloc overflows. */
1390 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1391 struct bfd_link_hash_entry *entry,
1393 const char *reloc_name,
1399 if (overflow_cutoff_limit == -1)
1402 einfo ("%X%C:", abfd, section, address);
1404 if (overflow_cutoff_limit >= 0
1405 && overflow_cutoff_limit-- == 0)
1407 einfo (_(" additional relocation overflows omitted from the output\n"));
1413 while (entry->type == bfd_link_hash_indirect
1414 || entry->type == bfd_link_hash_warning)
1415 entry = entry->u.i.link;
1416 switch (entry->type)
1418 case bfd_link_hash_undefined:
1419 case bfd_link_hash_undefweak:
1420 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1421 reloc_name, entry->root.string);
1423 case bfd_link_hash_defined:
1424 case bfd_link_hash_defweak:
1425 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1426 reloc_name, entry->root.string,
1427 entry->u.def.section,
1428 entry->u.def.section == bfd_abs_section_ptr
1429 ? link_info.output_bfd : entry->u.def.section->owner);
1437 einfo (_(" relocation truncated to fit: %s against `%T'"),
1440 einfo ("+%v", addend);
1445 /* This is called when a dangerous relocation is made. */
1448 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1449 const char *message,
1454 einfo (_("%X%C: dangerous relocation: %s\n"),
1455 abfd, section, address, message);
1459 /* This is called when a reloc is being generated attached to a symbol
1460 that is not being output. */
1463 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1469 einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1470 abfd, section, address, name);
1474 /* This is called if link_info.notice_all is set, or when a symbol in
1475 link_info.notice_hash is found. Symbols are put in notice_hash
1476 using the -y option, while notice_all is set if the --cref option
1477 has been supplied, or if there are any NOCROSSREFS sections in the
1478 linker script; and if plugins are active, since they need to monitor
1479 all references from non-IR files. */
1482 notice (struct bfd_link_info *info,
1483 struct bfd_link_hash_entry *h,
1492 if (command_line.cref || nocrossref_list != NULL)
1493 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1497 name = h->root.string;
1498 if (info->notice_hash != NULL
1499 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1501 if (bfd_is_und_section (section))
1502 einfo ("%B: reference to %s\n", abfd, name);
1504 einfo ("%B: definition of %s\n", abfd, name);
1507 if (command_line.cref || nocrossref_list != NULL)
1508 add_cref (name, abfd, section, value);