1 /* Main program of GNU linker.
2 Copyright (C) 1991-2015 Free Software Foundation, Inc.
3 Written by Steve Chamberlain steve@cygnus.com
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
24 #include "safe-ctype.h"
25 #include "libiberty.h"
28 #include "filenames.h"
43 #include "plugin-api.h"
44 #endif /* ENABLE_PLUGINS */
46 /* Somewhere above, sys/stat.h got included. */
47 #if !defined(S_ISDIR) && defined(S_IFDIR)
48 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
59 #ifndef TARGET_SYSTEM_ROOT
60 #define TARGET_SYSTEM_ROOT ""
65 FILE *saved_script_handle
= NULL
;
66 FILE *previous_script_handle
= NULL
;
67 bfd_boolean force_make_executable
= FALSE
;
70 const char *output_filename
= "a.out";
72 /* Name this program was invoked by. */
75 /* The prefix for system library directories. */
76 const char *ld_sysroot
;
78 /* The canonical representation of ld_sysroot. */
79 char * ld_canon_sysroot
;
80 int ld_canon_sysroot_len
;
82 /* Set by -G argument, for targets like MIPS ELF. */
83 int g_switch_value
= 8;
85 /* Nonzero means print names of input files as processed. */
86 bfd_boolean trace_files
;
88 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
91 /* Nonzero means version number was printed, so exit successfully
92 instead of complaining if no input files are given. */
93 bfd_boolean version_printed
;
95 /* TRUE if we should demangle symbol names. */
96 bfd_boolean demangling
;
98 args_type command_line
;
100 ld_config_type config
;
102 sort_type sort_section
;
104 static const char *get_sysroot
106 static char *get_emulation
108 static bfd_boolean add_archive_element
109 (struct bfd_link_info
*, bfd
*, const char *, bfd
**);
110 static bfd_boolean multiple_definition
111 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
112 bfd
*, asection
*, bfd_vma
);
113 static bfd_boolean multiple_common
114 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
115 bfd
*, enum bfd_link_hash_type
, bfd_vma
);
116 static bfd_boolean add_to_set
117 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
118 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
119 static bfd_boolean constructor_callback
120 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
121 asection
*, bfd_vma
);
122 static bfd_boolean warning_callback
123 (struct bfd_link_info
*, const char *, const char *, bfd
*,
124 asection
*, bfd_vma
);
125 static void warning_find_reloc
126 (bfd
*, asection
*, void *);
127 static bfd_boolean undefined_symbol
128 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
130 static bfd_boolean reloc_overflow
131 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
132 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
133 static bfd_boolean reloc_dangerous
134 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
135 static bfd_boolean unattached_reloc
136 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
137 static bfd_boolean notice
138 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
139 struct bfd_link_hash_entry
*, bfd
*, asection
*, bfd_vma
, flagword
);
141 static struct bfd_link_callbacks link_callbacks
=
147 constructor_callback
,
157 ldlang_override_segment_assignment
160 static bfd_assert_handler_type default_bfd_assert_handler
;
162 struct bfd_link_info link_info
;
167 bfd_cache_close_all ();
168 #ifdef ENABLE_PLUGINS
169 plugin_call_cleanup ();
171 if (output_filename
&& delete_output_file_on_failure
)
172 unlink_if_ordinary (output_filename
);
175 /* If there's a BFD assertion, we'll notice and exit with an error
176 unless otherwise instructed. */
179 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
180 const char *file
, int line
)
182 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
183 config
.make_executable
= FALSE
;
187 main (int argc
, char **argv
)
190 long start_time
= get_run_time ();
192 char *start_sbrk
= (char *) sbrk (0);
195 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
196 setlocale (LC_MESSAGES
, "");
198 #if defined (HAVE_SETLOCALE)
199 setlocale (LC_CTYPE
, "");
201 bindtextdomain (PACKAGE
, LOCALEDIR
);
202 textdomain (PACKAGE
);
204 program_name
= argv
[0];
205 xmalloc_set_program_name (program_name
);
207 START_PROGRESS (program_name
, 0);
209 expandargv (&argc
, &argv
);
213 bfd_set_error_program_name (program_name
);
215 /* We want to notice and fail on those nasty BFD assertions which are
216 likely to signal incorrect output being generated but otherwise may
218 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
220 xatexit (ld_cleanup
);
222 /* Set up the sysroot directory. */
223 ld_sysroot
= get_sysroot (argc
, argv
);
226 if (*TARGET_SYSTEM_ROOT
== 0)
228 einfo ("%P%F: this linker was not configured to use sysroots\n");
232 ld_canon_sysroot
= lrealpath (ld_sysroot
);
234 if (ld_canon_sysroot
)
235 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
237 ld_canon_sysroot_len
= -1;
239 /* Set the default BFD target based on the configured target. Doing
240 this permits the linker to be configured for a particular target,
241 and linked against a shared BFD library which was configured for
242 a different target. The macro TARGET is defined by Makefile. */
243 if (! bfd_set_default_target (TARGET
))
245 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
256 config
.build_constructors
= TRUE
;
257 config
.rpath_separator
= ':';
258 config
.split_by_reloc
= (unsigned) -1;
259 config
.split_by_file
= (bfd_size_type
) -1;
260 config
.make_executable
= TRUE
;
261 config
.magic_demand_paged
= TRUE
;
262 config
.text_read_only
= TRUE
;
263 link_info
.disable_target_specific_optimizations
= -1;
265 command_line
.warn_mismatch
= TRUE
;
266 command_line
.warn_search_mismatch
= TRUE
;
267 command_line
.check_section_addresses
= -1;
269 /* We initialize DEMANGLING based on the environment variable
270 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
271 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
272 environment. Acting the same way here lets us provide the same
273 interface by default. */
274 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
276 link_info
.allow_undefined_version
= TRUE
;
277 link_info
.keep_memory
= TRUE
;
278 link_info
.combreloc
= TRUE
;
279 link_info
.strip_discarded
= TRUE
;
280 link_info
.emit_hash
= TRUE
;
281 link_info
.callbacks
= &link_callbacks
;
282 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
283 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
284 and _fini symbols. We are compatible. */
285 link_info
.init_function
= "_init";
286 link_info
.fini_function
= "_fini";
287 link_info
.relax_pass
= 1;
288 link_info
.extern_protected_data
= -1;
289 link_info
.pei386_auto_import
= -1;
290 link_info
.spare_dynamic_tags
= 5;
291 link_info
.path_separator
= ':';
293 ldfile_add_arch ("");
294 emulation
= get_emulation (argc
, argv
);
295 ldemul_choose_mode (emulation
);
296 default_target
= ldemul_choose_target (argc
, argv
);
297 config
.maxpagesize
= bfd_emul_get_maxpagesize (default_target
);
298 config
.commonpagesize
= bfd_emul_get_commonpagesize (default_target
);
301 ldemul_before_parse ();
302 lang_has_input_file
= FALSE
;
303 parse_args (argc
, argv
);
305 if (config
.hash_table_size
!= 0)
306 bfd_hash_set_default_size (config
.hash_table_size
);
308 #ifdef ENABLE_PLUGINS
309 /* Now all the plugin arguments have been gathered, we can load them. */
310 plugin_load_plugins ();
311 #endif /* ENABLE_PLUGINS */
313 ldemul_set_symbols ();
315 /* If we have not already opened and parsed a linker script,
316 try the default script from command line first. */
317 if (saved_script_handle
== NULL
318 && command_line
.default_script
!= NULL
)
320 ldfile_open_command_file (command_line
.default_script
);
321 parser_input
= input_script
;
325 /* If we have not already opened and parsed a linker script
326 read the emulation's appropriate default script. */
327 if (saved_script_handle
== NULL
)
330 char *s
= ldemul_get_script (&isfile
);
333 ldfile_open_default_command_file (s
);
337 lex_redirect (s
, _("built in linker script"), 1);
339 parser_input
= input_script
;
346 if (saved_script_handle
)
347 info_msg (_("using external linker script:"));
349 info_msg (_("using internal linker script:"));
350 info_msg ("\n==================================================\n");
352 if (saved_script_handle
)
354 static const int ld_bufsz
= 8193;
356 char *buf
= (char *) xmalloc (ld_bufsz
);
358 rewind (saved_script_handle
);
359 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
364 rewind (saved_script_handle
);
371 info_msg (ldemul_get_script (&isfile
));
374 info_msg ("\n==================================================\n");
377 if (command_line
.print_output_format
)
378 info_msg ("%s\n", lang_get_output_target ());
382 /* If the only command line argument has been -v or --version or --verbose
383 then ignore any input files provided by linker scripts and exit now.
384 We do not want to create an output file when the linker is just invoked
385 to provide version information. */
386 if (argc
== 2 && version_printed
)
389 if (!lang_has_input_file
)
391 if (version_printed
|| command_line
.print_output_format
)
393 einfo (_("%P%F: no input files\n"));
397 info_msg (_("%P: mode %s\n"), emulation
);
399 ldemul_after_parse ();
401 if (config
.map_filename
)
403 if (strcmp (config
.map_filename
, "-") == 0)
405 config
.map_file
= stdout
;
409 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
410 if (config
.map_file
== (FILE *) NULL
)
412 bfd_set_error (bfd_error_system_call
);
413 einfo (_("%P%F: cannot open map file %s: %E\n"),
414 config
.map_filename
);
421 /* Print error messages for any missing symbols, for any warning
422 symbols, and possibly multiple definitions. */
423 if (bfd_link_relocatable (&link_info
))
424 link_info
.output_bfd
->flags
&= ~EXEC_P
;
426 link_info
.output_bfd
->flags
|= EXEC_P
;
428 if ((link_info
.compress_debug
& COMPRESS_DEBUG
))
430 link_info
.output_bfd
->flags
|= BFD_COMPRESS
;
431 if (link_info
.compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
432 link_info
.output_bfd
->flags
|= BFD_COMPRESS_GABI
;
437 if (config
.map_file
!= NULL
)
439 if (command_line
.cref
)
440 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
441 if (nocrossref_list
!= NULL
)
442 check_nocrossrefs ();
443 if (command_line
.print_memory_usage
)
444 lang_print_memory_usage ();
447 struct bfd_link_hash_entry
* h
;
449 h
= bfd_link_hash_lookup (link_info
.hash
, "__image_base__", 0,0,1);
450 fprintf (stderr
, "lookup = %p val %lx\n", h
, h
? h
->u
.def
.value
: 1);
456 /* Even if we're producing relocatable output, some non-fatal errors should
457 be reported in the exit status. (What non-fatal errors, if any, do we
458 want to ignore for relocatable output?) */
459 if (!config
.make_executable
&& !force_make_executable
)
462 einfo (_("%P: link errors found, deleting executable `%s'\n"),
465 /* The file will be removed by ld_cleanup. */
470 if (! bfd_close (link_info
.output_bfd
))
471 einfo (_("%F%B: final close failed: %E\n"), link_info
.output_bfd
);
473 /* If the --force-exe-suffix is enabled, and we're making an
474 executable file and it doesn't end in .exe, copy it to one
476 if (!bfd_link_relocatable (&link_info
)
477 && command_line
.force_exe_suffix
)
479 int len
= strlen (output_filename
);
482 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
483 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
487 const int bsize
= 4096;
488 char *buf
= (char *) xmalloc (bsize
);
490 char *dst_name
= (char *) xmalloc (len
+ 5);
492 strcpy (dst_name
, output_filename
);
493 strcat (dst_name
, ".exe");
494 src
= fopen (output_filename
, FOPEN_RB
);
495 dst
= fopen (dst_name
, FOPEN_WB
);
498 einfo (_("%P%F: unable to open for source of copy `%s'\n"),
501 einfo (_("%P%F: unable to open for destination of copy `%s'\n"),
503 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
505 int done
= fwrite (buf
, 1, l
, dst
);
508 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
512 if (fclose (dst
) == EOF
)
513 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
520 END_PROGRESS (program_name
);
525 char *lim
= (char *) sbrk (0);
527 long run_time
= get_run_time () - start_time
;
530 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
531 program_name
, run_time
/ 1000000, run_time
% 1000000);
533 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
534 (long) (lim
- start_sbrk
));
539 /* Prevent ld_cleanup from doing anything, after a successful link. */
540 output_filename
= NULL
;
546 /* If the configured sysroot is relocatable, try relocating it based on
547 default prefix FROM. Return the relocated directory if it exists,
548 otherwise return null. */
551 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
553 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
557 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
560 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
568 /* Return the sysroot directory. Return "" if no sysroot is being used. */
571 get_sysroot (int argc
, char **argv
)
576 for (i
= 1; i
< argc
; i
++)
577 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
578 return argv
[i
] + strlen ("--sysroot=");
580 path
= get_relative_sysroot (BINDIR
);
584 path
= get_relative_sysroot (TOOLBINDIR
);
588 return TARGET_SYSTEM_ROOT
;
591 /* We need to find any explicitly given emulation in order to initialize the
592 state that's needed by the lex&yacc argument parser (parse_args). */
595 get_emulation (int argc
, char **argv
)
600 emulation
= getenv (EMULATION_ENVIRON
);
601 if (emulation
== NULL
)
602 emulation
= DEFAULT_EMULATION
;
604 for (i
= 1; i
< argc
; i
++)
606 if (CONST_STRNEQ (argv
[i
], "-m"))
608 if (argv
[i
][2] == '\0')
613 emulation
= argv
[i
+ 1];
617 einfo (_("%P%F: missing argument to -m\n"));
619 else if (strcmp (argv
[i
], "-mips1") == 0
620 || strcmp (argv
[i
], "-mips2") == 0
621 || strcmp (argv
[i
], "-mips3") == 0
622 || strcmp (argv
[i
], "-mips4") == 0
623 || strcmp (argv
[i
], "-mips5") == 0
624 || strcmp (argv
[i
], "-mips32") == 0
625 || strcmp (argv
[i
], "-mips32r2") == 0
626 || strcmp (argv
[i
], "-mips32r6") == 0
627 || strcmp (argv
[i
], "-mips64") == 0
628 || strcmp (argv
[i
], "-mips64r2") == 0
629 || strcmp (argv
[i
], "-mips64r6") == 0)
631 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
632 passed to the linker by some MIPS compilers. They
633 generally tell the linker to use a slightly different
634 library path. Perhaps someday these should be
635 implemented as emulations; until then, we just ignore
636 the arguments and hope that nobody ever creates
637 emulations named ips1, ips2 or ips3. */
639 else if (strcmp (argv
[i
], "-m486") == 0)
641 /* FIXME: The argument -m486 is passed to the linker on
642 some Linux systems. Hope that nobody creates an
643 emulation named 486. */
648 emulation
= &argv
[i
][2];
657 add_ysym (const char *name
)
659 if (link_info
.notice_hash
== NULL
)
661 link_info
.notice_hash
=
662 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
663 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
665 sizeof (struct bfd_hash_entry
),
667 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
670 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
671 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
675 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
677 if (info
->ignore_hash
== NULL
)
679 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
680 if (! bfd_hash_table_init_n (info
->ignore_hash
,
682 sizeof (struct bfd_hash_entry
),
684 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
687 if (bfd_hash_lookup (info
->ignore_hash
, name
, TRUE
, TRUE
) == NULL
)
688 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
691 /* Record a symbol to be wrapped, from the --wrap option. */
694 add_wrap (const char *name
)
696 if (link_info
.wrap_hash
== NULL
)
698 link_info
.wrap_hash
=
699 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
700 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
702 sizeof (struct bfd_hash_entry
),
704 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
707 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
708 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
711 /* Handle the -retain-symbols-file option. */
714 add_keepsyms_file (const char *filename
)
721 if (link_info
.strip
== strip_some
)
722 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
724 file
= fopen (filename
, "r");
727 bfd_set_error (bfd_error_system_call
);
728 einfo ("%X%P: %s: %E\n", filename
);
732 link_info
.keep_hash
= (struct bfd_hash_table
*)
733 xmalloc (sizeof (struct bfd_hash_table
));
734 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
735 sizeof (struct bfd_hash_entry
)))
736 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
739 buf
= (char *) xmalloc (bufsize
);
751 while (! ISSPACE (c
) && c
!= EOF
)
758 buf
= (char *) xrealloc (buf
, bufsize
);
765 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
766 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
770 if (link_info
.strip
!= strip_none
)
771 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
774 link_info
.strip
= strip_some
;
778 /* Callbacks from the BFD linker routines. */
780 /* This is called when BFD has decided to include an archive member in
784 add_archive_element (struct bfd_link_info
*info
,
787 bfd
**subsbfd ATTRIBUTE_UNUSED
)
789 lang_input_statement_type
*input
;
790 lang_input_statement_type orig_input
;
792 input
= (lang_input_statement_type
*)
793 xcalloc (1, sizeof (lang_input_statement_type
));
794 input
->filename
= abfd
->filename
;
795 input
->local_sym_name
= abfd
->filename
;
796 input
->the_bfd
= abfd
;
798 /* Save the original data for trace files/tries below, as plugins
799 (if enabled) may possibly alter it to point to a replacement
800 BFD, but we still want to output the original BFD filename. */
802 #ifdef ENABLE_PLUGINS
803 if (link_info
.lto_plugin_active
&& !no_more_claiming
)
805 /* We must offer this archive member to the plugins to claim. */
806 plugin_maybe_claim (input
);
807 if (input
->flags
.claimed
)
809 input
->flags
.claim_archive
= TRUE
;
810 *subsbfd
= input
->the_bfd
;
813 #endif /* ENABLE_PLUGINS */
815 ldlang_add_file (input
);
817 if (config
.map_file
!= NULL
)
819 static bfd_boolean header_printed
;
820 struct bfd_link_hash_entry
*h
;
824 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
836 case bfd_link_hash_defined
:
837 case bfd_link_hash_defweak
:
838 from
= h
->u
.def
.section
->owner
;
841 case bfd_link_hash_undefined
:
842 case bfd_link_hash_undefweak
:
843 from
= h
->u
.undef
.abfd
;
846 case bfd_link_hash_common
:
847 from
= h
->u
.c
.p
->section
->owner
;
852 if (! header_printed
)
856 sprintf (buf
, _("Archive member included "
857 "to satisfy reference by file (symbol)\n\n"));
859 header_printed
= TRUE
;
862 if (bfd_my_archive (abfd
) == NULL
)
864 minfo ("%s", bfd_get_filename (abfd
));
865 len
= strlen (bfd_get_filename (abfd
));
869 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
870 bfd_get_filename (abfd
));
871 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
872 + strlen (bfd_get_filename (abfd
))
890 minfo ("(%T)\n", h
->root
.string
);
892 minfo ("(%s)\n", name
);
895 if (trace_files
|| verbose
)
896 info_msg ("%I\n", &orig_input
);
900 /* This is called when BFD has discovered a symbol which is defined
904 multiple_definition (struct bfd_link_info
*info
,
905 struct bfd_link_hash_entry
*h
,
915 if (info
->allow_multiple_definition
)
920 case bfd_link_hash_defined
:
921 osec
= h
->u
.def
.section
;
922 oval
= h
->u
.def
.value
;
923 obfd
= h
->u
.def
.section
->owner
;
925 case bfd_link_hash_indirect
:
926 osec
= bfd_ind_section_ptr
;
934 /* Ignore a redefinition of an absolute symbol to the
935 same value; it's harmless. */
936 if (h
->type
== bfd_link_hash_defined
937 && bfd_is_abs_section (osec
)
938 && bfd_is_abs_section (nsec
)
942 /* If either section has the output_section field set to
943 bfd_abs_section_ptr, it means that the section is being
944 discarded, and this is not really a multiple definition at all.
945 FIXME: It would be cleaner to somehow ignore symbols defined in
946 sections which are being discarded. */
947 if ((osec
->output_section
!= NULL
948 && ! bfd_is_abs_section (osec
)
949 && bfd_is_abs_section (osec
->output_section
))
950 || (nsec
->output_section
!= NULL
951 && ! bfd_is_abs_section (nsec
)
952 && bfd_is_abs_section (nsec
->output_section
)))
955 name
= h
->root
.string
;
963 einfo (_("%X%C: multiple definition of `%T'\n"),
964 nbfd
, nsec
, nval
, name
);
966 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
968 if (RELAXATION_ENABLED_BY_USER
)
970 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
977 /* This is called when there is a definition of a common symbol, or
978 when a common symbol is found for a symbol that is already defined,
979 or when two common symbols are found. We only do something if
980 -warn-common was used. */
983 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
984 struct bfd_link_hash_entry
*h
,
986 enum bfd_link_hash_type ntype
,
991 enum bfd_link_hash_type otype
;
994 if (!config
.warn_common
)
997 name
= h
->root
.string
;
999 if (otype
== bfd_link_hash_common
)
1001 obfd
= h
->u
.c
.p
->section
->owner
;
1002 osize
= h
->u
.c
.size
;
1004 else if (otype
== bfd_link_hash_defined
1005 || otype
== bfd_link_hash_defweak
)
1007 obfd
= h
->u
.def
.section
->owner
;
1012 /* FIXME: It would nice if we could report the BFD which defined
1013 an indirect symbol, but we don't have anywhere to store the
1019 if (ntype
== bfd_link_hash_defined
1020 || ntype
== bfd_link_hash_defweak
1021 || ntype
== bfd_link_hash_indirect
)
1023 ASSERT (otype
== bfd_link_hash_common
);
1024 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1027 einfo (_("%B: warning: common is here\n"), obfd
);
1029 else if (otype
== bfd_link_hash_defined
1030 || otype
== bfd_link_hash_defweak
1031 || otype
== bfd_link_hash_indirect
)
1033 ASSERT (ntype
== bfd_link_hash_common
);
1034 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1037 einfo (_("%B: warning: defined here\n"), obfd
);
1041 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1044 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1047 einfo (_("%B: warning: larger common is here\n"), obfd
);
1049 else if (nsize
> osize
)
1051 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1054 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1058 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1060 einfo (_("%B: warning: previous common is here\n"), obfd
);
1067 /* This is called when BFD has discovered a set element. H is the
1068 entry in the linker hash table for the set. SECTION and VALUE
1069 represent a value which should be added to the set. */
1072 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1073 struct bfd_link_hash_entry
*h
,
1074 bfd_reloc_code_real_type reloc
,
1079 if (config
.warn_constructors
)
1080 einfo (_("%P: warning: global constructor %s used\n"),
1083 if (! config
.build_constructors
)
1086 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1088 if (h
->type
== bfd_link_hash_new
)
1090 h
->type
= bfd_link_hash_undefined
;
1091 h
->u
.undef
.abfd
= abfd
;
1092 /* We don't call bfd_link_add_undef to add this to the list of
1093 undefined symbols because we are going to define it
1100 /* This is called when BFD has discovered a constructor. This is only
1101 called for some object file formats--those which do not handle
1102 constructors in some more clever fashion. This is similar to
1103 adding an element to a set, but less general. */
1106 constructor_callback (struct bfd_link_info
*info
,
1107 bfd_boolean constructor
,
1114 struct bfd_link_hash_entry
*h
;
1115 char set_name
[1 + sizeof "__CTOR_LIST__"];
1117 if (config
.warn_constructors
)
1118 einfo (_("%P: warning: global constructor %s used\n"), name
);
1120 if (! config
.build_constructors
)
1123 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1124 useful error message. */
1125 if (bfd_reloc_type_lookup (info
->output_bfd
, BFD_RELOC_CTOR
) == NULL
1126 && (bfd_link_relocatable (info
)
1127 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1128 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1131 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1132 *s
++ = bfd_get_symbol_leading_char (abfd
);
1134 strcpy (s
, "__CTOR_LIST__");
1136 strcpy (s
, "__DTOR_LIST__");
1138 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1139 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1140 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1141 if (h
->type
== bfd_link_hash_new
)
1143 h
->type
= bfd_link_hash_undefined
;
1144 h
->u
.undef
.abfd
= abfd
;
1145 /* We don't call bfd_link_add_undef to add this to the list of
1146 undefined symbols because we are going to define it
1150 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1154 /* A structure used by warning_callback to pass information through
1155 bfd_map_over_sections. */
1157 struct warning_callback_info
1160 const char *warning
;
1165 /* Look through the relocs to see if we can find a plausible address
1166 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1169 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1171 struct warning_callback_info cinfo
;
1173 if (!bfd_generic_link_read_symbols (abfd
))
1174 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1176 cinfo
.found
= FALSE
;
1177 cinfo
.warning
= warning
;
1178 cinfo
.symbol
= symbol
;
1179 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1180 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1184 /* This is called when there is a reference to a warning symbol. */
1187 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1188 const char *warning
,
1194 /* This is a hack to support warn_multiple_gp. FIXME: This should
1195 have a cleaner interface, but what? */
1196 if (! config
.warn_multiple_gp
1197 && strcmp (warning
, "using multiple gp values") == 0)
1200 if (section
!= NULL
)
1201 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1202 else if (abfd
== NULL
)
1203 einfo ("%P: %s%s\n", _("warning: "), warning
);
1204 else if (symbol
== NULL
)
1205 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1206 else if (! symbol_warning (warning
, symbol
, abfd
))
1209 /* Search all input files for a reference to SYMBOL. */
1210 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1211 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1213 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1219 /* This is called by warning_callback for each section. It checks the
1220 relocs of the section to see if it can find a reference to the
1221 symbol which triggered the warning. If it can, it uses the reloc
1222 to give an error message with a file and line number. */
1225 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1227 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1231 arelent
**p
, **pend
;
1236 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1238 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1242 relpp
= (arelent
**) xmalloc (relsize
);
1243 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1245 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1248 pend
= p
+ relcount
;
1249 for (; p
< pend
&& *p
!= NULL
; p
++)
1253 if (q
->sym_ptr_ptr
!= NULL
1254 && *q
->sym_ptr_ptr
!= NULL
1255 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1257 /* We found a reloc for the symbol we are looking for. */
1258 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1268 /* This is called when an undefined symbol is found. */
1271 undefined_symbol (struct bfd_link_info
*info
,
1278 static char *error_name
;
1279 static unsigned int error_count
;
1281 #define MAX_ERRORS_IN_A_ROW 5
1283 if (info
->ignore_hash
!= NULL
1284 && bfd_hash_lookup (info
->ignore_hash
, name
, FALSE
, FALSE
) != NULL
)
1287 if (config
.warn_once
)
1289 /* Only warn once about a particular undefined symbol. */
1290 add_ignoresym (info
, name
);
1293 /* We never print more than a reasonable number of errors in a row
1294 for a single symbol. */
1295 if (error_name
!= NULL
1296 && strcmp (name
, error_name
) == 0)
1301 if (error_name
!= NULL
)
1303 error_name
= xstrdup (name
);
1306 if (section
!= NULL
)
1308 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1311 einfo (_("%X%C: undefined reference to `%T'\n"),
1312 abfd
, section
, address
, name
);
1314 einfo (_("%C: warning: undefined reference to `%T'\n"),
1315 abfd
, section
, address
, name
);
1317 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1320 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1321 abfd
, section
, address
, name
);
1323 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1324 abfd
, section
, address
, name
);
1331 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1334 einfo (_("%X%B: undefined reference to `%T'\n"),
1337 einfo (_("%B: warning: undefined reference to `%T'\n"),
1340 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1343 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1346 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1356 /* Counter to limit the number of relocation overflow error messages
1357 to print. Errors are printed as it is decremented. When it's
1358 called and the counter is zero, a final message is printed
1359 indicating more relocations were omitted. When it gets to -1, no
1360 such errors are printed. If it's initially set to a value less
1361 than -1, all such errors will be printed (--verbose does this). */
1363 int overflow_cutoff_limit
= 10;
1365 /* This is called when a reloc overflows. */
1368 reloc_overflow (struct bfd_link_info
*info
,
1369 struct bfd_link_hash_entry
*entry
,
1371 const char *reloc_name
,
1377 if (overflow_cutoff_limit
== -1)
1380 einfo ("%X%H:", abfd
, section
, address
);
1382 if (overflow_cutoff_limit
>= 0
1383 && overflow_cutoff_limit
-- == 0)
1385 einfo (_(" additional relocation overflows omitted from the output\n"));
1391 while (entry
->type
== bfd_link_hash_indirect
1392 || entry
->type
== bfd_link_hash_warning
)
1393 entry
= entry
->u
.i
.link
;
1394 switch (entry
->type
)
1396 case bfd_link_hash_undefined
:
1397 case bfd_link_hash_undefweak
:
1398 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1399 reloc_name
, entry
->root
.string
);
1401 case bfd_link_hash_defined
:
1402 case bfd_link_hash_defweak
:
1403 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1404 reloc_name
, entry
->root
.string
,
1405 entry
->u
.def
.section
,
1406 entry
->u
.def
.section
== bfd_abs_section_ptr
1407 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1415 einfo (_(" relocation truncated to fit: %s against `%T'"),
1418 einfo ("+%v", addend
);
1423 /* This is called when a dangerous relocation is made. */
1426 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1427 const char *message
,
1432 einfo (_("%X%H: dangerous relocation: %s\n"),
1433 abfd
, section
, address
, message
);
1437 /* This is called when a reloc is being generated attached to a symbol
1438 that is not being output. */
1441 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1447 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1448 abfd
, section
, address
, name
);
1452 /* This is called if link_info.notice_all is set, or when a symbol in
1453 link_info.notice_hash is found. Symbols are put in notice_hash
1454 using the -y option, while notice_all is set if the --cref option
1455 has been supplied, or if there are any NOCROSSREFS sections in the
1456 linker script; and if plugins are active, since they need to monitor
1457 all references from non-IR files. */
1460 notice (struct bfd_link_info
*info
,
1461 struct bfd_link_hash_entry
*h
,
1462 struct bfd_link_hash_entry
*inh ATTRIBUTE_UNUSED
,
1466 flagword flags ATTRIBUTE_UNUSED
)
1472 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1473 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1477 name
= h
->root
.string
;
1478 if (info
->notice_hash
!= NULL
1479 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1481 if (bfd_is_und_section (section
))
1482 einfo ("%B: reference to %s\n", abfd
, name
);
1484 einfo ("%B: definition of %s\n", abfd
, name
);
1487 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1488 add_cref (name
, abfd
, section
, value
);