1 /* Main program of GNU linker.
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
3 Written by Steve Chamberlain steve@cygnus.com
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
24 #include "safe-ctype.h"
25 #include "libiberty.h"
28 #include "filenames.h"
43 #include "plugin-api.h"
45 #endif /* ENABLE_PLUGINS */
47 /* Somewhere above, sys/stat.h got included. */
48 #if !defined(S_ISDIR) && defined(S_IFDIR)
49 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
60 #ifndef TARGET_SYSTEM_ROOT
61 #define TARGET_SYSTEM_ROOT ""
66 FILE *saved_script_handle
= NULL
;
67 FILE *previous_script_handle
= NULL
;
68 bfd_boolean force_make_executable
= FALSE
;
71 const char *output_filename
= "a.out";
73 /* Name this program was invoked by. */
76 /* The prefix for system library directories. */
77 const char *ld_sysroot
;
79 /* The canonical representation of ld_sysroot. */
80 char * ld_canon_sysroot
;
81 int ld_canon_sysroot_len
;
83 /* Set by -G argument, for targets like MIPS ELF. */
84 int g_switch_value
= 8;
86 /* Nonzero means print names of input files as processed. */
87 bfd_boolean trace_files
;
89 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
92 /* Nonzero means version number was printed, so exit successfully
93 instead of complaining if no input files are given. */
94 bfd_boolean version_printed
;
96 /* TRUE if we should demangle symbol names. */
97 bfd_boolean demangling
;
99 args_type command_line
;
101 ld_config_type config
;
103 sort_type sort_section
;
105 static const char *get_sysroot
107 static char *get_emulation
109 static bfd_boolean add_archive_element
110 (struct bfd_link_info
*, bfd
*, const char *, bfd
**);
111 static bfd_boolean multiple_definition
112 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
113 bfd
*, asection
*, bfd_vma
);
114 static bfd_boolean multiple_common
115 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
116 bfd
*, enum bfd_link_hash_type
, bfd_vma
);
117 static bfd_boolean add_to_set
118 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
119 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
120 static bfd_boolean constructor_callback
121 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
122 asection
*, bfd_vma
);
123 static bfd_boolean warning_callback
124 (struct bfd_link_info
*, const char *, const char *, bfd
*,
125 asection
*, bfd_vma
);
126 static void warning_find_reloc
127 (bfd
*, asection
*, void *);
128 static bfd_boolean undefined_symbol
129 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
131 static bfd_boolean reloc_overflow
132 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
133 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
134 static bfd_boolean reloc_dangerous
135 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
136 static bfd_boolean unattached_reloc
137 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
138 static bfd_boolean notice
139 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
140 bfd
*, asection
*, bfd_vma
, flagword
, const char *);
142 static struct bfd_link_callbacks link_callbacks
=
148 constructor_callback
,
158 ldlang_override_segment_assignment
161 static bfd_assert_handler_type default_bfd_assert_handler
;
163 struct bfd_link_info link_info
;
168 bfd_cache_close_all ();
169 #ifdef ENABLE_PLUGINS
170 plugin_call_cleanup ();
172 if (output_filename
&& delete_output_file_on_failure
)
173 unlink_if_ordinary (output_filename
);
176 /* If there's a BFD assertion, we'll notice and exit with an error
177 unless otherwise instructed. */
180 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
181 const char *file
, int line
)
183 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
184 config
.make_executable
= FALSE
;
188 main (int argc
, char **argv
)
191 long start_time
= get_run_time ();
193 char *start_sbrk
= (char *) sbrk (0);
196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
197 setlocale (LC_MESSAGES
, "");
199 #if defined (HAVE_SETLOCALE)
200 setlocale (LC_CTYPE
, "");
202 bindtextdomain (PACKAGE
, LOCALEDIR
);
203 textdomain (PACKAGE
);
205 program_name
= argv
[0];
206 xmalloc_set_program_name (program_name
);
208 START_PROGRESS (program_name
, 0);
210 expandargv (&argc
, &argv
);
214 bfd_set_error_program_name (program_name
);
216 /* We want to notice and fail on those nasty BFD assertions which are
217 likely to signal incorrect output being generated but otherwise may
219 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
221 xatexit (ld_cleanup
);
223 /* Set up the sysroot directory. */
224 ld_sysroot
= get_sysroot (argc
, argv
);
227 if (*TARGET_SYSTEM_ROOT
== 0)
229 einfo ("%P%F: this linker was not configured to use sysroots\n");
233 ld_canon_sysroot
= lrealpath (ld_sysroot
);
235 if (ld_canon_sysroot
)
236 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
238 ld_canon_sysroot_len
= -1;
240 /* Set the default BFD target based on the configured target. Doing
241 this permits the linker to be configured for a particular target,
242 and linked against a shared BFD library which was configured for
243 a different target. The macro TARGET is defined by Makefile. */
244 if (! bfd_set_default_target (TARGET
))
246 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
257 config
.build_constructors
= TRUE
;
258 config
.rpath_separator
= ':';
259 config
.split_by_reloc
= (unsigned) -1;
260 config
.split_by_file
= (bfd_size_type
) -1;
261 config
.make_executable
= TRUE
;
262 config
.magic_demand_paged
= TRUE
;
263 config
.text_read_only
= TRUE
;
264 link_info
.disable_target_specific_optimizations
= -1;
266 command_line
.warn_mismatch
= TRUE
;
267 command_line
.warn_search_mismatch
= TRUE
;
268 command_line
.check_section_addresses
= -1;
270 /* We initialize DEMANGLING based on the environment variable
271 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
272 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
273 environment. Acting the same way here lets us provide the same
274 interface by default. */
275 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
277 link_info
.allow_undefined_version
= TRUE
;
278 link_info
.keep_memory
= TRUE
;
279 link_info
.combreloc
= TRUE
;
280 link_info
.strip_discarded
= TRUE
;
281 link_info
.emit_hash
= TRUE
;
282 link_info
.callbacks
= &link_callbacks
;
283 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
284 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
285 and _fini symbols. We are compatible. */
286 link_info
.init_function
= "_init";
287 link_info
.fini_function
= "_fini";
288 link_info
.relax_pass
= 1;
289 link_info
.pei386_auto_import
= -1;
290 link_info
.spare_dynamic_tags
= 5;
291 link_info
.path_separator
= ':';
293 ldfile_add_arch ("");
294 emulation
= get_emulation (argc
, argv
);
295 ldemul_choose_mode (emulation
);
296 default_target
= ldemul_choose_target (argc
, argv
);
297 config
.maxpagesize
= bfd_emul_get_maxpagesize (default_target
);
298 config
.commonpagesize
= bfd_emul_get_commonpagesize (default_target
);
300 ldemul_before_parse ();
301 lang_has_input_file
= FALSE
;
302 parse_args (argc
, argv
);
304 if (config
.hash_table_size
!= 0)
305 bfd_hash_set_default_size (config
.hash_table_size
);
307 #ifdef ENABLE_PLUGINS
308 /* Now all the plugin arguments have been gathered, we can load them. */
309 plugin_load_plugins ();
310 #endif /* ENABLE_PLUGINS */
312 ldemul_set_symbols ();
314 /* If we have not already opened and parsed a linker script,
315 try the default script from command line first. */
316 if (saved_script_handle
== NULL
317 && command_line
.default_script
!= NULL
)
319 ldfile_open_command_file (command_line
.default_script
);
320 parser_input
= input_script
;
324 /* If we have not already opened and parsed a linker script
325 read the emulation's appropriate default script. */
326 if (saved_script_handle
== NULL
)
329 char *s
= ldemul_get_script (&isfile
);
332 ldfile_open_default_command_file (s
);
336 lex_redirect (s
, _("built in linker script"), 1);
338 parser_input
= input_script
;
345 if (saved_script_handle
)
346 info_msg (_("using external linker script:"));
348 info_msg (_("using internal linker script:"));
349 info_msg ("\n==================================================\n");
351 if (saved_script_handle
)
353 static const int ld_bufsz
= 8193;
355 char *buf
= (char *) xmalloc (ld_bufsz
);
357 rewind (saved_script_handle
);
358 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
363 rewind (saved_script_handle
);
370 info_msg (ldemul_get_script (&isfile
));
373 info_msg ("\n==================================================\n");
376 if (command_line
.print_output_format
)
377 info_msg ("%s\n", lang_get_output_target ());
381 if (!lang_has_input_file
)
383 if (version_printed
|| command_line
.print_output_format
)
385 einfo (_("%P%F: no input files\n"));
389 info_msg (_("%P: mode %s\n"), emulation
);
391 ldemul_after_parse ();
393 if (config
.map_filename
)
395 if (strcmp (config
.map_filename
, "-") == 0)
397 config
.map_file
= stdout
;
401 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
402 if (config
.map_file
== (FILE *) NULL
)
404 bfd_set_error (bfd_error_system_call
);
405 einfo (_("%P%F: cannot open map file %s: %E\n"),
406 config
.map_filename
);
413 /* Print error messages for any missing symbols, for any warning
414 symbols, and possibly multiple definitions. */
415 if (link_info
.relocatable
)
416 link_info
.output_bfd
->flags
&= ~EXEC_P
;
418 link_info
.output_bfd
->flags
|= EXEC_P
;
422 if (config
.map_file
!= NULL
)
424 if (command_line
.cref
)
425 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
426 if (nocrossref_list
!= NULL
)
427 check_nocrossrefs ();
431 /* Even if we're producing relocatable output, some non-fatal errors should
432 be reported in the exit status. (What non-fatal errors, if any, do we
433 want to ignore for relocatable output?) */
434 if (!config
.make_executable
&& !force_make_executable
)
437 einfo (_("%P: link errors found, deleting executable `%s'\n"),
440 /* The file will be removed by ld_cleanup. */
445 if (! bfd_close (link_info
.output_bfd
))
446 einfo (_("%F%B: final close failed: %E\n"), link_info
.output_bfd
);
448 /* If the --force-exe-suffix is enabled, and we're making an
449 executable file and it doesn't end in .exe, copy it to one
451 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
453 int len
= strlen (output_filename
);
456 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
457 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
461 const int bsize
= 4096;
462 char *buf
= (char *) xmalloc (bsize
);
464 char *dst_name
= (char *) xmalloc (len
+ 5);
466 strcpy (dst_name
, output_filename
);
467 strcat (dst_name
, ".exe");
468 src
= fopen (output_filename
, FOPEN_RB
);
469 dst
= fopen (dst_name
, FOPEN_WB
);
472 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
475 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
477 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
479 int done
= fwrite (buf
, 1, l
, dst
);
482 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
486 if (fclose (dst
) == EOF
)
487 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
494 END_PROGRESS (program_name
);
499 char *lim
= (char *) sbrk (0);
501 long run_time
= get_run_time () - start_time
;
504 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
505 program_name
, run_time
/ 1000000, run_time
% 1000000);
507 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
508 (long) (lim
- start_sbrk
));
513 /* Prevent ld_cleanup from doing anything, after a successful link. */
514 output_filename
= NULL
;
520 /* If the configured sysroot is relocatable, try relocating it based on
521 default prefix FROM. Return the relocated directory if it exists,
522 otherwise return null. */
525 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
527 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
531 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
534 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
542 /* Return the sysroot directory. Return "" if no sysroot is being used. */
545 get_sysroot (int argc
, char **argv
)
550 for (i
= 1; i
< argc
; i
++)
551 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
552 return argv
[i
] + strlen ("--sysroot=");
554 path
= get_relative_sysroot (BINDIR
);
558 path
= get_relative_sysroot (TOOLBINDIR
);
562 return TARGET_SYSTEM_ROOT
;
565 /* We need to find any explicitly given emulation in order to initialize the
566 state that's needed by the lex&yacc argument parser (parse_args). */
569 get_emulation (int argc
, char **argv
)
574 emulation
= getenv (EMULATION_ENVIRON
);
575 if (emulation
== NULL
)
576 emulation
= DEFAULT_EMULATION
;
578 for (i
= 1; i
< argc
; i
++)
580 if (CONST_STRNEQ (argv
[i
], "-m"))
582 if (argv
[i
][2] == '\0')
587 emulation
= argv
[i
+ 1];
591 einfo (_("%P%F: missing argument to -m\n"));
593 else if (strcmp (argv
[i
], "-mips1") == 0
594 || strcmp (argv
[i
], "-mips2") == 0
595 || strcmp (argv
[i
], "-mips3") == 0
596 || strcmp (argv
[i
], "-mips4") == 0
597 || strcmp (argv
[i
], "-mips5") == 0
598 || strcmp (argv
[i
], "-mips32") == 0
599 || strcmp (argv
[i
], "-mips32r2") == 0
600 || strcmp (argv
[i
], "-mips64") == 0
601 || strcmp (argv
[i
], "-mips64r2") == 0)
603 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
604 passed to the linker by some MIPS compilers. They
605 generally tell the linker to use a slightly different
606 library path. Perhaps someday these should be
607 implemented as emulations; until then, we just ignore
608 the arguments and hope that nobody ever creates
609 emulations named ips1, ips2 or ips3. */
611 else if (strcmp (argv
[i
], "-m486") == 0)
613 /* FIXME: The argument -m486 is passed to the linker on
614 some Linux systems. Hope that nobody creates an
615 emulation named 486. */
620 emulation
= &argv
[i
][2];
629 add_ysym (const char *name
)
631 if (link_info
.notice_hash
== NULL
)
633 link_info
.notice_hash
=
634 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
635 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
637 sizeof (struct bfd_hash_entry
),
639 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
642 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
643 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
647 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
649 if (info
->ignore_hash
== NULL
)
651 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
652 if (! bfd_hash_table_init_n (info
->ignore_hash
,
654 sizeof (struct bfd_hash_entry
),
656 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
659 if (bfd_hash_lookup (info
->ignore_hash
, name
, TRUE
, TRUE
) == NULL
)
660 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
663 /* Record a symbol to be wrapped, from the --wrap option. */
666 add_wrap (const char *name
)
668 if (link_info
.wrap_hash
== NULL
)
670 link_info
.wrap_hash
=
671 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
672 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
674 sizeof (struct bfd_hash_entry
),
676 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
679 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
680 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
683 /* Handle the -retain-symbols-file option. */
686 add_keepsyms_file (const char *filename
)
693 if (link_info
.strip
== strip_some
)
694 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
696 file
= fopen (filename
, "r");
699 bfd_set_error (bfd_error_system_call
);
700 einfo ("%X%P: %s: %E\n", filename
);
704 link_info
.keep_hash
= (struct bfd_hash_table
*)
705 xmalloc (sizeof (struct bfd_hash_table
));
706 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
707 sizeof (struct bfd_hash_entry
)))
708 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
711 buf
= (char *) xmalloc (bufsize
);
723 while (! ISSPACE (c
) && c
!= EOF
)
730 buf
= (char *) xrealloc (buf
, bufsize
);
737 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
738 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
742 if (link_info
.strip
!= strip_none
)
743 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
746 link_info
.strip
= strip_some
;
750 /* Callbacks from the BFD linker routines. */
752 /* This is called when BFD has decided to include an archive member in
756 add_archive_element (struct bfd_link_info
*info
,
759 bfd
**subsbfd ATTRIBUTE_UNUSED
)
761 lang_input_statement_type
*input
;
762 lang_input_statement_type orig_input
;
764 input
= (lang_input_statement_type
*)
765 xcalloc (1, sizeof (lang_input_statement_type
));
766 input
->filename
= abfd
->filename
;
767 input
->local_sym_name
= abfd
->filename
;
768 input
->the_bfd
= abfd
;
770 /* Save the original data for trace files/tries below, as plugins
771 (if enabled) may possibly alter it to point to a replacement
772 BFD, but we still want to output the original BFD filename. */
774 #ifdef ENABLE_PLUGINS
775 if (plugin_active_plugins_p () && !no_more_claiming
)
777 /* We must offer this archive member to the plugins to claim. */
778 const char *filename
= (bfd_my_archive (abfd
) != NULL
779 ? bfd_my_archive (abfd
)->filename
: abfd
->filename
);
780 int fd
= open (filename
, O_RDONLY
| O_BINARY
);
783 struct ld_plugin_input_file file
;
785 /* Offset and filesize must refer to the individual archive
786 member, not the whole file, and must exclude the header.
787 Fortunately for us, that is how the data is stored in the
788 origin field of the bfd and in the arelt_data. */
789 file
.name
= filename
;
790 file
.offset
= abfd
->origin
;
791 file
.filesize
= arelt_size (abfd
);
793 plugin_maybe_claim (&file
, input
);
794 if (input
->flags
.claimed
)
796 input
->flags
.claim_archive
= TRUE
;
797 *subsbfd
= input
->the_bfd
;
801 #endif /* ENABLE_PLUGINS */
803 ldlang_add_file (input
);
805 if (config
.map_file
!= NULL
)
807 static bfd_boolean header_printed
;
808 struct bfd_link_hash_entry
*h
;
812 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
824 case bfd_link_hash_defined
:
825 case bfd_link_hash_defweak
:
826 from
= h
->u
.def
.section
->owner
;
829 case bfd_link_hash_undefined
:
830 case bfd_link_hash_undefweak
:
831 from
= h
->u
.undef
.abfd
;
834 case bfd_link_hash_common
:
835 from
= h
->u
.c
.p
->section
->owner
;
840 if (! header_printed
)
844 sprintf (buf
, _("Archive member included "
845 "to satisfy reference by file (symbol)\n\n"));
847 header_printed
= TRUE
;
850 if (bfd_my_archive (abfd
) == NULL
)
852 minfo ("%s", bfd_get_filename (abfd
));
853 len
= strlen (bfd_get_filename (abfd
));
857 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
858 bfd_get_filename (abfd
));
859 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
860 + strlen (bfd_get_filename (abfd
))
878 minfo ("(%T)\n", h
->root
.string
);
880 minfo ("(%s)\n", name
);
883 if (trace_files
|| verbose
)
884 info_msg ("%I\n", &orig_input
);
888 /* This is called when BFD has discovered a symbol which is defined
892 multiple_definition (struct bfd_link_info
*info
,
893 struct bfd_link_hash_entry
*h
,
903 if (info
->allow_multiple_definition
)
908 case bfd_link_hash_defined
:
909 osec
= h
->u
.def
.section
;
910 oval
= h
->u
.def
.value
;
911 obfd
= h
->u
.def
.section
->owner
;
913 case bfd_link_hash_indirect
:
914 osec
= bfd_ind_section_ptr
;
922 /* Ignore a redefinition of an absolute symbol to the
923 same value; it's harmless. */
924 if (h
->type
== bfd_link_hash_defined
925 && bfd_is_abs_section (osec
)
926 && bfd_is_abs_section (nsec
)
930 /* If either section has the output_section field set to
931 bfd_abs_section_ptr, it means that the section is being
932 discarded, and this is not really a multiple definition at all.
933 FIXME: It would be cleaner to somehow ignore symbols defined in
934 sections which are being discarded. */
935 if ((osec
->output_section
!= NULL
936 && ! bfd_is_abs_section (osec
)
937 && bfd_is_abs_section (osec
->output_section
))
938 || (nsec
->output_section
!= NULL
939 && ! bfd_is_abs_section (nsec
)
940 && bfd_is_abs_section (nsec
->output_section
)))
943 name
= h
->root
.string
;
951 einfo (_("%X%C: multiple definition of `%T'\n"),
952 nbfd
, nsec
, nval
, name
);
954 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
956 if (RELAXATION_ENABLED_BY_USER
)
958 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
965 /* This is called when there is a definition of a common symbol, or
966 when a common symbol is found for a symbol that is already defined,
967 or when two common symbols are found. We only do something if
968 -warn-common was used. */
971 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
972 struct bfd_link_hash_entry
*h
,
974 enum bfd_link_hash_type ntype
,
979 enum bfd_link_hash_type otype
;
982 if (!config
.warn_common
)
985 name
= h
->root
.string
;
987 if (otype
== bfd_link_hash_common
)
989 obfd
= h
->u
.c
.p
->section
->owner
;
992 else if (otype
== bfd_link_hash_defined
993 || otype
== bfd_link_hash_defweak
)
995 obfd
= h
->u
.def
.section
->owner
;
1000 /* FIXME: It would nice if we could report the BFD which defined
1001 an indirect symbol, but we don't have anywhere to store the
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 (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 /* Look through the relocs to see if we can find a plausible address
1154 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1157 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1159 struct warning_callback_info cinfo
;
1161 if (!bfd_generic_link_read_symbols (abfd
))
1162 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1164 cinfo
.found
= FALSE
;
1165 cinfo
.warning
= warning
;
1166 cinfo
.symbol
= symbol
;
1167 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1168 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1172 /* This is called when there is a reference to a warning symbol. */
1175 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1176 const char *warning
,
1182 /* This is a hack to support warn_multiple_gp. FIXME: This should
1183 have a cleaner interface, but what? */
1184 if (! config
.warn_multiple_gp
1185 && strcmp (warning
, "using multiple gp values") == 0)
1188 if (section
!= NULL
)
1189 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1190 else if (abfd
== NULL
)
1191 einfo ("%P: %s%s\n", _("warning: "), warning
);
1192 else if (symbol
== NULL
)
1193 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1194 else if (! symbol_warning (warning
, symbol
, abfd
))
1197 /* Search all input files for a reference to SYMBOL. */
1198 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
1199 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1201 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1207 /* This is called by warning_callback for each section. It checks the
1208 relocs of the section to see if it can find a reference to the
1209 symbol which triggered the warning. If it can, it uses the reloc
1210 to give an error message with a file and line number. */
1213 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1215 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1219 arelent
**p
, **pend
;
1224 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1226 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1230 relpp
= (arelent
**) xmalloc (relsize
);
1231 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1233 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1236 pend
= p
+ relcount
;
1237 for (; p
< pend
&& *p
!= NULL
; p
++)
1241 if (q
->sym_ptr_ptr
!= NULL
1242 && *q
->sym_ptr_ptr
!= NULL
1243 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1245 /* We found a reloc for the symbol we are looking for. */
1246 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1256 /* This is called when an undefined symbol is found. */
1259 undefined_symbol (struct bfd_link_info
*info
,
1266 static char *error_name
;
1267 static unsigned int error_count
;
1269 #define MAX_ERRORS_IN_A_ROW 5
1271 if (info
->ignore_hash
!= NULL
1272 && bfd_hash_lookup (info
->ignore_hash
, name
, FALSE
, FALSE
) != NULL
)
1275 if (config
.warn_once
)
1277 /* Only warn once about a particular undefined symbol. */
1278 add_ignoresym (info
, name
);
1281 /* We never print more than a reasonable number of errors in a row
1282 for a single symbol. */
1283 if (error_name
!= NULL
1284 && strcmp (name
, error_name
) == 0)
1289 if (error_name
!= NULL
)
1291 error_name
= xstrdup (name
);
1294 if (section
!= NULL
)
1296 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1299 einfo (_("%X%C: undefined reference to `%T'\n"),
1300 abfd
, section
, address
, name
);
1302 einfo (_("%C: warning: undefined reference to `%T'\n"),
1303 abfd
, section
, address
, name
);
1305 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1308 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1309 abfd
, section
, address
, name
);
1311 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1312 abfd
, section
, address
, name
);
1319 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1322 einfo (_("%X%B: undefined reference to `%T'\n"),
1325 einfo (_("%B: warning: undefined reference to `%T'\n"),
1328 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1331 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1334 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1344 /* Counter to limit the number of relocation overflow error messages
1345 to print. Errors are printed as it is decremented. When it's
1346 called and the counter is zero, a final message is printed
1347 indicating more relocations were omitted. When it gets to -1, no
1348 such errors are printed. If it's initially set to a value less
1349 than -1, all such errors will be printed (--verbose does this). */
1351 int overflow_cutoff_limit
= 10;
1353 /* This is called when a reloc overflows. */
1356 reloc_overflow (struct bfd_link_info
*info
,
1357 struct bfd_link_hash_entry
*entry
,
1359 const char *reloc_name
,
1365 if (overflow_cutoff_limit
== -1)
1368 einfo ("%X%H:", abfd
, section
, address
);
1370 if (overflow_cutoff_limit
>= 0
1371 && overflow_cutoff_limit
-- == 0)
1373 einfo (_(" additional relocation overflows omitted from the output\n"));
1379 while (entry
->type
== bfd_link_hash_indirect
1380 || entry
->type
== bfd_link_hash_warning
)
1381 entry
= entry
->u
.i
.link
;
1382 switch (entry
->type
)
1384 case bfd_link_hash_undefined
:
1385 case bfd_link_hash_undefweak
:
1386 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1387 reloc_name
, entry
->root
.string
);
1389 case bfd_link_hash_defined
:
1390 case bfd_link_hash_defweak
:
1391 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1392 reloc_name
, entry
->root
.string
,
1393 entry
->u
.def
.section
,
1394 entry
->u
.def
.section
== bfd_abs_section_ptr
1395 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1403 einfo (_(" relocation truncated to fit: %s against `%T'"),
1406 einfo ("+%v", addend
);
1411 /* This is called when a dangerous relocation is made. */
1414 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1415 const char *message
,
1420 einfo (_("%X%H: dangerous relocation: %s\n"),
1421 abfd
, section
, address
, message
);
1425 /* This is called when a reloc is being generated attached to a symbol
1426 that is not being output. */
1429 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1435 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1436 abfd
, section
, address
, name
);
1440 /* This is called if link_info.notice_all is set, or when a symbol in
1441 link_info.notice_hash is found. Symbols are put in notice_hash
1442 using the -y option, while notice_all is set if the --cref option
1443 has been supplied, or if there are any NOCROSSREFS sections in the
1444 linker script; and if plugins are active, since they need to monitor
1445 all references from non-IR files. */
1448 notice (struct bfd_link_info
*info
,
1449 struct bfd_link_hash_entry
*h
,
1453 flagword flags ATTRIBUTE_UNUSED
,
1454 const char *string ATTRIBUTE_UNUSED
)
1460 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1461 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1465 name
= h
->root
.string
;
1466 if (info
->notice_hash
!= NULL
1467 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1469 if (bfd_is_und_section (section
))
1470 einfo ("%B: reference to %s\n", abfd
, name
);
1472 einfo ("%B: definition of %s\n", abfd
, name
);
1475 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1476 add_cref (name
, abfd
, section
, value
);