libpam: Trim sources that create empty objects.
[dragonfly.git] / contrib / binutils-2.25 / ld / ldmain.c
blob818d108496ca10aa254af215a4b166e67fab44bd
1 /* Main program of GNU linker.
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
3 Written by Steve Chamberlain steve@cygnus.com
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "safe-ctype.h"
25 #include "libiberty.h"
26 #include "progress.h"
27 #include "bfdlink.h"
28 #include "filenames.h"
30 #include "ld.h"
31 #include "ldmain.h"
32 #include "ldmisc.h"
33 #include "ldwrite.h"
34 #include "ldexp.h"
35 #include "ldlang.h"
36 #include <ldgram.h>
37 #include "ldlex.h"
38 #include "ldfile.h"
39 #include "ldemul.h"
40 #include "ldctor.h"
41 #ifdef ENABLE_PLUGINS
42 #include "plugin.h"
43 #include "plugin-api.h"
44 #include "libbfd.h"
45 #endif /* ENABLE_PLUGINS */
47 /* Somewhere above, sys/stat.h got included. */
48 #if !defined(S_ISDIR) && defined(S_IFDIR)
49 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
50 #endif
52 #include <string.h>
54 #ifdef HAVE_SBRK
55 #if !HAVE_DECL_SBRK
56 extern void *sbrk ();
57 #endif
58 #endif
60 #ifndef TARGET_SYSTEM_ROOT
61 #define TARGET_SYSTEM_ROOT ""
62 #endif
64 /* EXPORTS */
66 FILE *saved_script_handle = NULL;
67 FILE *previous_script_handle = NULL;
68 bfd_boolean force_make_executable = FALSE;
70 char *default_target;
71 const char *output_filename = "a.out";
73 /* Name this program was invoked by. */
74 char *program_name;
76 /* The prefix for system library directories. */
77 const char *ld_sysroot;
79 /* The canonical representation of ld_sysroot. */
80 char * ld_canon_sysroot;
81 int ld_canon_sysroot_len;
83 /* Set by -G argument, for targets like MIPS ELF. */
84 int g_switch_value = 8;
86 /* Nonzero means print names of input files as processed. */
87 bfd_boolean trace_files;
89 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
90 bfd_boolean verbose;
92 /* Nonzero means version number was printed, so exit successfully
93 instead of complaining if no input files are given. */
94 bfd_boolean version_printed;
96 /* TRUE if we should demangle symbol names. */
97 bfd_boolean demangling;
99 args_type command_line;
101 ld_config_type config;
103 sort_type sort_section;
105 static const char *get_sysroot
106 (int, char **);
107 static char *get_emulation
108 (int, char **);
109 static bfd_boolean add_archive_element
110 (struct bfd_link_info *, bfd *, const char *, bfd **);
111 static bfd_boolean multiple_definition
112 (struct bfd_link_info *, struct bfd_link_hash_entry *,
113 bfd *, asection *, bfd_vma);
114 static bfd_boolean multiple_common
115 (struct bfd_link_info *, struct bfd_link_hash_entry *,
116 bfd *, enum bfd_link_hash_type, bfd_vma);
117 static bfd_boolean add_to_set
118 (struct bfd_link_info *, struct bfd_link_hash_entry *,
119 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
120 static bfd_boolean constructor_callback
121 (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
122 asection *, bfd_vma);
123 static bfd_boolean warning_callback
124 (struct bfd_link_info *, const char *, const char *, bfd *,
125 asection *, bfd_vma);
126 static void warning_find_reloc
127 (bfd *, asection *, void *);
128 static bfd_boolean undefined_symbol
129 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
130 bfd_boolean);
131 static bfd_boolean reloc_overflow
132 (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
133 const char *, bfd_vma, bfd *, asection *, bfd_vma);
134 static bfd_boolean reloc_dangerous
135 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
136 static bfd_boolean unattached_reloc
137 (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
138 static bfd_boolean notice
139 (struct bfd_link_info *, struct bfd_link_hash_entry *,
140 struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
142 static struct bfd_link_callbacks link_callbacks =
144 add_archive_element,
145 multiple_definition,
146 multiple_common,
147 add_to_set,
148 constructor_callback,
149 warning_callback,
150 undefined_symbol,
151 reloc_overflow,
152 reloc_dangerous,
153 unattached_reloc,
154 notice,
155 einfo,
156 info_msg,
157 minfo,
158 ldlang_override_segment_assignment
161 static bfd_assert_handler_type default_bfd_assert_handler;
163 struct bfd_link_info link_info;
165 static void
166 ld_cleanup (void)
168 bfd_cache_close_all ();
169 #ifdef ENABLE_PLUGINS
170 plugin_call_cleanup ();
171 #endif
172 if (output_filename && delete_output_file_on_failure)
173 unlink_if_ordinary (output_filename);
176 /* If there's a BFD assertion, we'll notice and exit with an error
177 unless otherwise instructed. */
179 static void
180 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
181 const char *file, int line)
183 (*default_bfd_assert_handler) (fmt, bfdver, file, line);
184 config.make_executable = FALSE;
188 main (int argc, char **argv)
190 char *emulation;
191 long start_time = get_run_time ();
192 #ifdef HAVE_SBRK
193 char *start_sbrk = (char *) sbrk (0);
194 #endif
196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
197 setlocale (LC_MESSAGES, "");
198 #endif
199 #if defined (HAVE_SETLOCALE)
200 setlocale (LC_CTYPE, "");
201 #endif
202 bindtextdomain (PACKAGE, LOCALEDIR);
203 textdomain (PACKAGE);
205 program_name = argv[0];
206 xmalloc_set_program_name (program_name);
208 START_PROGRESS (program_name, 0);
210 expandargv (&argc, &argv);
212 bfd_init ();
214 bfd_set_error_program_name (program_name);
216 /* We want to notice and fail on those nasty BFD assertions which are
217 likely to signal incorrect output being generated but otherwise may
218 leave no trace. */
219 default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
221 xatexit (ld_cleanup);
223 /* Set up the sysroot directory. */
224 ld_sysroot = get_sysroot (argc, argv);
225 if (*ld_sysroot)
227 if (*TARGET_SYSTEM_ROOT == 0)
229 einfo ("%P%F: this linker was not configured to use sysroots\n");
230 ld_sysroot = "";
232 else
233 ld_canon_sysroot = lrealpath (ld_sysroot);
235 if (ld_canon_sysroot)
236 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
237 else
238 ld_canon_sysroot_len = -1;
240 /* Set the default BFD target based on the configured target. Doing
241 this permits the linker to be configured for a particular target,
242 and linked against a shared BFD library which was configured for
243 a different target. The macro TARGET is defined by Makefile. */
244 if (! bfd_set_default_target (TARGET))
246 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
247 xexit (1);
250 #if YYDEBUG
252 extern int yydebug;
253 yydebug = 1;
255 #endif
257 config.build_constructors = TRUE;
258 config.rpath_separator = ':';
259 config.split_by_reloc = (unsigned) -1;
260 config.split_by_file = (bfd_size_type) -1;
261 config.make_executable = TRUE;
262 config.magic_demand_paged = TRUE;
263 config.text_read_only = TRUE;
264 link_info.disable_target_specific_optimizations = -1;
266 command_line.warn_mismatch = TRUE;
267 command_line.warn_search_mismatch = TRUE;
268 command_line.check_section_addresses = -1;
270 /* We initialize DEMANGLING based on the environment variable
271 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
272 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
273 environment. Acting the same way here lets us provide the same
274 interface by default. */
275 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
277 link_info.allow_undefined_version = TRUE;
278 link_info.keep_memory = TRUE;
279 link_info.combreloc = TRUE;
280 link_info.strip_discarded = TRUE;
281 link_info.emit_hash = TRUE;
282 link_info.callbacks = &link_callbacks;
283 link_info.input_bfds_tail = &link_info.input_bfds;
284 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
285 and _fini symbols. We are compatible. */
286 link_info.init_function = "_init";
287 link_info.fini_function = "_fini";
288 link_info.relax_pass = 1;
289 link_info.pei386_auto_import = -1;
290 link_info.spare_dynamic_tags = 5;
291 link_info.path_separator = ':';
293 ldfile_add_arch ("");
294 emulation = get_emulation (argc, argv);
295 ldemul_choose_mode (emulation);
296 default_target = ldemul_choose_target (argc, argv);
297 config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
298 config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
299 lang_init ();
300 ldexp_init ();
301 ldemul_before_parse ();
302 lang_has_input_file = FALSE;
303 parse_args (argc, argv);
305 if (config.hash_table_size != 0)
306 bfd_hash_set_default_size (config.hash_table_size);
308 #ifdef ENABLE_PLUGINS
309 /* Now all the plugin arguments have been gathered, we can load them. */
310 plugin_load_plugins ();
311 #endif /* ENABLE_PLUGINS */
313 ldemul_set_symbols ();
315 /* If we have not already opened and parsed a linker script,
316 try the default script from command line first. */
317 if (saved_script_handle == NULL
318 && command_line.default_script != NULL)
320 ldfile_open_command_file (command_line.default_script);
321 parser_input = input_script;
322 yyparse ();
325 /* If we have not already opened and parsed a linker script
326 read the emulation's appropriate default script. */
327 if (saved_script_handle == NULL)
329 int isfile;
330 char *s = ldemul_get_script (&isfile);
332 if (isfile)
333 ldfile_open_default_command_file (s);
334 else
336 lex_string = s;
337 lex_redirect (s, _("built in linker script"), 1);
339 parser_input = input_script;
340 yyparse ();
341 lex_string = NULL;
344 if (verbose)
346 if (saved_script_handle)
347 info_msg (_("using external linker script:"));
348 else
349 info_msg (_("using internal linker script:"));
350 info_msg ("\n==================================================\n");
352 if (saved_script_handle)
354 static const int ld_bufsz = 8193;
355 size_t n;
356 char *buf = (char *) xmalloc (ld_bufsz);
358 rewind (saved_script_handle);
359 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
361 buf[n] = 0;
362 info_msg (buf);
364 rewind (saved_script_handle);
365 free (buf);
367 else
369 int isfile;
371 info_msg (ldemul_get_script (&isfile));
374 info_msg ("\n==================================================\n");
377 if (command_line.print_output_format)
378 info_msg ("%s\n", lang_get_output_target ());
380 lang_final ();
382 /* If the only command line argument has been -v or --version or --verbose
383 then ignore any input files provided by linker scripts and exit now.
384 We do not want to create an output file when the linker is just invoked
385 to provide version information. */
386 if (argc == 2 && version_printed)
387 xexit (0);
389 if (!lang_has_input_file)
391 if (version_printed || command_line.print_output_format)
392 xexit (0);
393 einfo (_("%P%F: no input files\n"));
396 if (trace_files)
397 info_msg (_("%P: mode %s\n"), emulation);
399 ldemul_after_parse ();
401 if (config.map_filename)
403 if (strcmp (config.map_filename, "-") == 0)
405 config.map_file = stdout;
407 else
409 config.map_file = fopen (config.map_filename, FOPEN_WT);
410 if (config.map_file == (FILE *) NULL)
412 bfd_set_error (bfd_error_system_call);
413 einfo (_("%P%F: cannot open map file %s: %E\n"),
414 config.map_filename);
419 lang_process ();
421 /* Print error messages for any missing symbols, for any warning
422 symbols, and possibly multiple definitions. */
423 if (link_info.relocatable)
424 link_info.output_bfd->flags &= ~EXEC_P;
425 else
426 link_info.output_bfd->flags |= EXEC_P;
428 ldwrite ();
430 if (config.map_file != NULL)
431 lang_map ();
432 if (command_line.cref)
433 output_cref (config.map_file != NULL ? config.map_file : stdout);
434 if (nocrossref_list != NULL)
435 check_nocrossrefs ();
436 #if 0
438 struct bfd_link_hash_entry * h;
440 h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
441 fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
443 #endif
444 ldexp_finish ();
445 lang_finish ();
447 /* Even if we're producing relocatable output, some non-fatal errors should
448 be reported in the exit status. (What non-fatal errors, if any, do we
449 want to ignore for relocatable output?) */
450 if (!config.make_executable && !force_make_executable)
452 if (trace_files)
453 einfo (_("%P: link errors found, deleting executable `%s'\n"),
454 output_filename);
456 /* The file will be removed by ld_cleanup. */
457 xexit (1);
459 else
461 if (! bfd_close (link_info.output_bfd))
462 einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
464 /* If the --force-exe-suffix is enabled, and we're making an
465 executable file and it doesn't end in .exe, copy it to one
466 which does. */
467 if (! link_info.relocatable && command_line.force_exe_suffix)
469 int len = strlen (output_filename);
471 if (len < 4
472 || (strcasecmp (output_filename + len - 4, ".exe") != 0
473 && strcasecmp (output_filename + len - 4, ".dll") != 0))
475 FILE *src;
476 FILE *dst;
477 const int bsize = 4096;
478 char *buf = (char *) xmalloc (bsize);
479 int l;
480 char *dst_name = (char *) xmalloc (len + 5);
482 strcpy (dst_name, output_filename);
483 strcat (dst_name, ".exe");
484 src = fopen (output_filename, FOPEN_RB);
485 dst = fopen (dst_name, FOPEN_WB);
487 if (!src)
488 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
489 output_filename);
490 if (!dst)
491 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
492 dst_name);
493 while ((l = fread (buf, 1, bsize, src)) > 0)
495 int done = fwrite (buf, 1, l, dst);
497 if (done != l)
498 einfo (_("%P: Error writing file `%s'\n"), dst_name);
501 fclose (src);
502 if (fclose (dst) == EOF)
503 einfo (_("%P: Error closing file `%s'\n"), dst_name);
504 free (dst_name);
505 free (buf);
510 END_PROGRESS (program_name);
512 if (config.stats)
514 #ifdef HAVE_SBRK
515 char *lim = (char *) sbrk (0);
516 #endif
517 long run_time = get_run_time () - start_time;
519 fflush (stdout);
520 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
521 program_name, run_time / 1000000, run_time % 1000000);
522 #ifdef HAVE_SBRK
523 fprintf (stderr, _("%s: data size %ld\n"), program_name,
524 (long) (lim - start_sbrk));
525 #endif
526 fflush (stderr);
529 /* Prevent ld_cleanup from doing anything, after a successful link. */
530 output_filename = NULL;
532 xexit (0);
533 return 0;
536 /* If the configured sysroot is relocatable, try relocating it based on
537 default prefix FROM. Return the relocated directory if it exists,
538 otherwise return null. */
540 static char *
541 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
543 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
544 char *path;
545 struct stat s;
547 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
548 if (path)
550 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
551 return path;
552 free (path);
554 #endif
555 return 0;
558 /* Return the sysroot directory. Return "" if no sysroot is being used. */
560 static const char *
561 get_sysroot (int argc, char **argv)
563 int i;
564 const char *path;
566 for (i = 1; i < argc; i++)
567 if (CONST_STRNEQ (argv[i], "--sysroot="))
568 return argv[i] + strlen ("--sysroot=");
570 path = get_relative_sysroot (BINDIR);
571 if (path)
572 return path;
574 path = get_relative_sysroot (TOOLBINDIR);
575 if (path)
576 return path;
578 return TARGET_SYSTEM_ROOT;
581 /* We need to find any explicitly given emulation in order to initialize the
582 state that's needed by the lex&yacc argument parser (parse_args). */
584 static char *
585 get_emulation (int argc, char **argv)
587 char *emulation;
588 int i;
590 emulation = getenv (EMULATION_ENVIRON);
591 if (emulation == NULL)
592 emulation = DEFAULT_EMULATION;
594 for (i = 1; i < argc; i++)
596 if (CONST_STRNEQ (argv[i], "-m"))
598 if (argv[i][2] == '\0')
600 /* -m EMUL */
601 if (i < argc - 1)
603 emulation = argv[i + 1];
604 i++;
606 else
607 einfo (_("%P%F: missing argument to -m\n"));
609 else if (strcmp (argv[i], "-mips1") == 0
610 || strcmp (argv[i], "-mips2") == 0
611 || strcmp (argv[i], "-mips3") == 0
612 || strcmp (argv[i], "-mips4") == 0
613 || strcmp (argv[i], "-mips5") == 0
614 || strcmp (argv[i], "-mips32") == 0
615 || strcmp (argv[i], "-mips32r2") == 0
616 || strcmp (argv[i], "-mips32r6") == 0
617 || strcmp (argv[i], "-mips64") == 0
618 || strcmp (argv[i], "-mips64r2") == 0
619 || strcmp (argv[i], "-mips64r6") == 0)
621 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
622 passed to the linker by some MIPS compilers. They
623 generally tell the linker to use a slightly different
624 library path. Perhaps someday these should be
625 implemented as emulations; until then, we just ignore
626 the arguments and hope that nobody ever creates
627 emulations named ips1, ips2 or ips3. */
629 else if (strcmp (argv[i], "-m486") == 0)
631 /* FIXME: The argument -m486 is passed to the linker on
632 some Linux systems. Hope that nobody creates an
633 emulation named 486. */
635 else
637 /* -mEMUL */
638 emulation = &argv[i][2];
643 return emulation;
646 void
647 add_ysym (const char *name)
649 if (link_info.notice_hash == NULL)
651 link_info.notice_hash =
652 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
653 if (!bfd_hash_table_init_n (link_info.notice_hash,
654 bfd_hash_newfunc,
655 sizeof (struct bfd_hash_entry),
656 61))
657 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
660 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
661 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
664 void
665 add_ignoresym (struct bfd_link_info *info, const char *name)
667 if (info->ignore_hash == NULL)
669 info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
670 if (! bfd_hash_table_init_n (info->ignore_hash,
671 bfd_hash_newfunc,
672 sizeof (struct bfd_hash_entry),
673 61))
674 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
677 if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
678 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
681 /* Record a symbol to be wrapped, from the --wrap option. */
683 void
684 add_wrap (const char *name)
686 if (link_info.wrap_hash == NULL)
688 link_info.wrap_hash =
689 (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
690 if (!bfd_hash_table_init_n (link_info.wrap_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.wrap_hash, name, TRUE, TRUE) == NULL)
698 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
701 /* Handle the -retain-symbols-file option. */
703 void
704 add_keepsyms_file (const char *filename)
706 FILE *file;
707 char *buf;
708 size_t bufsize;
709 int c;
711 if (link_info.strip == strip_some)
712 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
714 file = fopen (filename, "r");
715 if (file == NULL)
717 bfd_set_error (bfd_error_system_call);
718 einfo ("%X%P: %s: %E\n", filename);
719 return;
722 link_info.keep_hash = (struct bfd_hash_table *)
723 xmalloc (sizeof (struct bfd_hash_table));
724 if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
725 sizeof (struct bfd_hash_entry)))
726 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
728 bufsize = 100;
729 buf = (char *) xmalloc (bufsize);
731 c = getc (file);
732 while (c != EOF)
734 while (ISSPACE (c))
735 c = getc (file);
737 if (c != EOF)
739 size_t len = 0;
741 while (! ISSPACE (c) && c != EOF)
743 buf[len] = c;
744 ++len;
745 if (len >= bufsize)
747 bufsize *= 2;
748 buf = (char *) xrealloc (buf, bufsize);
750 c = getc (file);
753 buf[len] = '\0';
755 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
756 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
760 if (link_info.strip != strip_none)
761 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
763 free (buf);
764 link_info.strip = strip_some;
765 fclose (file);
768 /* Callbacks from the BFD linker routines. */
770 /* This is called when BFD has decided to include an archive member in
771 a link. */
773 static bfd_boolean
774 add_archive_element (struct bfd_link_info *info,
775 bfd *abfd,
776 const char *name,
777 bfd **subsbfd ATTRIBUTE_UNUSED)
779 lang_input_statement_type *input;
780 lang_input_statement_type orig_input;
782 input = (lang_input_statement_type *)
783 xcalloc (1, sizeof (lang_input_statement_type));
784 input->filename = abfd->filename;
785 input->local_sym_name = abfd->filename;
786 input->the_bfd = abfd;
788 /* Save the original data for trace files/tries below, as plugins
789 (if enabled) may possibly alter it to point to a replacement
790 BFD, but we still want to output the original BFD filename. */
791 orig_input = *input;
792 #ifdef ENABLE_PLUGINS
793 if (plugin_active_plugins_p () && !no_more_claiming)
795 /* We must offer this archive member to the plugins to claim. */
796 const char *filename = (bfd_my_archive (abfd) != NULL
797 ? bfd_my_archive (abfd)->filename : abfd->filename);
798 int fd = open (filename, O_RDONLY | O_BINARY);
799 if (fd >= 0)
801 struct ld_plugin_input_file file;
803 /* Offset and filesize must refer to the individual archive
804 member, not the whole file, and must exclude the header.
805 Fortunately for us, that is how the data is stored in the
806 origin field of the bfd and in the arelt_data. */
807 file.name = filename;
808 file.offset = abfd->origin;
809 file.filesize = arelt_size (abfd);
810 file.fd = fd;
811 plugin_maybe_claim (&file, input);
812 if (input->flags.claimed)
814 input->flags.claim_archive = TRUE;
815 *subsbfd = input->the_bfd;
819 #endif /* ENABLE_PLUGINS */
821 ldlang_add_file (input);
823 if (config.map_file != NULL)
825 static bfd_boolean header_printed;
826 struct bfd_link_hash_entry *h;
827 bfd *from;
828 int len;
830 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
832 if (h == NULL)
833 from = NULL;
834 else
836 switch (h->type)
838 default:
839 from = NULL;
840 break;
842 case bfd_link_hash_defined:
843 case bfd_link_hash_defweak:
844 from = h->u.def.section->owner;
845 break;
847 case bfd_link_hash_undefined:
848 case bfd_link_hash_undefweak:
849 from = h->u.undef.abfd;
850 break;
852 case bfd_link_hash_common:
853 from = h->u.c.p->section->owner;
854 break;
858 if (! header_printed)
860 char buf[100];
862 sprintf (buf, _("Archive member included "
863 "to satisfy reference by file (symbol)\n\n"));
864 minfo ("%s", buf);
865 header_printed = TRUE;
868 if (bfd_my_archive (abfd) == NULL)
870 minfo ("%s", bfd_get_filename (abfd));
871 len = strlen (bfd_get_filename (abfd));
873 else
875 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
876 bfd_get_filename (abfd));
877 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
878 + strlen (bfd_get_filename (abfd))
879 + 2);
882 if (len >= 29)
884 print_nl ();
885 len = 0;
887 while (len < 30)
889 print_space ();
890 ++len;
893 if (from != NULL)
894 minfo ("%B ", from);
895 if (h != NULL)
896 minfo ("(%T)\n", h->root.string);
897 else
898 minfo ("(%s)\n", name);
901 if (trace_files || verbose)
902 info_msg ("%I\n", &orig_input);
903 return TRUE;
906 /* This is called when BFD has discovered a symbol which is defined
907 multiple times. */
909 static bfd_boolean
910 multiple_definition (struct bfd_link_info *info,
911 struct bfd_link_hash_entry *h,
912 bfd *nbfd,
913 asection *nsec,
914 bfd_vma nval)
916 const char *name;
917 bfd *obfd;
918 asection *osec;
919 bfd_vma oval;
921 if (info->allow_multiple_definition)
922 return TRUE;
924 switch (h->type)
926 case bfd_link_hash_defined:
927 osec = h->u.def.section;
928 oval = h->u.def.value;
929 obfd = h->u.def.section->owner;
930 break;
931 case bfd_link_hash_indirect:
932 osec = bfd_ind_section_ptr;
933 oval = 0;
934 obfd = NULL;
935 break;
936 default:
937 abort ();
940 /* Ignore a redefinition of an absolute symbol to the
941 same value; it's harmless. */
942 if (h->type == bfd_link_hash_defined
943 && bfd_is_abs_section (osec)
944 && bfd_is_abs_section (nsec)
945 && nval == oval)
946 return TRUE;
948 /* If either section has the output_section field set to
949 bfd_abs_section_ptr, it means that the section is being
950 discarded, and this is not really a multiple definition at all.
951 FIXME: It would be cleaner to somehow ignore symbols defined in
952 sections which are being discarded. */
953 if ((osec->output_section != NULL
954 && ! bfd_is_abs_section (osec)
955 && bfd_is_abs_section (osec->output_section))
956 || (nsec->output_section != NULL
957 && ! bfd_is_abs_section (nsec)
958 && bfd_is_abs_section (nsec->output_section)))
959 return TRUE;
961 name = h->root.string;
962 if (nbfd == NULL)
964 nbfd = obfd;
965 nsec = osec;
966 nval = oval;
967 obfd = NULL;
969 einfo (_("%X%C: multiple definition of `%T'\n"),
970 nbfd, nsec, nval, name);
971 if (obfd != NULL)
972 einfo (_("%D: first defined here\n"), obfd, osec, oval);
974 if (RELAXATION_ENABLED_BY_USER)
976 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
977 DISABLE_RELAXATION;
980 return TRUE;
983 /* This is called when there is a definition of a common symbol, or
984 when a common symbol is found for a symbol that is already defined,
985 or when two common symbols are found. We only do something if
986 -warn-common was used. */
988 static bfd_boolean
989 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
990 struct bfd_link_hash_entry *h,
991 bfd *nbfd,
992 enum bfd_link_hash_type ntype,
993 bfd_vma nsize)
995 const char *name;
996 bfd *obfd;
997 enum bfd_link_hash_type otype;
998 bfd_vma osize;
1000 if (!config.warn_common)
1001 return TRUE;
1003 name = h->root.string;
1004 otype = h->type;
1005 if (otype == bfd_link_hash_common)
1007 obfd = h->u.c.p->section->owner;
1008 osize = h->u.c.size;
1010 else if (otype == bfd_link_hash_defined
1011 || otype == bfd_link_hash_defweak)
1013 obfd = h->u.def.section->owner;
1014 osize = 0;
1016 else
1018 /* FIXME: It would nice if we could report the BFD which defined
1019 an indirect symbol, but we don't have anywhere to store the
1020 information. */
1021 obfd = NULL;
1022 osize = 0;
1025 if (ntype == bfd_link_hash_defined
1026 || ntype == bfd_link_hash_defweak
1027 || ntype == bfd_link_hash_indirect)
1029 ASSERT (otype == bfd_link_hash_common);
1030 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1031 nbfd, name);
1032 if (obfd != NULL)
1033 einfo (_("%B: warning: common is here\n"), obfd);
1035 else if (otype == bfd_link_hash_defined
1036 || otype == bfd_link_hash_defweak
1037 || otype == bfd_link_hash_indirect)
1039 ASSERT (ntype == bfd_link_hash_common);
1040 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1041 nbfd, name);
1042 if (obfd != NULL)
1043 einfo (_("%B: warning: defined here\n"), obfd);
1045 else
1047 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1048 if (osize > nsize)
1050 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1051 nbfd, name);
1052 if (obfd != NULL)
1053 einfo (_("%B: warning: larger common is here\n"), obfd);
1055 else if (nsize > osize)
1057 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1058 nbfd, name);
1059 if (obfd != NULL)
1060 einfo (_("%B: warning: smaller common is here\n"), obfd);
1062 else
1064 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1065 if (obfd != NULL)
1066 einfo (_("%B: warning: previous common is here\n"), obfd);
1070 return TRUE;
1073 /* This is called when BFD has discovered a set element. H is the
1074 entry in the linker hash table for the set. SECTION and VALUE
1075 represent a value which should be added to the set. */
1077 static bfd_boolean
1078 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1079 struct bfd_link_hash_entry *h,
1080 bfd_reloc_code_real_type reloc,
1081 bfd *abfd,
1082 asection *section,
1083 bfd_vma value)
1085 if (config.warn_constructors)
1086 einfo (_("%P: warning: global constructor %s used\n"),
1087 h->root.string);
1089 if (! config.build_constructors)
1090 return TRUE;
1092 ldctor_add_set_entry (h, reloc, NULL, section, value);
1094 if (h->type == bfd_link_hash_new)
1096 h->type = bfd_link_hash_undefined;
1097 h->u.undef.abfd = abfd;
1098 /* We don't call bfd_link_add_undef to add this to the list of
1099 undefined symbols because we are going to define it
1100 ourselves. */
1103 return TRUE;
1106 /* This is called when BFD has discovered a constructor. This is only
1107 called for some object file formats--those which do not handle
1108 constructors in some more clever fashion. This is similar to
1109 adding an element to a set, but less general. */
1111 static bfd_boolean
1112 constructor_callback (struct bfd_link_info *info,
1113 bfd_boolean constructor,
1114 const char *name,
1115 bfd *abfd,
1116 asection *section,
1117 bfd_vma value)
1119 char *s;
1120 struct bfd_link_hash_entry *h;
1121 char set_name[1 + sizeof "__CTOR_LIST__"];
1123 if (config.warn_constructors)
1124 einfo (_("%P: warning: global constructor %s used\n"), name);
1126 if (! config.build_constructors)
1127 return TRUE;
1129 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1130 useful error message. */
1131 if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1132 && (info->relocatable
1133 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1134 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1136 s = set_name;
1137 if (bfd_get_symbol_leading_char (abfd) != '\0')
1138 *s++ = bfd_get_symbol_leading_char (abfd);
1139 if (constructor)
1140 strcpy (s, "__CTOR_LIST__");
1141 else
1142 strcpy (s, "__DTOR_LIST__");
1144 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1145 if (h == (struct bfd_link_hash_entry *) NULL)
1146 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1147 if (h->type == bfd_link_hash_new)
1149 h->type = bfd_link_hash_undefined;
1150 h->u.undef.abfd = abfd;
1151 /* We don't call bfd_link_add_undef to add this to the list of
1152 undefined symbols because we are going to define it
1153 ourselves. */
1156 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1157 return TRUE;
1160 /* A structure used by warning_callback to pass information through
1161 bfd_map_over_sections. */
1163 struct warning_callback_info
1165 bfd_boolean found;
1166 const char *warning;
1167 const char *symbol;
1168 asymbol **asymbols;
1171 /* Look through the relocs to see if we can find a plausible address
1172 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1174 static bfd_boolean
1175 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1177 struct warning_callback_info cinfo;
1179 if (!bfd_generic_link_read_symbols (abfd))
1180 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1182 cinfo.found = FALSE;
1183 cinfo.warning = warning;
1184 cinfo.symbol = symbol;
1185 cinfo.asymbols = bfd_get_outsymbols (abfd);
1186 bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1187 return cinfo.found;
1190 /* This is called when there is a reference to a warning symbol. */
1192 static bfd_boolean
1193 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1194 const char *warning,
1195 const char *symbol,
1196 bfd *abfd,
1197 asection *section,
1198 bfd_vma address)
1200 /* This is a hack to support warn_multiple_gp. FIXME: This should
1201 have a cleaner interface, but what? */
1202 if (! config.warn_multiple_gp
1203 && strcmp (warning, "using multiple gp values") == 0)
1204 return TRUE;
1206 if (section != NULL)
1207 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1208 else if (abfd == NULL)
1209 einfo ("%P: %s%s\n", _("warning: "), warning);
1210 else if (symbol == NULL)
1211 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1212 else if (! symbol_warning (warning, symbol, abfd))
1214 bfd *b;
1215 /* Search all input files for a reference to SYMBOL. */
1216 for (b = info->input_bfds; b; b = b->link.next)
1217 if (b != abfd && symbol_warning (warning, symbol, b))
1218 return TRUE;
1219 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1222 return TRUE;
1225 /* This is called by warning_callback for each section. It checks the
1226 relocs of the section to see if it can find a reference to the
1227 symbol which triggered the warning. If it can, it uses the reloc
1228 to give an error message with a file and line number. */
1230 static void
1231 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1233 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1234 long relsize;
1235 arelent **relpp;
1236 long relcount;
1237 arelent **p, **pend;
1239 if (info->found)
1240 return;
1242 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1243 if (relsize < 0)
1244 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1245 if (relsize == 0)
1246 return;
1248 relpp = (arelent **) xmalloc (relsize);
1249 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1250 if (relcount < 0)
1251 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1253 p = relpp;
1254 pend = p + relcount;
1255 for (; p < pend && *p != NULL; p++)
1257 arelent *q = *p;
1259 if (q->sym_ptr_ptr != NULL
1260 && *q->sym_ptr_ptr != NULL
1261 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1263 /* We found a reloc for the symbol we are looking for. */
1264 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1265 info->warning);
1266 info->found = TRUE;
1267 break;
1271 free (relpp);
1274 /* This is called when an undefined symbol is found. */
1276 static bfd_boolean
1277 undefined_symbol (struct bfd_link_info *info,
1278 const char *name,
1279 bfd *abfd,
1280 asection *section,
1281 bfd_vma address,
1282 bfd_boolean error)
1284 static char *error_name;
1285 static unsigned int error_count;
1287 #define MAX_ERRORS_IN_A_ROW 5
1289 if (info->ignore_hash != NULL
1290 && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1291 return TRUE;
1293 if (config.warn_once)
1295 /* Only warn once about a particular undefined symbol. */
1296 add_ignoresym (info, name);
1299 /* We never print more than a reasonable number of errors in a row
1300 for a single symbol. */
1301 if (error_name != NULL
1302 && strcmp (name, error_name) == 0)
1303 ++error_count;
1304 else
1306 error_count = 0;
1307 if (error_name != NULL)
1308 free (error_name);
1309 error_name = xstrdup (name);
1312 if (section != NULL)
1314 if (error_count < MAX_ERRORS_IN_A_ROW)
1316 if (error)
1317 einfo (_("%X%C: undefined reference to `%T'\n"),
1318 abfd, section, address, name);
1319 else
1320 einfo (_("%C: warning: undefined reference to `%T'\n"),
1321 abfd, section, address, name);
1323 else if (error_count == MAX_ERRORS_IN_A_ROW)
1325 if (error)
1326 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1327 abfd, section, address, name);
1328 else
1329 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1330 abfd, section, address, name);
1332 else if (error)
1333 einfo ("%X");
1335 else
1337 if (error_count < MAX_ERRORS_IN_A_ROW)
1339 if (error)
1340 einfo (_("%X%B: undefined reference to `%T'\n"),
1341 abfd, name);
1342 else
1343 einfo (_("%B: warning: undefined reference to `%T'\n"),
1344 abfd, name);
1346 else if (error_count == MAX_ERRORS_IN_A_ROW)
1348 if (error)
1349 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1350 abfd, name);
1351 else
1352 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1353 abfd, name);
1355 else if (error)
1356 einfo ("%X");
1359 return TRUE;
1362 /* Counter to limit the number of relocation overflow error messages
1363 to print. Errors are printed as it is decremented. When it's
1364 called and the counter is zero, a final message is printed
1365 indicating more relocations were omitted. When it gets to -1, no
1366 such errors are printed. If it's initially set to a value less
1367 than -1, all such errors will be printed (--verbose does this). */
1369 int overflow_cutoff_limit = 10;
1371 /* This is called when a reloc overflows. */
1373 static bfd_boolean
1374 reloc_overflow (struct bfd_link_info *info,
1375 struct bfd_link_hash_entry *entry,
1376 const char *name,
1377 const char *reloc_name,
1378 bfd_vma addend,
1379 bfd *abfd,
1380 asection *section,
1381 bfd_vma address)
1383 if (overflow_cutoff_limit == -1)
1384 return TRUE;
1386 einfo ("%X%H:", abfd, section, address);
1388 if (overflow_cutoff_limit >= 0
1389 && overflow_cutoff_limit-- == 0)
1391 einfo (_(" additional relocation overflows omitted from the output\n"));
1392 return TRUE;
1395 if (entry)
1397 while (entry->type == bfd_link_hash_indirect
1398 || entry->type == bfd_link_hash_warning)
1399 entry = entry->u.i.link;
1400 switch (entry->type)
1402 case bfd_link_hash_undefined:
1403 case bfd_link_hash_undefweak:
1404 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1405 reloc_name, entry->root.string);
1406 break;
1407 case bfd_link_hash_defined:
1408 case bfd_link_hash_defweak:
1409 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1410 reloc_name, entry->root.string,
1411 entry->u.def.section,
1412 entry->u.def.section == bfd_abs_section_ptr
1413 ? info->output_bfd : entry->u.def.section->owner);
1414 break;
1415 default:
1416 abort ();
1417 break;
1420 else
1421 einfo (_(" relocation truncated to fit: %s against `%T'"),
1422 reloc_name, name);
1423 if (addend != 0)
1424 einfo ("+%v", addend);
1425 einfo ("\n");
1426 return TRUE;
1429 /* This is called when a dangerous relocation is made. */
1431 static bfd_boolean
1432 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1433 const char *message,
1434 bfd *abfd,
1435 asection *section,
1436 bfd_vma address)
1438 einfo (_("%X%H: dangerous relocation: %s\n"),
1439 abfd, section, address, message);
1440 return TRUE;
1443 /* This is called when a reloc is being generated attached to a symbol
1444 that is not being output. */
1446 static bfd_boolean
1447 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1448 const char *name,
1449 bfd *abfd,
1450 asection *section,
1451 bfd_vma address)
1453 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1454 abfd, section, address, name);
1455 return TRUE;
1458 /* This is called if link_info.notice_all is set, or when a symbol in
1459 link_info.notice_hash is found. Symbols are put in notice_hash
1460 using the -y option, while notice_all is set if the --cref option
1461 has been supplied, or if there are any NOCROSSREFS sections in the
1462 linker script; and if plugins are active, since they need to monitor
1463 all references from non-IR files. */
1465 static bfd_boolean
1466 notice (struct bfd_link_info *info,
1467 struct bfd_link_hash_entry *h,
1468 struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1469 bfd *abfd,
1470 asection *section,
1471 bfd_vma value,
1472 flagword flags ATTRIBUTE_UNUSED)
1474 const char *name;
1476 if (h == NULL)
1478 if (command_line.cref || nocrossref_list != NULL)
1479 return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1480 return TRUE;
1483 name = h->root.string;
1484 if (info->notice_hash != NULL
1485 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1487 if (bfd_is_und_section (section))
1488 einfo ("%B: reference to %s\n", abfd, name);
1489 else
1490 einfo ("%B: definition of %s\n", abfd, name);
1493 if (command_line.cref || nocrossref_list != NULL)
1494 add_cref (name, abfd, section, value);
1496 return TRUE;