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. */
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
;
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
)
192 long start_time
= get_run_time ();
194 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
195 setlocale (LC_MESSAGES
, "");
197 #if defined (HAVE_SETLOCALE)
198 setlocale (LC_CTYPE
, "");
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
);
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
);
220 if (*TARGET_SYSTEM_ROOT
== 0)
222 einfo ("%P%F: this linker was not configured to use sysroots\n");
226 ld_canon_sysroot
= lrealpath (ld_sysroot
);
228 if (ld_canon_sysroot
)
229 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
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
);
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
);
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
315 switch (command_line
.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
;
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
;
336 switch (command_line
.dynamic_list
)
338 case dynamic_list_unset
:
340 case dynamic_list_data
:
341 link_info
.dynamic_data
= TRUE
;
343 link_info
.dynamic
= TRUE
;
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
;
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
)
383 char *s
= ldemul_get_script (&isfile
);
386 ldfile_open_default_command_file (s
);
392 parser_input
= input_script
;
397 if (trace_file_tries
)
399 if (saved_script_handle
)
400 info_msg (_("using external linker script:"));
402 info_msg (_("using internal linker script:"));
403 info_msg ("\n==================================================\n");
405 if (saved_script_handle
)
407 static const int ld_bufsz
= 8193;
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)
417 rewind (saved_script_handle
);
424 info_msg (ldemul_get_script (&isfile
));
427 info_msg ("\n==================================================\n");
432 if (!lang_has_input_file
)
436 einfo (_("%P%F: no input files\n"));
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
;
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
);
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
;
469 link_info
.output_bfd
->flags
|= EXEC_P
;
473 if (config
.map_file
!= NULL
)
475 if (command_line
.cref
)
476 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
477 if (nocrossref_list
!= NULL
)
478 check_nocrossrefs ();
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
)
494 einfo (_("%P: link errors found, deleting executable `%s'\n"),
497 /* The file will be removed by remove_output. */
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
508 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
510 int len
= strlen (output_filename
);
513 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
514 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
518 const int bsize
= 4096;
519 char *buf
= (char *) xmalloc (bsize
);
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
);
529 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
532 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
534 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
536 int done
= fwrite (buf
, 1, l
, dst
);
539 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
543 if (fclose (dst
) == EOF
)
544 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
551 END_PROGRESS (program_name
);
556 char *lim
= (char *) sbrk (0);
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);
563 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
564 (long) (lim
- (char *) &environ
));
568 /* Prevent remove_output from doing anything, after a successful link. */
569 output_filename
= NULL
;
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. */
580 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
582 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
586 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
589 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
597 /* Return the sysroot directory. Return "" if no sysroot is being used. */
600 get_sysroot (int argc
, char **argv
)
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
);
613 path
= get_relative_sysroot (TOOLBINDIR
);
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). */
624 get_emulation (int argc
, char **argv
)
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')
642 emulation
= argv
[i
+ 1];
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. */
675 emulation
= &argv
[i
][2];
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
,
692 sizeof (struct bfd_hash_entry
),
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. */
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
,
712 sizeof (struct bfd_hash_entry
),
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. */
724 add_keepsyms_file (const char *filename
)
731 if (link_info
.strip
== strip_some
)
732 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
734 file
= fopen (filename
, "r");
737 bfd_set_error (bfd_error_system_call
);
738 einfo ("%X%P: %s: %E\n", filename
);
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"));
749 buf
= (char *) xmalloc (bufsize
);
761 while (! ISSPACE (c
) && c
!= EOF
)
768 buf
= (char *) xrealloc (buf
, bufsize
);
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"));
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
793 add_archive_element (struct bfd_link_info
*info
,
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. */
811 #ifdef ENABLE_PLUGINS
812 if (bfd_my_archive (abfd
) != NULL
&& plugin_active_plugins_p ())
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
);
818 struct ld_plugin_input_file file
;
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
);
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 /* fd belongs to us, not the plugin; but we don't need it. */
838 /* Substitute the dummy BFD. */
839 input
->the_bfd
= file
.handle
;
840 input
->claimed
= TRUE
;
841 bfd_make_readable (input
->the_bfd
);
842 *subsbfd
= input
->the_bfd
;
846 /* Abandon the dummy BFD. */
847 bfd_close_all_done (file
.handle
);
848 input
->claimed
= FALSE
;
852 #endif /* ENABLE_PLUGINS */
854 ldlang_add_file (input
);
856 if (config
.map_file
!= NULL
)
858 static bfd_boolean header_printed
;
859 struct bfd_link_hash_entry
*h
;
863 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
875 case bfd_link_hash_defined
:
876 case bfd_link_hash_defweak
:
877 from
= h
->u
.def
.section
->owner
;
880 case bfd_link_hash_undefined
:
881 case bfd_link_hash_undefweak
:
882 from
= h
->u
.undef
.abfd
;
885 case bfd_link_hash_common
:
886 from
= h
->u
.c
.p
->section
->owner
;
891 if (! header_printed
)
895 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
897 header_printed
= TRUE
;
900 if (bfd_my_archive (abfd
) == NULL
)
902 minfo ("%s", bfd_get_filename (abfd
));
903 len
= strlen (bfd_get_filename (abfd
));
907 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
908 bfd_get_filename (abfd
));
909 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
910 + strlen (bfd_get_filename (abfd
))
928 minfo ("(%T)\n", h
->root
.string
);
930 minfo ("(%s)\n", name
);
933 if (trace_files
|| trace_file_tries
)
934 info_msg ("%I\n", &orig_input
);
938 /* This is called when BFD has discovered a symbol which is defined
942 multiple_definition (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
951 #ifdef ENABLE_PLUGINS
952 /* We may get called back even when --allow-multiple-definition is in
953 effect, as the plugin infrastructure needs to use this hook in
954 order to swap out IR-only symbols for real ones. In that case,
955 it will let us know not to continue by returning TRUE even if this
956 is not an IR-only vs. non-IR symbol conflict. */
957 if (plugin_multiple_definition (info
, name
, obfd
, osec
, oval
, nbfd
,
960 #endif /* ENABLE_PLUGINS */
962 /* If either section has the output_section field set to
963 bfd_abs_section_ptr, it means that the section is being
964 discarded, and this is not really a multiple definition at all.
965 FIXME: It would be cleaner to somehow ignore symbols defined in
966 sections which are being discarded. */
967 if ((osec
->output_section
!= NULL
968 && ! bfd_is_abs_section (osec
)
969 && bfd_is_abs_section (osec
->output_section
))
970 || (nsec
->output_section
!= NULL
971 && ! bfd_is_abs_section (nsec
)
972 && bfd_is_abs_section (nsec
->output_section
)))
975 einfo (_("%X%C: multiple definition of `%T'\n"),
976 nbfd
, nsec
, nval
, name
);
978 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
980 if (RELAXATION_ENABLED
)
982 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
983 command_line
.disable_target_specific_optimizations
= -1;
989 /* This is called when there is a definition of a common symbol, or
990 when a common symbol is found for a symbol that is already defined,
991 or when two common symbols are found. We only do something if
992 -warn-common was used. */
995 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
998 enum bfd_link_hash_type otype
,
1001 enum bfd_link_hash_type ntype
,
1004 if (! config
.warn_common
)
1007 if (ntype
== bfd_link_hash_defined
1008 || ntype
== bfd_link_hash_defweak
1009 || ntype
== bfd_link_hash_indirect
)
1011 ASSERT (otype
== bfd_link_hash_common
);
1012 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1015 einfo (_("%B: warning: common is here\n"), obfd
);
1017 else if (otype
== bfd_link_hash_defined
1018 || otype
== bfd_link_hash_defweak
1019 || otype
== bfd_link_hash_indirect
)
1021 ASSERT (ntype
== bfd_link_hash_common
);
1022 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1025 einfo (_("%B: warning: defined here\n"), obfd
);
1029 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1032 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1035 einfo (_("%B: warning: larger common is here\n"), obfd
);
1037 else if (nsize
> osize
)
1039 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1042 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1046 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1048 einfo (_("%B: warning: previous common is here\n"), obfd
);
1055 /* This is called when BFD has discovered a set element. H is the
1056 entry in the linker hash table for the set. SECTION and VALUE
1057 represent a value which should be added to the set. */
1060 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1061 struct bfd_link_hash_entry
*h
,
1062 bfd_reloc_code_real_type reloc
,
1067 if (config
.warn_constructors
)
1068 einfo (_("%P: warning: global constructor %s used\n"),
1071 if (! config
.build_constructors
)
1074 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1076 if (h
->type
== bfd_link_hash_new
)
1078 h
->type
= bfd_link_hash_undefined
;
1079 h
->u
.undef
.abfd
= abfd
;
1080 /* We don't call bfd_link_add_undef to add this to the list of
1081 undefined symbols because we are going to define it
1088 /* This is called when BFD has discovered a constructor. This is only
1089 called for some object file formats--those which do not handle
1090 constructors in some more clever fashion. This is similar to
1091 adding an element to a set, but less general. */
1094 constructor_callback (struct bfd_link_info
*info
,
1095 bfd_boolean constructor
,
1102 struct bfd_link_hash_entry
*h
;
1103 char set_name
[1 + sizeof "__CTOR_LIST__"];
1105 if (config
.warn_constructors
)
1106 einfo (_("%P: warning: global constructor %s used\n"), name
);
1108 if (! config
.build_constructors
)
1111 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1112 useful error message. */
1113 if (bfd_reloc_type_lookup (link_info
.output_bfd
, BFD_RELOC_CTOR
) == NULL
1114 && (info
->relocatable
1115 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1116 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1119 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1120 *s
++ = bfd_get_symbol_leading_char (abfd
);
1122 strcpy (s
, "__CTOR_LIST__");
1124 strcpy (s
, "__DTOR_LIST__");
1126 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1127 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1128 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1129 if (h
->type
== bfd_link_hash_new
)
1131 h
->type
= bfd_link_hash_undefined
;
1132 h
->u
.undef
.abfd
= abfd
;
1133 /* We don't call bfd_link_add_undef to add this to the list of
1134 undefined symbols because we are going to define it
1138 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1142 /* A structure used by warning_callback to pass information through
1143 bfd_map_over_sections. */
1145 struct warning_callback_info
1148 const char *warning
;
1153 /* This is called when there is a reference to a warning symbol. */
1156 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1157 const char *warning
,
1163 /* This is a hack to support warn_multiple_gp. FIXME: This should
1164 have a cleaner interface, but what? */
1165 if (! config
.warn_multiple_gp
1166 && strcmp (warning
, "using multiple gp values") == 0)
1169 if (section
!= NULL
)
1170 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1171 else if (abfd
== NULL
)
1172 einfo ("%P: %s%s\n", _("warning: "), warning
);
1173 else if (symbol
== NULL
)
1174 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1177 struct warning_callback_info cinfo
;
1179 /* Look through the relocs to see if we can find a plausible
1182 if (!bfd_generic_link_read_symbols (abfd
))
1183 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1185 cinfo
.found
= FALSE
;
1186 cinfo
.warning
= warning
;
1187 cinfo
.symbol
= symbol
;
1188 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1189 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1192 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1198 /* This is called by warning_callback for each section. It checks the
1199 relocs of the section to see if it can find a reference to the
1200 symbol which triggered the warning. If it can, it uses the reloc
1201 to give an error message with a file and line number. */
1204 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1206 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1210 arelent
**p
, **pend
;
1215 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1217 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1221 relpp
= (arelent
**) xmalloc (relsize
);
1222 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1224 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1227 pend
= p
+ relcount
;
1228 for (; p
< pend
&& *p
!= NULL
; p
++)
1232 if (q
->sym_ptr_ptr
!= NULL
1233 && *q
->sym_ptr_ptr
!= NULL
1234 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1236 /* We found a reloc for the symbol we are looking for. */
1237 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1247 /* This is called when an undefined symbol is found. */
1250 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1257 static char *error_name
;
1258 static unsigned int error_count
;
1260 #define MAX_ERRORS_IN_A_ROW 5
1262 if (config
.warn_once
)
1264 static struct bfd_hash_table
*hash
;
1266 /* Only warn once about a particular undefined symbol. */
1269 hash
= (struct bfd_hash_table
*)
1270 xmalloc (sizeof (struct bfd_hash_table
));
1271 if (!bfd_hash_table_init (hash
, bfd_hash_newfunc
,
1272 sizeof (struct bfd_hash_entry
)))
1273 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1276 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1279 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1280 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1283 /* We never print more than a reasonable number of errors in a row
1284 for a single symbol. */
1285 if (error_name
!= NULL
1286 && strcmp (name
, error_name
) == 0)
1291 if (error_name
!= NULL
)
1293 error_name
= xstrdup (name
);
1296 if (section
!= NULL
)
1298 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1301 einfo (_("%X%C: undefined reference to `%T'\n"),
1302 abfd
, section
, address
, name
);
1304 einfo (_("%C: warning: undefined reference to `%T'\n"),
1305 abfd
, section
, address
, name
);
1307 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1310 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1311 abfd
, section
, address
, name
);
1313 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1314 abfd
, section
, address
, name
);
1321 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1324 einfo (_("%X%B: undefined reference to `%T'\n"),
1327 einfo (_("%B: warning: undefined reference to `%T'\n"),
1330 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1333 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1336 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1346 /* Counter to limit the number of relocation overflow error messages
1347 to print. Errors are printed as it is decremented. When it's
1348 called and the counter is zero, a final message is printed
1349 indicating more relocations were omitted. When it gets to -1, no
1350 such errors are printed. If it's initially set to a value less
1351 than -1, all such errors will be printed (--verbose does this). */
1353 int overflow_cutoff_limit
= 10;
1355 /* This is called when a reloc overflows. */
1358 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1359 struct bfd_link_hash_entry
*entry
,
1361 const char *reloc_name
,
1367 if (overflow_cutoff_limit
== -1)
1370 einfo ("%X%C:", abfd
, section
, address
);
1372 if (overflow_cutoff_limit
>= 0
1373 && overflow_cutoff_limit
-- == 0)
1375 einfo (_(" additional relocation overflows omitted from the output\n"));
1381 while (entry
->type
== bfd_link_hash_indirect
1382 || entry
->type
== bfd_link_hash_warning
)
1383 entry
= entry
->u
.i
.link
;
1384 switch (entry
->type
)
1386 case bfd_link_hash_undefined
:
1387 case bfd_link_hash_undefweak
:
1388 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1389 reloc_name
, entry
->root
.string
);
1391 case bfd_link_hash_defined
:
1392 case bfd_link_hash_defweak
:
1393 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1394 reloc_name
, entry
->root
.string
,
1395 entry
->u
.def
.section
,
1396 entry
->u
.def
.section
== bfd_abs_section_ptr
1397 ? link_info
.output_bfd
: entry
->u
.def
.section
->owner
);
1405 einfo (_(" relocation truncated to fit: %s against `%T'"),
1408 einfo ("+%v", addend
);
1413 /* This is called when a dangerous relocation is made. */
1416 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1417 const char *message
,
1422 einfo (_("%X%C: dangerous relocation: %s\n"),
1423 abfd
, section
, address
, message
);
1427 /* This is called when a reloc is being generated attached to a symbol
1428 that is not being output. */
1431 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1437 einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1438 abfd
, section
, address
, name
);
1442 /* This is called if link_info.notice_all is set, or when a symbol in
1443 link_info.notice_hash is found. Symbols are put in notice_hash
1444 using the -y option, while notice_all is set if the --cref option
1445 has been supplied, or if there are any NOCROSSREFS sections in the
1446 linker script; and if plugins are active, since they need to monitor
1447 all references from non-IR files. */
1450 notice (struct bfd_link_info
*info
,
1458 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1459 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1463 #ifdef ENABLE_PLUGINS
1464 /* We should hide symbols in the dummy IR BFDs from the nocrossrefs list
1465 and let the real object files that are generated and added later trip
1466 the error instead. Similarly would be better to trace the real symbol
1467 from the real file than the temporary dummy. */
1468 if (!plugin_notice (info
, name
, abfd
, section
, value
))
1470 #endif /* ENABLE_PLUGINS */
1472 if (info
->notice_hash
!= NULL
1473 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1475 if (bfd_is_und_section (section
))
1476 einfo ("%B: reference to %s\n", abfd
, name
);
1478 einfo ("%B: definition of %s\n", abfd
, name
);
1481 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1482 add_cref (name
, abfd
, section
, value
);