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"),
486 plugin_error_plugin ());
487 #endif /* ENABLE_PLUGINS */
489 /* Even if we're producing relocatable output, some non-fatal errors should
490 be reported in the exit status. (What non-fatal errors, if any, do we
491 want to ignore for relocatable output?) */
492 if (!config
.make_executable
&& !force_make_executable
)
495 einfo (_("%P: link errors found, deleting executable `%s'\n"),
498 /* The file will be removed by remove_output. */
503 if (! bfd_close (link_info
.output_bfd
))
504 einfo (_("%F%B: final close failed: %E\n"), link_info
.output_bfd
);
506 /* If the --force-exe-suffix is enabled, and we're making an
507 executable file and it doesn't end in .exe, copy it to one
509 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
511 int len
= strlen (output_filename
);
514 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
515 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
519 const int bsize
= 4096;
520 char *buf
= (char *) xmalloc (bsize
);
522 char *dst_name
= (char *) xmalloc (len
+ 5);
524 strcpy (dst_name
, output_filename
);
525 strcat (dst_name
, ".exe");
526 src
= fopen (output_filename
, FOPEN_RB
);
527 dst
= fopen (dst_name
, FOPEN_WB
);
530 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
533 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
535 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
537 int done
= fwrite (buf
, 1, l
, dst
);
540 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
544 if (fclose (dst
) == EOF
)
545 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
552 END_PROGRESS (program_name
);
557 char *lim
= (char *) sbrk (0);
559 long run_time
= get_run_time () - start_time
;
561 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
562 program_name
, run_time
/ 1000000, run_time
% 1000000);
564 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
565 (long) (lim
- (char *) &environ
));
569 /* Prevent remove_output from doing anything, after a successful link. */
570 output_filename
= NULL
;
576 /* If the configured sysroot is relocatable, try relocating it based on
577 default prefix FROM. Return the relocated directory if it exists,
578 otherwise return null. */
581 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
583 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
587 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
590 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
598 /* Return the sysroot directory. Return "" if no sysroot is being used. */
601 get_sysroot (int argc
, char **argv
)
606 for (i
= 1; i
< argc
; i
++)
607 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
608 return argv
[i
] + strlen ("--sysroot=");
610 path
= get_relative_sysroot (BINDIR
);
614 path
= get_relative_sysroot (TOOLBINDIR
);
618 return TARGET_SYSTEM_ROOT
;
621 /* We need to find any explicitly given emulation in order to initialize the
622 state that's needed by the lex&yacc argument parser (parse_args). */
625 get_emulation (int argc
, char **argv
)
630 emulation
= getenv (EMULATION_ENVIRON
);
631 if (emulation
== NULL
)
632 emulation
= DEFAULT_EMULATION
;
634 for (i
= 1; i
< argc
; i
++)
636 if (CONST_STRNEQ (argv
[i
], "-m"))
638 if (argv
[i
][2] == '\0')
643 emulation
= argv
[i
+ 1];
647 einfo (_("%P%F: missing argument to -m\n"));
649 else if (strcmp (argv
[i
], "-mips1") == 0
650 || strcmp (argv
[i
], "-mips2") == 0
651 || strcmp (argv
[i
], "-mips3") == 0
652 || strcmp (argv
[i
], "-mips4") == 0
653 || strcmp (argv
[i
], "-mips5") == 0
654 || strcmp (argv
[i
], "-mips32") == 0
655 || strcmp (argv
[i
], "-mips32r2") == 0
656 || strcmp (argv
[i
], "-mips64") == 0
657 || strcmp (argv
[i
], "-mips64r2") == 0)
659 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
660 passed to the linker by some MIPS compilers. They
661 generally tell the linker to use a slightly different
662 library path. Perhaps someday these should be
663 implemented as emulations; until then, we just ignore
664 the arguments and hope that nobody ever creates
665 emulations named ips1, ips2 or ips3. */
667 else if (strcmp (argv
[i
], "-m486") == 0)
669 /* FIXME: The argument -m486 is passed to the linker on
670 some Linux systems. Hope that nobody creates an
671 emulation named 486. */
676 emulation
= &argv
[i
][2];
685 add_ysym (const char *name
)
687 if (link_info
.notice_hash
== NULL
)
689 link_info
.notice_hash
=
690 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
691 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
693 sizeof (struct bfd_hash_entry
),
695 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
698 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
699 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
702 /* Record a symbol to be wrapped, from the --wrap option. */
705 add_wrap (const char *name
)
707 if (link_info
.wrap_hash
== NULL
)
709 link_info
.wrap_hash
=
710 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
711 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
713 sizeof (struct bfd_hash_entry
),
715 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
718 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
719 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
722 /* Handle the -retain-symbols-file option. */
725 add_keepsyms_file (const char *filename
)
732 if (link_info
.strip
== strip_some
)
733 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
735 file
= fopen (filename
, "r");
738 bfd_set_error (bfd_error_system_call
);
739 einfo ("%X%P: %s: %E\n", filename
);
743 link_info
.keep_hash
= (struct bfd_hash_table
*)
744 xmalloc (sizeof (struct bfd_hash_table
));
745 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
746 sizeof (struct bfd_hash_entry
)))
747 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
750 buf
= (char *) xmalloc (bufsize
);
762 while (! ISSPACE (c
) && c
!= EOF
)
769 buf
= (char *) xrealloc (buf
, bufsize
);
776 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
777 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
781 if (link_info
.strip
!= strip_none
)
782 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
785 link_info
.strip
= strip_some
;
788 /* Callbacks from the BFD linker routines. */
790 /* This is called when BFD has decided to include an archive member in
794 add_archive_element (struct bfd_link_info
*info
,
797 bfd
**subsbfd ATTRIBUTE_UNUSED
)
799 lang_input_statement_type
*input
;
800 lang_input_statement_type orig_input
;
802 input
= (lang_input_statement_type
*)
803 xcalloc (1, sizeof (lang_input_statement_type
));
804 input
->filename
= abfd
->filename
;
805 input
->local_sym_name
= abfd
->filename
;
806 input
->the_bfd
= abfd
;
808 /* Save the original data for trace files/tries below, as plugins
809 (if enabled) may possibly alter it to point to a replacement
810 BFD, but we still want to output the original BFD filename. */
812 #ifdef ENABLE_PLUGINS
813 if (bfd_my_archive (abfd
) != NULL
&& plugin_active_plugins_p ())
815 /* We must offer this archive member to the plugins to claim. */
816 int fd
= open (bfd_my_archive (abfd
)->filename
, O_RDONLY
| O_BINARY
);
819 struct ld_plugin_input_file file
;
821 /* Offset and filesize must refer to the individual archive
822 member, not the whole file, and must exclude the header.
823 Fortunately for us, that is how the data is stored in the
824 origin field of the bfd and in the arelt_data. */
825 file
.name
= bfd_my_archive (abfd
)->filename
;
826 file
.offset
= abfd
->origin
;
827 file
.filesize
= arelt_size (abfd
);
829 /* We create a dummy BFD, initially empty, to house
830 whatever symbols the plugin may want to add. */
831 file
.handle
= plugin_get_ir_dummy_bfd (abfd
->filename
, abfd
);
832 if (plugin_call_claim_file (&file
, &claimed
))
833 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
834 plugin_error_plugin ());
835 /* fd belongs to us, not the plugin; but we don't need it. */
839 /* Substitute the dummy BFD. */
840 input
->the_bfd
= file
.handle
;
841 input
->claimed
= TRUE
;
842 bfd_make_readable (input
->the_bfd
);
843 *subsbfd
= input
->the_bfd
;
847 /* Abandon the dummy BFD. */
848 bfd_close_all_done (file
.handle
);
849 input
->claimed
= FALSE
;
853 #endif /* ENABLE_PLUGINS */
855 ldlang_add_file (input
);
857 if (config
.map_file
!= NULL
)
859 static bfd_boolean header_printed
;
860 struct bfd_link_hash_entry
*h
;
864 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
876 case bfd_link_hash_defined
:
877 case bfd_link_hash_defweak
:
878 from
= h
->u
.def
.section
->owner
;
881 case bfd_link_hash_undefined
:
882 case bfd_link_hash_undefweak
:
883 from
= h
->u
.undef
.abfd
;
886 case bfd_link_hash_common
:
887 from
= h
->u
.c
.p
->section
->owner
;
892 if (! header_printed
)
896 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
898 header_printed
= TRUE
;
901 if (bfd_my_archive (abfd
) == NULL
)
903 minfo ("%s", bfd_get_filename (abfd
));
904 len
= strlen (bfd_get_filename (abfd
));
908 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
909 bfd_get_filename (abfd
));
910 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
911 + strlen (bfd_get_filename (abfd
))
929 minfo ("(%T)\n", h
->root
.string
);
931 minfo ("(%s)\n", name
);
934 if (trace_files
|| trace_file_tries
)
935 info_msg ("%I\n", &orig_input
);
939 /* This is called when BFD has discovered a symbol which is defined
943 multiple_definition (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
952 #ifdef ENABLE_PLUGINS
953 /* We may get called back even when --allow-multiple-definition is in
954 effect, as the plugin infrastructure needs to use this hook in
955 order to swap out IR-only symbols for real ones. In that case,
956 it will let us know not to continue by returning TRUE even if this
957 is not an IR-only vs. non-IR symbol conflict. */
958 if (plugin_multiple_definition (info
, name
, obfd
, osec
, oval
, nbfd
,
961 #endif /* ENABLE_PLUGINS */
963 /* If either section has the output_section field set to
964 bfd_abs_section_ptr, it means that the section is being
965 discarded, and this is not really a multiple definition at all.
966 FIXME: It would be cleaner to somehow ignore symbols defined in
967 sections which are being discarded. */
968 if ((osec
->output_section
!= NULL
969 && ! bfd_is_abs_section (osec
)
970 && bfd_is_abs_section (osec
->output_section
))
971 || (nsec
->output_section
!= NULL
972 && ! bfd_is_abs_section (nsec
)
973 && bfd_is_abs_section (nsec
->output_section
)))
976 einfo (_("%X%C: multiple definition of `%T'\n"),
977 nbfd
, nsec
, nval
, name
);
979 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
981 if (RELAXATION_ENABLED
)
983 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
984 command_line
.disable_target_specific_optimizations
= -1;
990 /* This is called when there is a definition of a common symbol, or
991 when a common symbol is found for a symbol that is already defined,
992 or when two common symbols are found. We only do something if
993 -warn-common was used. */
996 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
999 enum bfd_link_hash_type otype
,
1002 enum bfd_link_hash_type ntype
,
1005 if (! config
.warn_common
)
1008 if (ntype
== bfd_link_hash_defined
1009 || ntype
== bfd_link_hash_defweak
1010 || ntype
== bfd_link_hash_indirect
)
1012 ASSERT (otype
== bfd_link_hash_common
);
1013 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1016 einfo (_("%B: warning: common is here\n"), obfd
);
1018 else if (otype
== bfd_link_hash_defined
1019 || otype
== bfd_link_hash_defweak
1020 || otype
== bfd_link_hash_indirect
)
1022 ASSERT (ntype
== bfd_link_hash_common
);
1023 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1026 einfo (_("%B: warning: defined here\n"), obfd
);
1030 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1033 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1036 einfo (_("%B: warning: larger common is here\n"), obfd
);
1038 else if (nsize
> osize
)
1040 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1043 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1047 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1049 einfo (_("%B: warning: previous common is here\n"), obfd
);
1056 /* This is called when BFD has discovered a set element. H is the
1057 entry in the linker hash table for the set. SECTION and VALUE
1058 represent a value which should be added to the set. */
1061 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1062 struct bfd_link_hash_entry
*h
,
1063 bfd_reloc_code_real_type reloc
,
1068 if (config
.warn_constructors
)
1069 einfo (_("%P: warning: global constructor %s used\n"),
1072 if (! config
.build_constructors
)
1075 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1077 if (h
->type
== bfd_link_hash_new
)
1079 h
->type
= bfd_link_hash_undefined
;
1080 h
->u
.undef
.abfd
= abfd
;
1081 /* We don't call bfd_link_add_undef to add this to the list of
1082 undefined symbols because we are going to define it
1089 /* This is called when BFD has discovered a constructor. This is only
1090 called for some object file formats--those which do not handle
1091 constructors in some more clever fashion. This is similar to
1092 adding an element to a set, but less general. */
1095 constructor_callback (struct bfd_link_info
*info
,
1096 bfd_boolean constructor
,
1103 struct bfd_link_hash_entry
*h
;
1104 char set_name
[1 + sizeof "__CTOR_LIST__"];
1106 if (config
.warn_constructors
)
1107 einfo (_("%P: warning: global constructor %s used\n"), name
);
1109 if (! config
.build_constructors
)
1112 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1113 useful error message. */
1114 if (bfd_reloc_type_lookup (link_info
.output_bfd
, BFD_RELOC_CTOR
) == NULL
1115 && (info
->relocatable
1116 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1117 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1120 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1121 *s
++ = bfd_get_symbol_leading_char (abfd
);
1123 strcpy (s
, "__CTOR_LIST__");
1125 strcpy (s
, "__DTOR_LIST__");
1127 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1128 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1129 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1130 if (h
->type
== bfd_link_hash_new
)
1132 h
->type
= bfd_link_hash_undefined
;
1133 h
->u
.undef
.abfd
= abfd
;
1134 /* We don't call bfd_link_add_undef to add this to the list of
1135 undefined symbols because we are going to define it
1139 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1143 /* A structure used by warning_callback to pass information through
1144 bfd_map_over_sections. */
1146 struct warning_callback_info
1149 const char *warning
;
1154 /* This is called when there is a reference to a warning symbol. */
1157 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1158 const char *warning
,
1164 /* This is a hack to support warn_multiple_gp. FIXME: This should
1165 have a cleaner interface, but what? */
1166 if (! config
.warn_multiple_gp
1167 && strcmp (warning
, "using multiple gp values") == 0)
1170 if (section
!= NULL
)
1171 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1172 else if (abfd
== NULL
)
1173 einfo ("%P: %s%s\n", _("warning: "), warning
);
1174 else if (symbol
== NULL
)
1175 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1178 struct warning_callback_info cinfo
;
1180 /* Look through the relocs to see if we can find a plausible
1183 if (!bfd_generic_link_read_symbols (abfd
))
1184 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1186 cinfo
.found
= FALSE
;
1187 cinfo
.warning
= warning
;
1188 cinfo
.symbol
= symbol
;
1189 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1190 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1193 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1199 /* This is called by warning_callback for each section. It checks the
1200 relocs of the section to see if it can find a reference to the
1201 symbol which triggered the warning. If it can, it uses the reloc
1202 to give an error message with a file and line number. */
1205 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1207 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1211 arelent
**p
, **pend
;
1216 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1218 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1222 relpp
= (arelent
**) xmalloc (relsize
);
1223 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1225 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1228 pend
= p
+ relcount
;
1229 for (; p
< pend
&& *p
!= NULL
; p
++)
1233 if (q
->sym_ptr_ptr
!= NULL
1234 && *q
->sym_ptr_ptr
!= NULL
1235 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1237 /* We found a reloc for the symbol we are looking for. */
1238 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1248 /* This is called when an undefined symbol is found. */
1251 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1258 static char *error_name
;
1259 static unsigned int error_count
;
1261 #define MAX_ERRORS_IN_A_ROW 5
1263 if (config
.warn_once
)
1265 static struct bfd_hash_table
*hash
;
1267 /* Only warn once about a particular undefined symbol. */
1270 hash
= (struct bfd_hash_table
*)
1271 xmalloc (sizeof (struct bfd_hash_table
));
1272 if (!bfd_hash_table_init (hash
, bfd_hash_newfunc
,
1273 sizeof (struct bfd_hash_entry
)))
1274 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1277 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1280 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1281 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1284 /* We never print more than a reasonable number of errors in a row
1285 for a single symbol. */
1286 if (error_name
!= NULL
1287 && strcmp (name
, error_name
) == 0)
1292 if (error_name
!= NULL
)
1294 error_name
= xstrdup (name
);
1297 if (section
!= NULL
)
1299 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1302 einfo (_("%X%C: undefined reference to `%T'\n"),
1303 abfd
, section
, address
, name
);
1305 einfo (_("%C: warning: undefined reference to `%T'\n"),
1306 abfd
, section
, address
, name
);
1308 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1311 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1312 abfd
, section
, address
, name
);
1314 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1315 abfd
, section
, address
, name
);
1322 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1325 einfo (_("%X%B: undefined reference to `%T'\n"),
1328 einfo (_("%B: warning: undefined reference to `%T'\n"),
1331 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1334 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1337 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1347 /* Counter to limit the number of relocation overflow error messages
1348 to print. Errors are printed as it is decremented. When it's
1349 called and the counter is zero, a final message is printed
1350 indicating more relocations were omitted. When it gets to -1, no
1351 such errors are printed. If it's initially set to a value less
1352 than -1, all such errors will be printed (--verbose does this). */
1354 int overflow_cutoff_limit
= 10;
1356 /* This is called when a reloc overflows. */
1359 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1360 struct bfd_link_hash_entry
*entry
,
1362 const char *reloc_name
,
1368 if (overflow_cutoff_limit
== -1)
1371 einfo ("%X%C:", abfd
, section
, address
);
1373 if (overflow_cutoff_limit
>= 0
1374 && overflow_cutoff_limit
-- == 0)
1376 einfo (_(" additional relocation overflows omitted from the output\n"));
1382 while (entry
->type
== bfd_link_hash_indirect
1383 || entry
->type
== bfd_link_hash_warning
)
1384 entry
= entry
->u
.i
.link
;
1385 switch (entry
->type
)
1387 case bfd_link_hash_undefined
:
1388 case bfd_link_hash_undefweak
:
1389 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1390 reloc_name
, entry
->root
.string
);
1392 case bfd_link_hash_defined
:
1393 case bfd_link_hash_defweak
:
1394 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1395 reloc_name
, entry
->root
.string
,
1396 entry
->u
.def
.section
,
1397 entry
->u
.def
.section
== bfd_abs_section_ptr
1398 ? link_info
.output_bfd
: entry
->u
.def
.section
->owner
);
1406 einfo (_(" relocation truncated to fit: %s against `%T'"),
1409 einfo ("+%v", addend
);
1414 /* This is called when a dangerous relocation is made. */
1417 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1418 const char *message
,
1423 einfo (_("%X%C: dangerous relocation: %s\n"),
1424 abfd
, section
, address
, message
);
1428 /* This is called when a reloc is being generated attached to a symbol
1429 that is not being output. */
1432 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1438 einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1439 abfd
, section
, address
, name
);
1443 /* This is called if link_info.notice_all is set, or when a symbol in
1444 link_info.notice_hash is found. Symbols are put in notice_hash
1445 using the -y option, while notice_all is set if the --cref option
1446 has been supplied, or if there are any NOCROSSREFS sections in the
1447 linker script; and if plugins are active, since they need to monitor
1448 all references from non-IR files. */
1451 notice (struct bfd_link_info
*info
,
1459 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1460 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1464 #ifdef ENABLE_PLUGINS
1465 /* We should hide symbols in the dummy IR BFDs from the nocrossrefs list
1466 and let the real object files that are generated and added later trip
1467 the error instead. Similarly would be better to trace the real symbol
1468 from the real file than the temporary dummy. */
1469 if (!plugin_notice (info
, name
, abfd
, section
, value
))
1471 #endif /* ENABLE_PLUGINS */
1473 if (info
->notice_hash
!= NULL
1474 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1476 if (bfd_is_und_section (section
))
1477 einfo ("%B: reference to %s\n", abfd
, name
);
1479 einfo ("%B: definition of %s\n", abfd
, name
);
1482 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1483 add_cref (name
, abfd
, section
, value
);