1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain steve@cygnus.com
7 This file is part of GLD, the Gnu Linker.
9 GLD is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GLD is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GLD; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
27 #include "safe-ctype.h"
28 #include "libiberty.h"
31 #include "filenames.h"
45 /* Somewhere above, sys/stat.h got included. */
46 #if !defined(S_ISDIR) && defined(S_IFDIR)
47 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
53 #ifdef NEED_DECLARATION_SBRK
58 #ifndef TARGET_SYSTEM_ROOT
59 #define TARGET_SYSTEM_ROOT ""
65 const char *output_filename = "a.out";
67 /* Name this program was invoked by. */
70 /* The prefix for system library directories. */
71 const char *ld_sysroot;
73 /* The canonical representation of ld_sysroot. */
74 char * ld_canon_sysroot;
75 int ld_canon_sysroot_len;
77 /* The file that we're creating. */
80 /* Set by -G argument, for MIPS ECOFF target. */
81 int g_switch_value = 8;
83 /* Nonzero means print names of input files as processed. */
84 bfd_boolean trace_files;
86 /* Nonzero means same, but note open failures, too. */
87 bfd_boolean trace_file_tries;
89 /* Nonzero means version number was printed, so exit successfully
90 instead of complaining if no input files are given. */
91 bfd_boolean version_printed;
93 /* Nonzero means link in every member of an archive. */
94 bfd_boolean whole_archive;
96 /* Nonzero means create DT_NEEDED entries only if a dynamic library
97 actually satisfies some reference in a regular object. */
98 bfd_boolean as_needed;
100 /* Nonzero means never create DT_NEEDED entries for dynamic libraries
101 in DT_NEEDED tags. */
102 bfd_boolean add_needed = TRUE;
104 /* TRUE if we should demangle symbol names. */
105 bfd_boolean demangling;
107 args_type command_line;
109 ld_config_type config;
111 sort_type sort_section;
113 static const char *get_sysroot
115 static char *get_emulation
117 static void set_scripts_dir
119 static bfd_boolean add_archive_element
120 (struct bfd_link_info *, bfd *, const char *);
121 static bfd_boolean multiple_definition
122 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
123 bfd *, asection *, bfd_vma);
124 static bfd_boolean multiple_common
125 (struct bfd_link_info *, const char *, bfd *, enum bfd_link_hash_type,
126 bfd_vma, bfd *, enum bfd_link_hash_type, bfd_vma);
127 static bfd_boolean add_to_set
128 (struct bfd_link_info *, struct bfd_link_hash_entry *,
129 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
130 static bfd_boolean constructor_callback
131 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
132 asection *, bfd_vma);
133 static bfd_boolean warning_callback
134 (struct bfd_link_info *, const char *, const char *, bfd *,
135 asection *, bfd_vma);
136 static void warning_find_reloc
137 (bfd *, asection *, void *);
138 static bfd_boolean undefined_symbol
139 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
141 static bfd_boolean reloc_overflow
142 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
143 const char *, bfd_vma, bfd *, asection *, bfd_vma);
144 static bfd_boolean reloc_dangerous
145 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
146 static bfd_boolean unattached_reloc
147 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
148 static bfd_boolean notice
149 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
151 static struct bfd_link_callbacks link_callbacks =
157 constructor_callback,
166 struct bfd_link_info link_info;
174 bfd_cache_close (output_bfd);
175 if (delete_output_file_on_failure)
176 unlink_if_ordinary (output_filename);
181 main (int argc, char **argv)
184 long start_time = get_run_time ();
186 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
187 setlocale (LC_MESSAGES, "");
189 #if defined (HAVE_SETLOCALE)
190 setlocale (LC_CTYPE, "");
192 bindtextdomain (PACKAGE, LOCALEDIR);
193 textdomain (PACKAGE);
195 program_name = argv[0];
196 xmalloc_set_program_name (program_name);
198 START_PROGRESS (program_name, 0);
202 bfd_set_error_program_name (program_name);
204 xatexit (remove_output);
206 /* Set up the sysroot directory. */
207 ld_sysroot = get_sysroot (argc, argv);
210 if (*TARGET_SYSTEM_ROOT == 0)
212 einfo ("%P%F: this linker was not configured to use sysroots");
216 ld_canon_sysroot = lrealpath (ld_sysroot);
218 if (ld_canon_sysroot)
219 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
221 ld_canon_sysroot_len = -1;
223 /* Set the default BFD target based on the configured target. Doing
224 this permits the linker to be configured for a particular target,
225 and linked against a shared BFD library which was configured for
226 a different target. The macro TARGET is defined by Makefile. */
227 if (! bfd_set_default_target (TARGET))
229 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
240 /* Initialize the data about options. */
241 trace_files = trace_file_tries = version_printed = FALSE;
242 whole_archive = FALSE;
243 config.build_constructors = TRUE;
244 config.dynamic_link = FALSE;
245 config.has_shared = FALSE;
246 config.split_by_reloc = (unsigned) -1;
247 config.split_by_file = (bfd_size_type) -1;
248 config.hash_table_size = 0;
249 command_line.force_common_definition = FALSE;
250 command_line.inhibit_common_definition = FALSE;
251 command_line.interpreter = NULL;
252 command_line.rpath = NULL;
253 command_line.warn_mismatch = TRUE;
254 command_line.check_section_addresses = TRUE;
255 command_line.accept_unknown_input_arch = FALSE;
256 command_line.reduce_memory_overheads = FALSE;
260 /* We initialize DEMANGLING based on the environment variable
261 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
262 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
263 environment. Acting the same way here lets us provide the same
264 interface by default. */
265 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
267 link_info.relocatable = FALSE;
268 link_info.emitrelocations = FALSE;
269 link_info.task_link = FALSE;
270 link_info.shared = FALSE;
271 link_info.pie = FALSE;
272 link_info.executable = FALSE;
273 link_info.symbolic = FALSE;
274 link_info.export_dynamic = FALSE;
275 link_info.static_link = FALSE;
276 link_info.traditional_format = FALSE;
277 link_info.optimize = FALSE;
278 link_info.unresolved_syms_in_objects = RM_NOT_YET_SET;
279 link_info.unresolved_syms_in_shared_libs = RM_NOT_YET_SET;
280 link_info.allow_multiple_definition = FALSE;
281 link_info.allow_undefined_version = TRUE;
282 link_info.create_default_symver = FALSE;
283 link_info.default_imported_symver = FALSE;
284 link_info.keep_memory = TRUE;
285 link_info.notice_all = FALSE;
286 link_info.nocopyreloc = FALSE;
287 link_info.new_dtags = FALSE;
288 link_info.combreloc = TRUE;
289 link_info.eh_frame_hdr = FALSE;
290 link_info.relro = FALSE;
291 link_info.strip_discarded = TRUE;
292 link_info.strip = strip_none;
293 link_info.discard = discard_sec_merge;
294 link_info.common_skip_ar_aymbols = bfd_link_common_skip_none;
295 link_info.callbacks = &link_callbacks;
296 link_info.hash = NULL;
297 link_info.keep_hash = NULL;
298 link_info.notice_hash = NULL;
299 link_info.wrap_hash = NULL;
300 link_info.input_bfds = NULL;
301 link_info.create_object_symbols_section = NULL;
302 link_info.gc_sym_list = NULL;
303 link_info.base_file = NULL;
304 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
305 and _fini symbols. We are compatible. */
306 link_info.init_function = "_init";
307 link_info.fini_function = "_fini";
308 link_info.pei386_auto_import = -1;
309 link_info.pei386_runtime_pseudo_reloc = FALSE;
310 link_info.spare_dynamic_tags = 5;
312 link_info.flags_1 = 0;
313 link_info.need_relax_finalize = FALSE;
314 link_info.warn_shared_textrel = FALSE;
316 ldfile_add_arch ("");
318 config.make_executable = TRUE;
319 force_make_executable = FALSE;
320 config.magic_demand_paged = TRUE;
321 config.text_read_only = TRUE;
323 emulation = get_emulation (argc, argv);
324 ldemul_choose_mode (emulation);
325 default_target = ldemul_choose_target (argc, argv);
327 ldemul_before_parse ();
328 lang_has_input_file = FALSE;
329 parse_args (argc, argv);
331 if (config.hash_table_size != 0)
332 bfd_hash_set_default_size (config.hash_table_size);
334 ldemul_set_symbols ();
336 if (link_info.relocatable)
338 if (command_line.gc_sections)
339 einfo ("%P%F: --gc-sections and -r may not be used together\n");
340 else if (command_line.relax)
341 einfo (_("%P%F: --relax and -r may not be used together\n"));
342 if (link_info.shared)
343 einfo (_("%P%F: -r and -shared may not be used together\n"));
346 if (!config.dynamic_link && link_info.shared)
347 einfo (_("%P%F: -static and -shared may not be used together\n"));
349 if (! link_info.shared)
351 if (command_line.filter_shlib)
352 einfo (_("%P%F: -F may not be used without -shared\n"));
353 if (command_line.auxiliary_filters)
354 einfo (_("%P%F: -f may not be used without -shared\n"));
357 if (! link_info.shared || link_info.pie)
358 link_info.executable = TRUE;
360 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
361 don't see how else this can be handled, since in this case we
362 must preserve all externally visible symbols. */
363 if (link_info.relocatable && link_info.strip == strip_all)
365 link_info.strip = strip_debugger;
366 if (link_info.discard == discard_sec_merge)
367 link_info.discard = discard_all;
370 /* This essentially adds another -L directory so this must be done after
371 the -L's in argv have been processed. */
374 /* If we have not already opened and parsed a linker script
375 read the emulation's appropriate default script. */
376 if (saved_script_handle == NULL)
379 char *s = ldemul_get_script (&isfile);
382 ldfile_open_command_file (s);
388 parser_input = input_script;
393 if (trace_file_tries)
395 if (saved_script_handle)
396 info_msg (_("using external linker script:"));
398 info_msg (_("using internal linker script:"));
399 info_msg ("\n==================================================\n");
401 if (saved_script_handle)
403 static const int ld_bufsz = 8193;
405 char *buf = xmalloc (ld_bufsz);
407 rewind (saved_script_handle);
408 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
413 rewind (saved_script_handle);
420 info_msg (ldemul_get_script (&isfile));
423 info_msg ("\n==================================================\n");
428 if (!lang_has_input_file)
432 einfo (_("%P%F: no input files\n"));
436 info_msg (_("%P: mode %s\n"), emulation);
438 ldemul_after_parse ();
440 if (config.map_filename)
442 if (strcmp (config.map_filename, "-") == 0)
444 config.map_file = stdout;
448 config.map_file = fopen (config.map_filename, FOPEN_WT);
449 if (config.map_file == (FILE *) NULL)
451 bfd_set_error (bfd_error_system_call);
452 einfo (_("%P%F: cannot open map file %s: %E\n"),
453 config.map_filename);
460 /* Print error messages for any missing symbols, for any warning
461 symbols, and possibly multiple definitions. */
462 if (link_info.relocatable)
463 output_bfd->flags &= ~EXEC_P;
465 output_bfd->flags |= EXEC_P;
469 if (config.map_file != NULL)
471 if (command_line.cref)
472 output_cref (config.map_file != NULL ? config.map_file : stdout);
473 if (nocrossref_list != NULL)
474 check_nocrossrefs ();
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 remove_output. */
490 if (! bfd_close (output_bfd))
491 einfo (_("%F%B: final close failed: %E\n"), 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 (! link_info.relocatable && command_line.force_exe_suffix)
498 int len = strlen (output_filename);
501 || (strcasecmp (output_filename + len - 4, ".exe") != 0
502 && strcasecmp (output_filename + len - 4, ".dll") != 0))
506 const int bsize = 4096;
507 char *buf = xmalloc (bsize);
509 char *dst_name = xmalloc (len + 5);
511 strcpy (dst_name, output_filename);
512 strcat (dst_name, ".exe");
513 src = fopen (output_filename, FOPEN_RB);
514 dst = fopen (dst_name, FOPEN_WB);
517 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
520 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
522 while ((l = fread (buf, 1, bsize, src)) > 0)
524 int done = fwrite (buf, 1, l, dst);
527 einfo (_("%P: Error writing file `%s'\n"), dst_name);
531 if (fclose (dst) == EOF)
532 einfo (_("%P: Error closing file `%s'\n"), dst_name);
539 END_PROGRESS (program_name);
544 char *lim = sbrk (0);
546 long run_time = get_run_time () - start_time;
548 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
549 program_name, run_time / 1000000, run_time % 1000000);
551 fprintf (stderr, _("%s: data size %ld\n"), program_name,
552 (long) (lim - (char *) &environ));
556 /* Prevent remove_output from doing anything, after a successful link. */
557 output_filename = NULL;
563 /* If the configured sysroot is relocatable, try relocating it based on
564 default prefix FROM. Return the relocated directory if it exists,
565 otherwise return null. */
568 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
570 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
574 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
577 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
585 /* Return the sysroot directory. Return "" if no sysroot is being used. */
588 get_sysroot (int argc, char **argv)
593 for (i = 1; i < argc; i++)
594 if (strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")) == 0)
595 return argv[i] + strlen ("--sysroot=");
597 path = get_relative_sysroot (BINDIR);
601 path = get_relative_sysroot (TOOLBINDIR);
605 return TARGET_SYSTEM_ROOT;
608 /* We need to find any explicitly given emulation in order to initialize the
609 state that's needed by the lex&yacc argument parser (parse_args). */
612 get_emulation (int argc, char **argv)
617 emulation = getenv (EMULATION_ENVIRON);
618 if (emulation == NULL)
619 emulation = DEFAULT_EMULATION;
621 for (i = 1; i < argc; i++)
623 if (!strncmp (argv[i], "-m", 2))
625 if (argv[i][2] == '\0')
630 emulation = argv[i + 1];
634 einfo (_("%P%F: missing argument to -m\n"));
636 else if (strcmp (argv[i], "-mips1") == 0
637 || strcmp (argv[i], "-mips2") == 0
638 || strcmp (argv[i], "-mips3") == 0
639 || strcmp (argv[i], "-mips4") == 0
640 || strcmp (argv[i], "-mips5") == 0
641 || strcmp (argv[i], "-mips32") == 0
642 || strcmp (argv[i], "-mips32r2") == 0
643 || strcmp (argv[i], "-mips64") == 0
644 || strcmp (argv[i], "-mips64r2") == 0)
646 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
647 passed to the linker by some MIPS compilers. They
648 generally tell the linker to use a slightly different
649 library path. Perhaps someday these should be
650 implemented as emulations; until then, we just ignore
651 the arguments and hope that nobody ever creates
652 emulations named ips1, ips2 or ips3. */
654 else if (strcmp (argv[i], "-m486") == 0)
656 /* FIXME: The argument -m486 is passed to the linker on
657 some Linux systems. Hope that nobody creates an
658 emulation named 486. */
663 emulation = &argv[i][2];
671 /* If directory DIR contains an "ldscripts" subdirectory,
672 add DIR to the library search path and return TRUE,
673 else return FALSE. */
676 check_for_scripts_dir (char *dir)
683 dirlen = strlen (dir);
684 /* sizeof counts the terminating NUL. */
685 buf = xmalloc (dirlen + sizeof ("/ldscripts"));
686 sprintf (buf, "%s/ldscripts", dir);
688 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
691 ldfile_add_library_path (dir, FALSE);
695 /* Set the default directory for finding script files.
696 Libraries will be searched for here too, but that's ok.
697 We look for the "ldscripts" directory in:
699 SCRIPTDIR (passed from Makefile)
700 (adjusted according to the current location of the binary)
701 SCRIPTDIR (passed from Makefile)
702 the dir where this program is (for using it from the build tree)
703 the dir where this program is/../lib
704 (for installing the tool suite elsewhere). */
707 set_scripts_dir (void)
713 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
716 found = check_for_scripts_dir (dir);
722 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
725 found = check_for_scripts_dir (dir);
731 if (check_for_scripts_dir (SCRIPTDIR))
732 /* We've been installed normally. */
735 /* Look for "ldscripts" in the dir where our binary is. */
736 end = strrchr (program_name, '/');
737 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
739 /* We could have \foo\bar, or /foo\bar. */
740 char *bslash = strrchr (program_name, '\\');
742 if (end == NULL || (bslash != NULL && bslash > end))
748 /* Don't look for ldscripts in the current directory. There is
749 too much potential for confusion. */
752 dirlen = end - program_name;
753 /* Make a copy of program_name in dir.
754 Leave room for later "/../lib". */
755 dir = xmalloc (dirlen + 8);
756 strncpy (dir, program_name, dirlen);
759 if (check_for_scripts_dir (dir))
765 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
766 strcpy (dir + dirlen, "/../lib");
767 check_for_scripts_dir (dir);
772 add_ysym (const char *name)
774 if (link_info.notice_hash == NULL)
776 link_info.notice_hash = xmalloc (sizeof (struct bfd_hash_table));
777 if (! bfd_hash_table_init_n (link_info.notice_hash,
780 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
783 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
784 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
787 /* Record a symbol to be wrapped, from the --wrap option. */
790 add_wrap (const char *name)
792 if (link_info.wrap_hash == NULL)
794 link_info.wrap_hash = xmalloc (sizeof (struct bfd_hash_table));
795 if (! bfd_hash_table_init_n (link_info.wrap_hash,
798 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
801 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
802 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
805 /* Handle the -retain-symbols-file option. */
808 add_keepsyms_file (const char *filename)
815 if (link_info.strip == strip_some)
816 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
818 file = fopen (filename, "r");
821 bfd_set_error (bfd_error_system_call);
822 einfo ("%X%P: %s: %E\n", filename);
826 link_info.keep_hash = xmalloc (sizeof (struct bfd_hash_table));
827 if (! bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc))
828 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
831 buf = xmalloc (bufsize);
843 while (! ISSPACE (c) && c != EOF)
850 buf = xrealloc (buf, bufsize);
857 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
858 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
862 if (link_info.strip != strip_none)
863 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
866 link_info.strip = strip_some;
869 /* Callbacks from the BFD linker routines. */
871 /* This is called when BFD has decided to include an archive member in
875 add_archive_element (struct bfd_link_info *info ATTRIBUTE_UNUSED,
879 lang_input_statement_type *input;
881 input = xmalloc (sizeof (lang_input_statement_type));
882 input->filename = abfd->filename;
883 input->local_sym_name = abfd->filename;
884 input->the_bfd = abfd;
885 input->asymbols = NULL;
887 input->just_syms_flag = FALSE;
888 input->loaded = FALSE;
889 input->search_dirs_flag = FALSE;
891 /* FIXME: The following fields are not set: header.next,
892 header.type, closed, passive_position, symbol_count,
893 next_real_file, is_archive, target, real. This bit of code is
894 from the old decode_library_subfile function. I don't know
895 whether any of those fields matters. */
897 ldlang_add_file (input);
899 if (config.map_file != NULL)
901 static bfd_boolean header_printed;
902 struct bfd_link_hash_entry *h;
906 h = bfd_link_hash_lookup (link_info.hash, name, FALSE, FALSE, TRUE);
918 case bfd_link_hash_defined:
919 case bfd_link_hash_defweak:
920 from = h->u.def.section->owner;
923 case bfd_link_hash_undefined:
924 case bfd_link_hash_undefweak:
925 from = h->u.undef.abfd;
928 case bfd_link_hash_common:
929 from = h->u.c.p->section->owner;
934 if (! header_printed)
938 sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
940 header_printed = TRUE;
943 if (bfd_my_archive (abfd) == NULL)
945 minfo ("%s", bfd_get_filename (abfd));
946 len = strlen (bfd_get_filename (abfd));
950 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
951 bfd_get_filename (abfd));
952 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
953 + strlen (bfd_get_filename (abfd))
971 minfo ("(%T)\n", h->root.string);
973 minfo ("(%s)\n", name);
976 if (trace_files || trace_file_tries)
977 info_msg ("%I\n", input);
982 /* This is called when BFD has discovered a symbol which is defined
986 multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
995 /* If either section has the output_section field set to
996 bfd_abs_section_ptr, it means that the section is being
997 discarded, and this is not really a multiple definition at all.
998 FIXME: It would be cleaner to somehow ignore symbols defined in
999 sections which are being discarded. */
1000 if ((osec->output_section != NULL
1001 && ! bfd_is_abs_section (osec)
1002 && bfd_is_abs_section (osec->output_section))
1003 || (nsec->output_section != NULL
1004 && ! bfd_is_abs_section (nsec)
1005 && bfd_is_abs_section (nsec->output_section)))
1008 einfo (_("%X%C: multiple definition of `%T'\n"),
1009 nbfd, nsec, nval, name);
1011 einfo (_("%D: first defined here\n"), obfd, osec, oval);
1013 if (command_line.relax)
1015 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
1016 command_line.relax = 0;
1022 /* This is called when there is a definition of a common symbol, or
1023 when a common symbol is found for a symbol that is already defined,
1024 or when two common symbols are found. We only do something if
1025 -warn-common was used. */
1028 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1031 enum bfd_link_hash_type otype,
1034 enum bfd_link_hash_type ntype,
1037 if (! config.warn_common)
1040 if (ntype == bfd_link_hash_defined
1041 || ntype == bfd_link_hash_defweak
1042 || ntype == bfd_link_hash_indirect)
1044 ASSERT (otype == bfd_link_hash_common);
1045 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1048 einfo (_("%B: warning: common is here\n"), obfd);
1050 else if (otype == bfd_link_hash_defined
1051 || otype == bfd_link_hash_defweak
1052 || otype == bfd_link_hash_indirect)
1054 ASSERT (ntype == bfd_link_hash_common);
1055 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1058 einfo (_("%B: warning: defined here\n"), obfd);
1062 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1065 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1068 einfo (_("%B: warning: larger common is here\n"), obfd);
1070 else if (nsize > osize)
1072 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1075 einfo (_("%B: warning: smaller common is here\n"), obfd);
1079 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1081 einfo (_("%B: warning: previous common is here\n"), obfd);
1088 /* This is called when BFD has discovered a set element. H is the
1089 entry in the linker hash table for the set. SECTION and VALUE
1090 represent a value which should be added to the set. */
1093 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1094 struct bfd_link_hash_entry *h,
1095 bfd_reloc_code_real_type reloc,
1100 if (config.warn_constructors)
1101 einfo (_("%P: warning: global constructor %s used\n"),
1104 if (! config.build_constructors)
1107 ldctor_add_set_entry (h, reloc, NULL, section, value);
1109 if (h->type == bfd_link_hash_new)
1111 h->type = bfd_link_hash_undefined;
1112 h->u.undef.abfd = abfd;
1113 /* We don't call bfd_link_add_undef to add this to the list of
1114 undefined symbols because we are going to define it
1121 /* This is called when BFD has discovered a constructor. This is only
1122 called for some object file formats--those which do not handle
1123 constructors in some more clever fashion. This is similar to
1124 adding an element to a set, but less general. */
1127 constructor_callback (struct bfd_link_info *info,
1128 bfd_boolean constructor,
1135 struct bfd_link_hash_entry *h;
1136 char set_name[1 + sizeof "__CTOR_LIST__"];
1138 if (config.warn_constructors)
1139 einfo (_("%P: warning: global constructor %s used\n"), name);
1141 if (! config.build_constructors)
1144 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1145 useful error message. */
1146 if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL
1147 && (link_info.relocatable
1148 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1149 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1152 if (bfd_get_symbol_leading_char (abfd) != '\0')
1153 *s++ = bfd_get_symbol_leading_char (abfd);
1155 strcpy (s, "__CTOR_LIST__");
1157 strcpy (s, "__DTOR_LIST__");
1159 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1160 if (h == (struct bfd_link_hash_entry *) NULL)
1161 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1162 if (h->type == bfd_link_hash_new)
1164 h->type = bfd_link_hash_undefined;
1165 h->u.undef.abfd = abfd;
1166 /* We don't call bfd_link_add_undef to add this to the list of
1167 undefined symbols because we are going to define it
1171 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1175 /* A structure used by warning_callback to pass information through
1176 bfd_map_over_sections. */
1178 struct warning_callback_info
1181 const char *warning;
1186 /* This is called when there is a reference to a warning symbol. */
1189 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1190 const char *warning,
1196 /* This is a hack to support warn_multiple_gp. FIXME: This should
1197 have a cleaner interface, but what? */
1198 if (! config.warn_multiple_gp
1199 && strcmp (warning, "using multiple gp values") == 0)
1202 if (section != NULL)
1203 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1204 else if (abfd == NULL)
1205 einfo ("%P: %s%s\n", _("warning: "), warning);
1206 else if (symbol == NULL)
1207 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1210 lang_input_statement_type *entry;
1212 struct warning_callback_info info;
1214 /* Look through the relocs to see if we can find a plausible
1216 entry = (lang_input_statement_type *) abfd->usrdata;
1217 if (entry != NULL && entry->asymbols != NULL)
1218 asymbols = entry->asymbols;
1224 symsize = bfd_get_symtab_upper_bound (abfd);
1226 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1227 asymbols = xmalloc (symsize);
1228 symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
1229 if (symbol_count < 0)
1230 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1233 entry->asymbols = asymbols;
1234 entry->symbol_count = symbol_count;
1239 info.warning = warning;
1240 info.symbol = symbol;
1241 info.asymbols = asymbols;
1242 bfd_map_over_sections (abfd, warning_find_reloc, &info);
1245 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1254 /* This is called by warning_callback for each section. It checks the
1255 relocs of the section to see if it can find a reference to the
1256 symbol which triggered the warning. If it can, it uses the reloc
1257 to give an error message with a file and line number. */
1260 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1262 struct warning_callback_info *info = iarg;
1266 arelent **p, **pend;
1271 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1273 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1277 relpp = xmalloc (relsize);
1278 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1280 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1283 pend = p + relcount;
1284 for (; p < pend && *p != NULL; p++)
1288 if (q->sym_ptr_ptr != NULL
1289 && *q->sym_ptr_ptr != NULL
1290 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1292 /* We found a reloc for the symbol we are looking for. */
1293 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1303 /* This is called when an undefined symbol is found. */
1306 undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1313 static char *error_name;
1314 static unsigned int error_count;
1316 #define MAX_ERRORS_IN_A_ROW 5
1318 if (config.warn_once)
1320 static struct bfd_hash_table *hash;
1322 /* Only warn once about a particular undefined symbol. */
1325 hash = xmalloc (sizeof (struct bfd_hash_table));
1326 if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
1327 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1330 if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1333 if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1334 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1337 /* We never print more than a reasonable number of errors in a row
1338 for a single symbol. */
1339 if (error_name != NULL
1340 && strcmp (name, error_name) == 0)
1345 if (error_name != NULL)
1347 error_name = xstrdup (name);
1350 if (section != NULL)
1352 if (error_count < MAX_ERRORS_IN_A_ROW)
1355 einfo (_("%X%C: undefined reference to `%T'\n"),
1356 abfd, section, address, name);
1358 einfo (_("%C: warning: undefined reference to `%T'\n"),
1359 abfd, section, address, name);
1361 else if (error_count == MAX_ERRORS_IN_A_ROW)
1364 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1365 abfd, section, address, name);
1367 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1368 abfd, section, address, name);
1375 if (error_count < MAX_ERRORS_IN_A_ROW)
1378 einfo (_("%X%B: undefined reference to `%T'\n"),
1381 einfo (_("%B: warning: undefined reference to `%T'\n"),
1384 else if (error_count == MAX_ERRORS_IN_A_ROW)
1387 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1390 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1400 /* Counter to limit the number of relocation overflow error messages
1401 to print. Errors are printed as it is decremented. When it's
1402 called and the counter is zero, a final message is printed
1403 indicating more relocations were omitted. When it gets to -1, no
1404 such errors are printed. If it's initially set to a value less
1405 than -1, all such errors will be printed (--verbose does this). */
1407 int overflow_cutoff_limit = 10;
1409 /* This is called when a reloc overflows. */
1412 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1413 struct bfd_link_hash_entry *entry,
1415 const char *reloc_name,
1421 if (overflow_cutoff_limit == -1)
1425 einfo (_("%P%X: generated"));
1427 einfo ("%X%C:", abfd, section, address);
1429 if (overflow_cutoff_limit >= 0
1430 && overflow_cutoff_limit-- == 0)
1432 einfo (_(" additional relocation overflows omitted from the output\n"));
1438 while (entry->type == bfd_link_hash_indirect
1439 || entry->type == bfd_link_hash_warning)
1440 entry = entry->u.i.link;
1441 switch (entry->type)
1443 case bfd_link_hash_undefined:
1444 case bfd_link_hash_undefweak:
1445 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1446 reloc_name, entry->root.string);
1448 case bfd_link_hash_defined:
1449 case bfd_link_hash_defweak:
1450 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1451 reloc_name, entry->root.string,
1452 entry->u.def.section, entry->u.def.section->owner);
1460 einfo (_(" relocation truncated to fit: %s against `%T'"),
1463 einfo ("+%v", addend);
1468 /* This is called when a dangerous relocation is made. */
1471 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1472 const char *message,
1478 einfo (_("%P%X: generated"));
1480 einfo ("%X%C:", abfd, section, address);
1481 einfo (_("dangerous relocation: %s\n"), message);
1485 /* This is called when a reloc is being generated attached to a symbol
1486 that is not being output. */
1489 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1496 einfo (_("%P%X: generated"));
1498 einfo ("%X%C:", abfd, section, address);
1499 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name);
1503 /* This is called if link_info.notice_all is set, or when a symbol in
1504 link_info.notice_hash is found. Symbols are put in notice_hash
1505 using the -y option. */
1508 notice (struct bfd_link_info *info,
1514 if (! info->notice_all
1515 || (info->notice_hash != NULL
1516 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1518 if (bfd_is_und_section (section))
1519 einfo ("%B: reference to %s\n", abfd, name);
1521 einfo ("%B: definition of %s\n", abfd, name);
1524 if (command_line.cref || nocrossref_list != NULL)
1525 add_cref (name, abfd, section, value);