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. */
26 #include "safe-ctype.h"
27 #include "libiberty.h"
30 #include "filenames.h"
45 #include "plugin-api.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)
62 #ifndef TARGET_SYSTEM_ROOT
63 #define TARGET_SYSTEM_ROOT ""
68 FILE *saved_script_handle
= NULL
;
69 FILE *previous_script_handle
= NULL
;
70 bfd_boolean force_make_executable
= FALSE
;
73 const char *output_filename
= "a.out";
75 /* Name this program was invoked by. */
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
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
121 static char *get_emulation
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
,
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
=
161 constructor_callback
,
171 ldlang_override_segment_assignment
174 struct bfd_link_info link_info
;
179 bfd_cache_close_all ();
180 #ifdef ENABLE_PLUGINS
181 plugin_call_cleanup ();
183 if (output_filename
&& delete_output_file_on_failure
)
184 unlink_if_ordinary (output_filename
);
188 main (int argc
, char **argv
)
191 long start_time
= get_run_time ();
193 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
194 setlocale (LC_MESSAGES
, "");
196 #if defined (HAVE_SETLOCALE)
197 setlocale (LC_CTYPE
, "");
199 bindtextdomain (PACKAGE
, LOCALEDIR
);
200 textdomain (PACKAGE
);
202 program_name
= argv
[0];
203 xmalloc_set_program_name (program_name
);
205 START_PROGRESS (program_name
, 0);
207 expandargv (&argc
, &argv
);
211 bfd_set_error_program_name (program_name
);
213 xatexit (ld_cleanup
);
215 /* Set up the sysroot directory. */
216 ld_sysroot
= get_sysroot (argc
, argv
);
219 if (*TARGET_SYSTEM_ROOT
== 0)
221 einfo ("%P%F: this linker was not configured to use sysroots\n");
225 ld_canon_sysroot
= lrealpath (ld_sysroot
);
227 if (ld_canon_sysroot
)
228 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
230 ld_canon_sysroot_len
= -1;
232 /* Set the default BFD target based on the configured target. Doing
233 this permits the linker to be configured for a particular target,
234 and linked against a shared BFD library which was configured for
235 a different target. The macro TARGET is defined by Makefile. */
236 if (! bfd_set_default_target (TARGET
))
238 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
249 config
.build_constructors
= TRUE
;
250 config
.rpath_separator
= ':';
251 config
.split_by_reloc
= (unsigned) -1;
252 config
.split_by_file
= (bfd_size_type
) -1;
253 config
.make_executable
= TRUE
;
254 config
.magic_demand_paged
= TRUE
;
255 config
.text_read_only
= TRUE
;
257 command_line
.warn_mismatch
= TRUE
;
258 command_line
.warn_search_mismatch
= TRUE
;
259 command_line
.check_section_addresses
= -1;
260 command_line
.disable_target_specific_optimizations
= -1;
262 /* We initialize DEMANGLING based on the environment variable
263 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
264 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
265 environment. Acting the same way here lets us provide the same
266 interface by default. */
267 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
269 link_info
.allow_undefined_version
= TRUE
;
270 link_info
.keep_memory
= TRUE
;
271 link_info
.combreloc
= TRUE
;
272 link_info
.strip_discarded
= TRUE
;
273 link_info
.emit_hash
= TRUE
;
274 link_info
.callbacks
= &link_callbacks
;
275 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
276 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
277 and _fini symbols. We are compatible. */
278 link_info
.init_function
= "_init";
279 link_info
.fini_function
= "_fini";
280 link_info
.relax_pass
= 1;
281 link_info
.pei386_auto_import
= -1;
282 link_info
.spare_dynamic_tags
= 5;
283 link_info
.path_separator
= ':';
285 ldfile_add_arch ("");
286 emulation
= get_emulation (argc
, argv
);
287 ldemul_choose_mode (emulation
);
288 default_target
= ldemul_choose_target (argc
, argv
);
289 config
.maxpagesize
= bfd_emul_get_maxpagesize (default_target
);
290 config
.commonpagesize
= bfd_emul_get_commonpagesize (default_target
);
292 ldemul_before_parse ();
293 lang_has_input_file
= FALSE
;
294 parse_args (argc
, argv
);
296 if (config
.hash_table_size
!= 0)
297 bfd_hash_set_default_size (config
.hash_table_size
);
299 ldemul_set_symbols ();
301 if (link_info
.relocatable
)
303 if (command_line
.check_section_addresses
< 0)
304 command_line
.check_section_addresses
= 0;
305 if (link_info
.shared
)
306 einfo (_("%P%F: -r and -shared may not be used together\n"));
309 /* We may have -Bsymbolic, -Bsymbolic-functions, --dynamic-list-data,
310 --dynamic-list-cpp-new, --dynamic-list-cpp-typeinfo and
311 --dynamic-list FILE. -Bsymbolic and -Bsymbolic-functions are
312 for shared libraries. -Bsymbolic overrides all others and vice
314 switch (command_line
.symbolic
)
319 /* -Bsymbolic is for shared library only. */
320 if (link_info
.shared
)
322 link_info
.symbolic
= TRUE
;
323 /* Should we free the unused memory? */
324 link_info
.dynamic_list
= NULL
;
325 command_line
.dynamic_list
= dynamic_list_unset
;
328 case symbolic_functions
:
329 /* -Bsymbolic-functions is for shared library only. */
330 if (link_info
.shared
)
331 command_line
.dynamic_list
= dynamic_list_data
;
335 switch (command_line
.dynamic_list
)
337 case dynamic_list_unset
:
339 case dynamic_list_data
:
340 link_info
.dynamic_data
= TRUE
;
342 link_info
.dynamic
= TRUE
;
346 if (! link_info
.shared
)
348 if (command_line
.filter_shlib
)
349 einfo (_("%P%F: -F may not be used without -shared\n"));
350 if (command_line
.auxiliary_filters
)
351 einfo (_("%P%F: -f may not be used without -shared\n"));
354 if (! link_info
.shared
|| link_info
.pie
)
355 link_info
.executable
= TRUE
;
357 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
358 don't see how else this can be handled, since in this case we
359 must preserve all externally visible symbols. */
360 if (link_info
.relocatable
&& link_info
.strip
== strip_all
)
362 link_info
.strip
= strip_debugger
;
363 if (link_info
.discard
== discard_sec_merge
)
364 link_info
.discard
= discard_all
;
367 /* If we have not already opened and parsed a linker script,
368 try the default script from command line first. */
369 if (saved_script_handle
== NULL
370 && command_line
.default_script
!= NULL
)
372 ldfile_open_command_file (command_line
.default_script
);
373 parser_input
= input_script
;
377 /* If we have not already opened and parsed a linker script
378 read the emulation's appropriate default script. */
379 if (saved_script_handle
== NULL
)
382 char *s
= ldemul_get_script (&isfile
);
385 ldfile_open_default_command_file (s
);
391 parser_input
= input_script
;
396 if (trace_file_tries
)
398 if (saved_script_handle
)
399 info_msg (_("using external linker script:"));
401 info_msg (_("using internal linker script:"));
402 info_msg ("\n==================================================\n");
404 if (saved_script_handle
)
406 static const int ld_bufsz
= 8193;
408 char *buf
= (char *) xmalloc (ld_bufsz
);
410 rewind (saved_script_handle
);
411 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
416 rewind (saved_script_handle
);
423 info_msg (ldemul_get_script (&isfile
));
426 info_msg ("\n==================================================\n");
431 if (!lang_has_input_file
)
435 einfo (_("%P%F: no input files\n"));
439 info_msg (_("%P: mode %s\n"), emulation
);
441 ldemul_after_parse ();
443 if (config
.map_filename
)
445 if (strcmp (config
.map_filename
, "-") == 0)
447 config
.map_file
= stdout
;
451 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
452 if (config
.map_file
== (FILE *) NULL
)
454 bfd_set_error (bfd_error_system_call
);
455 einfo (_("%P%F: cannot open map file %s: %E\n"),
456 config
.map_filename
);
463 /* Print error messages for any missing symbols, for any warning
464 symbols, and possibly multiple definitions. */
465 if (link_info
.relocatable
)
466 link_info
.output_bfd
->flags
&= ~EXEC_P
;
468 link_info
.output_bfd
->flags
|= EXEC_P
;
472 if (config
.map_file
!= NULL
)
474 if (command_line
.cref
)
475 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
476 if (nocrossref_list
!= NULL
)
477 check_nocrossrefs ();
481 /* Even if we're producing relocatable output, some non-fatal errors should
482 be reported in the exit status. (What non-fatal errors, if any, do we
483 want to ignore for relocatable output?) */
484 if (!config
.make_executable
&& !force_make_executable
)
487 einfo (_("%P: link errors found, deleting executable `%s'\n"),
490 /* The file will be removed by remove_output. */
495 if (! bfd_close (link_info
.output_bfd
))
496 einfo (_("%F%B: final close failed: %E\n"), link_info
.output_bfd
);
498 /* If the --force-exe-suffix is enabled, and we're making an
499 executable file and it doesn't end in .exe, copy it to one
501 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
503 int len
= strlen (output_filename
);
506 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
507 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
511 const int bsize
= 4096;
512 char *buf
= (char *) xmalloc (bsize
);
514 char *dst_name
= (char *) xmalloc (len
+ 5);
516 strcpy (dst_name
, output_filename
);
517 strcat (dst_name
, ".exe");
518 src
= fopen (output_filename
, FOPEN_RB
);
519 dst
= fopen (dst_name
, FOPEN_WB
);
522 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
525 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
527 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
529 int done
= fwrite (buf
, 1, l
, dst
);
532 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
536 if (fclose (dst
) == EOF
)
537 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
544 END_PROGRESS (program_name
);
549 char *lim
= (char *) sbrk (0);
551 long run_time
= get_run_time () - start_time
;
554 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
555 program_name
, run_time
/ 1000000, run_time
% 1000000);
557 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
558 (long) (lim
- (char *) &environ
));
563 /* Prevent remove_output from doing anything, after a successful link. */
564 output_filename
= NULL
;
570 /* If the configured sysroot is relocatable, try relocating it based on
571 default prefix FROM. Return the relocated directory if it exists,
572 otherwise return null. */
575 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
577 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
581 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
584 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
592 /* Return the sysroot directory. Return "" if no sysroot is being used. */
595 get_sysroot (int argc
, char **argv
)
600 for (i
= 1; i
< argc
; i
++)
601 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
602 return argv
[i
] + strlen ("--sysroot=");
604 path
= get_relative_sysroot (BINDIR
);
608 path
= get_relative_sysroot (TOOLBINDIR
);
612 return TARGET_SYSTEM_ROOT
;
615 /* We need to find any explicitly given emulation in order to initialize the
616 state that's needed by the lex&yacc argument parser (parse_args). */
619 get_emulation (int argc
, char **argv
)
624 emulation
= getenv (EMULATION_ENVIRON
);
625 if (emulation
== NULL
)
626 emulation
= DEFAULT_EMULATION
;
628 for (i
= 1; i
< argc
; i
++)
630 if (CONST_STRNEQ (argv
[i
], "-m"))
632 if (argv
[i
][2] == '\0')
637 emulation
= argv
[i
+ 1];
641 einfo (_("%P%F: missing argument to -m\n"));
643 else if (strcmp (argv
[i
], "-mips1") == 0
644 || strcmp (argv
[i
], "-mips2") == 0
645 || strcmp (argv
[i
], "-mips3") == 0
646 || strcmp (argv
[i
], "-mips4") == 0
647 || strcmp (argv
[i
], "-mips5") == 0
648 || strcmp (argv
[i
], "-mips32") == 0
649 || strcmp (argv
[i
], "-mips32r2") == 0
650 || strcmp (argv
[i
], "-mips64") == 0
651 || strcmp (argv
[i
], "-mips64r2") == 0)
653 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
654 passed to the linker by some MIPS compilers. They
655 generally tell the linker to use a slightly different
656 library path. Perhaps someday these should be
657 implemented as emulations; until then, we just ignore
658 the arguments and hope that nobody ever creates
659 emulations named ips1, ips2 or ips3. */
661 else if (strcmp (argv
[i
], "-m486") == 0)
663 /* FIXME: The argument -m486 is passed to the linker on
664 some Linux systems. Hope that nobody creates an
665 emulation named 486. */
670 emulation
= &argv
[i
][2];
679 add_ysym (const char *name
)
681 if (link_info
.notice_hash
== NULL
)
683 link_info
.notice_hash
=
684 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
685 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
687 sizeof (struct bfd_hash_entry
),
689 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
692 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
693 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
696 /* Record a symbol to be wrapped, from the --wrap option. */
699 add_wrap (const char *name
)
701 if (link_info
.wrap_hash
== NULL
)
703 link_info
.wrap_hash
=
704 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
705 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
707 sizeof (struct bfd_hash_entry
),
709 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
712 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
713 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
716 /* Handle the -retain-symbols-file option. */
719 add_keepsyms_file (const char *filename
)
726 if (link_info
.strip
== strip_some
)
727 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
729 file
= fopen (filename
, "r");
732 bfd_set_error (bfd_error_system_call
);
733 einfo ("%X%P: %s: %E\n", filename
);
737 link_info
.keep_hash
= (struct bfd_hash_table
*)
738 xmalloc (sizeof (struct bfd_hash_table
));
739 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
740 sizeof (struct bfd_hash_entry
)))
741 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
744 buf
= (char *) xmalloc (bufsize
);
756 while (! ISSPACE (c
) && c
!= EOF
)
763 buf
= (char *) xrealloc (buf
, bufsize
);
770 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
771 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
775 if (link_info
.strip
!= strip_none
)
776 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
779 link_info
.strip
= strip_some
;
782 /* Callbacks from the BFD linker routines. */
784 /* This is called when BFD has decided to include an archive member in
788 add_archive_element (struct bfd_link_info
*info
,
791 bfd
**subsbfd ATTRIBUTE_UNUSED
)
793 lang_input_statement_type
*input
;
794 lang_input_statement_type orig_input
;
796 input
= (lang_input_statement_type
*)
797 xcalloc (1, sizeof (lang_input_statement_type
));
798 input
->filename
= abfd
->filename
;
799 input
->local_sym_name
= abfd
->filename
;
800 input
->the_bfd
= abfd
;
802 /* Save the original data for trace files/tries below, as plugins
803 (if enabled) may possibly alter it to point to a replacement
804 BFD, but we still want to output the original BFD filename. */
806 #ifdef ENABLE_PLUGINS
807 if (bfd_my_archive (abfd
) != NULL
&& plugin_active_plugins_p ())
809 /* We must offer this archive member to the plugins to claim. */
810 int fd
= open (bfd_my_archive (abfd
)->filename
, O_RDONLY
| O_BINARY
);
813 struct ld_plugin_input_file file
;
815 /* Offset and filesize must refer to the individual archive
816 member, not the whole file, and must exclude the header.
817 Fortunately for us, that is how the data is stored in the
818 origin field of the bfd and in the arelt_data. */
819 file
.name
= bfd_my_archive (abfd
)->filename
;
820 file
.offset
= abfd
->origin
;
821 file
.filesize
= arelt_size (abfd
);
823 /* We create a dummy BFD, initially empty, to house
824 whatever symbols the plugin may want to add. */
825 file
.handle
= plugin_get_ir_dummy_bfd (abfd
->filename
, abfd
);
826 if (plugin_call_claim_file (&file
, &claimed
))
827 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
828 plugin_error_plugin ());
829 /* fd belongs to us, not the plugin; but we don't need it. */
833 /* Substitute the dummy BFD. */
834 input
->the_bfd
= file
.handle
;
835 input
->claimed
= TRUE
;
836 input
->claim_archive
= TRUE
;
837 bfd_make_readable (input
->the_bfd
);
838 *subsbfd
= input
->the_bfd
;
842 /* Abandon the dummy BFD. */
843 bfd_close_all_done (file
.handle
);
844 input
->claimed
= FALSE
;
848 #endif /* ENABLE_PLUGINS */
850 ldlang_add_file (input
);
852 if (config
.map_file
!= NULL
)
854 static bfd_boolean header_printed
;
855 struct bfd_link_hash_entry
*h
;
859 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
871 case bfd_link_hash_defined
:
872 case bfd_link_hash_defweak
:
873 from
= h
->u
.def
.section
->owner
;
876 case bfd_link_hash_undefined
:
877 case bfd_link_hash_undefweak
:
878 from
= h
->u
.undef
.abfd
;
881 case bfd_link_hash_common
:
882 from
= h
->u
.c
.p
->section
->owner
;
887 if (! header_printed
)
891 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
893 header_printed
= TRUE
;
896 if (bfd_my_archive (abfd
) == NULL
)
898 minfo ("%s", bfd_get_filename (abfd
));
899 len
= strlen (bfd_get_filename (abfd
));
903 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
904 bfd_get_filename (abfd
));
905 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
906 + strlen (bfd_get_filename (abfd
))
924 minfo ("(%T)\n", h
->root
.string
);
926 minfo ("(%s)\n", name
);
929 if (trace_files
|| trace_file_tries
)
930 info_msg ("%I\n", &orig_input
);
934 /* This is called when BFD has discovered a symbol which is defined
938 multiple_definition (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
947 #ifdef ENABLE_PLUGINS
948 /* We may get called back even when --allow-multiple-definition is in
949 effect, as the plugin infrastructure needs to use this hook in
950 order to swap out IR-only symbols for real ones. In that case,
951 it will let us know not to continue by returning TRUE even if this
952 is not an IR-only vs. non-IR symbol conflict. */
953 if (plugin_multiple_definition (info
, name
, obfd
, osec
, oval
, nbfd
,
956 #endif /* ENABLE_PLUGINS */
958 /* If either section has the output_section field set to
959 bfd_abs_section_ptr, it means that the section is being
960 discarded, and this is not really a multiple definition at all.
961 FIXME: It would be cleaner to somehow ignore symbols defined in
962 sections which are being discarded. */
963 if ((osec
->output_section
!= NULL
964 && ! bfd_is_abs_section (osec
)
965 && bfd_is_abs_section (osec
->output_section
))
966 || (nsec
->output_section
!= NULL
967 && ! bfd_is_abs_section (nsec
)
968 && bfd_is_abs_section (nsec
->output_section
)))
971 einfo (_("%X%C: multiple definition of `%T'\n"),
972 nbfd
, nsec
, nval
, name
);
974 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
976 if (RELAXATION_ENABLED
)
978 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
979 command_line
.disable_target_specific_optimizations
= -1;
985 /* This is called when there is a definition of a common symbol, or
986 when a common symbol is found for a symbol that is already defined,
987 or when two common symbols are found. We only do something if
988 -warn-common was used. */
991 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
994 enum bfd_link_hash_type otype
,
997 enum bfd_link_hash_type ntype
,
1000 if (! config
.warn_common
)
1003 if (ntype
== bfd_link_hash_defined
1004 || ntype
== bfd_link_hash_defweak
1005 || ntype
== bfd_link_hash_indirect
)
1007 ASSERT (otype
== bfd_link_hash_common
);
1008 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1011 einfo (_("%B: warning: common is here\n"), obfd
);
1013 else if (otype
== bfd_link_hash_defined
1014 || otype
== bfd_link_hash_defweak
1015 || otype
== bfd_link_hash_indirect
)
1017 ASSERT (ntype
== bfd_link_hash_common
);
1018 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1021 einfo (_("%B: warning: defined here\n"), obfd
);
1025 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1028 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1031 einfo (_("%B: warning: larger common is here\n"), obfd
);
1033 else if (nsize
> osize
)
1035 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1038 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1042 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1044 einfo (_("%B: warning: previous common is here\n"), obfd
);
1051 /* This is called when BFD has discovered a set element. H is the
1052 entry in the linker hash table for the set. SECTION and VALUE
1053 represent a value which should be added to the set. */
1056 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1057 struct bfd_link_hash_entry
*h
,
1058 bfd_reloc_code_real_type reloc
,
1063 if (config
.warn_constructors
)
1064 einfo (_("%P: warning: global constructor %s used\n"),
1067 if (! config
.build_constructors
)
1070 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1072 if (h
->type
== bfd_link_hash_new
)
1074 h
->type
= bfd_link_hash_undefined
;
1075 h
->u
.undef
.abfd
= abfd
;
1076 /* We don't call bfd_link_add_undef to add this to the list of
1077 undefined symbols because we are going to define it
1084 /* This is called when BFD has discovered a constructor. This is only
1085 called for some object file formats--those which do not handle
1086 constructors in some more clever fashion. This is similar to
1087 adding an element to a set, but less general. */
1090 constructor_callback (struct bfd_link_info
*info
,
1091 bfd_boolean constructor
,
1098 struct bfd_link_hash_entry
*h
;
1099 char set_name
[1 + sizeof "__CTOR_LIST__"];
1101 if (config
.warn_constructors
)
1102 einfo (_("%P: warning: global constructor %s used\n"), name
);
1104 if (! config
.build_constructors
)
1107 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1108 useful error message. */
1109 if (bfd_reloc_type_lookup (link_info
.output_bfd
, BFD_RELOC_CTOR
) == NULL
1110 && (info
->relocatable
1111 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1112 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1115 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1116 *s
++ = bfd_get_symbol_leading_char (abfd
);
1118 strcpy (s
, "__CTOR_LIST__");
1120 strcpy (s
, "__DTOR_LIST__");
1122 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1123 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1124 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1125 if (h
->type
== bfd_link_hash_new
)
1127 h
->type
= bfd_link_hash_undefined
;
1128 h
->u
.undef
.abfd
= abfd
;
1129 /* We don't call bfd_link_add_undef to add this to the list of
1130 undefined symbols because we are going to define it
1134 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1138 /* A structure used by warning_callback to pass information through
1139 bfd_map_over_sections. */
1141 struct warning_callback_info
1144 const char *warning
;
1149 /* This is called when there is a reference to a warning symbol. */
1152 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1153 const char *warning
,
1159 /* This is a hack to support warn_multiple_gp. FIXME: This should
1160 have a cleaner interface, but what? */
1161 if (! config
.warn_multiple_gp
1162 && strcmp (warning
, "using multiple gp values") == 0)
1165 if (section
!= NULL
)
1166 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1167 else if (abfd
== NULL
)
1168 einfo ("%P: %s%s\n", _("warning: "), warning
);
1169 else if (symbol
== NULL
)
1170 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1173 struct warning_callback_info cinfo
;
1175 /* Look through the relocs to see if we can find a plausible
1178 if (!bfd_generic_link_read_symbols (abfd
))
1179 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1181 cinfo
.found
= FALSE
;
1182 cinfo
.warning
= warning
;
1183 cinfo
.symbol
= symbol
;
1184 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1185 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1188 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1194 /* This is called by warning_callback for each section. It checks the
1195 relocs of the section to see if it can find a reference to the
1196 symbol which triggered the warning. If it can, it uses the reloc
1197 to give an error message with a file and line number. */
1200 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1202 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1206 arelent
**p
, **pend
;
1211 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1213 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1217 relpp
= (arelent
**) xmalloc (relsize
);
1218 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1220 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1223 pend
= p
+ relcount
;
1224 for (; p
< pend
&& *p
!= NULL
; p
++)
1228 if (q
->sym_ptr_ptr
!= NULL
1229 && *q
->sym_ptr_ptr
!= NULL
1230 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1232 /* We found a reloc for the symbol we are looking for. */
1233 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1243 /* This is called when an undefined symbol is found. */
1246 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1253 static char *error_name
;
1254 static unsigned int error_count
;
1256 #define MAX_ERRORS_IN_A_ROW 5
1258 if (config
.warn_once
)
1260 static struct bfd_hash_table
*hash
;
1262 /* Only warn once about a particular undefined symbol. */
1265 hash
= (struct bfd_hash_table
*)
1266 xmalloc (sizeof (struct bfd_hash_table
));
1267 if (!bfd_hash_table_init (hash
, bfd_hash_newfunc
,
1268 sizeof (struct bfd_hash_entry
)))
1269 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1272 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1275 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1276 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1279 /* We never print more than a reasonable number of errors in a row
1280 for a single symbol. */
1281 if (error_name
!= NULL
1282 && strcmp (name
, error_name
) == 0)
1287 if (error_name
!= NULL
)
1289 error_name
= xstrdup (name
);
1292 if (section
!= NULL
)
1294 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1297 einfo (_("%X%C: undefined reference to `%T'\n"),
1298 abfd
, section
, address
, name
);
1300 einfo (_("%C: warning: undefined reference to `%T'\n"),
1301 abfd
, section
, address
, name
);
1303 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1306 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1307 abfd
, section
, address
, name
);
1309 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1310 abfd
, section
, address
, name
);
1317 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1320 einfo (_("%X%B: undefined reference to `%T'\n"),
1323 einfo (_("%B: warning: undefined reference to `%T'\n"),
1326 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1329 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1332 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1342 /* Counter to limit the number of relocation overflow error messages
1343 to print. Errors are printed as it is decremented. When it's
1344 called and the counter is zero, a final message is printed
1345 indicating more relocations were omitted. When it gets to -1, no
1346 such errors are printed. If it's initially set to a value less
1347 than -1, all such errors will be printed (--verbose does this). */
1349 int overflow_cutoff_limit
= 10;
1351 /* This is called when a reloc overflows. */
1354 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1355 struct bfd_link_hash_entry
*entry
,
1357 const char *reloc_name
,
1363 if (overflow_cutoff_limit
== -1)
1366 einfo ("%X%C:", abfd
, section
, address
);
1368 if (overflow_cutoff_limit
>= 0
1369 && overflow_cutoff_limit
-- == 0)
1371 einfo (_(" additional relocation overflows omitted from the output\n"));
1377 while (entry
->type
== bfd_link_hash_indirect
1378 || entry
->type
== bfd_link_hash_warning
)
1379 entry
= entry
->u
.i
.link
;
1380 switch (entry
->type
)
1382 case bfd_link_hash_undefined
:
1383 case bfd_link_hash_undefweak
:
1384 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1385 reloc_name
, entry
->root
.string
);
1387 case bfd_link_hash_defined
:
1388 case bfd_link_hash_defweak
:
1389 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1390 reloc_name
, entry
->root
.string
,
1391 entry
->u
.def
.section
,
1392 entry
->u
.def
.section
== bfd_abs_section_ptr
1393 ? link_info
.output_bfd
: entry
->u
.def
.section
->owner
);
1401 einfo (_(" relocation truncated to fit: %s against `%T'"),
1404 einfo ("+%v", addend
);
1409 /* This is called when a dangerous relocation is made. */
1412 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1413 const char *message
,
1418 einfo (_("%X%C: dangerous relocation: %s\n"),
1419 abfd
, section
, address
, message
);
1423 /* This is called when a reloc is being generated attached to a symbol
1424 that is not being output. */
1427 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1433 einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1434 abfd
, section
, address
, name
);
1438 /* This is called if link_info.notice_all is set, or when a symbol in
1439 link_info.notice_hash is found. Symbols are put in notice_hash
1440 using the -y option, while notice_all is set if the --cref option
1441 has been supplied, or if there are any NOCROSSREFS sections in the
1442 linker script; and if plugins are active, since they need to monitor
1443 all references from non-IR files. */
1446 notice (struct bfd_link_info
*info
,
1454 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1455 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1459 #ifdef ENABLE_PLUGINS
1460 /* We should hide symbols in the dummy IR BFDs from the nocrossrefs list
1461 and let the real object files that are generated and added later trip
1462 the error instead. Similarly would be better to trace the real symbol
1463 from the real file than the temporary dummy. */
1464 if (!plugin_notice (info
, name
, abfd
, section
, value
))
1466 #endif /* ENABLE_PLUGINS */
1468 if (info
->notice_hash
!= NULL
1469 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1471 if (bfd_is_und_section (section
))
1472 einfo ("%B: reference to %s\n", abfd
, name
);
1474 einfo ("%B: definition of %s\n", abfd
, name
);
1477 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1478 add_cref (name
, abfd
, section
, value
);