1 /* Main program of GNU linker.
2 Copyright (C) 1991-2018 Free Software Foundation, Inc.
3 Written by Steve Chamberlain steve@cygnus.com
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
24 #include "safe-ctype.h"
25 #include "libiberty.h"
28 #include "filenames.h"
43 #include "plugin-api.h"
44 #endif /* ENABLE_PLUGINS */
46 /* Somewhere above, sys/stat.h got included. */
47 #if !defined(S_ISDIR) && defined(S_IFDIR)
48 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
53 #ifndef TARGET_SYSTEM_ROOT
54 #define TARGET_SYSTEM_ROOT ""
59 FILE *saved_script_handle = NULL;
60 FILE *previous_script_handle = NULL;
61 bfd_boolean force_make_executable = FALSE;
64 const char *output_filename = "a.out";
66 /* Name this program was invoked by. */
69 /* The prefix for system library directories. */
70 const char *ld_sysroot;
72 /* The canonical representation of ld_sysroot. */
73 char *ld_canon_sysroot;
74 int ld_canon_sysroot_len;
76 /* Set by -G argument, for targets like MIPS ELF. */
77 int g_switch_value = 8;
79 /* Nonzero means print names of input files as processed. */
80 bfd_boolean trace_files;
82 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
85 /* Nonzero means version number was printed, so exit successfully
86 instead of complaining if no input files are given. */
87 bfd_boolean version_printed;
89 /* TRUE if we should demangle symbol names. */
90 bfd_boolean demangling;
92 args_type command_line;
94 ld_config_type config;
96 sort_type sort_section;
98 static const char *get_sysroot
100 static char *get_emulation
102 static bfd_boolean add_archive_element
103 (struct bfd_link_info *, bfd *, const char *, bfd **);
104 static void multiple_definition
105 (struct bfd_link_info *, struct bfd_link_hash_entry *,
106 bfd *, asection *, bfd_vma);
107 static void multiple_common
108 (struct bfd_link_info *, struct bfd_link_hash_entry *,
109 bfd *, enum bfd_link_hash_type, bfd_vma);
110 static void add_to_set
111 (struct bfd_link_info *, struct bfd_link_hash_entry *,
112 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
113 static void constructor_callback
114 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
115 asection *, bfd_vma);
116 static void warning_callback
117 (struct bfd_link_info *, const char *, const char *, bfd *,
118 asection *, bfd_vma);
119 static void warning_find_reloc
120 (bfd *, asection *, void *);
121 static void undefined_symbol
122 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
124 static void reloc_overflow
125 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
126 const char *, bfd_vma, bfd *, asection *, bfd_vma);
127 static void reloc_dangerous
128 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
129 static void unattached_reloc
130 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
131 static bfd_boolean notice
132 (struct bfd_link_info *, struct bfd_link_hash_entry *,
133 struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
135 static struct bfd_link_callbacks link_callbacks =
141 constructor_callback,
151 ldlang_override_segment_assignment
154 static bfd_assert_handler_type default_bfd_assert_handler;
155 static bfd_error_handler_type default_bfd_error_handler;
157 struct bfd_link_info link_info;
162 bfd_cache_close_all ();
163 #ifdef ENABLE_PLUGINS
164 plugin_call_cleanup ();
166 if (output_filename && delete_output_file_on_failure)
167 unlink_if_ordinary (output_filename);
170 /* Hook to notice BFD assertions. */
173 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
174 const char *file, int line)
176 config.make_executable = FALSE;
177 (*default_bfd_assert_handler) (fmt, bfdver, file, line);
180 /* Hook the bfd error/warning handler for --fatal-warnings. */
183 ld_bfd_error_handler (const char *fmt, va_list ap)
185 if (config.fatal_warnings)
186 config.make_executable = FALSE;
187 (*default_bfd_error_handler) (fmt, ap);
191 main (int argc, char **argv)
194 long start_time = get_run_time ();
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);
212 if (bfd_init () != BFD_INIT_MAGIC)
213 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
215 bfd_set_error_program_name (program_name);
217 /* We want to notice and fail on those nasty BFD assertions which are
218 likely to signal incorrect output being generated but otherwise may
220 default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
222 /* Also hook the bfd error/warning handler for --fatal-warnings. */
223 default_bfd_error_handler = bfd_set_error_handler (ld_bfd_error_handler);
225 xatexit (ld_cleanup);
227 /* Set up the sysroot directory. */
228 ld_sysroot = get_sysroot (argc, argv);
230 ld_canon_sysroot = lrealpath (ld_sysroot);
231 if (ld_canon_sysroot)
233 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
235 /* is_sysrooted_pathname() relies on no trailing dirsep. */
236 if (ld_canon_sysroot_len > 0
237 && IS_DIR_SEPARATOR (ld_canon_sysroot [ld_canon_sysroot_len - 1]))
238 ld_canon_sysroot [--ld_canon_sysroot_len] = '\0';
241 ld_canon_sysroot_len = -1;
243 /* Set the default BFD target based on the configured target. Doing
244 this permits the linker to be configured for a particular target,
245 and linked against a shared BFD library which was configured for
246 a different target. The macro TARGET is defined by Makefile. */
247 if (!bfd_set_default_target (TARGET))
249 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
260 config.build_constructors = TRUE;
261 config.rpath_separator = ':';
262 config.split_by_reloc = (unsigned) -1;
263 config.split_by_file = (bfd_size_type) -1;
264 config.make_executable = TRUE;
265 config.magic_demand_paged = TRUE;
266 config.text_read_only = TRUE;
267 link_info.disable_target_specific_optimizations = -1;
269 command_line.warn_mismatch = TRUE;
270 command_line.warn_search_mismatch = TRUE;
271 command_line.check_section_addresses = -1;
273 /* We initialize DEMANGLING based on the environment variable
274 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
275 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
276 environment. Acting the same way here lets us provide the same
277 interface by default. */
278 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
280 link_info.allow_undefined_version = TRUE;
281 link_info.keep_memory = TRUE;
282 link_info.combreloc = TRUE;
283 link_info.strip_discarded = TRUE;
284 link_info.prohibit_multiple_definition_absolute = FALSE;
285 link_info.emit_hash = DEFAULT_EMIT_SYSV_HASH;
286 link_info.emit_gnu_hash = DEFAULT_EMIT_GNU_HASH;
287 link_info.callbacks = &link_callbacks;
288 link_info.input_bfds_tail = &link_info.input_bfds;
289 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
290 and _fini symbols. We are compatible. */
291 link_info.init_function = "_init";
292 link_info.fini_function = "_fini";
293 link_info.relax_pass = 1;
294 link_info.extern_protected_data = -1;
295 link_info.dynamic_undefined_weak = -1;
296 link_info.pei386_auto_import = -1;
297 link_info.spare_dynamic_tags = 5;
298 link_info.path_separator = ':';
299 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
300 link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
302 #ifdef DEFAULT_NEW_DTAGS
303 link_info.new_dtags = DEFAULT_NEW_DTAGS;
306 ldfile_add_arch ("");
307 emulation = get_emulation (argc, argv);
308 ldemul_choose_mode (emulation);
309 default_target = ldemul_choose_target (argc, argv);
312 ldemul_before_parse ();
313 lang_has_input_file = FALSE;
314 parse_args (argc, argv);
316 if (config.hash_table_size != 0)
317 bfd_hash_set_default_size (config.hash_table_size);
319 #ifdef ENABLE_PLUGINS
320 /* Now all the plugin arguments have been gathered, we can load them. */
321 plugin_load_plugins ();
322 #endif /* ENABLE_PLUGINS */
324 ldemul_set_symbols ();
326 /* If we have not already opened and parsed a linker script,
327 try the default script from command line first. */
328 if (saved_script_handle == NULL
329 && command_line.default_script != NULL)
331 ldfile_open_command_file (command_line.default_script);
332 parser_input = input_script;
336 /* If we have not already opened and parsed a linker script
337 read the emulation's appropriate default script. */
338 if (saved_script_handle == NULL)
341 char *s = ldemul_get_script (&isfile);
344 ldfile_open_default_command_file (s);
348 lex_redirect (s, _("built in linker script"), 1);
350 parser_input = input_script;
357 if (saved_script_handle)
358 info_msg (_("using external linker script:"));
360 info_msg (_("using internal linker script:"));
361 info_msg ("\n==================================================\n");
363 if (saved_script_handle)
365 static const int ld_bufsz = 8193;
367 char *buf = (char *) xmalloc (ld_bufsz);
369 rewind (saved_script_handle);
370 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
373 info_msg ("%s", buf);
375 rewind (saved_script_handle);
382 info_msg (ldemul_get_script (&isfile));
385 info_msg ("\n==================================================\n");
388 if (command_line.force_group_allocation
389 || !bfd_link_relocatable (&link_info))
390 link_info.resolve_section_groups = TRUE;
392 link_info.resolve_section_groups = FALSE;
394 if (command_line.print_output_format)
395 info_msg ("%s\n", lang_get_output_target ());
399 /* If the only command line argument has been -v or --version or --verbose
400 then ignore any input files provided by linker scripts and exit now.
401 We do not want to create an output file when the linker is just invoked
402 to provide version information. */
403 if (argc == 2 && version_printed)
406 if (link_info.inhibit_common_definition && !bfd_link_dll (&link_info))
407 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
409 if (!lang_has_input_file)
411 if (version_printed || command_line.print_output_format)
413 einfo (_("%F%P: no input files\n"));
417 info_msg (_("%P: mode %s\n"), emulation);
419 ldemul_after_parse ();
421 if (config.map_filename)
423 if (strcmp (config.map_filename, "-") == 0)
425 config.map_file = stdout;
429 config.map_file = fopen (config.map_filename, FOPEN_WT);
430 if (config.map_file == (FILE *) NULL)
432 bfd_set_error (bfd_error_system_call);
433 einfo (_("%F%P: cannot open map file %s: %E\n"),
434 config.map_filename);
441 /* Print error messages for any missing symbols, for any warning
442 symbols, and possibly multiple definitions. */
443 if (bfd_link_relocatable (&link_info))
444 link_info.output_bfd->flags &= ~EXEC_P;
446 link_info.output_bfd->flags |= EXEC_P;
448 if ((link_info.compress_debug & COMPRESS_DEBUG))
450 link_info.output_bfd->flags |= BFD_COMPRESS;
451 if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
452 link_info.output_bfd->flags |= BFD_COMPRESS_GABI;
457 if (config.map_file != NULL)
459 if (command_line.cref)
460 output_cref (config.map_file != NULL ? config.map_file : stdout);
461 if (nocrossref_list != NULL)
462 check_nocrossrefs ();
463 if (command_line.print_memory_usage)
464 lang_print_memory_usage ();
467 struct bfd_link_hash_entry *h;
469 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
470 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
476 /* Even if we're producing relocatable output, some non-fatal errors should
477 be reported in the exit status. (What non-fatal errors, if any, do we
478 want to ignore for relocatable output?) */
479 if (!config.make_executable && !force_make_executable)
482 einfo (_("%P: link errors found, deleting executable `%s'\n"),
485 /* The file will be removed by ld_cleanup. */
490 if (!bfd_close (link_info.output_bfd))
491 einfo (_("%F%P: %pB: final close failed: %E\n"), link_info.output_bfd);
493 /* If the --force-exe-suffix is enabled, and we're making an
494 executable file and it doesn't end in .exe, copy it to one
496 if (!bfd_link_relocatable (&link_info)
497 && command_line.force_exe_suffix)
499 int len = strlen (output_filename);
502 || (strcasecmp (output_filename + len - 4, ".exe") != 0
503 && strcasecmp (output_filename + len - 4, ".dll") != 0))
507 const int bsize = 4096;
508 char *buf = (char *) xmalloc (bsize);
510 char *dst_name = (char *) xmalloc (len + 5);
512 strcpy (dst_name, output_filename);
513 strcat (dst_name, ".exe");
514 src = fopen (output_filename, FOPEN_RB);
515 dst = fopen (dst_name, FOPEN_WB);
518 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
521 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
523 while ((l = fread (buf, 1, bsize, src)) > 0)
525 int done = fwrite (buf, 1, l, dst);
528 einfo (_("%P: error writing file `%s'\n"), dst_name);
532 if (fclose (dst) == EOF)
533 einfo (_("%P: error closing file `%s'\n"), dst_name);
540 END_PROGRESS (program_name);
544 long run_time = get_run_time () - start_time;
547 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
548 program_name, run_time / 1000000, run_time % 1000000);
552 /* Prevent ld_cleanup from doing anything, after a successful link. */
553 output_filename = NULL;
559 /* If the configured sysroot is relocatable, try relocating it based on
560 default prefix FROM. Return the relocated directory if it exists,
561 otherwise return null. */
564 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
566 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
570 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
573 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
581 /* Return the sysroot directory. Return "" if no sysroot is being used. */
584 get_sysroot (int argc, char **argv)
589 for (i = 1; i < argc; i++)
590 if (CONST_STRNEQ (argv[i], "--sysroot="))
591 return argv[i] + strlen ("--sysroot=");
593 path = get_relative_sysroot (BINDIR);
597 path = get_relative_sysroot (TOOLBINDIR);
601 return TARGET_SYSTEM_ROOT;
604 /* We need to find any explicitly given emulation in order to initialize the
605 state that's needed by the lex&yacc argument parser (parse_args). */
608 get_emulation (int argc, char **argv)
613 emulation = getenv (EMULATION_ENVIRON);
614 if (emulation == NULL)
615 emulation = DEFAULT_EMULATION;
617 for (i = 1; i < argc; i++)
619 if (CONST_STRNEQ (argv[i], "-m"))
621 if (argv[i][2] == '\0')
626 emulation = argv[i + 1];
630 einfo (_("%F%P: missing argument to -m\n"));
632 else if (strcmp (argv[i], "-mips1") == 0
633 || strcmp (argv[i], "-mips2") == 0
634 || strcmp (argv[i], "-mips3") == 0
635 || strcmp (argv[i], "-mips4") == 0
636 || strcmp (argv[i], "-mips5") == 0
637 || strcmp (argv[i], "-mips32") == 0
638 || strcmp (argv[i], "-mips32r2") == 0
639 || strcmp (argv[i], "-mips32r6") == 0
640 || strcmp (argv[i], "-mips64") == 0
641 || strcmp (argv[i], "-mips64r2") == 0
642 || strcmp (argv[i], "-mips64r6") == 0)
644 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
645 passed to the linker by some MIPS compilers. They
646 generally tell the linker to use a slightly different
647 library path. Perhaps someday these should be
648 implemented as emulations; until then, we just ignore
649 the arguments and hope that nobody ever creates
650 emulations named ips1, ips2 or ips3. */
652 else if (strcmp (argv[i], "-m486") == 0)
654 /* FIXME: The argument -m486 is passed to the linker on
655 some Linux systems. Hope that nobody creates an
656 emulation named 486. */
661 emulation = &argv[i][2];
670 add_ysym (const char *name)
672 if (link_info.notice_hash == NULL)
674 link_info.notice_hash
675 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
676 if (!bfd_hash_table_init_n (link_info.notice_hash,
678 sizeof (struct bfd_hash_entry),
680 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
683 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
684 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
688 add_ignoresym (struct bfd_link_info *info, const char *name)
690 if (info->ignore_hash == NULL)
692 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
693 if (!bfd_hash_table_init_n (info->ignore_hash,
695 sizeof (struct bfd_hash_entry),
697 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
700 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
701 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
704 /* Record a symbol to be wrapped, from the --wrap option. */
707 add_wrap (const char *name)
709 if (link_info.wrap_hash == NULL)
712 = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
713 if (!bfd_hash_table_init_n (link_info.wrap_hash,
715 sizeof (struct bfd_hash_entry),
717 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
720 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
721 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
724 /* Handle the -retain-symbols-file option. */
727 add_keepsyms_file (const char *filename)
734 if (link_info.strip == strip_some)
735 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
737 file = fopen (filename, "r");
740 bfd_set_error (bfd_error_system_call);
741 einfo ("%X%P: %s: %E\n", filename);
745 link_info.keep_hash = (struct bfd_hash_table *)
746 xmalloc (sizeof (struct bfd_hash_table));
747 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
748 sizeof (struct bfd_hash_entry)))
749 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
752 buf = (char *) xmalloc (bufsize);
764 while (!ISSPACE (c) && c != EOF)
771 buf = (char *) xrealloc (buf, bufsize);
778 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
779 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
783 if (link_info.strip != strip_none)
784 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
787 link_info.strip = strip_some;
791 /* Callbacks from the BFD linker routines. */
793 /* This is called when BFD has decided to include an archive member in
797 add_archive_element (struct bfd_link_info *info,
800 bfd **subsbfd ATTRIBUTE_UNUSED)
802 lang_input_statement_type *input;
803 lang_input_statement_type *parent;
804 lang_input_statement_type orig_input;
806 input = (lang_input_statement_type *)
807 xcalloc (1, sizeof (lang_input_statement_type));
808 input->header.type = lang_input_statement_enum;
809 input->filename = abfd->filename;
810 input->local_sym_name = abfd->filename;
811 input->the_bfd = abfd;
813 parent = abfd->my_archive->usrdata;
814 if (parent != NULL && !parent->flags.reload)
815 parent->next = (lang_statement_union_type *) input;
817 /* Save the original data for trace files/tries below, as plugins
818 (if enabled) may possibly alter it to point to a replacement
819 BFD, but we still want to output the original BFD filename. */
821 #ifdef ENABLE_PLUGINS
822 if (link_info.lto_plugin_active)
824 /* We must offer this archive member to the plugins to claim. */
825 plugin_maybe_claim (input);
826 if (input->flags.claimed)
828 if (no_more_claiming)
830 /* Don't claim new IR symbols after all IR symbols have
832 if (trace_files || verbose)
833 info_msg ("%pI: no new IR symbols to claimi\n",
835 input->flags.claimed = 0;
838 input->flags.claim_archive = TRUE;
839 *subsbfd = input->the_bfd;
842 #endif /* ENABLE_PLUGINS */
844 ldlang_add_file (input);
846 if (config.map_file != NULL)
848 static bfd_boolean header_printed;
849 struct bfd_link_hash_entry *h;
853 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
855 && info->pei386_auto_import
856 && CONST_STRNEQ (name, "__imp_"))
857 h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
869 case bfd_link_hash_defined:
870 case bfd_link_hash_defweak:
871 from = h->u.def.section->owner;
874 case bfd_link_hash_undefined:
875 case bfd_link_hash_undefweak:
876 from = h->u.undef.abfd;
879 case bfd_link_hash_common:
880 from = h->u.c.p->section->owner;
887 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
888 header_printed = TRUE;
891 if (abfd->my_archive == NULL
892 || bfd_is_thin_archive (abfd->my_archive))
894 minfo ("%s", bfd_get_filename (abfd));
895 len = strlen (bfd_get_filename (abfd));
899 minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
900 bfd_get_filename (abfd));
901 len = (strlen (bfd_get_filename (abfd->my_archive))
902 + strlen (bfd_get_filename (abfd))
918 minfo ("%pB ", from);
920 minfo ("(%pT)\n", h->root.string);
922 minfo ("(%s)\n", name);
925 if (trace_files || verbose)
926 info_msg ("%pI\n", &orig_input);
930 /* This is called when BFD has discovered a symbol which is defined
934 multiple_definition (struct bfd_link_info *info,
935 struct bfd_link_hash_entry *h,
945 if (info->allow_multiple_definition)
950 case bfd_link_hash_defined:
951 osec = h->u.def.section;
952 oval = h->u.def.value;
953 obfd = h->u.def.section->owner;
955 case bfd_link_hash_indirect:
956 osec = bfd_ind_section_ptr;
964 /* Ignore a redefinition of an absolute symbol to the
965 same value; it's harmless. */
966 if (h->type == bfd_link_hash_defined
967 && bfd_is_abs_section (osec)
968 && bfd_is_abs_section (nsec)
972 /* If either section has the output_section field set to
973 bfd_abs_section_ptr, it means that the section is being
974 discarded, and this is not really a multiple definition at all.
975 FIXME: It would be cleaner to somehow ignore symbols defined in
976 sections which are being discarded. */
977 if (!info->prohibit_multiple_definition_absolute
978 && ((osec->output_section != NULL
979 && ! bfd_is_abs_section (osec)
980 && bfd_is_abs_section (osec->output_section))
981 || (nsec->output_section != NULL
982 && !bfd_is_abs_section (nsec)
983 && bfd_is_abs_section (nsec->output_section))))
986 name = h->root.string;
994 einfo (_("%X%P: %C: multiple definition of `%pT'"),
995 nbfd, nsec, nval, name);
997 einfo (_("; %D: first defined here"), obfd, osec, oval);
1000 if (RELAXATION_ENABLED_BY_USER)
1002 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1007 /* This is called when there is a definition of a common symbol, or
1008 when a common symbol is found for a symbol that is already defined,
1009 or when two common symbols are found. We only do something if
1010 -warn-common was used. */
1013 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1014 struct bfd_link_hash_entry *h,
1016 enum bfd_link_hash_type ntype,
1021 enum bfd_link_hash_type otype;
1024 if (!config.warn_common)
1027 name = h->root.string;
1029 if (otype == bfd_link_hash_common)
1031 obfd = h->u.c.p->section->owner;
1032 osize = h->u.c.size;
1034 else if (otype == bfd_link_hash_defined
1035 || otype == bfd_link_hash_defweak)
1037 obfd = h->u.def.section->owner;
1042 /* FIXME: It would nice if we could report the BFD which defined
1043 an indirect symbol, but we don't have anywhere to store the
1049 if (ntype == bfd_link_hash_defined
1050 || ntype == bfd_link_hash_defweak
1051 || ntype == bfd_link_hash_indirect)
1053 ASSERT (otype == bfd_link_hash_common);
1055 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1059 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1062 else if (otype == bfd_link_hash_defined
1063 || otype == bfd_link_hash_defweak
1064 || otype == bfd_link_hash_indirect)
1066 ASSERT (ntype == bfd_link_hash_common);
1068 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1072 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1077 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1081 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1082 " by larger common from %pB\n"),
1085 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1086 " by larger common\n"),
1089 else if (nsize > osize)
1092 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1093 " smaller common from %pB\n"),
1096 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1097 " smaller common\n"),
1103 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1106 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1112 /* This is called when BFD has discovered a set element. H is the
1113 entry in the linker hash table for the set. SECTION and VALUE
1114 represent a value which should be added to the set. */
1117 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1118 struct bfd_link_hash_entry *h,
1119 bfd_reloc_code_real_type reloc,
1124 if (config.warn_constructors)
1125 einfo (_("%P: warning: global constructor %s used\n"),
1128 if (!config.build_constructors)
1131 ldctor_add_set_entry (h, reloc, NULL, section, value);
1133 if (h->type == bfd_link_hash_new)
1135 h->type = bfd_link_hash_undefined;
1136 h->u.undef.abfd = abfd;
1137 /* We don't call bfd_link_add_undef to add this to the list of
1138 undefined symbols because we are going to define it
1143 /* This is called when BFD has discovered a constructor. This is only
1144 called for some object file formats--those which do not handle
1145 constructors in some more clever fashion. This is similar to
1146 adding an element to a set, but less general. */
1149 constructor_callback (struct bfd_link_info *info,
1150 bfd_boolean constructor,
1157 struct bfd_link_hash_entry *h;
1158 char set_name[1 + sizeof "__CTOR_LIST__"];
1160 if (config.warn_constructors)
1161 einfo (_("%P: warning: global constructor %s used\n"), name);
1163 if (!config.build_constructors)
1166 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1167 useful error message. */
1168 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1169 && (bfd_link_relocatable (info)
1170 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1171 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1174 if (bfd_get_symbol_leading_char (abfd) != '\0')
1175 *s++ = bfd_get_symbol_leading_char (abfd);
1177 strcpy (s, "__CTOR_LIST__");
1179 strcpy (s, "__DTOR_LIST__");
1181 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1182 if (h == (struct bfd_link_hash_entry *) NULL)
1183 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1184 if (h->type == bfd_link_hash_new)
1186 h->type = bfd_link_hash_undefined;
1187 h->u.undef.abfd = abfd;
1188 /* We don't call bfd_link_add_undef to add this to the list of
1189 undefined symbols because we are going to define it
1193 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1196 /* A structure used by warning_callback to pass information through
1197 bfd_map_over_sections. */
1199 struct warning_callback_info
1202 const char *warning;
1207 /* Look through the relocs to see if we can find a plausible address
1208 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1211 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1213 struct warning_callback_info cinfo;
1215 if (!bfd_generic_link_read_symbols (abfd))
1216 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
1218 cinfo.found = FALSE;
1219 cinfo.warning = warning;
1220 cinfo.symbol = symbol;
1221 cinfo.asymbols = bfd_get_outsymbols (abfd);
1222 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1226 /* This is called when there is a reference to a warning symbol. */
1229 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1230 const char *warning,
1236 /* This is a hack to support warn_multiple_gp. FIXME: This should
1237 have a cleaner interface, but what? */
1238 if (!config.warn_multiple_gp
1239 && strcmp (warning, "using multiple gp values") == 0)
1242 if (section != NULL)
1243 einfo ("%P: %C: %s%s\n", abfd, section, address, _("warning: "), warning);
1244 else if (abfd == NULL)
1245 einfo ("%P: %s%s\n", _("warning: "), warning);
1246 else if (symbol == NULL)
1247 einfo ("%P: %pB: %s%s\n", abfd, _("warning: "), warning);
1248 else if (!symbol_warning (warning, symbol, abfd))
1251 /* Search all input files for a reference to SYMBOL. */
1252 for (b = info->input_bfds; b; b = b->link.next)
1253 if (b != abfd && symbol_warning (warning, symbol, b))
1255 einfo ("%P: %pB: %s%s\n", abfd, _("warning: "), warning);
1259 /* This is called by warning_callback for each section. It checks the
1260 relocs of the section to see if it can find a reference to the
1261 symbol which triggered the warning. If it can, it uses the reloc
1262 to give an error message with a file and line number. */
1265 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1267 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1271 arelent **p, **pend;
1276 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1278 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
1282 relpp = (arelent **) xmalloc (relsize);
1283 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1285 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
1288 pend = p + relcount;
1289 for (; p < pend && *p != NULL; p++)
1293 if (q->sym_ptr_ptr != NULL
1294 && *q->sym_ptr_ptr != NULL
1295 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1297 /* We found a reloc for the symbol we are looking for. */
1298 einfo ("%P: %C: %s%s\n", abfd, sec, q->address, _("warning: "),
1308 /* This is called when an undefined symbol is found. */
1311 undefined_symbol (struct bfd_link_info *info,
1318 static char *error_name;
1319 static unsigned int error_count;
1321 #define MAX_ERRORS_IN_A_ROW 5
1323 if (info->ignore_hash != NULL
1324 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1327 if (config.warn_once)
1329 /* Only warn once about a particular undefined symbol. */
1330 add_ignoresym (info, name);
1333 /* We never print more than a reasonable number of errors in a row
1334 for a single symbol. */
1335 if (error_name != NULL
1336 && strcmp (name, error_name) == 0)
1341 if (error_name != NULL)
1343 error_name = xstrdup (name);
1346 if (section != NULL)
1348 if (error_count < MAX_ERRORS_IN_A_ROW)
1351 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1352 abfd, section, address, name);
1354 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1355 abfd, section, address, name);
1357 else if (error_count == MAX_ERRORS_IN_A_ROW)
1360 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1361 abfd, section, address, name);
1363 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1364 abfd, section, address, name);
1371 if (error_count < MAX_ERRORS_IN_A_ROW)
1374 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1377 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1380 else if (error_count == MAX_ERRORS_IN_A_ROW)
1383 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1386 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1394 /* Counter to limit the number of relocation overflow error messages
1395 to print. Errors are printed as it is decremented. When it's
1396 called and the counter is zero, a final message is printed
1397 indicating more relocations were omitted. When it gets to -1, no
1398 such errors are printed. If it's initially set to a value less
1399 than -1, all such errors will be printed (--verbose does this). */
1401 int overflow_cutoff_limit = 10;
1403 /* This is called when a reloc overflows. */
1406 reloc_overflow (struct bfd_link_info *info,
1407 struct bfd_link_hash_entry *entry,
1409 const char *reloc_name,
1415 if (overflow_cutoff_limit == -1)
1418 einfo ("%X%P: %H:", abfd, section, address);
1420 if (overflow_cutoff_limit >= 0
1421 && overflow_cutoff_limit-- == 0)
1423 einfo (_(" additional relocation overflows omitted from the output\n"));
1429 while (entry->type == bfd_link_hash_indirect
1430 || entry->type == bfd_link_hash_warning)
1431 entry = entry->u.i.link;
1432 switch (entry->type)
1434 case bfd_link_hash_undefined:
1435 case bfd_link_hash_undefweak:
1436 einfo (_(" relocation truncated to fit: "
1437 "%s against undefined symbol `%pT'"),
1438 reloc_name, entry->root.string);
1440 case bfd_link_hash_defined:
1441 case bfd_link_hash_defweak:
1442 einfo (_(" relocation truncated to fit: "
1443 "%s against symbol `%pT' defined in %pA section in %pB"),
1444 reloc_name, entry->root.string,
1445 entry->u.def.section,
1446 entry->u.def.section == bfd_abs_section_ptr
1447 ? info->output_bfd : entry->u.def.section->owner);
1455 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1458 einfo ("+%v", addend);
1462 /* This is called when a dangerous relocation is made. */
1465 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1466 const char *message,
1471 einfo (_("%X%P: %H: dangerous relocation: %s\n"),
1472 abfd, section, address, message);
1475 /* This is called when a reloc is being generated attached to a symbol
1476 that is not being output. */
1479 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1485 einfo (_("%X%P: %H: reloc refers to symbol `%pT' which is not being output\n"),
1486 abfd, section, address, name);
1489 /* This is called if link_info.notice_all is set, or when a symbol in
1490 link_info.notice_hash is found. Symbols are put in notice_hash
1491 using the -y option, while notice_all is set if the --cref option
1492 has been supplied, or if there are any NOCROSSREFS sections in the
1493 linker script; and if plugins are active, since they need to monitor
1494 all references from non-IR files. */
1497 notice (struct bfd_link_info *info,
1498 struct bfd_link_hash_entry *h,
1499 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1503 flagword flags ATTRIBUTE_UNUSED)
1509 if (command_line.cref || nocrossref_list != NULL)
1510 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1514 name = h->root.string;
1515 if (info->notice_hash != NULL
1516 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1518 if (bfd_is_und_section (section))
1519 einfo (_("%P: %pB: reference to %s\n"), abfd, name);
1521 einfo (_("%P: %pB: definition of %s\n"), abfd, name);
1524 if (command_line.cref || nocrossref_list != NULL)
1525 add_cref (name, abfd, section, value);