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.combreloc = TRUE;
280 link_info.strip_discarded = TRUE;
281 link_info.emit_hash = TRUE;
282 link_info.callbacks = &link_callbacks;
283 link_info.input_bfds_tail = &link_info.input_bfds;
284 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
285 and _fini symbols. We are compatible. */
286 link_info.init_function = "_init";
287 link_info.fini_function = "_fini";
288 link_info.relax_pass = 1;
289 link_info.pei386_auto_import = -1;
290 link_info.spare_dynamic_tags = 5;
291 link_info.path_separator = ':';
293 ldfile_add_arch ("");
294 emulation = get_emulation (argc, argv);
295 ldemul_choose_mode (emulation);
296 default_target = ldemul_choose_target (argc, argv);
297 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
298 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
300 ldemul_before_parse ();
301 lang_has_input_file = FALSE;
302 parse_args (argc, argv);
304 if (config.hash_table_size != 0)
305 bfd_hash_set_default_size (config.hash_table_size);
307 #ifdef ENABLE_PLUGINS
308 /* Now all the plugin arguments have been gathered, we can load them. */
309 plugin_load_plugins ();
310 #endif /* ENABLE_PLUGINS */
312 ldemul_set_symbols ();
314 /* If we have not already opened and parsed a linker script,
315 try the default script from command line first. */
316 if (saved_script_handle == NULL
317 && command_line.default_script != NULL)
319 ldfile_open_command_file (command_line.default_script);
320 parser_input = input_script;
324 /* If we have not already opened and parsed a linker script
325 read the emulation's appropriate default script. */
326 if (saved_script_handle == NULL)
329 char *s = ldemul_get_script (&isfile);
332 ldfile_open_default_command_file (s);
336 lex_redirect (s, _("built in linker script"), 1);
338 parser_input = input_script;
345 if (saved_script_handle)
346 info_msg (_("using external linker script:"));
348 info_msg (_("using internal linker script:"));
349 info_msg ("\n==================================================\n");
351 if (saved_script_handle)
353 static const int ld_bufsz = 8193;
355 char *buf = (char *) xmalloc (ld_bufsz);
357 rewind (saved_script_handle);
358 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
363 rewind (saved_script_handle);
370 info_msg (ldemul_get_script (&isfile));
373 info_msg ("\n==================================================\n");
376 if (command_line.print_output_format)
377 info_msg ("%s\n", lang_get_output_target ());
381 /* If the only command line argument has been -v or --version or --verbose
382 then ignore any input files provided by linker scripts and exit now.
383 We do not want to create an output file when the linker is just invoked
384 to provide version information. */
385 if (argc == 2 && version_printed)
388 if (!lang_has_input_file)
390 if (version_printed || command_line.print_output_format)
392 einfo (_("%P%F: no input files\n"));
396 info_msg (_("%P: mode %s\n"), emulation);
398 ldemul_after_parse ();
400 if (config.map_filename)
402 if (strcmp (config.map_filename, "-") == 0)
404 config.map_file = stdout;
408 config.map_file = fopen (config.map_filename, FOPEN_WT);
409 if (config.map_file == (FILE *) NULL)
411 bfd_set_error (bfd_error_system_call);
412 einfo (_("%P%F: cannot open map file %s: %E\n"),
413 config.map_filename);
420 /* Print error messages for any missing symbols, for any warning
421 symbols, and possibly multiple definitions. */
422 if (link_info.relocatable)
423 link_info.output_bfd->flags &= ~EXEC_P;
425 link_info.output_bfd->flags |= EXEC_P;
429 if (config.map_file != NULL)
431 if (command_line.cref)
432 output_cref (config.map_file != NULL ? config.map_file : stdout);
433 if (nocrossref_list != NULL)
434 check_nocrossrefs ();
437 struct bfd_link_hash_entry * h;
439 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
440 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
445 /* Even if we're producing relocatable output, some non-fatal errors should
446 be reported in the exit status. (What non-fatal errors, if any, do we
447 want to ignore for relocatable output?) */
448 if (!config.make_executable && !force_make_executable)
451 einfo (_("%P: link errors found, deleting executable `%s'\n"),
454 /* The file will be removed by ld_cleanup. */
459 if (! bfd_close (link_info.output_bfd))
460 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
462 /* If the --force-exe-suffix is enabled, and we're making an
463 executable file and it doesn't end in .exe, copy it to one
465 if (! link_info.relocatable && command_line.force_exe_suffix)
467 int len = strlen (output_filename);
470 || (strcasecmp (output_filename + len - 4, ".exe") != 0
471 && strcasecmp (output_filename + len - 4, ".dll") != 0))
475 const int bsize = 4096;
476 char *buf = (char *) xmalloc (bsize);
478 char *dst_name = (char *) xmalloc (len + 5);
480 strcpy (dst_name, output_filename);
481 strcat (dst_name, ".exe");
482 src = fopen (output_filename, FOPEN_RB);
483 dst = fopen (dst_name, FOPEN_WB);
486 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
489 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
491 while ((l = fread (buf, 1, bsize, src)) > 0)
493 int done = fwrite (buf, 1, l, dst);
496 einfo (_("%P: Error writing file `%s'\n"), dst_name);
500 if (fclose (dst) == EOF)
501 einfo (_("%P: Error closing file `%s'\n"), dst_name);
508 END_PROGRESS (program_name);
513 char *lim = (char *) sbrk (0);
515 long run_time = get_run_time () - start_time;
518 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
519 program_name, run_time / 1000000, run_time % 1000000);
521 fprintf (stderr, _("%s: data size %ld\n"), program_name,
522 (long) (lim - start_sbrk));
527 /* Prevent ld_cleanup from doing anything, after a successful link. */
528 output_filename = NULL;
534 /* If the configured sysroot is relocatable, try relocating it based on
535 default prefix FROM. Return the relocated directory if it exists,
536 otherwise return null. */
539 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
541 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
545 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
548 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
556 /* Return the sysroot directory. Return "" if no sysroot is being used. */
559 get_sysroot (int argc, char **argv)
564 for (i = 1; i < argc; i++)
565 if (CONST_STRNEQ (argv[i], "--sysroot="))
566 return argv[i] + strlen ("--sysroot=");
568 path = get_relative_sysroot (BINDIR);
572 path = get_relative_sysroot (TOOLBINDIR);
576 return TARGET_SYSTEM_ROOT;
579 /* We need to find any explicitly given emulation in order to initialize the
580 state that's needed by the lex&yacc argument parser (parse_args). */
583 get_emulation (int argc, char **argv)
588 emulation = getenv (EMULATION_ENVIRON);
589 if (emulation == NULL)
590 emulation = DEFAULT_EMULATION;
592 for (i = 1; i < argc; i++)
594 if (CONST_STRNEQ (argv[i], "-m"))
596 if (argv[i][2] == '\0')
601 emulation = argv[i + 1];
605 einfo (_("%P%F: missing argument to -m\n"));
607 else if (strcmp (argv[i], "-mips1") == 0
608 || strcmp (argv[i], "-mips2") == 0
609 || strcmp (argv[i], "-mips3") == 0
610 || strcmp (argv[i], "-mips4") == 0
611 || strcmp (argv[i], "-mips5") == 0
612 || strcmp (argv[i], "-mips32") == 0
613 || strcmp (argv[i], "-mips32r2") == 0
614 || strcmp (argv[i], "-mips32r6") == 0
615 || strcmp (argv[i], "-mips64") == 0
616 || strcmp (argv[i], "-mips64r2") == 0
617 || strcmp (argv[i], "-mips64r6") == 0)
619 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
620 passed to the linker by some MIPS compilers. They
621 generally tell the linker to use a slightly different
622 library path. Perhaps someday these should be
623 implemented as emulations; until then, we just ignore
624 the arguments and hope that nobody ever creates
625 emulations named ips1, ips2 or ips3. */
627 else if (strcmp (argv[i], "-m486") == 0)
629 /* FIXME: The argument -m486 is passed to the linker on
630 some Linux systems. Hope that nobody creates an
631 emulation named 486. */
636 emulation = &argv[i][2];
645 add_ysym (const char *name)
647 if (link_info.notice_hash == NULL)
649 link_info.notice_hash =
650 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
651 if (!bfd_hash_table_init_n (link_info.notice_hash,
653 sizeof (struct bfd_hash_entry),
655 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
658 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
659 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
663 add_ignoresym (struct bfd_link_info *info, const char *name)
665 if (info->ignore_hash == NULL)
667 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
668 if (! bfd_hash_table_init_n (info->ignore_hash,
670 sizeof (struct bfd_hash_entry),
672 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
675 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
676 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
679 /* Record a symbol to be wrapped, from the --wrap option. */
682 add_wrap (const char *name)
684 if (link_info.wrap_hash == NULL)
686 link_info.wrap_hash =
687 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
688 if (!bfd_hash_table_init_n (link_info.wrap_hash,
690 sizeof (struct bfd_hash_entry),
692 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
695 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
696 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
699 /* Handle the -retain-symbols-file option. */
702 add_keepsyms_file (const char *filename)
709 if (link_info.strip == strip_some)
710 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
712 file = fopen (filename, "r");
715 bfd_set_error (bfd_error_system_call);
716 einfo ("%X%P: %s: %E\n", filename);
720 link_info.keep_hash = (struct bfd_hash_table *)
721 xmalloc (sizeof (struct bfd_hash_table));
722 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
723 sizeof (struct bfd_hash_entry)))
724 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
727 buf = (char *) xmalloc (bufsize);
739 while (! ISSPACE (c) && c != EOF)
746 buf = (char *) xrealloc (buf, bufsize);
753 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
754 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
758 if (link_info.strip != strip_none)
759 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
762 link_info.strip = strip_some;
766 /* Callbacks from the BFD linker routines. */
768 /* This is called when BFD has decided to include an archive member in
772 add_archive_element (struct bfd_link_info *info,
775 bfd **subsbfd ATTRIBUTE_UNUSED)
777 lang_input_statement_type *input;
778 lang_input_statement_type orig_input;
780 input = (lang_input_statement_type *)
781 xcalloc (1, sizeof (lang_input_statement_type));
782 input->filename = abfd->filename;
783 input->local_sym_name = abfd->filename;
784 input->the_bfd = abfd;
786 /* Save the original data for trace files/tries below, as plugins
787 (if enabled) may possibly alter it to point to a replacement
788 BFD, but we still want to output the original BFD filename. */
790 #ifdef ENABLE_PLUGINS
791 if (plugin_active_plugins_p () && !no_more_claiming)
793 /* We must offer this archive member to the plugins to claim. */
794 const char *filename = (bfd_my_archive (abfd) != NULL
795 ? bfd_my_archive (abfd)->filename : abfd->filename);
796 int fd = open (filename, O_RDONLY | O_BINARY);
799 struct ld_plugin_input_file file;
801 /* Offset and filesize must refer to the individual archive
802 member, not the whole file, and must exclude the header.
803 Fortunately for us, that is how the data is stored in the
804 origin field of the bfd and in the arelt_data. */
805 file.name = filename;
806 file.offset = abfd->origin;
807 file.filesize = arelt_size (abfd);
809 plugin_maybe_claim (&file, input);
810 if (input->flags.claimed)
812 input->flags.claim_archive = TRUE;
813 *subsbfd = input->the_bfd;
817 #endif /* ENABLE_PLUGINS */
819 ldlang_add_file (input);
821 if (config.map_file != NULL)
823 static bfd_boolean header_printed;
824 struct bfd_link_hash_entry *h;
828 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
840 case bfd_link_hash_defined:
841 case bfd_link_hash_defweak:
842 from = h->u.def.section->owner;
845 case bfd_link_hash_undefined:
846 case bfd_link_hash_undefweak:
847 from = h->u.undef.abfd;
850 case bfd_link_hash_common:
851 from = h->u.c.p->section->owner;
856 if (! header_printed)
860 sprintf (buf, _("Archive member included "
861 "to satisfy reference by file (symbol)\n\n"));
863 header_printed = TRUE;
866 if (bfd_my_archive (abfd) == NULL)
868 minfo ("%s", bfd_get_filename (abfd));
869 len = strlen (bfd_get_filename (abfd));
873 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
874 bfd_get_filename (abfd));
875 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
876 + strlen (bfd_get_filename (abfd))
894 minfo ("(%T)\n", h->root.string);
896 minfo ("(%s)\n", name);
899 if (trace_files || verbose)
900 info_msg ("%I\n", &orig_input);
904 /* This is called when BFD has discovered a symbol which is defined
908 multiple_definition (struct bfd_link_info *info,
909 struct bfd_link_hash_entry *h,
919 if (info->allow_multiple_definition)
924 case bfd_link_hash_defined:
925 osec = h->u.def.section;
926 oval = h->u.def.value;
927 obfd = h->u.def.section->owner;
929 case bfd_link_hash_indirect:
930 osec = bfd_ind_section_ptr;
938 /* Ignore a redefinition of an absolute symbol to the
939 same value; it's harmless. */
940 if (h->type == bfd_link_hash_defined
941 && bfd_is_abs_section (osec)
942 && bfd_is_abs_section (nsec)
946 /* If either section has the output_section field set to
947 bfd_abs_section_ptr, it means that the section is being
948 discarded, and this is not really a multiple definition at all.
949 FIXME: It would be cleaner to somehow ignore symbols defined in
950 sections which are being discarded. */
951 if ((osec->output_section != NULL
952 && ! bfd_is_abs_section (osec)
953 && bfd_is_abs_section (osec->output_section))
954 || (nsec->output_section != NULL
955 && ! bfd_is_abs_section (nsec)
956 && bfd_is_abs_section (nsec->output_section)))
959 name = h->root.string;
967 einfo (_("%X%C: multiple definition of `%T'\n"),
968 nbfd, nsec, nval, name);
970 einfo (_("%D: first defined here\n"), obfd, osec, oval);
972 if (RELAXATION_ENABLED_BY_USER)
974 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
981 /* This is called when there is a definition of a common symbol, or
982 when a common symbol is found for a symbol that is already defined,
983 or when two common symbols are found. We only do something if
984 -warn-common was used. */
987 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
988 struct bfd_link_hash_entry *h,
990 enum bfd_link_hash_type ntype,
995 enum bfd_link_hash_type otype;
998 if (!config.warn_common)
1001 name = h->root.string;
1003 if (otype == bfd_link_hash_common)
1005 obfd = h->u.c.p->section->owner;
1006 osize = h->u.c.size;
1008 else if (otype == bfd_link_hash_defined
1009 || otype == bfd_link_hash_defweak)
1011 obfd = h->u.def.section->owner;
1016 /* FIXME: It would nice if we could report the BFD which defined
1017 an indirect symbol, but we don't have anywhere to store the
1023 if (ntype == bfd_link_hash_defined
1024 || ntype == bfd_link_hash_defweak
1025 || ntype == bfd_link_hash_indirect)
1027 ASSERT (otype == bfd_link_hash_common);
1028 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1031 einfo (_("%B: warning: common is here\n"), obfd);
1033 else if (otype == bfd_link_hash_defined
1034 || otype == bfd_link_hash_defweak
1035 || otype == bfd_link_hash_indirect)
1037 ASSERT (ntype == bfd_link_hash_common);
1038 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1041 einfo (_("%B: warning: defined here\n"), obfd);
1045 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1048 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1051 einfo (_("%B: warning: larger common is here\n"), obfd);
1053 else if (nsize > osize)
1055 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1058 einfo (_("%B: warning: smaller common is here\n"), obfd);
1062 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1064 einfo (_("%B: warning: previous common is here\n"), obfd);
1071 /* This is called when BFD has discovered a set element. H is the
1072 entry in the linker hash table for the set. SECTION and VALUE
1073 represent a value which should be added to the set. */
1076 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1077 struct bfd_link_hash_entry *h,
1078 bfd_reloc_code_real_type reloc,
1083 if (config.warn_constructors)
1084 einfo (_("%P: warning: global constructor %s used\n"),
1087 if (! config.build_constructors)
1090 ldctor_add_set_entry (h, reloc, NULL, section, value);
1092 if (h->type == bfd_link_hash_new)
1094 h->type = bfd_link_hash_undefined;
1095 h->u.undef.abfd = abfd;
1096 /* We don't call bfd_link_add_undef to add this to the list of
1097 undefined symbols because we are going to define it
1104 /* This is called when BFD has discovered a constructor. This is only
1105 called for some object file formats--those which do not handle
1106 constructors in some more clever fashion. This is similar to
1107 adding an element to a set, but less general. */
1110 constructor_callback (struct bfd_link_info *info,
1111 bfd_boolean constructor,
1118 struct bfd_link_hash_entry *h;
1119 char set_name[1 + sizeof "__CTOR_LIST__"];
1121 if (config.warn_constructors)
1122 einfo (_("%P: warning: global constructor %s used\n"), name);
1124 if (! config.build_constructors)
1127 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1128 useful error message. */
1129 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1130 && (info->relocatable
1131 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1132 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1135 if (bfd_get_symbol_leading_char (abfd) != '\0')
1136 *s++ = bfd_get_symbol_leading_char (abfd);
1138 strcpy (s, "__CTOR_LIST__");
1140 strcpy (s, "__DTOR_LIST__");
1142 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1143 if (h == (struct bfd_link_hash_entry *) NULL)
1144 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1145 if (h->type == bfd_link_hash_new)
1147 h->type = bfd_link_hash_undefined;
1148 h->u.undef.abfd = abfd;
1149 /* We don't call bfd_link_add_undef to add this to the list of
1150 undefined symbols because we are going to define it
1154 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1158 /* A structure used by warning_callback to pass information through
1159 bfd_map_over_sections. */
1161 struct warning_callback_info
1164 const char *warning;
1169 /* Look through the relocs to see if we can find a plausible address
1170 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1173 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1175 struct warning_callback_info cinfo;
1177 if (!bfd_generic_link_read_symbols (abfd))
1178 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1180 cinfo.found = FALSE;
1181 cinfo.warning = warning;
1182 cinfo.symbol = symbol;
1183 cinfo.asymbols = bfd_get_outsymbols (abfd);
1184 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1188 /* This is called when there is a reference to a warning symbol. */
1191 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1192 const char *warning,
1198 /* This is a hack to support warn_multiple_gp. FIXME: This should
1199 have a cleaner interface, but what? */
1200 if (! config.warn_multiple_gp
1201 && strcmp (warning, "using multiple gp values") == 0)
1204 if (section != NULL)
1205 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1206 else if (abfd == NULL)
1207 einfo ("%P: %s%s\n", _("warning: "), warning);
1208 else if (symbol == NULL)
1209 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1210 else if (! symbol_warning (warning, symbol, abfd))
1213 /* Search all input files for a reference to SYMBOL. */
1214 for (b = info->input_bfds; b; b = b->link.next)
1215 if (b != abfd && symbol_warning (warning, symbol, b))
1217 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1223 /* This is called by warning_callback for each section. It checks the
1224 relocs of the section to see if it can find a reference to the
1225 symbol which triggered the warning. If it can, it uses the reloc
1226 to give an error message with a file and line number. */
1229 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1231 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1235 arelent **p, **pend;
1240 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1242 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1246 relpp = (arelent **) xmalloc (relsize);
1247 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1249 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1252 pend = p + relcount;
1253 for (; p < pend && *p != NULL; p++)
1257 if (q->sym_ptr_ptr != NULL
1258 && *q->sym_ptr_ptr != NULL
1259 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1261 /* We found a reloc for the symbol we are looking for. */
1262 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1272 /* This is called when an undefined symbol is found. */
1275 undefined_symbol (struct bfd_link_info *info,
1282 static char *error_name;
1283 static unsigned int error_count;
1285 #define MAX_ERRORS_IN_A_ROW 5
1287 if (info->ignore_hash != NULL
1288 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1291 if (config.warn_once)
1293 /* Only warn once about a particular undefined symbol. */
1294 add_ignoresym (info, name);
1297 /* We never print more than a reasonable number of errors in a row
1298 for a single symbol. */
1299 if (error_name != NULL
1300 && strcmp (name, error_name) == 0)
1305 if (error_name != NULL)
1307 error_name = xstrdup (name);
1310 if (section != NULL)
1312 if (error_count < MAX_ERRORS_IN_A_ROW)
1315 einfo (_("%X%C: undefined reference to `%T'\n"),
1316 abfd, section, address, name);
1318 einfo (_("%C: warning: undefined reference to `%T'\n"),
1319 abfd, section, address, name);
1321 else if (error_count == MAX_ERRORS_IN_A_ROW)
1324 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1325 abfd, section, address, name);
1327 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1328 abfd, section, address, name);
1335 if (error_count < MAX_ERRORS_IN_A_ROW)
1338 einfo (_("%X%B: undefined reference to `%T'\n"),
1341 einfo (_("%B: warning: undefined reference to `%T'\n"),
1344 else if (error_count == MAX_ERRORS_IN_A_ROW)
1347 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1350 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1360 /* Counter to limit the number of relocation overflow error messages
1361 to print. Errors are printed as it is decremented. When it's
1362 called and the counter is zero, a final message is printed
1363 indicating more relocations were omitted. When it gets to -1, no
1364 such errors are printed. If it's initially set to a value less
1365 than -1, all such errors will be printed (--verbose does this). */
1367 int overflow_cutoff_limit = 10;
1369 /* This is called when a reloc overflows. */
1372 reloc_overflow (struct bfd_link_info *info,
1373 struct bfd_link_hash_entry *entry,
1375 const char *reloc_name,
1381 if (overflow_cutoff_limit == -1)
1384 einfo ("%X%H:", abfd, section, address);
1386 if (overflow_cutoff_limit >= 0
1387 && overflow_cutoff_limit-- == 0)
1389 einfo (_(" additional relocation overflows omitted from the output\n"));
1395 while (entry->type == bfd_link_hash_indirect
1396 || entry->type == bfd_link_hash_warning)
1397 entry = entry->u.i.link;
1398 switch (entry->type)
1400 case bfd_link_hash_undefined:
1401 case bfd_link_hash_undefweak:
1402 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1403 reloc_name, entry->root.string);
1405 case bfd_link_hash_defined:
1406 case bfd_link_hash_defweak:
1407 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1408 reloc_name, entry->root.string,
1409 entry->u.def.section,
1410 entry->u.def.section == bfd_abs_section_ptr
1411 ? info->output_bfd : entry->u.def.section->owner);
1419 einfo (_(" relocation truncated to fit: %s against `%T'"),
1422 einfo ("+%v", addend);
1427 /* This is called when a dangerous relocation is made. */
1430 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1431 const char *message,
1436 einfo (_("%X%H: dangerous relocation: %s\n"),
1437 abfd, section, address, message);
1441 /* This is called when a reloc is being generated attached to a symbol
1442 that is not being output. */
1445 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1451 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1452 abfd, section, address, name);
1456 /* This is called if link_info.notice_all is set, or when a symbol in
1457 link_info.notice_hash is found. Symbols are put in notice_hash
1458 using the -y option, while notice_all is set if the --cref option
1459 has been supplied, or if there are any NOCROSSREFS sections in the
1460 linker script; and if plugins are active, since they need to monitor
1461 all references from non-IR files. */
1464 notice (struct bfd_link_info *info,
1465 struct bfd_link_hash_entry *h,
1466 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1470 flagword flags ATTRIBUTE_UNUSED)
1476 if (command_line.cref || nocrossref_list != NULL)
1477 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1481 name = h->root.string;
1482 if (info->notice_hash != NULL
1483 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1485 if (bfd_is_und_section (section))
1486 einfo ("%B: reference to %s\n", abfd, name);
1488 einfo ("%B: definition of %s\n", abfd, name);
1491 if (command_line.cref || nocrossref_list != NULL)
1492 add_cref (name, abfd, section, value);