daily update
[binutils.git] / ld / ldmain.c
blob04b56335e87cff50f130309b8053fde151f0b650
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
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 = TRUE;
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 *, const char *, bfd *, asection *, bfd_vma,
127 bfd *, asection *, bfd_vma);
128 static bfd_boolean multiple_common
129 (struct bfd_link_info *, const char *, bfd *, enum bfd_link_hash_type,
130 bfd_vma, 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 *, const char *, bfd *, asection *, bfd_vma);
155 static struct bfd_link_callbacks link_callbacks =
157 add_archive_element,
158 multiple_definition,
159 multiple_common,
160 add_to_set,
161 constructor_callback,
162 warning_callback,
163 undefined_symbol,
164 reloc_overflow,
165 reloc_dangerous,
166 unattached_reloc,
167 notice,
168 einfo,
169 info_msg,
170 minfo,
171 ldlang_override_segment_assignment
174 struct bfd_link_info link_info;
176 static void
177 remove_output (void)
179 if (output_filename)
181 if (link_info.output_bfd)
182 bfd_cache_close (link_info.output_bfd);
183 if (delete_output_file_on_failure)
184 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 (remove_output);
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 ldemul_set_symbols ();
302 if (link_info.relocatable)
304 if (command_line.check_section_addresses < 0)
305 command_line.check_section_addresses = 0;
306 if (link_info.shared)
307 einfo (_("%P%F: -r and -shared may not be used together\n"));
310 /* We may have -Bsymbolic, -Bsymbolic-functions, --dynamic-list-data,
311 --dynamic-list-cpp-new, --dynamic-list-cpp-typeinfo and
312 --dynamic-list FILE. -Bsymbolic and -Bsymbolic-functions are
313 for shared libraries. -Bsymbolic overrides all others and vice
314 versa. */
315 switch (command_line.symbolic)
317 case symbolic_unset:
318 break;
319 case symbolic:
320 /* -Bsymbolic is for shared library only. */
321 if (link_info.shared)
323 link_info.symbolic = TRUE;
324 /* Should we free the unused memory? */
325 link_info.dynamic_list = NULL;
326 command_line.dynamic_list = dynamic_list_unset;
328 break;
329 case symbolic_functions:
330 /* -Bsymbolic-functions is for shared library only. */
331 if (link_info.shared)
332 command_line.dynamic_list = dynamic_list_data;
333 break;
336 switch (command_line.dynamic_list)
338 case dynamic_list_unset:
339 break;
340 case dynamic_list_data:
341 link_info.dynamic_data = TRUE;
342 case dynamic_list:
343 link_info.dynamic = TRUE;
344 break;
347 if (! link_info.shared)
349 if (command_line.filter_shlib)
350 einfo (_("%P%F: -F may not be used without -shared\n"));
351 if (command_line.auxiliary_filters)
352 einfo (_("%P%F: -f may not be used without -shared\n"));
355 if (! link_info.shared || link_info.pie)
356 link_info.executable = TRUE;
358 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
359 don't see how else this can be handled, since in this case we
360 must preserve all externally visible symbols. */
361 if (link_info.relocatable && link_info.strip == strip_all)
363 link_info.strip = strip_debugger;
364 if (link_info.discard == discard_sec_merge)
365 link_info.discard = discard_all;
368 /* If we have not already opened and parsed a linker script,
369 try the default script from command line first. */
370 if (saved_script_handle == NULL
371 && command_line.default_script != NULL)
373 ldfile_open_command_file (command_line.default_script);
374 parser_input = input_script;
375 yyparse ();
378 /* If we have not already opened and parsed a linker script
379 read the emulation's appropriate default script. */
380 if (saved_script_handle == NULL)
382 int isfile;
383 char *s = ldemul_get_script (&isfile);
385 if (isfile)
386 ldfile_open_default_command_file (s);
387 else
389 lex_string = s;
390 lex_redirect (s);
392 parser_input = input_script;
393 yyparse ();
394 lex_string = NULL;
397 if (trace_file_tries)
399 if (saved_script_handle)
400 info_msg (_("using external linker script:"));
401 else
402 info_msg (_("using internal linker script:"));
403 info_msg ("\n==================================================\n");
405 if (saved_script_handle)
407 static const int ld_bufsz = 8193;
408 size_t n;
409 char *buf = (char *) xmalloc (ld_bufsz);
411 rewind (saved_script_handle);
412 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
414 buf[n] = 0;
415 info_msg (buf);
417 rewind (saved_script_handle);
418 free (buf);
420 else
422 int isfile;
424 info_msg (ldemul_get_script (&isfile));
427 info_msg ("\n==================================================\n");
430 lang_final ();
432 if (!lang_has_input_file)
434 if (version_printed)
435 xexit (0);
436 einfo (_("%P%F: no input files\n"));
439 if (trace_files)
440 info_msg (_("%P: mode %s\n"), emulation);
442 ldemul_after_parse ();
444 if (config.map_filename)
446 if (strcmp (config.map_filename, "-") == 0)
448 config.map_file = stdout;
450 else
452 config.map_file = fopen (config.map_filename, FOPEN_WT);
453 if (config.map_file == (FILE *) NULL)
455 bfd_set_error (bfd_error_system_call);
456 einfo (_("%P%F: cannot open map file %s: %E\n"),
457 config.map_filename);
462 lang_process ();
464 /* Print error messages for any missing symbols, for any warning
465 symbols, and possibly multiple definitions. */
466 if (link_info.relocatable)
467 link_info.output_bfd->flags &= ~EXEC_P;
468 else
469 link_info.output_bfd->flags |= EXEC_P;
471 ldwrite ();
473 if (config.map_file != NULL)
474 lang_map ();
475 if (command_line.cref)
476 output_cref (config.map_file != NULL ? config.map_file : stdout);
477 if (nocrossref_list != NULL)
478 check_nocrossrefs ();
480 lang_finish ();
482 #ifdef ENABLE_PLUGINS
483 /* Now everything is finished, we can tell the plugins to clean up. */
484 if (plugin_call_cleanup ())
485 info_msg (_("%P: %s: error in plugin cleanup (ignored)\n"), plugin_error_plugin ());
486 #endif /* ENABLE_PLUGINS */
488 /* Even if we're producing relocatable output, some non-fatal errors should
489 be reported in the exit status. (What non-fatal errors, if any, do we
490 want to ignore for relocatable output?) */
491 if (!config.make_executable && !force_make_executable)
493 if (trace_files)
494 einfo (_("%P: link errors found, deleting executable `%s'\n"),
495 output_filename);
497 /* The file will be removed by remove_output. */
498 xexit (1);
500 else
502 if (! bfd_close (link_info.output_bfd))
503 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
505 /* If the --force-exe-suffix is enabled, and we're making an
506 executable file and it doesn't end in .exe, copy it to one
507 which does. */
508 if (! link_info.relocatable && command_line.force_exe_suffix)
510 int len = strlen (output_filename);
512 if (len < 4
513 || (strcasecmp (output_filename + len - 4, ".exe") != 0
514 && strcasecmp (output_filename + len - 4, ".dll") != 0))
516 FILE *src;
517 FILE *dst;
518 const int bsize = 4096;
519 char *buf = (char *) xmalloc (bsize);
520 int l;
521 char *dst_name = (char *) xmalloc (len + 5);
523 strcpy (dst_name, output_filename);
524 strcat (dst_name, ".exe");
525 src = fopen (output_filename, FOPEN_RB);
526 dst = fopen (dst_name, FOPEN_WB);
528 if (!src)
529 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
530 output_filename);
531 if (!dst)
532 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
533 dst_name);
534 while ((l = fread (buf, 1, bsize, src)) > 0)
536 int done = fwrite (buf, 1, l, dst);
538 if (done != l)
539 einfo (_("%P: Error writing file `%s'\n"), dst_name);
542 fclose (src);
543 if (fclose (dst) == EOF)
544 einfo (_("%P: Error closing file `%s'\n"), dst_name);
545 free (dst_name);
546 free (buf);
551 END_PROGRESS (program_name);
553 if (config.stats)
555 #ifdef HAVE_SBRK
556 char *lim = (char *) sbrk (0);
557 #endif
558 long run_time = get_run_time () - start_time;
560 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
561 program_name, run_time / 1000000, run_time % 1000000);
562 #ifdef HAVE_SBRK
563 fprintf (stderr, _("%s: data size %ld\n"), program_name,
564 (long) (lim - (char *) &environ));
565 #endif
568 /* Prevent remove_output from doing anything, after a successful link. */
569 output_filename = NULL;
571 xexit (0);
572 return 0;
575 /* If the configured sysroot is relocatable, try relocating it based on
576 default prefix FROM. Return the relocated directory if it exists,
577 otherwise return null. */
579 static char *
580 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
582 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
583 char *path;
584 struct stat s;
586 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
587 if (path)
589 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
590 return path;
591 free (path);
593 #endif
594 return 0;
597 /* Return the sysroot directory. Return "" if no sysroot is being used. */
599 static const char *
600 get_sysroot (int argc, char **argv)
602 int i;
603 const char *path;
605 for (i = 1; i < argc; i++)
606 if (CONST_STRNEQ (argv[i], "--sysroot="))
607 return argv[i] + strlen ("--sysroot=");
609 path = get_relative_sysroot (BINDIR);
610 if (path)
611 return path;
613 path = get_relative_sysroot (TOOLBINDIR);
614 if (path)
615 return path;
617 return TARGET_SYSTEM_ROOT;
620 /* We need to find any explicitly given emulation in order to initialize the
621 state that's needed by the lex&yacc argument parser (parse_args). */
623 static char *
624 get_emulation (int argc, char **argv)
626 char *emulation;
627 int i;
629 emulation = getenv (EMULATION_ENVIRON);
630 if (emulation == NULL)
631 emulation = DEFAULT_EMULATION;
633 for (i = 1; i < argc; i++)
635 if (CONST_STRNEQ (argv[i], "-m"))
637 if (argv[i][2] == '\0')
639 /* -m EMUL */
640 if (i < argc - 1)
642 emulation = argv[i + 1];
643 i++;
645 else
646 einfo (_("%P%F: missing argument to -m\n"));
648 else if (strcmp (argv[i], "-mips1") == 0
649 || strcmp (argv[i], "-mips2") == 0
650 || strcmp (argv[i], "-mips3") == 0
651 || strcmp (argv[i], "-mips4") == 0
652 || strcmp (argv[i], "-mips5") == 0
653 || strcmp (argv[i], "-mips32") == 0
654 || strcmp (argv[i], "-mips32r2") == 0
655 || strcmp (argv[i], "-mips64") == 0
656 || strcmp (argv[i], "-mips64r2") == 0)
658 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
659 passed to the linker by some MIPS compilers. They
660 generally tell the linker to use a slightly different
661 library path. Perhaps someday these should be
662 implemented as emulations; until then, we just ignore
663 the arguments and hope that nobody ever creates
664 emulations named ips1, ips2 or ips3. */
666 else if (strcmp (argv[i], "-m486") == 0)
668 /* FIXME: The argument -m486 is passed to the linker on
669 some Linux systems. Hope that nobody creates an
670 emulation named 486. */
672 else
674 /* -mEMUL */
675 emulation = &argv[i][2];
680 return emulation;
683 void
684 add_ysym (const char *name)
686 if (link_info.notice_hash == NULL)
688 link_info.notice_hash =
689 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
690 if (!bfd_hash_table_init_n (link_info.notice_hash,
691 bfd_hash_newfunc,
692 sizeof (struct bfd_hash_entry),
693 61))
694 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
697 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
698 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
701 /* Record a symbol to be wrapped, from the --wrap option. */
703 void
704 add_wrap (const char *name)
706 if (link_info.wrap_hash == NULL)
708 link_info.wrap_hash =
709 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
710 if (!bfd_hash_table_init_n (link_info.wrap_hash,
711 bfd_hash_newfunc,
712 sizeof (struct bfd_hash_entry),
713 61))
714 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
717 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
718 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
721 /* Handle the -retain-symbols-file option. */
723 void
724 add_keepsyms_file (const char *filename)
726 FILE *file;
727 char *buf;
728 size_t bufsize;
729 int c;
731 if (link_info.strip == strip_some)
732 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
734 file = fopen (filename, "r");
735 if (file == NULL)
737 bfd_set_error (bfd_error_system_call);
738 einfo ("%X%P: %s: %E\n", filename);
739 return;
742 link_info.keep_hash = (struct bfd_hash_table *)
743 xmalloc (sizeof (struct bfd_hash_table));
744 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
745 sizeof (struct bfd_hash_entry)))
746 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
748 bufsize = 100;
749 buf = (char *) xmalloc (bufsize);
751 c = getc (file);
752 while (c != EOF)
754 while (ISSPACE (c))
755 c = getc (file);
757 if (c != EOF)
759 size_t len = 0;
761 while (! ISSPACE (c) && c != EOF)
763 buf[len] = c;
764 ++len;
765 if (len >= bufsize)
767 bufsize *= 2;
768 buf = (char *) xrealloc (buf, bufsize);
770 c = getc (file);
773 buf[len] = '\0';
775 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
776 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
780 if (link_info.strip != strip_none)
781 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
783 free (buf);
784 link_info.strip = strip_some;
787 /* Callbacks from the BFD linker routines. */
789 /* This is called when BFD has decided to include an archive member in
790 a link. */
792 static bfd_boolean
793 add_archive_element (struct bfd_link_info *info,
794 bfd *abfd,
795 const char *name,
796 bfd **subsbfd ATTRIBUTE_UNUSED)
798 lang_input_statement_type *input;
799 lang_input_statement_type orig_input;
801 input = (lang_input_statement_type *)
802 xcalloc (1, sizeof (lang_input_statement_type));
803 input->filename = abfd->filename;
804 input->local_sym_name = abfd->filename;
805 input->the_bfd = abfd;
807 /* Save the original data for trace files/tries below, as plugins
808 (if enabled) may possibly alter it to point to a replacement
809 BFD, but we still want to output the original BFD filename. */
810 orig_input = *input;
811 #ifdef ENABLE_PLUGINS
812 if (bfd_my_archive (abfd) != NULL)
814 /* We must offer this archive member to the plugins to claim. */
815 int fd = open (bfd_my_archive (abfd)->filename, O_RDONLY | O_BINARY);
816 if (fd >= 0)
818 struct ld_plugin_input_file file;
819 int claimed = 0;
820 /* Offset and filesize must refer to the individual archive
821 member, not the whole file, and must exclude the header.
822 Fortunately for us, that is how the data is stored in the
823 origin field of the bfd and in the arelt_data. */
824 file.name = bfd_my_archive (abfd)->filename;
825 file.offset = abfd->origin;
826 file.filesize = arelt_size (abfd);
827 file.fd = fd;
828 /* We create a dummy BFD, initially empty, to house
829 whatever symbols the plugin may want to add. */
830 file.handle = plugin_get_ir_dummy_bfd (abfd->filename, abfd);
831 if (plugin_call_claim_file (&file, &claimed))
832 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
833 plugin_error_plugin ());
834 if (claimed)
836 /* Substitute the dummy BFD. */
837 input->the_bfd = file.handle;
838 input->claimed = TRUE;
839 bfd_make_readable (input->the_bfd);
840 *subsbfd = input->the_bfd;
842 else
844 /* Abandon the dummy BFD. */
845 bfd_close_all_done (file.handle);
846 close (fd);
847 input->claimed = FALSE;
851 #endif /* ENABLE_PLUGINS */
853 ldlang_add_file (input);
855 if (config.map_file != NULL)
857 static bfd_boolean header_printed;
858 struct bfd_link_hash_entry *h;
859 bfd *from;
860 int len;
862 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
864 if (h == NULL)
865 from = NULL;
866 else
868 switch (h->type)
870 default:
871 from = NULL;
872 break;
874 case bfd_link_hash_defined:
875 case bfd_link_hash_defweak:
876 from = h->u.def.section->owner;
877 break;
879 case bfd_link_hash_undefined:
880 case bfd_link_hash_undefweak:
881 from = h->u.undef.abfd;
882 break;
884 case bfd_link_hash_common:
885 from = h->u.c.p->section->owner;
886 break;
890 if (! header_printed)
892 char buf[100];
894 sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
895 minfo ("%s", buf);
896 header_printed = TRUE;
899 if (bfd_my_archive (abfd) == NULL)
901 minfo ("%s", bfd_get_filename (abfd));
902 len = strlen (bfd_get_filename (abfd));
904 else
906 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
907 bfd_get_filename (abfd));
908 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
909 + strlen (bfd_get_filename (abfd))
910 + 2);
913 if (len >= 29)
915 print_nl ();
916 len = 0;
918 while (len < 30)
920 print_space ();
921 ++len;
924 if (from != NULL)
925 minfo ("%B ", from);
926 if (h != NULL)
927 minfo ("(%T)\n", h->root.string);
928 else
929 minfo ("(%s)\n", name);
932 if (trace_files || trace_file_tries)
933 info_msg ("%I\n", &orig_input);
934 return TRUE;
937 /* This is called when BFD has discovered a symbol which is defined
938 multiple times. */
940 static bfd_boolean
941 multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
942 const char *name,
943 bfd *obfd,
944 asection *osec,
945 bfd_vma oval,
946 bfd *nbfd,
947 asection *nsec,
948 bfd_vma nval)
950 #ifdef ENABLE_PLUGINS
951 /* We may get called back even when --allow-multiple-definition is in
952 effect, as the plugin infrastructure needs to use this hook in
953 order to swap out IR-only symbols for real ones. In that case,
954 it will let us know not to continue by returning TRUE even if this
955 is not an IR-only vs. non-IR symbol conflict. */
956 if (plugin_multiple_definition (info, name, obfd, osec, oval, nbfd,
957 nsec, nval))
958 return TRUE;
959 #endif /* ENABLE_PLUGINS */
961 /* If either section has the output_section field set to
962 bfd_abs_section_ptr, it means that the section is being
963 discarded, and this is not really a multiple definition at all.
964 FIXME: It would be cleaner to somehow ignore symbols defined in
965 sections which are being discarded. */
966 if ((osec->output_section != NULL
967 && ! bfd_is_abs_section (osec)
968 && bfd_is_abs_section (osec->output_section))
969 || (nsec->output_section != NULL
970 && ! bfd_is_abs_section (nsec)
971 && bfd_is_abs_section (nsec->output_section)))
972 return TRUE;
974 einfo (_("%X%C: multiple definition of `%T'\n"),
975 nbfd, nsec, nval, name);
976 if (obfd != NULL)
977 einfo (_("%D: first defined here\n"), obfd, osec, oval);
979 if (RELAXATION_ENABLED)
981 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
982 command_line.disable_target_specific_optimizations = -1;
985 return TRUE;
988 /* This is called when there is a definition of a common symbol, or
989 when a common symbol is found for a symbol that is already defined,
990 or when two common symbols are found. We only do something if
991 -warn-common was used. */
993 static bfd_boolean
994 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
995 const char *name,
996 bfd *obfd,
997 enum bfd_link_hash_type otype,
998 bfd_vma osize,
999 bfd *nbfd,
1000 enum bfd_link_hash_type ntype,
1001 bfd_vma nsize)
1003 if (! config.warn_common)
1004 return TRUE;
1006 if (ntype == bfd_link_hash_defined
1007 || ntype == bfd_link_hash_defweak
1008 || ntype == bfd_link_hash_indirect)
1010 ASSERT (otype == bfd_link_hash_common);
1011 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1012 nbfd, name);
1013 if (obfd != NULL)
1014 einfo (_("%B: warning: common is here\n"), obfd);
1016 else if (otype == bfd_link_hash_defined
1017 || otype == bfd_link_hash_defweak
1018 || otype == bfd_link_hash_indirect)
1020 ASSERT (ntype == bfd_link_hash_common);
1021 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1022 nbfd, name);
1023 if (obfd != NULL)
1024 einfo (_("%B: warning: defined here\n"), obfd);
1026 else
1028 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1029 if (osize > nsize)
1031 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1032 nbfd, name);
1033 if (obfd != NULL)
1034 einfo (_("%B: warning: larger common is here\n"), obfd);
1036 else if (nsize > osize)
1038 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1039 nbfd, name);
1040 if (obfd != NULL)
1041 einfo (_("%B: warning: smaller common is here\n"), obfd);
1043 else
1045 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1046 if (obfd != NULL)
1047 einfo (_("%B: warning: previous common is here\n"), obfd);
1051 return TRUE;
1054 /* This is called when BFD has discovered a set element. H is the
1055 entry in the linker hash table for the set. SECTION and VALUE
1056 represent a value which should be added to the set. */
1058 static bfd_boolean
1059 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1060 struct bfd_link_hash_entry *h,
1061 bfd_reloc_code_real_type reloc,
1062 bfd *abfd,
1063 asection *section,
1064 bfd_vma value)
1066 if (config.warn_constructors)
1067 einfo (_("%P: warning: global constructor %s used\n"),
1068 h->root.string);
1070 if (! config.build_constructors)
1071 return TRUE;
1073 ldctor_add_set_entry (h, reloc, NULL, section, value);
1075 if (h->type == bfd_link_hash_new)
1077 h->type = bfd_link_hash_undefined;
1078 h->u.undef.abfd = abfd;
1079 /* We don't call bfd_link_add_undef to add this to the list of
1080 undefined symbols because we are going to define it
1081 ourselves. */
1084 return TRUE;
1087 /* This is called when BFD has discovered a constructor. This is only
1088 called for some object file formats--those which do not handle
1089 constructors in some more clever fashion. This is similar to
1090 adding an element to a set, but less general. */
1092 static bfd_boolean
1093 constructor_callback (struct bfd_link_info *info,
1094 bfd_boolean constructor,
1095 const char *name,
1096 bfd *abfd,
1097 asection *section,
1098 bfd_vma value)
1100 char *s;
1101 struct bfd_link_hash_entry *h;
1102 char set_name[1 + sizeof "__CTOR_LIST__"];
1104 if (config.warn_constructors)
1105 einfo (_("%P: warning: global constructor %s used\n"), name);
1107 if (! config.build_constructors)
1108 return TRUE;
1110 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1111 useful error message. */
1112 if (bfd_reloc_type_lookup (link_info.output_bfd, BFD_RELOC_CTOR) == NULL
1113 && (info->relocatable
1114 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1115 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1117 s = set_name;
1118 if (bfd_get_symbol_leading_char (abfd) != '\0')
1119 *s++ = bfd_get_symbol_leading_char (abfd);
1120 if (constructor)
1121 strcpy (s, "__CTOR_LIST__");
1122 else
1123 strcpy (s, "__DTOR_LIST__");
1125 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1126 if (h == (struct bfd_link_hash_entry *) NULL)
1127 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1128 if (h->type == bfd_link_hash_new)
1130 h->type = bfd_link_hash_undefined;
1131 h->u.undef.abfd = abfd;
1132 /* We don't call bfd_link_add_undef to add this to the list of
1133 undefined symbols because we are going to define it
1134 ourselves. */
1137 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1138 return TRUE;
1141 /* A structure used by warning_callback to pass information through
1142 bfd_map_over_sections. */
1144 struct warning_callback_info
1146 bfd_boolean found;
1147 const char *warning;
1148 const char *symbol;
1149 asymbol **asymbols;
1152 /* This is called when there is a reference to a warning symbol. */
1154 static bfd_boolean
1155 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1156 const char *warning,
1157 const char *symbol,
1158 bfd *abfd,
1159 asection *section,
1160 bfd_vma address)
1162 /* This is a hack to support warn_multiple_gp. FIXME: This should
1163 have a cleaner interface, but what? */
1164 if (! config.warn_multiple_gp
1165 && strcmp (warning, "using multiple gp values") == 0)
1166 return TRUE;
1168 if (section != NULL)
1169 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1170 else if (abfd == NULL)
1171 einfo ("%P: %s%s\n", _("warning: "), warning);
1172 else if (symbol == NULL)
1173 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1174 else
1176 struct warning_callback_info cinfo;
1178 /* Look through the relocs to see if we can find a plausible
1179 address. */
1181 if (!bfd_generic_link_read_symbols (abfd))
1182 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1184 cinfo.found = FALSE;
1185 cinfo.warning = warning;
1186 cinfo.symbol = symbol;
1187 cinfo.asymbols = bfd_get_outsymbols (abfd);
1188 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1190 if (! cinfo.found)
1191 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1194 return TRUE;
1197 /* This is called by warning_callback for each section. It checks the
1198 relocs of the section to see if it can find a reference to the
1199 symbol which triggered the warning. If it can, it uses the reloc
1200 to give an error message with a file and line number. */
1202 static void
1203 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1205 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1206 long relsize;
1207 arelent **relpp;
1208 long relcount;
1209 arelent **p, **pend;
1211 if (info->found)
1212 return;
1214 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1215 if (relsize < 0)
1216 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1217 if (relsize == 0)
1218 return;
1220 relpp = (arelent **) xmalloc (relsize);
1221 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1222 if (relcount < 0)
1223 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1225 p = relpp;
1226 pend = p + relcount;
1227 for (; p < pend && *p != NULL; p++)
1229 arelent *q = *p;
1231 if (q->sym_ptr_ptr != NULL
1232 && *q->sym_ptr_ptr != NULL
1233 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1235 /* We found a reloc for the symbol we are looking for. */
1236 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1237 info->warning);
1238 info->found = TRUE;
1239 break;
1243 free (relpp);
1246 /* This is called when an undefined symbol is found. */
1248 static bfd_boolean
1249 undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1250 const char *name,
1251 bfd *abfd,
1252 asection *section,
1253 bfd_vma address,
1254 bfd_boolean error)
1256 static char *error_name;
1257 static unsigned int error_count;
1259 #define MAX_ERRORS_IN_A_ROW 5
1261 if (config.warn_once)
1263 static struct bfd_hash_table *hash;
1265 /* Only warn once about a particular undefined symbol. */
1266 if (hash == NULL)
1268 hash = (struct bfd_hash_table *)
1269 xmalloc (sizeof (struct bfd_hash_table));
1270 if (!bfd_hash_table_init (hash, bfd_hash_newfunc,
1271 sizeof (struct bfd_hash_entry)))
1272 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1275 if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1276 return TRUE;
1278 if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1279 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1282 /* We never print more than a reasonable number of errors in a row
1283 for a single symbol. */
1284 if (error_name != NULL
1285 && strcmp (name, error_name) == 0)
1286 ++error_count;
1287 else
1289 error_count = 0;
1290 if (error_name != NULL)
1291 free (error_name);
1292 error_name = xstrdup (name);
1295 if (section != NULL)
1297 if (error_count < MAX_ERRORS_IN_A_ROW)
1299 if (error)
1300 einfo (_("%X%C: undefined reference to `%T'\n"),
1301 abfd, section, address, name);
1302 else
1303 einfo (_("%C: warning: undefined reference to `%T'\n"),
1304 abfd, section, address, name);
1306 else if (error_count == MAX_ERRORS_IN_A_ROW)
1308 if (error)
1309 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1310 abfd, section, address, name);
1311 else
1312 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1313 abfd, section, address, name);
1315 else if (error)
1316 einfo ("%X");
1318 else
1320 if (error_count < MAX_ERRORS_IN_A_ROW)
1322 if (error)
1323 einfo (_("%X%B: undefined reference to `%T'\n"),
1324 abfd, name);
1325 else
1326 einfo (_("%B: warning: undefined reference to `%T'\n"),
1327 abfd, name);
1329 else if (error_count == MAX_ERRORS_IN_A_ROW)
1331 if (error)
1332 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1333 abfd, name);
1334 else
1335 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1336 abfd, name);
1338 else if (error)
1339 einfo ("%X");
1342 return TRUE;
1345 /* Counter to limit the number of relocation overflow error messages
1346 to print. Errors are printed as it is decremented. When it's
1347 called and the counter is zero, a final message is printed
1348 indicating more relocations were omitted. When it gets to -1, no
1349 such errors are printed. If it's initially set to a value less
1350 than -1, all such errors will be printed (--verbose does this). */
1352 int overflow_cutoff_limit = 10;
1354 /* This is called when a reloc overflows. */
1356 static bfd_boolean
1357 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1358 struct bfd_link_hash_entry *entry,
1359 const char *name,
1360 const char *reloc_name,
1361 bfd_vma addend,
1362 bfd *abfd,
1363 asection *section,
1364 bfd_vma address)
1366 if (overflow_cutoff_limit == -1)
1367 return TRUE;
1369 einfo ("%X%C:", abfd, section, address);
1371 if (overflow_cutoff_limit >= 0
1372 && overflow_cutoff_limit-- == 0)
1374 einfo (_(" additional relocation overflows omitted from the output\n"));
1375 return TRUE;
1378 if (entry)
1380 while (entry->type == bfd_link_hash_indirect
1381 || entry->type == bfd_link_hash_warning)
1382 entry = entry->u.i.link;
1383 switch (entry->type)
1385 case bfd_link_hash_undefined:
1386 case bfd_link_hash_undefweak:
1387 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1388 reloc_name, entry->root.string);
1389 break;
1390 case bfd_link_hash_defined:
1391 case bfd_link_hash_defweak:
1392 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1393 reloc_name, entry->root.string,
1394 entry->u.def.section,
1395 entry->u.def.section == bfd_abs_section_ptr
1396 ? link_info.output_bfd : entry->u.def.section->owner);
1397 break;
1398 default:
1399 abort ();
1400 break;
1403 else
1404 einfo (_(" relocation truncated to fit: %s against `%T'"),
1405 reloc_name, name);
1406 if (addend != 0)
1407 einfo ("+%v", addend);
1408 einfo ("\n");
1409 return TRUE;
1412 /* This is called when a dangerous relocation is made. */
1414 static bfd_boolean
1415 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1416 const char *message,
1417 bfd *abfd,
1418 asection *section,
1419 bfd_vma address)
1421 einfo (_("%X%C: dangerous relocation: %s\n"),
1422 abfd, section, address, message);
1423 return TRUE;
1426 /* This is called when a reloc is being generated attached to a symbol
1427 that is not being output. */
1429 static bfd_boolean
1430 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1431 const char *name,
1432 bfd *abfd,
1433 asection *section,
1434 bfd_vma address)
1436 einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1437 abfd, section, address, name);
1438 return TRUE;
1441 /* This is called if link_info.notice_all is set, or when a symbol in
1442 link_info.notice_hash is found. Symbols are put in notice_hash
1443 using the -y option, while notice_all is set if the --cref option
1444 has been supplied, or if there are any NOCROSSREFS sections in the
1445 linker script; and if plugins are active, since they need to monitor
1446 all references from non-IR files. */
1448 static bfd_boolean
1449 notice (struct bfd_link_info *info,
1450 const char *name,
1451 bfd *abfd,
1452 asection *section,
1453 bfd_vma value)
1455 if (name == NULL)
1457 if (command_line.cref || nocrossref_list != NULL)
1458 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1459 return TRUE;
1462 #ifdef ENABLE_PLUGINS
1463 /* We should hide symbols in the dummy IR BFDs from the nocrossrefs list
1464 and let the real object files that are generated and added later trip
1465 the error instead. Similarly would be better to trace the real symbol
1466 from the real file than the temporary dummy. */
1467 if (!plugin_notice (info, name, abfd, section, value))
1468 return TRUE;
1469 #endif /* ENABLE_PLUGINS */
1471 if (info->notice_hash != NULL
1472 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1474 if (bfd_is_und_section (section))
1475 einfo ("%B: reference to %s\n", abfd, name);
1476 else
1477 einfo ("%B: definition of %s\n", abfd, name);
1480 if (command_line.cref || nocrossref_list != NULL)
1481 add_cref (name, abfd, section, value);
1483 return TRUE;