1 /* Main program of GNU linker.
2 Copyright (C) 1991-2014 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"
45 #endif /* ENABLE_PLUGINS */
47 /* Somewhere above, sys/stat.h got included. */
48 #if !defined(S_ISDIR) && defined(S_IFDIR)
49 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
60 #ifndef TARGET_SYSTEM_ROOT
61 #define TARGET_SYSTEM_ROOT ""
66 FILE *saved_script_handle = NULL;
67 FILE *previous_script_handle = NULL;
68 bfd_boolean force_make_executable = FALSE;
71 const char *output_filename = "a.out";
73 /* Name this program was invoked by. */
76 /* The prefix for system library directories. */
77 const char *ld_sysroot;
79 /* The canonical representation of ld_sysroot. */
80 char * ld_canon_sysroot;
81 int ld_canon_sysroot_len;
83 /* Set by -G argument, for targets like MIPS ELF. */
84 int g_switch_value = 8;
86 /* Nonzero means print names of input files as processed. */
87 bfd_boolean trace_files;
89 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
92 /* Nonzero means version number was printed, so exit successfully
93 instead of complaining if no input files are given. */
94 bfd_boolean version_printed;
96 /* TRUE if we should demangle symbol names. */
97 bfd_boolean demangling;
99 args_type command_line;
101 ld_config_type config;
103 sort_type sort_section;
105 static const char *get_sysroot
107 static char *get_emulation
109 static bfd_boolean add_archive_element
110 (struct bfd_link_info *, bfd *, const char *, bfd **);
111 static bfd_boolean multiple_definition
112 (struct bfd_link_info *, struct bfd_link_hash_entry *,
113 bfd *, asection *, bfd_vma);
114 static bfd_boolean multiple_common
115 (struct bfd_link_info *, struct bfd_link_hash_entry *,
116 bfd *, enum bfd_link_hash_type, bfd_vma);
117 static bfd_boolean add_to_set
118 (struct bfd_link_info *, struct bfd_link_hash_entry *,
119 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
120 static bfd_boolean constructor_callback
121 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
122 asection *, bfd_vma);
123 static bfd_boolean warning_callback
124 (struct bfd_link_info *, const char *, const char *, bfd *,
125 asection *, bfd_vma);
126 static void warning_find_reloc
127 (bfd *, asection *, void *);
128 static bfd_boolean undefined_symbol
129 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
131 static bfd_boolean reloc_overflow
132 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
133 const char *, bfd_vma, bfd *, asection *, bfd_vma);
134 static bfd_boolean reloc_dangerous
135 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
136 static bfd_boolean unattached_reloc
137 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
138 static bfd_boolean notice
139 (struct bfd_link_info *, struct bfd_link_hash_entry *,
140 struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
142 static struct bfd_link_callbacks link_callbacks =
148 constructor_callback,
158 ldlang_override_segment_assignment
161 static bfd_assert_handler_type default_bfd_assert_handler;
163 struct bfd_link_info link_info;
168 bfd_cache_close_all ();
169 #ifdef ENABLE_PLUGINS
170 plugin_call_cleanup ();
172 if (output_filename && delete_output_file_on_failure)
173 unlink_if_ordinary (output_filename);
176 /* If there's a BFD assertion, we'll notice and exit with an error
177 unless otherwise instructed. */
180 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
181 const char *file, int line)
183 (*default_bfd_assert_handler) (fmt, bfdver, file, line);
184 config.make_executable = FALSE;
188 main (int argc, char **argv)
191 long start_time = get_run_time ();
193 char *start_sbrk = (char *) sbrk (0);
196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
197 setlocale (LC_MESSAGES, "");
199 #if defined (HAVE_SETLOCALE)
200 setlocale (LC_CTYPE, "");
202 bindtextdomain (PACKAGE, LOCALEDIR);
203 textdomain (PACKAGE);
205 program_name = argv[0];
206 xmalloc_set_program_name (program_name);
208 START_PROGRESS (program_name, 0);
210 expandargv (&argc, &argv);
214 bfd_set_error_program_name (program_name);
216 /* We want to notice and fail on those nasty BFD assertions which are
217 likely to signal incorrect output being generated but otherwise may
219 default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
221 xatexit (ld_cleanup);
223 /* Set up the sysroot directory. */
224 ld_sysroot = get_sysroot (argc, argv);
227 if (*TARGET_SYSTEM_ROOT == 0)
229 einfo ("%P%F: this linker was not configured to use sysroots\n");
233 ld_canon_sysroot = lrealpath (ld_sysroot);
235 if (ld_canon_sysroot)
236 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
238 ld_canon_sysroot_len = -1;
240 /* Set the default BFD target based on the configured target. Doing
241 this permits the linker to be configured for a particular target,
242 and linked against a shared BFD library which was configured for
243 a different target. The macro TARGET is defined by Makefile. */
244 if (! bfd_set_default_target (TARGET))
246 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
257 config.build_constructors = TRUE;
258 config.rpath_separator = ':';
259 config.split_by_reloc = (unsigned) -1;
260 config.split_by_file = (bfd_size_type) -1;
261 config.make_executable = TRUE;
262 config.magic_demand_paged = TRUE;
263 config.text_read_only = TRUE;
264 link_info.disable_target_specific_optimizations = -1;
266 command_line.warn_mismatch = TRUE;
267 command_line.warn_search_mismatch = TRUE;
268 command_line.check_section_addresses = -1;
270 /* We initialize DEMANGLING based on the environment variable
271 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
272 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
273 environment. Acting the same way here lets us provide the same
274 interface by default. */
275 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
277 link_info.allow_undefined_version = TRUE;
278 link_info.keep_memory = TRUE;
279 link_info.new_dtags = TRUE;
280 link_info.combreloc = TRUE;
281 link_info.strip_discarded = TRUE;
282 link_info.emit_hash = TRUE;
283 link_info.emit_gnu_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 = ':';
294 if (getenv ("LD_AS_NEEDED") && atoi(getenv ("LD_AS_NEEDED")) > 0)
295 input_flags.add_DT_NEEDED_for_regular = TRUE;
297 ldfile_add_arch ("");
298 emulation = get_emulation (argc, argv);
299 ldemul_choose_mode (emulation);
300 default_target = ldemul_choose_target (argc, argv);
301 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
302 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
304 ldemul_before_parse ();
305 lang_has_input_file = FALSE;
306 parse_args (argc, argv);
308 if (config.hash_table_size != 0)
309 bfd_hash_set_default_size (config.hash_table_size);
311 #ifdef ENABLE_PLUGINS
312 /* Now all the plugin arguments have been gathered, we can load them. */
313 plugin_load_plugins ();
314 #endif /* ENABLE_PLUGINS */
316 ldemul_set_symbols ();
318 /* If we have not already opened and parsed a linker script,
319 try the default script from command line first. */
320 if (saved_script_handle == NULL
321 && command_line.default_script != NULL)
323 ldfile_open_command_file (command_line.default_script);
324 parser_input = input_script;
328 /* If we have not already opened and parsed a linker script
329 read the emulation's appropriate default script. */
330 if (saved_script_handle == NULL)
333 char *s = ldemul_get_script (&isfile);
336 ldfile_open_default_command_file (s);
340 lex_redirect (s, _("built in linker script"), 1);
342 parser_input = input_script;
349 if (saved_script_handle)
350 info_msg (_("using external linker script:"));
352 info_msg (_("using internal linker script:"));
353 info_msg ("\n==================================================\n");
355 if (saved_script_handle)
357 static const int ld_bufsz = 8193;
359 char *buf = (char *) xmalloc (ld_bufsz);
361 rewind (saved_script_handle);
362 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
367 rewind (saved_script_handle);
374 info_msg (ldemul_get_script (&isfile));
377 info_msg ("\n==================================================\n");
380 if (command_line.print_output_format)
381 info_msg ("%s\n", lang_get_output_target ());
385 /* If the only command line argument has been -v or --version or --verbose
386 then ignore any input files provided by linker scripts and exit now.
387 We do not want to create an output file when the linker is just invoked
388 to provide version information. */
389 if (argc == 2 && version_printed)
392 if (!lang_has_input_file)
394 if (version_printed || command_line.print_output_format)
396 einfo (_("%P%F: no input files\n"));
400 info_msg (_("%P: mode %s\n"), emulation);
402 ldemul_after_parse ();
404 if (config.map_filename)
406 if (strcmp (config.map_filename, "-") == 0)
408 config.map_file = stdout;
412 config.map_file = fopen (config.map_filename, FOPEN_WT);
413 if (config.map_file == (FILE *) NULL)
415 bfd_set_error (bfd_error_system_call);
416 einfo (_("%P%F: cannot open map file %s: %E\n"),
417 config.map_filename);
424 /* Print error messages for any missing symbols, for any warning
425 symbols, and possibly multiple definitions. */
426 if (link_info.relocatable)
427 link_info.output_bfd->flags &= ~EXEC_P;
429 link_info.output_bfd->flags |= EXEC_P;
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 ();
441 struct bfd_link_hash_entry * h;
443 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
444 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
449 /* Even if we're producing relocatable output, some non-fatal errors should
450 be reported in the exit status. (What non-fatal errors, if any, do we
451 want to ignore for relocatable output?) */
452 if (!config.make_executable && !force_make_executable)
455 einfo (_("%P: link errors found, deleting executable `%s'\n"),
458 /* The file will be removed by ld_cleanup. */
463 if (! bfd_close (link_info.output_bfd))
464 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
466 /* If the --force-exe-suffix is enabled, and we're making an
467 executable file and it doesn't end in .exe, copy it to one
469 if (! link_info.relocatable && command_line.force_exe_suffix)
471 int len = strlen (output_filename);
474 || (strcasecmp (output_filename + len - 4, ".exe") != 0
475 && strcasecmp (output_filename + len - 4, ".dll") != 0))
479 const int bsize = 4096;
480 char *buf = (char *) xmalloc (bsize);
482 char *dst_name = (char *) xmalloc (len + 5);
484 strcpy (dst_name, output_filename);
485 strcat (dst_name, ".exe");
486 src = fopen (output_filename, FOPEN_RB);
487 dst = fopen (dst_name, FOPEN_WB);
490 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
493 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
495 while ((l = fread (buf, 1, bsize, src)) > 0)
497 int done = fwrite (buf, 1, l, dst);
500 einfo (_("%P: Error writing file `%s'\n"), dst_name);
504 if (fclose (dst) == EOF)
505 einfo (_("%P: Error closing file `%s'\n"), dst_name);
512 END_PROGRESS (program_name);
517 char *lim = (char *) sbrk (0);
519 long run_time = get_run_time () - start_time;
522 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
523 program_name, run_time / 1000000, run_time % 1000000);
525 fprintf (stderr, _("%s: data size %ld\n"), program_name,
526 (long) (lim - start_sbrk));
531 /* Prevent ld_cleanup from doing anything, after a successful link. */
532 output_filename = NULL;
538 /* If the configured sysroot is relocatable, try relocating it based on
539 default prefix FROM. Return the relocated directory if it exists,
540 otherwise return null. */
543 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
545 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
549 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
552 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
560 /* Return the sysroot directory. Return "" if no sysroot is being used. */
563 get_sysroot (int argc, char **argv)
568 for (i = 1; i < argc; i++)
569 if (CONST_STRNEQ (argv[i], "--sysroot="))
570 return argv[i] + strlen ("--sysroot=");
572 path = get_relative_sysroot (BINDIR);
576 path = get_relative_sysroot (TOOLBINDIR);
580 return TARGET_SYSTEM_ROOT;
583 /* We need to find any explicitly given emulation in order to initialize the
584 state that's needed by the lex&yacc argument parser (parse_args). */
587 get_emulation (int argc, char **argv)
592 emulation = getenv (EMULATION_ENVIRON);
593 if (emulation == NULL)
594 emulation = DEFAULT_EMULATION;
596 for (i = 1; i < argc; i++)
598 if (CONST_STRNEQ (argv[i], "-m"))
600 if (argv[i][2] == '\0')
605 emulation = argv[i + 1];
609 einfo (_("%P%F: missing argument to -m\n"));
611 else if (strcmp (argv[i], "-mips1") == 0
612 || strcmp (argv[i], "-mips2") == 0
613 || strcmp (argv[i], "-mips3") == 0
614 || strcmp (argv[i], "-mips4") == 0
615 || strcmp (argv[i], "-mips5") == 0
616 || strcmp (argv[i], "-mips32") == 0
617 || strcmp (argv[i], "-mips32r2") == 0
618 || strcmp (argv[i], "-mips32r6") == 0
619 || strcmp (argv[i], "-mips64") == 0
620 || strcmp (argv[i], "-mips64r2") == 0
621 || strcmp (argv[i], "-mips64r6") == 0)
623 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
624 passed to the linker by some MIPS compilers. They
625 generally tell the linker to use a slightly different
626 library path. Perhaps someday these should be
627 implemented as emulations; until then, we just ignore
628 the arguments and hope that nobody ever creates
629 emulations named ips1, ips2 or ips3. */
631 else if (strcmp (argv[i], "-m486") == 0)
633 /* FIXME: The argument -m486 is passed to the linker on
634 some Linux systems. Hope that nobody creates an
635 emulation named 486. */
640 emulation = &argv[i][2];
649 add_ysym (const char *name)
651 if (link_info.notice_hash == NULL)
653 link_info.notice_hash =
654 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
655 if (!bfd_hash_table_init_n (link_info.notice_hash,
657 sizeof (struct bfd_hash_entry),
659 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
662 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
663 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
667 add_ignoresym (struct bfd_link_info *info, const char *name)
669 if (info->ignore_hash == NULL)
671 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
672 if (! bfd_hash_table_init_n (info->ignore_hash,
674 sizeof (struct bfd_hash_entry),
676 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
679 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
680 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
683 /* Record a symbol to be wrapped, from the --wrap option. */
686 add_wrap (const char *name)
688 if (link_info.wrap_hash == NULL)
690 link_info.wrap_hash =
691 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
692 if (!bfd_hash_table_init_n (link_info.wrap_hash,
694 sizeof (struct bfd_hash_entry),
696 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
699 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
700 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
703 /* Handle the -retain-symbols-file option. */
706 add_keepsyms_file (const char *filename)
713 if (link_info.strip == strip_some)
714 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
716 file = fopen (filename, "r");
719 bfd_set_error (bfd_error_system_call);
720 einfo ("%X%P: %s: %E\n", filename);
724 link_info.keep_hash = (struct bfd_hash_table *)
725 xmalloc (sizeof (struct bfd_hash_table));
726 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
727 sizeof (struct bfd_hash_entry)))
728 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
731 buf = (char *) xmalloc (bufsize);
743 while (! ISSPACE (c) && c != EOF)
750 buf = (char *) xrealloc (buf, bufsize);
757 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
758 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
762 if (link_info.strip != strip_none)
763 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
766 link_info.strip = strip_some;
770 /* Callbacks from the BFD linker routines. */
772 /* This is called when BFD has decided to include an archive member in
776 add_archive_element (struct bfd_link_info *info,
779 bfd **subsbfd ATTRIBUTE_UNUSED)
781 lang_input_statement_type *input;
782 lang_input_statement_type orig_input;
784 input = (lang_input_statement_type *)
785 xcalloc (1, sizeof (lang_input_statement_type));
786 input->filename = abfd->filename;
787 input->local_sym_name = abfd->filename;
788 input->the_bfd = abfd;
790 /* Save the original data for trace files/tries below, as plugins
791 (if enabled) may possibly alter it to point to a replacement
792 BFD, but we still want to output the original BFD filename. */
794 #ifdef ENABLE_PLUGINS
795 if (plugin_active_plugins_p () && !no_more_claiming)
797 /* We must offer this archive member to the plugins to claim. */
798 const char *filename = (bfd_my_archive (abfd) != NULL
799 ? bfd_my_archive (abfd)->filename : abfd->filename);
800 int fd = open (filename, O_RDONLY | O_BINARY);
803 struct ld_plugin_input_file file;
805 /* Offset and filesize must refer to the individual archive
806 member, not the whole file, and must exclude the header.
807 Fortunately for us, that is how the data is stored in the
808 origin field of the bfd and in the arelt_data. */
809 file.name = filename;
810 file.offset = abfd->origin;
811 file.filesize = arelt_size (abfd);
813 plugin_maybe_claim (&file, input);
814 if (input->flags.claimed)
816 input->flags.claim_archive = TRUE;
817 *subsbfd = input->the_bfd;
821 #endif /* ENABLE_PLUGINS */
823 ldlang_add_file (input);
825 if (config.map_file != NULL)
827 static bfd_boolean header_printed;
828 struct bfd_link_hash_entry *h;
832 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
844 case bfd_link_hash_defined:
845 case bfd_link_hash_defweak:
846 from = h->u.def.section->owner;
849 case bfd_link_hash_undefined:
850 case bfd_link_hash_undefweak:
851 from = h->u.undef.abfd;
854 case bfd_link_hash_common:
855 from = h->u.c.p->section->owner;
860 if (! header_printed)
864 sprintf (buf, _("Archive member included "
865 "to satisfy reference by file (symbol)\n\n"));
867 header_printed = TRUE;
870 if (bfd_my_archive (abfd) == NULL)
872 minfo ("%s", bfd_get_filename (abfd));
873 len = strlen (bfd_get_filename (abfd));
877 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
878 bfd_get_filename (abfd));
879 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
880 + strlen (bfd_get_filename (abfd))
898 minfo ("(%T)\n", h->root.string);
900 minfo ("(%s)\n", name);
903 if (trace_files || verbose)
904 info_msg ("%I\n", &orig_input);
908 /* This is called when BFD has discovered a symbol which is defined
912 multiple_definition (struct bfd_link_info *info,
913 struct bfd_link_hash_entry *h,
923 if (info->allow_multiple_definition)
928 case bfd_link_hash_defined:
929 osec = h->u.def.section;
930 oval = h->u.def.value;
931 obfd = h->u.def.section->owner;
933 case bfd_link_hash_indirect:
934 osec = bfd_ind_section_ptr;
942 /* Ignore a redefinition of an absolute symbol to the
943 same value; it's harmless. */
944 if (h->type == bfd_link_hash_defined
945 && bfd_is_abs_section (osec)
946 && bfd_is_abs_section (nsec)
950 /* If either section has the output_section field set to
951 bfd_abs_section_ptr, it means that the section is being
952 discarded, and this is not really a multiple definition at all.
953 FIXME: It would be cleaner to somehow ignore symbols defined in
954 sections which are being discarded. */
955 if ((osec->output_section != NULL
956 && ! bfd_is_abs_section (osec)
957 && bfd_is_abs_section (osec->output_section))
958 || (nsec->output_section != NULL
959 && ! bfd_is_abs_section (nsec)
960 && bfd_is_abs_section (nsec->output_section)))
963 name = h->root.string;
971 einfo (_("%X%C: multiple definition of `%T'\n"),
972 nbfd, nsec, nval, name);
974 einfo (_("%D: first defined here\n"), obfd, osec, oval);
976 if (RELAXATION_ENABLED_BY_USER)
978 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
985 /* This is called when there is a definition of a common symbol, or
986 when a common symbol is found for a symbol that is already defined,
987 or when two common symbols are found. We only do something if
988 -warn-common was used. */
991 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
992 struct bfd_link_hash_entry *h,
994 enum bfd_link_hash_type ntype,
999 enum bfd_link_hash_type otype;
1002 if (!config.warn_common)
1005 name = h->root.string;
1007 if (otype == bfd_link_hash_common)
1009 obfd = h->u.c.p->section->owner;
1010 osize = h->u.c.size;
1012 else if (otype == bfd_link_hash_defined
1013 || otype == bfd_link_hash_defweak)
1015 obfd = h->u.def.section->owner;
1020 /* FIXME: It would nice if we could report the BFD which defined
1021 an indirect symbol, but we don't have anywhere to store the
1027 if (ntype == bfd_link_hash_defined
1028 || ntype == bfd_link_hash_defweak
1029 || ntype == bfd_link_hash_indirect)
1031 ASSERT (otype == bfd_link_hash_common);
1032 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1035 einfo (_("%B: warning: common is here\n"), obfd);
1037 else if (otype == bfd_link_hash_defined
1038 || otype == bfd_link_hash_defweak
1039 || otype == bfd_link_hash_indirect)
1041 ASSERT (ntype == bfd_link_hash_common);
1042 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1045 einfo (_("%B: warning: defined here\n"), obfd);
1049 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1052 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1055 einfo (_("%B: warning: larger common is here\n"), obfd);
1057 else if (nsize > osize)
1059 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1062 einfo (_("%B: warning: smaller common is here\n"), obfd);
1066 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1068 einfo (_("%B: warning: previous common is here\n"), obfd);
1075 /* This is called when BFD has discovered a set element. H is the
1076 entry in the linker hash table for the set. SECTION and VALUE
1077 represent a value which should be added to the set. */
1080 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1081 struct bfd_link_hash_entry *h,
1082 bfd_reloc_code_real_type reloc,
1087 if (config.warn_constructors)
1088 einfo (_("%P: warning: global constructor %s used\n"),
1091 if (! config.build_constructors)
1094 ldctor_add_set_entry (h, reloc, NULL, section, value);
1096 if (h->type == bfd_link_hash_new)
1098 h->type = bfd_link_hash_undefined;
1099 h->u.undef.abfd = abfd;
1100 /* We don't call bfd_link_add_undef to add this to the list of
1101 undefined symbols because we are going to define it
1108 /* This is called when BFD has discovered a constructor. This is only
1109 called for some object file formats--those which do not handle
1110 constructors in some more clever fashion. This is similar to
1111 adding an element to a set, but less general. */
1114 constructor_callback (struct bfd_link_info *info,
1115 bfd_boolean constructor,
1122 struct bfd_link_hash_entry *h;
1123 char set_name[1 + sizeof "__CTOR_LIST__"];
1125 if (config.warn_constructors)
1126 einfo (_("%P: warning: global constructor %s used\n"), name);
1128 if (! config.build_constructors)
1131 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1132 useful error message. */
1133 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1134 && (info->relocatable
1135 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1136 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1139 if (bfd_get_symbol_leading_char (abfd) != '\0')
1140 *s++ = bfd_get_symbol_leading_char (abfd);
1142 strcpy (s, "__CTOR_LIST__");
1144 strcpy (s, "__DTOR_LIST__");
1146 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1147 if (h == (struct bfd_link_hash_entry *) NULL)
1148 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1149 if (h->type == bfd_link_hash_new)
1151 h->type = bfd_link_hash_undefined;
1152 h->u.undef.abfd = abfd;
1153 /* We don't call bfd_link_add_undef to add this to the list of
1154 undefined symbols because we are going to define it
1158 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1162 /* A structure used by warning_callback to pass information through
1163 bfd_map_over_sections. */
1165 struct warning_callback_info
1168 const char *warning;
1173 /* Look through the relocs to see if we can find a plausible address
1174 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1177 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1179 struct warning_callback_info cinfo;
1181 if (!bfd_generic_link_read_symbols (abfd))
1182 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1184 cinfo.found = FALSE;
1185 cinfo.warning = warning;
1186 cinfo.symbol = symbol;
1187 cinfo.asymbols = bfd_get_outsymbols (abfd);
1188 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1192 /* This is called when there is a reference to a warning symbol. */
1195 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1196 const char *warning,
1202 /* This is a hack to support warn_multiple_gp. FIXME: This should
1203 have a cleaner interface, but what? */
1204 if (! config.warn_multiple_gp
1205 && strcmp (warning, "using multiple gp values") == 0)
1208 if (section != NULL)
1209 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1210 else if (abfd == NULL)
1211 einfo ("%P: %s%s\n", _("warning: "), warning);
1212 else if (symbol == NULL)
1213 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1214 else if (! symbol_warning (warning, symbol, abfd))
1217 /* Search all input files for a reference to SYMBOL. */
1218 for (b = info->input_bfds; b; b = b->link.next)
1219 if (b != abfd && symbol_warning (warning, symbol, b))
1221 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1227 /* This is called by warning_callback for each section. It checks the
1228 relocs of the section to see if it can find a reference to the
1229 symbol which triggered the warning. If it can, it uses the reloc
1230 to give an error message with a file and line number. */
1233 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1235 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1239 arelent **p, **pend;
1244 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1246 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1250 relpp = (arelent **) xmalloc (relsize);
1251 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1253 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1256 pend = p + relcount;
1257 for (; p < pend && *p != NULL; p++)
1261 if (q->sym_ptr_ptr != NULL
1262 && *q->sym_ptr_ptr != NULL
1263 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1265 /* We found a reloc for the symbol we are looking for. */
1266 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1276 /* This is called when an undefined symbol is found. */
1279 undefined_symbol (struct bfd_link_info *info,
1286 static char *error_name;
1287 static unsigned int error_count;
1289 #define MAX_ERRORS_IN_A_ROW 5
1291 if (info->ignore_hash != NULL
1292 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1295 if (config.warn_once)
1297 /* Only warn once about a particular undefined symbol. */
1298 add_ignoresym (info, name);
1301 /* We never print more than a reasonable number of errors in a row
1302 for a single symbol. */
1303 if (error_name != NULL
1304 && strcmp (name, error_name) == 0)
1309 if (error_name != NULL)
1311 error_name = xstrdup (name);
1314 if (section != NULL)
1316 if (error_count < MAX_ERRORS_IN_A_ROW)
1319 einfo (_("%X%C: undefined reference to `%T'\n"),
1320 abfd, section, address, name);
1322 einfo (_("%C: warning: undefined reference to `%T'\n"),
1323 abfd, section, address, name);
1325 else if (error_count == MAX_ERRORS_IN_A_ROW)
1328 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1329 abfd, section, address, name);
1331 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1332 abfd, section, address, name);
1339 if (error_count < MAX_ERRORS_IN_A_ROW)
1342 einfo (_("%X%B: undefined reference to `%T'\n"),
1345 einfo (_("%B: warning: undefined reference to `%T'\n"),
1348 else if (error_count == MAX_ERRORS_IN_A_ROW)
1351 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1354 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1364 /* Counter to limit the number of relocation overflow error messages
1365 to print. Errors are printed as it is decremented. When it's
1366 called and the counter is zero, a final message is printed
1367 indicating more relocations were omitted. When it gets to -1, no
1368 such errors are printed. If it's initially set to a value less
1369 than -1, all such errors will be printed (--verbose does this). */
1371 int overflow_cutoff_limit = 10;
1373 /* This is called when a reloc overflows. */
1376 reloc_overflow (struct bfd_link_info *info,
1377 struct bfd_link_hash_entry *entry,
1379 const char *reloc_name,
1385 if (overflow_cutoff_limit == -1)
1388 einfo ("%X%H:", abfd, section, address);
1390 if (overflow_cutoff_limit >= 0
1391 && overflow_cutoff_limit-- == 0)
1393 einfo (_(" additional relocation overflows omitted from the output\n"));
1399 while (entry->type == bfd_link_hash_indirect
1400 || entry->type == bfd_link_hash_warning)
1401 entry = entry->u.i.link;
1402 switch (entry->type)
1404 case bfd_link_hash_undefined:
1405 case bfd_link_hash_undefweak:
1406 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1407 reloc_name, entry->root.string);
1409 case bfd_link_hash_defined:
1410 case bfd_link_hash_defweak:
1411 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1412 reloc_name, entry->root.string,
1413 entry->u.def.section,
1414 entry->u.def.section == bfd_abs_section_ptr
1415 ? info->output_bfd : entry->u.def.section->owner);
1423 einfo (_(" relocation truncated to fit: %s against `%T'"),
1426 einfo ("+%v", addend);
1431 /* This is called when a dangerous relocation is made. */
1434 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1435 const char *message,
1440 einfo (_("%X%H: dangerous relocation: %s\n"),
1441 abfd, section, address, message);
1445 /* This is called when a reloc is being generated attached to a symbol
1446 that is not being output. */
1449 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1455 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1456 abfd, section, address, name);
1460 /* This is called if link_info.notice_all is set, or when a symbol in
1461 link_info.notice_hash is found. Symbols are put in notice_hash
1462 using the -y option, while notice_all is set if the --cref option
1463 has been supplied, or if there are any NOCROSSREFS sections in the
1464 linker script; and if plugins are active, since they need to monitor
1465 all references from non-IR files. */
1468 notice (struct bfd_link_info *info,
1469 struct bfd_link_hash_entry *h,
1470 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1474 flagword flags ATTRIBUTE_UNUSED)
1480 if (command_line.cref || nocrossref_list != NULL)
1481 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1485 name = h->root.string;
1486 if (info->notice_hash != NULL
1487 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1489 if (bfd_is_und_section (section))
1490 einfo ("%B: reference to %s\n", abfd, name);
1492 einfo ("%B: definition of %s\n", abfd, name);
1495 if (command_line.cref || nocrossref_list != NULL)
1496 add_cref (name, abfd, section, value);