daily update
[binutils.git] / ld / ldmain.c
blob7aacf0f51a333329cdcf8514cb4329cd5c1f0e5c
1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain steve@cygnus.com
7 This file is part of the GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 #include "sysdep.h"
25 #include "bfd.h"
26 #include "safe-ctype.h"
27 #include "libiberty.h"
28 #include "progress.h"
29 #include "bfdlink.h"
30 #include "filenames.h"
32 #include "ld.h"
33 #include "ldmain.h"
34 #include "ldmisc.h"
35 #include "ldwrite.h"
36 #include "ldexp.h"
37 #include "ldlang.h"
38 #include <ldgram.h>
39 #include "ldlex.h"
40 #include "ldfile.h"
41 #include "ldemul.h"
42 #include "ldctor.h"
43 #ifdef ENABLE_PLUGINS
44 #include "plugin.h"
45 #include "plugin-api.h"
46 #include "libbfd.h"
47 #endif /* ENABLE_PLUGINS */
49 /* Somewhere above, sys/stat.h got included. */
50 #if !defined(S_ISDIR) && defined(S_IFDIR)
51 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
52 #endif
54 #include <string.h>
56 #ifdef HAVE_SBRK
57 #if !HAVE_DECL_SBRK
58 extern void *sbrk ();
59 #endif
60 #endif
62 #ifndef TARGET_SYSTEM_ROOT
63 #define TARGET_SYSTEM_ROOT ""
64 #endif
66 /* EXPORTS */
68 FILE *saved_script_handle = NULL;
69 FILE *previous_script_handle = NULL;
70 bfd_boolean force_make_executable = FALSE;
72 char *default_target;
73 const char *output_filename = "a.out";
75 /* Name this program was invoked by. */
76 char *program_name;
78 /* The prefix for system library directories. */
79 const char *ld_sysroot;
81 /* The canonical representation of ld_sysroot. */
82 char * ld_canon_sysroot;
83 int ld_canon_sysroot_len;
85 /* Set by -G argument, for MIPS ECOFF target. */
86 int g_switch_value = 8;
88 /* Nonzero means print names of input files as processed. */
89 bfd_boolean trace_files;
91 /* Nonzero means same, but note open failures, too. */
92 bfd_boolean trace_file_tries;
94 /* Nonzero means version number was printed, so exit successfully
95 instead of complaining if no input files are given. */
96 bfd_boolean version_printed;
98 /* Nonzero means link in every member of an archive. */
99 bfd_boolean whole_archive;
101 /* True means only create DT_NEEDED entries for dynamic libraries
102 if they actually satisfy some reference in a regular object. */
103 bfd_boolean add_DT_NEEDED_for_regular;
105 /* True means create DT_NEEDED entries for dynamic libraries that
106 are DT_NEEDED by dynamic libraries specifically mentioned on
107 the command line. */
108 bfd_boolean add_DT_NEEDED_for_dynamic;
110 /* TRUE if we should demangle symbol names. */
111 bfd_boolean demangling;
113 args_type command_line;
115 ld_config_type config;
117 sort_type sort_section;
119 static const char *get_sysroot
120 (int, char **);
121 static char *get_emulation
122 (int, char **);
123 static bfd_boolean add_archive_element
124 (struct bfd_link_info *, bfd *, const char *, bfd **);
125 static bfd_boolean multiple_definition
126 (struct bfd_link_info *, struct bfd_link_hash_entry *,
127 bfd *, asection *, bfd_vma);
128 static bfd_boolean multiple_common
129 (struct bfd_link_info *, struct bfd_link_hash_entry *,
130 bfd *, enum bfd_link_hash_type, bfd_vma);
131 static bfd_boolean add_to_set
132 (struct bfd_link_info *, struct bfd_link_hash_entry *,
133 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
134 static bfd_boolean constructor_callback
135 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
136 asection *, bfd_vma);
137 static bfd_boolean warning_callback
138 (struct bfd_link_info *, const char *, const char *, bfd *,
139 asection *, bfd_vma);
140 static void warning_find_reloc
141 (bfd *, asection *, void *);
142 static bfd_boolean undefined_symbol
143 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
144 bfd_boolean);
145 static bfd_boolean reloc_overflow
146 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
147 const char *, bfd_vma, bfd *, asection *, bfd_vma);
148 static bfd_boolean reloc_dangerous
149 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
150 static bfd_boolean unattached_reloc
151 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
152 static bfd_boolean notice
153 (struct bfd_link_info *, struct bfd_link_hash_entry *,
154 bfd *, asection *, bfd_vma, flagword, const char *);
156 static struct bfd_link_callbacks link_callbacks =
158 add_archive_element,
159 multiple_definition,
160 multiple_common,
161 add_to_set,
162 constructor_callback,
163 warning_callback,
164 undefined_symbol,
165 reloc_overflow,
166 reloc_dangerous,
167 unattached_reloc,
168 notice,
169 einfo,
170 info_msg,
171 minfo,
172 ldlang_override_segment_assignment
175 struct bfd_link_info link_info;
177 static void
178 ld_cleanup (void)
180 bfd_cache_close_all ();
181 #ifdef ENABLE_PLUGINS
182 plugin_call_cleanup ();
183 #endif
184 if (output_filename && delete_output_file_on_failure)
185 unlink_if_ordinary (output_filename);
189 main (int argc, char **argv)
191 char *emulation;
192 long start_time = get_run_time ();
194 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
195 setlocale (LC_MESSAGES, "");
196 #endif
197 #if defined (HAVE_SETLOCALE)
198 setlocale (LC_CTYPE, "");
199 #endif
200 bindtextdomain (PACKAGE, LOCALEDIR);
201 textdomain (PACKAGE);
203 program_name = argv[0];
204 xmalloc_set_program_name (program_name);
206 START_PROGRESS (program_name, 0);
208 expandargv (&argc, &argv);
210 bfd_init ();
212 bfd_set_error_program_name (program_name);
214 xatexit (ld_cleanup);
216 /* Set up the sysroot directory. */
217 ld_sysroot = get_sysroot (argc, argv);
218 if (*ld_sysroot)
220 if (*TARGET_SYSTEM_ROOT == 0)
222 einfo ("%P%F: this linker was not configured to use sysroots\n");
223 ld_sysroot = "";
225 else
226 ld_canon_sysroot = lrealpath (ld_sysroot);
228 if (ld_canon_sysroot)
229 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
230 else
231 ld_canon_sysroot_len = -1;
233 /* Set the default BFD target based on the configured target. Doing
234 this permits the linker to be configured for a particular target,
235 and linked against a shared BFD library which was configured for
236 a different target. The macro TARGET is defined by Makefile. */
237 if (! bfd_set_default_target (TARGET))
239 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
240 xexit (1);
243 #if YYDEBUG
245 extern int yydebug;
246 yydebug = 1;
248 #endif
250 config.build_constructors = TRUE;
251 config.rpath_separator = ':';
252 config.split_by_reloc = (unsigned) -1;
253 config.split_by_file = (bfd_size_type) -1;
254 config.make_executable = TRUE;
255 config.magic_demand_paged = TRUE;
256 config.text_read_only = TRUE;
258 command_line.warn_mismatch = TRUE;
259 command_line.warn_search_mismatch = TRUE;
260 command_line.check_section_addresses = -1;
261 command_line.disable_target_specific_optimizations = -1;
263 /* We initialize DEMANGLING based on the environment variable
264 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
265 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
266 environment. Acting the same way here lets us provide the same
267 interface by default. */
268 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
270 link_info.allow_undefined_version = TRUE;
271 link_info.keep_memory = TRUE;
272 link_info.combreloc = TRUE;
273 link_info.strip_discarded = TRUE;
274 link_info.emit_hash = TRUE;
275 link_info.callbacks = &link_callbacks;
276 link_info.input_bfds_tail = &link_info.input_bfds;
277 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
278 and _fini symbols. We are compatible. */
279 link_info.init_function = "_init";
280 link_info.fini_function = "_fini";
281 link_info.relax_pass = 1;
282 link_info.pei386_auto_import = -1;
283 link_info.spare_dynamic_tags = 5;
284 link_info.path_separator = ':';
286 ldfile_add_arch ("");
287 emulation = get_emulation (argc, argv);
288 ldemul_choose_mode (emulation);
289 default_target = ldemul_choose_target (argc, argv);
290 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
291 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
292 lang_init ();
293 ldemul_before_parse ();
294 lang_has_input_file = FALSE;
295 parse_args (argc, argv);
297 if (config.hash_table_size != 0)
298 bfd_hash_set_default_size (config.hash_table_size);
300 #ifdef ENABLE_PLUGINS
301 /* Now all the plugin arguments have been gathered, we can load them. */
302 if (plugin_load_plugins ())
303 einfo (_("%P%F: %s: error loading plugin\n"), plugin_error_plugin ());
304 #endif /* ENABLE_PLUGINS */
306 ldemul_set_symbols ();
308 /* If we have not already opened and parsed a linker script,
309 try the default script from command line first. */
310 if (saved_script_handle == NULL
311 && command_line.default_script != NULL)
313 ldfile_open_command_file (command_line.default_script);
314 parser_input = input_script;
315 yyparse ();
318 /* If we have not already opened and parsed a linker script
319 read the emulation's appropriate default script. */
320 if (saved_script_handle == NULL)
322 int isfile;
323 char *s = ldemul_get_script (&isfile);
325 if (isfile)
326 ldfile_open_default_command_file (s);
327 else
329 lex_string = s;
330 lex_redirect (s);
332 parser_input = input_script;
333 yyparse ();
334 lex_string = NULL;
337 if (trace_file_tries)
339 if (saved_script_handle)
340 info_msg (_("using external linker script:"));
341 else
342 info_msg (_("using internal linker script:"));
343 info_msg ("\n==================================================\n");
345 if (saved_script_handle)
347 static const int ld_bufsz = 8193;
348 size_t n;
349 char *buf = (char *) xmalloc (ld_bufsz);
351 rewind (saved_script_handle);
352 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
354 buf[n] = 0;
355 info_msg (buf);
357 rewind (saved_script_handle);
358 free (buf);
360 else
362 int isfile;
364 info_msg (ldemul_get_script (&isfile));
367 info_msg ("\n==================================================\n");
370 if (command_line.print_output_format)
371 info_msg ("%s\n", lang_get_output_target ());
373 lang_final ();
375 if (!lang_has_input_file)
377 if (version_printed || command_line.print_output_format)
378 xexit (0);
379 einfo (_("%P%F: no input files\n"));
382 if (trace_files)
383 info_msg (_("%P: mode %s\n"), emulation);
385 ldemul_after_parse ();
387 if (config.map_filename)
389 if (strcmp (config.map_filename, "-") == 0)
391 config.map_file = stdout;
393 else
395 config.map_file = fopen (config.map_filename, FOPEN_WT);
396 if (config.map_file == (FILE *) NULL)
398 bfd_set_error (bfd_error_system_call);
399 einfo (_("%P%F: cannot open map file %s: %E\n"),
400 config.map_filename);
405 lang_process ();
407 /* Print error messages for any missing symbols, for any warning
408 symbols, and possibly multiple definitions. */
409 if (link_info.relocatable)
410 link_info.output_bfd->flags &= ~EXEC_P;
411 else
412 link_info.output_bfd->flags |= EXEC_P;
414 ldwrite ();
416 if (config.map_file != NULL)
417 lang_map ();
418 if (command_line.cref)
419 output_cref (config.map_file != NULL ? config.map_file : stdout);
420 if (nocrossref_list != NULL)
421 check_nocrossrefs ();
423 lang_finish ();
425 /* Even if we're producing relocatable output, some non-fatal errors should
426 be reported in the exit status. (What non-fatal errors, if any, do we
427 want to ignore for relocatable output?) */
428 if (!config.make_executable && !force_make_executable)
430 if (trace_files)
431 einfo (_("%P: link errors found, deleting executable `%s'\n"),
432 output_filename);
434 /* The file will be removed by ld_cleanup. */
435 xexit (1);
437 else
439 if (! bfd_close (link_info.output_bfd))
440 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
442 /* If the --force-exe-suffix is enabled, and we're making an
443 executable file and it doesn't end in .exe, copy it to one
444 which does. */
445 if (! link_info.relocatable && command_line.force_exe_suffix)
447 int len = strlen (output_filename);
449 if (len < 4
450 || (strcasecmp (output_filename + len - 4, ".exe") != 0
451 && strcasecmp (output_filename + len - 4, ".dll") != 0))
453 FILE *src;
454 FILE *dst;
455 const int bsize = 4096;
456 char *buf = (char *) xmalloc (bsize);
457 int l;
458 char *dst_name = (char *) xmalloc (len + 5);
460 strcpy (dst_name, output_filename);
461 strcat (dst_name, ".exe");
462 src = fopen (output_filename, FOPEN_RB);
463 dst = fopen (dst_name, FOPEN_WB);
465 if (!src)
466 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
467 output_filename);
468 if (!dst)
469 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
470 dst_name);
471 while ((l = fread (buf, 1, bsize, src)) > 0)
473 int done = fwrite (buf, 1, l, dst);
475 if (done != l)
476 einfo (_("%P: Error writing file `%s'\n"), dst_name);
479 fclose (src);
480 if (fclose (dst) == EOF)
481 einfo (_("%P: Error closing file `%s'\n"), dst_name);
482 free (dst_name);
483 free (buf);
488 END_PROGRESS (program_name);
490 if (config.stats)
492 #ifdef HAVE_SBRK
493 char *lim = (char *) sbrk (0);
494 #endif
495 long run_time = get_run_time () - start_time;
497 fflush (stdout);
498 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
499 program_name, run_time / 1000000, run_time % 1000000);
500 #ifdef HAVE_SBRK
501 fprintf (stderr, _("%s: data size %ld\n"), program_name,
502 (long) (lim - (char *) &environ));
503 #endif
504 fflush (stderr);
507 /* Prevent ld_cleanup from doing anything, after a successful link. */
508 output_filename = NULL;
510 xexit (0);
511 return 0;
514 /* If the configured sysroot is relocatable, try relocating it based on
515 default prefix FROM. Return the relocated directory if it exists,
516 otherwise return null. */
518 static char *
519 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
521 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
522 char *path;
523 struct stat s;
525 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
526 if (path)
528 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
529 return path;
530 free (path);
532 #endif
533 return 0;
536 /* Return the sysroot directory. Return "" if no sysroot is being used. */
538 static const char *
539 get_sysroot (int argc, char **argv)
541 int i;
542 const char *path;
544 for (i = 1; i < argc; i++)
545 if (CONST_STRNEQ (argv[i], "--sysroot="))
546 return argv[i] + strlen ("--sysroot=");
548 path = get_relative_sysroot (BINDIR);
549 if (path)
550 return path;
552 path = get_relative_sysroot (TOOLBINDIR);
553 if (path)
554 return path;
556 return TARGET_SYSTEM_ROOT;
559 /* We need to find any explicitly given emulation in order to initialize the
560 state that's needed by the lex&yacc argument parser (parse_args). */
562 static char *
563 get_emulation (int argc, char **argv)
565 char *emulation;
566 int i;
568 emulation = getenv (EMULATION_ENVIRON);
569 if (emulation == NULL)
570 emulation = DEFAULT_EMULATION;
572 for (i = 1; i < argc; i++)
574 if (CONST_STRNEQ (argv[i], "-m"))
576 if (argv[i][2] == '\0')
578 /* -m EMUL */
579 if (i < argc - 1)
581 emulation = argv[i + 1];
582 i++;
584 else
585 einfo (_("%P%F: missing argument to -m\n"));
587 else if (strcmp (argv[i], "-mips1") == 0
588 || strcmp (argv[i], "-mips2") == 0
589 || strcmp (argv[i], "-mips3") == 0
590 || strcmp (argv[i], "-mips4") == 0
591 || strcmp (argv[i], "-mips5") == 0
592 || strcmp (argv[i], "-mips32") == 0
593 || strcmp (argv[i], "-mips32r2") == 0
594 || strcmp (argv[i], "-mips64") == 0
595 || strcmp (argv[i], "-mips64r2") == 0)
597 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
598 passed to the linker by some MIPS compilers. They
599 generally tell the linker to use a slightly different
600 library path. Perhaps someday these should be
601 implemented as emulations; until then, we just ignore
602 the arguments and hope that nobody ever creates
603 emulations named ips1, ips2 or ips3. */
605 else if (strcmp (argv[i], "-m486") == 0)
607 /* FIXME: The argument -m486 is passed to the linker on
608 some Linux systems. Hope that nobody creates an
609 emulation named 486. */
611 else
613 /* -mEMUL */
614 emulation = &argv[i][2];
619 return emulation;
622 void
623 add_ysym (const char *name)
625 if (link_info.notice_hash == NULL)
627 link_info.notice_hash =
628 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
629 if (!bfd_hash_table_init_n (link_info.notice_hash,
630 bfd_hash_newfunc,
631 sizeof (struct bfd_hash_entry),
632 61))
633 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
636 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
637 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
640 /* Record a symbol to be wrapped, from the --wrap option. */
642 void
643 add_wrap (const char *name)
645 if (link_info.wrap_hash == NULL)
647 link_info.wrap_hash =
648 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
649 if (!bfd_hash_table_init_n (link_info.wrap_hash,
650 bfd_hash_newfunc,
651 sizeof (struct bfd_hash_entry),
652 61))
653 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
656 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
657 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
660 /* Handle the -retain-symbols-file option. */
662 void
663 add_keepsyms_file (const char *filename)
665 FILE *file;
666 char *buf;
667 size_t bufsize;
668 int c;
670 if (link_info.strip == strip_some)
671 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
673 file = fopen (filename, "r");
674 if (file == NULL)
676 bfd_set_error (bfd_error_system_call);
677 einfo ("%X%P: %s: %E\n", filename);
678 return;
681 link_info.keep_hash = (struct bfd_hash_table *)
682 xmalloc (sizeof (struct bfd_hash_table));
683 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
684 sizeof (struct bfd_hash_entry)))
685 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
687 bufsize = 100;
688 buf = (char *) xmalloc (bufsize);
690 c = getc (file);
691 while (c != EOF)
693 while (ISSPACE (c))
694 c = getc (file);
696 if (c != EOF)
698 size_t len = 0;
700 while (! ISSPACE (c) && c != EOF)
702 buf[len] = c;
703 ++len;
704 if (len >= bufsize)
706 bufsize *= 2;
707 buf = (char *) xrealloc (buf, bufsize);
709 c = getc (file);
712 buf[len] = '\0';
714 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
715 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
719 if (link_info.strip != strip_none)
720 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
722 free (buf);
723 link_info.strip = strip_some;
726 /* Callbacks from the BFD linker routines. */
728 /* This is called when BFD has decided to include an archive member in
729 a link. */
731 static bfd_boolean
732 add_archive_element (struct bfd_link_info *info,
733 bfd *abfd,
734 const char *name,
735 bfd **subsbfd ATTRIBUTE_UNUSED)
737 lang_input_statement_type *input;
738 lang_input_statement_type orig_input;
740 input = (lang_input_statement_type *)
741 xcalloc (1, sizeof (lang_input_statement_type));
742 input->filename = abfd->filename;
743 input->local_sym_name = abfd->filename;
744 input->the_bfd = abfd;
746 /* Save the original data for trace files/tries below, as plugins
747 (if enabled) may possibly alter it to point to a replacement
748 BFD, but we still want to output the original BFD filename. */
749 orig_input = *input;
750 #ifdef ENABLE_PLUGINS
751 if (plugin_active_plugins_p () && !no_more_claiming)
753 /* We must offer this archive member to the plugins to claim. */
754 const char *filename = (bfd_my_archive (abfd) != NULL
755 ? bfd_my_archive (abfd)->filename : abfd->filename);
756 int fd = open (filename, O_RDONLY | O_BINARY);
757 if (fd >= 0)
759 struct ld_plugin_input_file file;
761 /* Offset and filesize must refer to the individual archive
762 member, not the whole file, and must exclude the header.
763 Fortunately for us, that is how the data is stored in the
764 origin field of the bfd and in the arelt_data. */
765 file.name = filename;
766 file.offset = abfd->origin;
767 file.filesize = arelt_size (abfd);
768 file.fd = fd;
769 plugin_maybe_claim (&file, input);
770 if (input->claimed)
772 input->claim_archive = TRUE;
773 *subsbfd = input->the_bfd;
777 #endif /* ENABLE_PLUGINS */
779 ldlang_add_file (input);
781 if (config.map_file != NULL)
783 static bfd_boolean header_printed;
784 struct bfd_link_hash_entry *h;
785 bfd *from;
786 int len;
788 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
790 if (h == NULL)
791 from = NULL;
792 else
794 switch (h->type)
796 default:
797 from = NULL;
798 break;
800 case bfd_link_hash_defined:
801 case bfd_link_hash_defweak:
802 from = h->u.def.section->owner;
803 break;
805 case bfd_link_hash_undefined:
806 case bfd_link_hash_undefweak:
807 from = h->u.undef.abfd;
808 break;
810 case bfd_link_hash_common:
811 from = h->u.c.p->section->owner;
812 break;
816 if (! header_printed)
818 char buf[100];
820 sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
821 minfo ("%s", buf);
822 header_printed = TRUE;
825 if (bfd_my_archive (abfd) == NULL)
827 minfo ("%s", bfd_get_filename (abfd));
828 len = strlen (bfd_get_filename (abfd));
830 else
832 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
833 bfd_get_filename (abfd));
834 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
835 + strlen (bfd_get_filename (abfd))
836 + 2);
839 if (len >= 29)
841 print_nl ();
842 len = 0;
844 while (len < 30)
846 print_space ();
847 ++len;
850 if (from != NULL)
851 minfo ("%B ", from);
852 if (h != NULL)
853 minfo ("(%T)\n", h->root.string);
854 else
855 minfo ("(%s)\n", name);
858 if (trace_files || trace_file_tries)
859 info_msg ("%I\n", &orig_input);
860 return TRUE;
863 /* This is called when BFD has discovered a symbol which is defined
864 multiple times. */
866 static bfd_boolean
867 multiple_definition (struct bfd_link_info *info,
868 struct bfd_link_hash_entry *h,
869 bfd *nbfd,
870 asection *nsec,
871 bfd_vma nval)
873 const char *name;
874 bfd *obfd;
875 asection *osec;
876 bfd_vma oval;
878 if (info->allow_multiple_definition)
879 return TRUE;
881 switch (h->type)
883 case bfd_link_hash_defined:
884 osec = h->u.def.section;
885 oval = h->u.def.value;
886 obfd = h->u.def.section->owner;
887 break;
888 case bfd_link_hash_indirect:
889 osec = bfd_ind_section_ptr;
890 oval = 0;
891 obfd = NULL;
892 break;
893 default:
894 abort ();
897 /* Ignore a redefinition of an absolute symbol to the
898 same value; it's harmless. */
899 if (h->type == bfd_link_hash_defined
900 && bfd_is_abs_section (osec)
901 && bfd_is_abs_section (nsec)
902 && nval == oval)
903 return TRUE;
905 /* If either section has the output_section field set to
906 bfd_abs_section_ptr, it means that the section is being
907 discarded, and this is not really a multiple definition at all.
908 FIXME: It would be cleaner to somehow ignore symbols defined in
909 sections which are being discarded. */
910 if ((osec->output_section != NULL
911 && ! bfd_is_abs_section (osec)
912 && bfd_is_abs_section (osec->output_section))
913 || (nsec->output_section != NULL
914 && ! bfd_is_abs_section (nsec)
915 && bfd_is_abs_section (nsec->output_section)))
916 return TRUE;
918 name = h->root.string;
919 if (nbfd == NULL)
921 nbfd = obfd;
922 nsec = osec;
923 nval = oval;
924 obfd = NULL;
926 einfo (_("%X%C: multiple definition of `%T'\n"),
927 nbfd, nsec, nval, name);
928 if (obfd != NULL)
929 einfo (_("%D: first defined here\n"), obfd, osec, oval);
931 if (RELAXATION_ENABLED)
933 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
934 command_line.disable_target_specific_optimizations = -1;
937 return TRUE;
940 /* This is called when there is a definition of a common symbol, or
941 when a common symbol is found for a symbol that is already defined,
942 or when two common symbols are found. We only do something if
943 -warn-common was used. */
945 static bfd_boolean
946 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
947 struct bfd_link_hash_entry *h,
948 bfd *nbfd,
949 enum bfd_link_hash_type ntype,
950 bfd_vma nsize)
952 const char *name;
953 bfd *obfd;
954 enum bfd_link_hash_type otype;
955 bfd_vma osize;
957 if (!config.warn_common)
958 return TRUE;
960 name = h->root.string;
961 otype = h->type;
962 if (otype == bfd_link_hash_common)
964 obfd = h->u.c.p->section->owner;
965 osize = h->u.c.size;
967 else if (otype == bfd_link_hash_defined
968 || otype == bfd_link_hash_defweak)
970 obfd = h->u.def.section->owner;
971 osize = 0;
973 else
975 /* FIXME: It would nice if we could report the BFD which defined
976 an indirect symbol, but we don't have anywhere to store the
977 information. */
978 obfd = NULL;
979 osize = 0;
982 if (ntype == bfd_link_hash_defined
983 || ntype == bfd_link_hash_defweak
984 || ntype == bfd_link_hash_indirect)
986 ASSERT (otype == bfd_link_hash_common);
987 einfo (_("%B: warning: definition of `%T' overriding common\n"),
988 nbfd, name);
989 if (obfd != NULL)
990 einfo (_("%B: warning: common is here\n"), obfd);
992 else if (otype == bfd_link_hash_defined
993 || otype == bfd_link_hash_defweak
994 || otype == bfd_link_hash_indirect)
996 ASSERT (ntype == bfd_link_hash_common);
997 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
998 nbfd, name);
999 if (obfd != NULL)
1000 einfo (_("%B: warning: defined here\n"), obfd);
1002 else
1004 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1005 if (osize > nsize)
1007 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1008 nbfd, name);
1009 if (obfd != NULL)
1010 einfo (_("%B: warning: larger common is here\n"), obfd);
1012 else if (nsize > osize)
1014 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1015 nbfd, name);
1016 if (obfd != NULL)
1017 einfo (_("%B: warning: smaller common is here\n"), obfd);
1019 else
1021 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1022 if (obfd != NULL)
1023 einfo (_("%B: warning: previous common is here\n"), obfd);
1027 return TRUE;
1030 /* This is called when BFD has discovered a set element. H is the
1031 entry in the linker hash table for the set. SECTION and VALUE
1032 represent a value which should be added to the set. */
1034 static bfd_boolean
1035 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1036 struct bfd_link_hash_entry *h,
1037 bfd_reloc_code_real_type reloc,
1038 bfd *abfd,
1039 asection *section,
1040 bfd_vma value)
1042 if (config.warn_constructors)
1043 einfo (_("%P: warning: global constructor %s used\n"),
1044 h->root.string);
1046 if (! config.build_constructors)
1047 return TRUE;
1049 ldctor_add_set_entry (h, reloc, NULL, section, value);
1051 if (h->type == bfd_link_hash_new)
1053 h->type = bfd_link_hash_undefined;
1054 h->u.undef.abfd = abfd;
1055 /* We don't call bfd_link_add_undef to add this to the list of
1056 undefined symbols because we are going to define it
1057 ourselves. */
1060 return TRUE;
1063 /* This is called when BFD has discovered a constructor. This is only
1064 called for some object file formats--those which do not handle
1065 constructors in some more clever fashion. This is similar to
1066 adding an element to a set, but less general. */
1068 static bfd_boolean
1069 constructor_callback (struct bfd_link_info *info,
1070 bfd_boolean constructor,
1071 const char *name,
1072 bfd *abfd,
1073 asection *section,
1074 bfd_vma value)
1076 char *s;
1077 struct bfd_link_hash_entry *h;
1078 char set_name[1 + sizeof "__CTOR_LIST__"];
1080 if (config.warn_constructors)
1081 einfo (_("%P: warning: global constructor %s used\n"), name);
1083 if (! config.build_constructors)
1084 return TRUE;
1086 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1087 useful error message. */
1088 if (bfd_reloc_type_lookup (link_info.output_bfd, BFD_RELOC_CTOR) == NULL
1089 && (info->relocatable
1090 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1091 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1093 s = set_name;
1094 if (bfd_get_symbol_leading_char (abfd) != '\0')
1095 *s++ = bfd_get_symbol_leading_char (abfd);
1096 if (constructor)
1097 strcpy (s, "__CTOR_LIST__");
1098 else
1099 strcpy (s, "__DTOR_LIST__");
1101 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1102 if (h == (struct bfd_link_hash_entry *) NULL)
1103 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1104 if (h->type == bfd_link_hash_new)
1106 h->type = bfd_link_hash_undefined;
1107 h->u.undef.abfd = abfd;
1108 /* We don't call bfd_link_add_undef to add this to the list of
1109 undefined symbols because we are going to define it
1110 ourselves. */
1113 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1114 return TRUE;
1117 /* A structure used by warning_callback to pass information through
1118 bfd_map_over_sections. */
1120 struct warning_callback_info
1122 bfd_boolean found;
1123 const char *warning;
1124 const char *symbol;
1125 asymbol **asymbols;
1128 /* This is called when there is a reference to a warning symbol. */
1130 static bfd_boolean
1131 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1132 const char *warning,
1133 const char *symbol,
1134 bfd *abfd,
1135 asection *section,
1136 bfd_vma address)
1138 /* This is a hack to support warn_multiple_gp. FIXME: This should
1139 have a cleaner interface, but what? */
1140 if (! config.warn_multiple_gp
1141 && strcmp (warning, "using multiple gp values") == 0)
1142 return TRUE;
1144 if (section != NULL)
1145 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1146 else if (abfd == NULL)
1147 einfo ("%P: %s%s\n", _("warning: "), warning);
1148 else if (symbol == NULL)
1149 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1150 else
1152 struct warning_callback_info cinfo;
1154 /* Look through the relocs to see if we can find a plausible
1155 address. */
1157 if (!bfd_generic_link_read_symbols (abfd))
1158 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1160 cinfo.found = FALSE;
1161 cinfo.warning = warning;
1162 cinfo.symbol = symbol;
1163 cinfo.asymbols = bfd_get_outsymbols (abfd);
1164 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1166 if (! cinfo.found)
1167 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1170 return TRUE;
1173 /* This is called by warning_callback for each section. It checks the
1174 relocs of the section to see if it can find a reference to the
1175 symbol which triggered the warning. If it can, it uses the reloc
1176 to give an error message with a file and line number. */
1178 static void
1179 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1181 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1182 long relsize;
1183 arelent **relpp;
1184 long relcount;
1185 arelent **p, **pend;
1187 if (info->found)
1188 return;
1190 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1191 if (relsize < 0)
1192 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1193 if (relsize == 0)
1194 return;
1196 relpp = (arelent **) xmalloc (relsize);
1197 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1198 if (relcount < 0)
1199 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1201 p = relpp;
1202 pend = p + relcount;
1203 for (; p < pend && *p != NULL; p++)
1205 arelent *q = *p;
1207 if (q->sym_ptr_ptr != NULL
1208 && *q->sym_ptr_ptr != NULL
1209 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1211 /* We found a reloc for the symbol we are looking for. */
1212 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1213 info->warning);
1214 info->found = TRUE;
1215 break;
1219 free (relpp);
1222 /* This is called when an undefined symbol is found. */
1224 static bfd_boolean
1225 undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1226 const char *name,
1227 bfd *abfd,
1228 asection *section,
1229 bfd_vma address,
1230 bfd_boolean error)
1232 static char *error_name;
1233 static unsigned int error_count;
1235 #define MAX_ERRORS_IN_A_ROW 5
1237 if (config.warn_once)
1239 static struct bfd_hash_table *hash;
1241 /* Only warn once about a particular undefined symbol. */
1242 if (hash == NULL)
1244 hash = (struct bfd_hash_table *)
1245 xmalloc (sizeof (struct bfd_hash_table));
1246 if (!bfd_hash_table_init (hash, bfd_hash_newfunc,
1247 sizeof (struct bfd_hash_entry)))
1248 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1251 if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1252 return TRUE;
1254 if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1255 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1258 /* We never print more than a reasonable number of errors in a row
1259 for a single symbol. */
1260 if (error_name != NULL
1261 && strcmp (name, error_name) == 0)
1262 ++error_count;
1263 else
1265 error_count = 0;
1266 if (error_name != NULL)
1267 free (error_name);
1268 error_name = xstrdup (name);
1271 if (section != NULL)
1273 if (error_count < MAX_ERRORS_IN_A_ROW)
1275 if (error)
1276 einfo (_("%X%C: undefined reference to `%T'\n"),
1277 abfd, section, address, name);
1278 else
1279 einfo (_("%C: warning: undefined reference to `%T'\n"),
1280 abfd, section, address, name);
1282 else if (error_count == MAX_ERRORS_IN_A_ROW)
1284 if (error)
1285 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1286 abfd, section, address, name);
1287 else
1288 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1289 abfd, section, address, name);
1291 else if (error)
1292 einfo ("%X");
1294 else
1296 if (error_count < MAX_ERRORS_IN_A_ROW)
1298 if (error)
1299 einfo (_("%X%B: undefined reference to `%T'\n"),
1300 abfd, name);
1301 else
1302 einfo (_("%B: warning: undefined reference to `%T'\n"),
1303 abfd, name);
1305 else if (error_count == MAX_ERRORS_IN_A_ROW)
1307 if (error)
1308 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1309 abfd, name);
1310 else
1311 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1312 abfd, name);
1314 else if (error)
1315 einfo ("%X");
1318 return TRUE;
1321 /* Counter to limit the number of relocation overflow error messages
1322 to print. Errors are printed as it is decremented. When it's
1323 called and the counter is zero, a final message is printed
1324 indicating more relocations were omitted. When it gets to -1, no
1325 such errors are printed. If it's initially set to a value less
1326 than -1, all such errors will be printed (--verbose does this). */
1328 int overflow_cutoff_limit = 10;
1330 /* This is called when a reloc overflows. */
1332 static bfd_boolean
1333 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1334 struct bfd_link_hash_entry *entry,
1335 const char *name,
1336 const char *reloc_name,
1337 bfd_vma addend,
1338 bfd *abfd,
1339 asection *section,
1340 bfd_vma address)
1342 if (overflow_cutoff_limit == -1)
1343 return TRUE;
1345 einfo ("%X%H:", abfd, section, address);
1347 if (overflow_cutoff_limit >= 0
1348 && overflow_cutoff_limit-- == 0)
1350 einfo (_(" additional relocation overflows omitted from the output\n"));
1351 return TRUE;
1354 if (entry)
1356 while (entry->type == bfd_link_hash_indirect
1357 || entry->type == bfd_link_hash_warning)
1358 entry = entry->u.i.link;
1359 switch (entry->type)
1361 case bfd_link_hash_undefined:
1362 case bfd_link_hash_undefweak:
1363 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1364 reloc_name, entry->root.string);
1365 break;
1366 case bfd_link_hash_defined:
1367 case bfd_link_hash_defweak:
1368 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1369 reloc_name, entry->root.string,
1370 entry->u.def.section,
1371 entry->u.def.section == bfd_abs_section_ptr
1372 ? link_info.output_bfd : entry->u.def.section->owner);
1373 break;
1374 default:
1375 abort ();
1376 break;
1379 else
1380 einfo (_(" relocation truncated to fit: %s against `%T'"),
1381 reloc_name, name);
1382 if (addend != 0)
1383 einfo ("+%v", addend);
1384 einfo ("\n");
1385 return TRUE;
1388 /* This is called when a dangerous relocation is made. */
1390 static bfd_boolean
1391 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1392 const char *message,
1393 bfd *abfd,
1394 asection *section,
1395 bfd_vma address)
1397 einfo (_("%X%H: dangerous relocation: %s\n"),
1398 abfd, section, address, message);
1399 return TRUE;
1402 /* This is called when a reloc is being generated attached to a symbol
1403 that is not being output. */
1405 static bfd_boolean
1406 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1407 const char *name,
1408 bfd *abfd,
1409 asection *section,
1410 bfd_vma address)
1412 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1413 abfd, section, address, name);
1414 return TRUE;
1417 /* This is called if link_info.notice_all is set, or when a symbol in
1418 link_info.notice_hash is found. Symbols are put in notice_hash
1419 using the -y option, while notice_all is set if the --cref option
1420 has been supplied, or if there are any NOCROSSREFS sections in the
1421 linker script; and if plugins are active, since they need to monitor
1422 all references from non-IR files. */
1424 static bfd_boolean
1425 notice (struct bfd_link_info *info,
1426 struct bfd_link_hash_entry *h,
1427 bfd *abfd,
1428 asection *section,
1429 bfd_vma value,
1430 flagword flags ATTRIBUTE_UNUSED,
1431 const char *string ATTRIBUTE_UNUSED)
1433 const char *name;
1435 if (h == NULL)
1437 if (command_line.cref || nocrossref_list != NULL)
1438 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1439 return TRUE;
1442 name = h->root.string;
1443 if (info->notice_hash != NULL
1444 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1446 if (bfd_is_und_section (section))
1447 einfo ("%B: reference to %s\n", abfd, name);
1448 else
1449 einfo ("%B: definition of %s\n", abfd, name);
1452 if (command_line.cref || nocrossref_list != NULL)
1453 add_cref (name, abfd, section, value);
1455 return TRUE;