1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
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 /* TRUE if we should demangle symbol names. */
99 bfd_boolean demangling
;
101 args_type command_line
;
103 ld_config_type config
;
105 sort_type sort_section
;
107 static const char *get_sysroot
109 static char *get_emulation
111 static bfd_boolean add_archive_element
112 (struct bfd_link_info
*, bfd
*, const char *, bfd
**);
113 static bfd_boolean multiple_definition
114 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
115 bfd
*, asection
*, bfd_vma
);
116 static bfd_boolean multiple_common
117 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
118 bfd
*, enum bfd_link_hash_type
, bfd_vma
);
119 static bfd_boolean add_to_set
120 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
121 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
122 static bfd_boolean constructor_callback
123 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
124 asection
*, bfd_vma
);
125 static bfd_boolean warning_callback
126 (struct bfd_link_info
*, const char *, const char *, bfd
*,
127 asection
*, bfd_vma
);
128 static void warning_find_reloc
129 (bfd
*, asection
*, void *);
130 static bfd_boolean undefined_symbol
131 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
133 static bfd_boolean reloc_overflow
134 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
135 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
136 static bfd_boolean reloc_dangerous
137 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
138 static bfd_boolean unattached_reloc
139 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
140 static bfd_boolean notice
141 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
142 bfd
*, asection
*, bfd_vma
, flagword
, const char *);
144 static struct bfd_link_callbacks link_callbacks
=
150 constructor_callback
,
160 ldlang_override_segment_assignment
163 static bfd_assert_handler_type default_bfd_assert_handler
;
165 struct bfd_link_info link_info
;
170 bfd_cache_close_all ();
171 #ifdef ENABLE_PLUGINS
172 plugin_call_cleanup ();
174 if (output_filename
&& delete_output_file_on_failure
)
175 unlink_if_ordinary (output_filename
);
178 /* If there's a BFD assertion, we'll notice and exit with an error
179 unless otherwise instructed. */
182 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
183 const char *file
, int line
)
185 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
186 config
.make_executable
= FALSE
;
190 main (int argc
, char **argv
)
193 long start_time
= get_run_time ();
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
;
264 command_line
.warn_mismatch
= TRUE
;
265 command_line
.warn_search_mismatch
= TRUE
;
266 command_line
.check_section_addresses
= -1;
267 command_line
.disable_target_specific_optimizations
= -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
.pei386_auto_import
= -1;
289 link_info
.spare_dynamic_tags
= 5;
290 link_info
.path_separator
= ':';
292 ldfile_add_arch ("");
293 emulation
= get_emulation (argc
, argv
);
294 ldemul_choose_mode (emulation
);
295 default_target
= ldemul_choose_target (argc
, argv
);
296 config
.maxpagesize
= bfd_emul_get_maxpagesize (default_target
);
297 config
.commonpagesize
= bfd_emul_get_commonpagesize (default_target
);
299 ldemul_before_parse ();
300 lang_has_input_file
= FALSE
;
301 parse_args (argc
, argv
);
303 if (config
.hash_table_size
!= 0)
304 bfd_hash_set_default_size (config
.hash_table_size
);
306 #ifdef ENABLE_PLUGINS
307 /* Now all the plugin arguments have been gathered, we can load them. */
308 if (plugin_load_plugins ())
309 einfo (_("%P%F: %s: error loading plugin\n"), plugin_error_plugin ());
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
;
343 if (trace_file_tries
)
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
- (char *) &environ
));
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"));
646 /* Record a symbol to be wrapped, from the --wrap option. */
649 add_wrap (const char *name
)
651 if (link_info
.wrap_hash
== NULL
)
653 link_info
.wrap_hash
=
654 (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
655 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
657 sizeof (struct bfd_hash_entry
),
659 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
662 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
663 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
666 /* Handle the -retain-symbols-file option. */
669 add_keepsyms_file (const char *filename
)
676 if (link_info
.strip
== strip_some
)
677 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
679 file
= fopen (filename
, "r");
682 bfd_set_error (bfd_error_system_call
);
683 einfo ("%X%P: %s: %E\n", filename
);
687 link_info
.keep_hash
= (struct bfd_hash_table
*)
688 xmalloc (sizeof (struct bfd_hash_table
));
689 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
690 sizeof (struct bfd_hash_entry
)))
691 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
694 buf
= (char *) xmalloc (bufsize
);
706 while (! ISSPACE (c
) && c
!= EOF
)
713 buf
= (char *) xrealloc (buf
, bufsize
);
720 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
721 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
725 if (link_info
.strip
!= strip_none
)
726 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
729 link_info
.strip
= strip_some
;
732 /* Callbacks from the BFD linker routines. */
734 /* This is called when BFD has decided to include an archive member in
738 add_archive_element (struct bfd_link_info
*info
,
741 bfd
**subsbfd ATTRIBUTE_UNUSED
)
743 lang_input_statement_type
*input
;
744 lang_input_statement_type orig_input
;
746 input
= (lang_input_statement_type
*)
747 xcalloc (1, sizeof (lang_input_statement_type
));
748 input
->filename
= abfd
->filename
;
749 input
->local_sym_name
= abfd
->filename
;
750 input
->the_bfd
= abfd
;
752 /* Save the original data for trace files/tries below, as plugins
753 (if enabled) may possibly alter it to point to a replacement
754 BFD, but we still want to output the original BFD filename. */
756 #ifdef ENABLE_PLUGINS
757 if (plugin_active_plugins_p () && !no_more_claiming
)
759 /* We must offer this archive member to the plugins to claim. */
760 const char *filename
= (bfd_my_archive (abfd
) != NULL
761 ? bfd_my_archive (abfd
)->filename
: abfd
->filename
);
762 int fd
= open (filename
, O_RDONLY
| O_BINARY
);
765 struct ld_plugin_input_file file
;
767 /* Offset and filesize must refer to the individual archive
768 member, not the whole file, and must exclude the header.
769 Fortunately for us, that is how the data is stored in the
770 origin field of the bfd and in the arelt_data. */
771 file
.name
= filename
;
772 file
.offset
= abfd
->origin
;
773 file
.filesize
= arelt_size (abfd
);
775 plugin_maybe_claim (&file
, input
);
776 if (input
->flags
.claimed
)
778 input
->flags
.claim_archive
= TRUE
;
779 *subsbfd
= input
->the_bfd
;
783 #endif /* ENABLE_PLUGINS */
785 ldlang_add_file (input
);
787 if (config
.map_file
!= NULL
)
789 static bfd_boolean header_printed
;
790 struct bfd_link_hash_entry
*h
;
794 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
806 case bfd_link_hash_defined
:
807 case bfd_link_hash_defweak
:
808 from
= h
->u
.def
.section
->owner
;
811 case bfd_link_hash_undefined
:
812 case bfd_link_hash_undefweak
:
813 from
= h
->u
.undef
.abfd
;
816 case bfd_link_hash_common
:
817 from
= h
->u
.c
.p
->section
->owner
;
822 if (! header_printed
)
826 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
828 header_printed
= TRUE
;
831 if (bfd_my_archive (abfd
) == NULL
)
833 minfo ("%s", bfd_get_filename (abfd
));
834 len
= strlen (bfd_get_filename (abfd
));
838 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
839 bfd_get_filename (abfd
));
840 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
841 + strlen (bfd_get_filename (abfd
))
859 minfo ("(%T)\n", h
->root
.string
);
861 minfo ("(%s)\n", name
);
864 if (trace_files
|| trace_file_tries
)
865 info_msg ("%I\n", &orig_input
);
869 /* This is called when BFD has discovered a symbol which is defined
873 multiple_definition (struct bfd_link_info
*info
,
874 struct bfd_link_hash_entry
*h
,
884 if (info
->allow_multiple_definition
)
889 case bfd_link_hash_defined
:
890 osec
= h
->u
.def
.section
;
891 oval
= h
->u
.def
.value
;
892 obfd
= h
->u
.def
.section
->owner
;
894 case bfd_link_hash_indirect
:
895 osec
= bfd_ind_section_ptr
;
903 /* Ignore a redefinition of an absolute symbol to the
904 same value; it's harmless. */
905 if (h
->type
== bfd_link_hash_defined
906 && bfd_is_abs_section (osec
)
907 && bfd_is_abs_section (nsec
)
911 /* If either section has the output_section field set to
912 bfd_abs_section_ptr, it means that the section is being
913 discarded, and this is not really a multiple definition at all.
914 FIXME: It would be cleaner to somehow ignore symbols defined in
915 sections which are being discarded. */
916 if ((osec
->output_section
!= NULL
917 && ! bfd_is_abs_section (osec
)
918 && bfd_is_abs_section (osec
->output_section
))
919 || (nsec
->output_section
!= NULL
920 && ! bfd_is_abs_section (nsec
)
921 && bfd_is_abs_section (nsec
->output_section
)))
924 name
= h
->root
.string
;
932 einfo (_("%X%C: multiple definition of `%T'\n"),
933 nbfd
, nsec
, nval
, name
);
935 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
937 if (RELAXATION_ENABLED
)
939 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
940 command_line
.disable_target_specific_optimizations
= -1;
946 /* This is called when there is a definition of a common symbol, or
947 when a common symbol is found for a symbol that is already defined,
948 or when two common symbols are found. We only do something if
949 -warn-common was used. */
952 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
953 struct bfd_link_hash_entry
*h
,
955 enum bfd_link_hash_type ntype
,
960 enum bfd_link_hash_type otype
;
963 if (!config
.warn_common
)
966 name
= h
->root
.string
;
968 if (otype
== bfd_link_hash_common
)
970 obfd
= h
->u
.c
.p
->section
->owner
;
973 else if (otype
== bfd_link_hash_defined
974 || otype
== bfd_link_hash_defweak
)
976 obfd
= h
->u
.def
.section
->owner
;
981 /* FIXME: It would nice if we could report the BFD which defined
982 an indirect symbol, but we don't have anywhere to store the
988 if (ntype
== bfd_link_hash_defined
989 || ntype
== bfd_link_hash_defweak
990 || ntype
== bfd_link_hash_indirect
)
992 ASSERT (otype
== bfd_link_hash_common
);
993 einfo (_("%B: warning: definition of `%T' overriding common\n"),
996 einfo (_("%B: warning: common is here\n"), obfd
);
998 else if (otype
== bfd_link_hash_defined
999 || otype
== bfd_link_hash_defweak
1000 || otype
== bfd_link_hash_indirect
)
1002 ASSERT (ntype
== bfd_link_hash_common
);
1003 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1006 einfo (_("%B: warning: defined here\n"), obfd
);
1010 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1013 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1016 einfo (_("%B: warning: larger common is here\n"), obfd
);
1018 else if (nsize
> osize
)
1020 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1023 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1027 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1029 einfo (_("%B: warning: previous common is here\n"), obfd
);
1036 /* This is called when BFD has discovered a set element. H is the
1037 entry in the linker hash table for the set. SECTION and VALUE
1038 represent a value which should be added to the set. */
1041 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1042 struct bfd_link_hash_entry
*h
,
1043 bfd_reloc_code_real_type reloc
,
1048 if (config
.warn_constructors
)
1049 einfo (_("%P: warning: global constructor %s used\n"),
1052 if (! config
.build_constructors
)
1055 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1057 if (h
->type
== bfd_link_hash_new
)
1059 h
->type
= bfd_link_hash_undefined
;
1060 h
->u
.undef
.abfd
= abfd
;
1061 /* We don't call bfd_link_add_undef to add this to the list of
1062 undefined symbols because we are going to define it
1069 /* This is called when BFD has discovered a constructor. This is only
1070 called for some object file formats--those which do not handle
1071 constructors in some more clever fashion. This is similar to
1072 adding an element to a set, but less general. */
1075 constructor_callback (struct bfd_link_info
*info
,
1076 bfd_boolean constructor
,
1083 struct bfd_link_hash_entry
*h
;
1084 char set_name
[1 + sizeof "__CTOR_LIST__"];
1086 if (config
.warn_constructors
)
1087 einfo (_("%P: warning: global constructor %s used\n"), name
);
1089 if (! config
.build_constructors
)
1092 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1093 useful error message. */
1094 if (bfd_reloc_type_lookup (link_info
.output_bfd
, BFD_RELOC_CTOR
) == NULL
1095 && (info
->relocatable
1096 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1097 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1100 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1101 *s
++ = bfd_get_symbol_leading_char (abfd
);
1103 strcpy (s
, "__CTOR_LIST__");
1105 strcpy (s
, "__DTOR_LIST__");
1107 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1108 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1109 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1110 if (h
->type
== bfd_link_hash_new
)
1112 h
->type
= bfd_link_hash_undefined
;
1113 h
->u
.undef
.abfd
= abfd
;
1114 /* We don't call bfd_link_add_undef to add this to the list of
1115 undefined symbols because we are going to define it
1119 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1123 /* A structure used by warning_callback to pass information through
1124 bfd_map_over_sections. */
1126 struct warning_callback_info
1129 const char *warning
;
1134 /* This is called when there is a reference to a warning symbol. */
1137 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1138 const char *warning
,
1144 /* This is a hack to support warn_multiple_gp. FIXME: This should
1145 have a cleaner interface, but what? */
1146 if (! config
.warn_multiple_gp
1147 && strcmp (warning
, "using multiple gp values") == 0)
1150 if (section
!= NULL
)
1151 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1152 else if (abfd
== NULL
)
1153 einfo ("%P: %s%s\n", _("warning: "), warning
);
1154 else if (symbol
== NULL
)
1155 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1158 struct warning_callback_info cinfo
;
1160 /* Look through the relocs to see if we can find a plausible
1163 if (!bfd_generic_link_read_symbols (abfd
))
1164 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1166 cinfo
.found
= FALSE
;
1167 cinfo
.warning
= warning
;
1168 cinfo
.symbol
= symbol
;
1169 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1170 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1173 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1179 /* This is called by warning_callback for each section. It checks the
1180 relocs of the section to see if it can find a reference to the
1181 symbol which triggered the warning. If it can, it uses the reloc
1182 to give an error message with a file and line number. */
1185 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1187 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1191 arelent
**p
, **pend
;
1196 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1198 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1202 relpp
= (arelent
**) xmalloc (relsize
);
1203 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1205 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1208 pend
= p
+ relcount
;
1209 for (; p
< pend
&& *p
!= NULL
; p
++)
1213 if (q
->sym_ptr_ptr
!= NULL
1214 && *q
->sym_ptr_ptr
!= NULL
1215 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1217 /* We found a reloc for the symbol we are looking for. */
1218 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1228 /* This is called when an undefined symbol is found. */
1231 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1238 static char *error_name
;
1239 static unsigned int error_count
;
1241 #define MAX_ERRORS_IN_A_ROW 5
1243 if (config
.warn_once
)
1245 static struct bfd_hash_table
*hash
;
1247 /* Only warn once about a particular undefined symbol. */
1250 hash
= (struct bfd_hash_table
*)
1251 xmalloc (sizeof (struct bfd_hash_table
));
1252 if (!bfd_hash_table_init (hash
, bfd_hash_newfunc
,
1253 sizeof (struct bfd_hash_entry
)))
1254 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1257 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1260 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1261 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1264 /* We never print more than a reasonable number of errors in a row
1265 for a single symbol. */
1266 if (error_name
!= NULL
1267 && strcmp (name
, error_name
) == 0)
1272 if (error_name
!= NULL
)
1274 error_name
= xstrdup (name
);
1277 if (section
!= NULL
)
1279 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1282 einfo (_("%X%C: undefined reference to `%T'\n"),
1283 abfd
, section
, address
, name
);
1285 einfo (_("%C: warning: undefined reference to `%T'\n"),
1286 abfd
, section
, address
, name
);
1288 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1291 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1292 abfd
, section
, address
, name
);
1294 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1295 abfd
, section
, address
, name
);
1302 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1305 einfo (_("%X%B: undefined reference to `%T'\n"),
1308 einfo (_("%B: warning: undefined reference to `%T'\n"),
1311 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1314 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1317 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1327 /* Counter to limit the number of relocation overflow error messages
1328 to print. Errors are printed as it is decremented. When it's
1329 called and the counter is zero, a final message is printed
1330 indicating more relocations were omitted. When it gets to -1, no
1331 such errors are printed. If it's initially set to a value less
1332 than -1, all such errors will be printed (--verbose does this). */
1334 int overflow_cutoff_limit
= 10;
1336 /* This is called when a reloc overflows. */
1339 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1340 struct bfd_link_hash_entry
*entry
,
1342 const char *reloc_name
,
1348 if (overflow_cutoff_limit
== -1)
1351 einfo ("%X%H:", abfd
, section
, address
);
1353 if (overflow_cutoff_limit
>= 0
1354 && overflow_cutoff_limit
-- == 0)
1356 einfo (_(" additional relocation overflows omitted from the output\n"));
1362 while (entry
->type
== bfd_link_hash_indirect
1363 || entry
->type
== bfd_link_hash_warning
)
1364 entry
= entry
->u
.i
.link
;
1365 switch (entry
->type
)
1367 case bfd_link_hash_undefined
:
1368 case bfd_link_hash_undefweak
:
1369 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1370 reloc_name
, entry
->root
.string
);
1372 case bfd_link_hash_defined
:
1373 case bfd_link_hash_defweak
:
1374 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1375 reloc_name
, entry
->root
.string
,
1376 entry
->u
.def
.section
,
1377 entry
->u
.def
.section
== bfd_abs_section_ptr
1378 ? link_info
.output_bfd
: entry
->u
.def
.section
->owner
);
1386 einfo (_(" relocation truncated to fit: %s against `%T'"),
1389 einfo ("+%v", addend
);
1394 /* This is called when a dangerous relocation is made. */
1397 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1398 const char *message
,
1403 einfo (_("%X%H: dangerous relocation: %s\n"),
1404 abfd
, section
, address
, message
);
1408 /* This is called when a reloc is being generated attached to a symbol
1409 that is not being output. */
1412 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1418 einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1419 abfd
, section
, address
, name
);
1423 /* This is called if link_info.notice_all is set, or when a symbol in
1424 link_info.notice_hash is found. Symbols are put in notice_hash
1425 using the -y option, while notice_all is set if the --cref option
1426 has been supplied, or if there are any NOCROSSREFS sections in the
1427 linker script; and if plugins are active, since they need to monitor
1428 all references from non-IR files. */
1431 notice (struct bfd_link_info
*info
,
1432 struct bfd_link_hash_entry
*h
,
1436 flagword flags ATTRIBUTE_UNUSED
,
1437 const char *string ATTRIBUTE_UNUSED
)
1443 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1444 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1448 name
= h
->root
.string
;
1449 if (info
->notice_hash
!= NULL
1450 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1452 if (bfd_is_und_section (section
))
1453 einfo ("%B: reference to %s\n", abfd
, name
);
1455 einfo ("%B: definition of %s\n", abfd
, name
);
1458 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1459 add_cref (name
, abfd
, section
, value
);