1 /* Main program of GNU linker.
2 Copyright (C) 1991-2020 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"
29 #include "filenames.h"
44 #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)
54 #ifndef TARGET_SYSTEM_ROOT
55 #define TARGET_SYSTEM_ROOT ""
60 FILE *saved_script_handle
= NULL
;
61 FILE *previous_script_handle
= NULL
;
62 bfd_boolean force_make_executable
= FALSE
;
65 const char *output_filename
= "a.out";
67 /* Name this program was invoked by. */
70 /* The prefix for system library directories. */
71 const char *ld_sysroot
;
73 /* The canonical representation of ld_sysroot. */
74 char *ld_canon_sysroot
;
75 int ld_canon_sysroot_len
;
77 /* Set by -G argument, for targets like MIPS ELF. */
78 int g_switch_value
= 8;
80 /* Nonzero means print names of input files as processed. */
81 unsigned int trace_files
;
83 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
86 /* Nonzero means version number was printed, so exit successfully
87 instead of complaining if no input files are given. */
88 bfd_boolean version_printed
;
90 /* TRUE if we should demangle symbol names. */
91 bfd_boolean demangling
;
93 args_type command_line
;
95 ld_config_type config
;
97 sort_type sort_section
;
99 static const char *get_sysroot
101 static char *get_emulation
103 static bfd_boolean add_archive_element
104 (struct bfd_link_info
*, bfd
*, const char *, bfd
**);
105 static void multiple_definition
106 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
107 bfd
*, asection
*, bfd_vma
);
108 static void multiple_common
109 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
110 bfd
*, enum bfd_link_hash_type
, bfd_vma
);
111 static void add_to_set
112 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
113 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
114 static void constructor_callback
115 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
116 asection
*, bfd_vma
);
117 static void warning_callback
118 (struct bfd_link_info
*, const char *, const char *, bfd
*,
119 asection
*, bfd_vma
);
120 static void warning_find_reloc
121 (bfd
*, asection
*, void *);
122 static void undefined_symbol
123 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
125 static void reloc_overflow
126 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
127 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
128 static void reloc_dangerous
129 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
130 static void unattached_reloc
131 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
132 static bfd_boolean notice
133 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
134 struct bfd_link_hash_entry
*, bfd
*, asection
*, bfd_vma
, flagword
);
136 static struct bfd_link_callbacks link_callbacks
=
142 constructor_callback
,
152 ldlang_override_segment_assignment
,
153 ldlang_ctf_apply_strsym
,
154 ldlang_write_ctf_late
157 static bfd_assert_handler_type default_bfd_assert_handler
;
158 static bfd_error_handler_type default_bfd_error_handler
;
160 struct bfd_link_info link_info
;
165 bfd_cache_close_all ();
166 #ifdef ENABLE_PLUGINS
167 plugin_call_cleanup ();
169 if (output_filename
&& delete_output_file_on_failure
)
170 unlink_if_ordinary (output_filename
);
173 /* Hook to notice BFD assertions. */
176 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
177 const char *file
, int line
)
179 config
.make_executable
= FALSE
;
180 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
183 /* Hook the bfd error/warning handler for --fatal-warnings. */
186 ld_bfd_error_handler (const char *fmt
, va_list ap
)
188 if (config
.fatal_warnings
)
189 config
.make_executable
= FALSE
;
190 (*default_bfd_error_handler
) (fmt
, ap
);
194 main (int argc
, char **argv
)
197 long start_time
= get_run_time ();
199 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
200 setlocale (LC_MESSAGES
, "");
202 #if defined (HAVE_SETLOCALE)
203 setlocale (LC_CTYPE
, "");
205 bindtextdomain (PACKAGE
, LOCALEDIR
);
206 textdomain (PACKAGE
);
208 program_name
= argv
[0];
209 xmalloc_set_program_name (program_name
);
211 START_PROGRESS (program_name
, 0);
213 expandargv (&argc
, &argv
);
215 if (bfd_init () != BFD_INIT_MAGIC
)
216 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
218 bfd_set_error_program_name (program_name
);
220 /* We want to notice and fail on those nasty BFD assertions which are
221 likely to signal incorrect output being generated but otherwise may
223 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
225 /* Also hook the bfd error/warning handler for --fatal-warnings. */
226 default_bfd_error_handler
= bfd_set_error_handler (ld_bfd_error_handler
);
228 xatexit (ld_cleanup
);
230 /* Set up the sysroot directory. */
231 ld_sysroot
= get_sysroot (argc
, argv
);
233 ld_canon_sysroot
= lrealpath (ld_sysroot
);
234 if (ld_canon_sysroot
)
236 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
238 /* is_sysrooted_pathname() relies on no trailing dirsep. */
239 if (ld_canon_sysroot_len
> 0
240 && IS_DIR_SEPARATOR (ld_canon_sysroot
[ld_canon_sysroot_len
- 1]))
241 ld_canon_sysroot
[--ld_canon_sysroot_len
] = '\0';
244 ld_canon_sysroot_len
= -1;
246 /* Set the default BFD target based on the configured target. Doing
247 this permits the linker to be configured for a particular target,
248 and linked against a shared BFD library which was configured for
249 a different target. The macro TARGET is defined by Makefile. */
250 if (!bfd_set_default_target (TARGET
))
252 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
263 config
.build_constructors
= TRUE
;
264 config
.rpath_separator
= ':';
265 config
.split_by_reloc
= (unsigned) -1;
266 config
.split_by_file
= (bfd_size_type
) -1;
267 config
.make_executable
= TRUE
;
268 config
.magic_demand_paged
= TRUE
;
269 config
.text_read_only
= TRUE
;
270 config
.print_map_discarded
= TRUE
;
271 link_info
.disable_target_specific_optimizations
= -1;
273 command_line
.warn_mismatch
= TRUE
;
274 command_line
.warn_search_mismatch
= TRUE
;
275 command_line
.check_section_addresses
= -1;
277 /* We initialize DEMANGLING based on the environment variable
278 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
279 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
280 environment. Acting the same way here lets us provide the same
281 interface by default. */
282 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
284 link_info
.allow_undefined_version
= TRUE
;
285 link_info
.keep_memory
= TRUE
;
286 link_info
.combreloc
= TRUE
;
287 link_info
.strip_discarded
= TRUE
;
288 link_info
.prohibit_multiple_definition_absolute
= FALSE
;
289 link_info
.emit_hash
= DEFAULT_EMIT_SYSV_HASH
;
290 link_info
.emit_gnu_hash
= DEFAULT_EMIT_GNU_HASH
;
291 link_info
.callbacks
= &link_callbacks
;
292 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
293 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
294 and _fini symbols. We are compatible. */
295 link_info
.init_function
= "_init";
296 link_info
.fini_function
= "_fini";
297 link_info
.relax_pass
= 1;
298 link_info
.extern_protected_data
= -1;
299 link_info
.dynamic_undefined_weak
= -1;
300 link_info
.pei386_auto_import
= -1;
301 link_info
.spare_dynamic_tags
= 5;
302 link_info
.path_separator
= ':';
303 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
304 link_info
.compress_debug
= COMPRESS_DEBUG_GABI_ZLIB
;
306 #ifdef DEFAULT_NEW_DTAGS
307 link_info
.new_dtags
= DEFAULT_NEW_DTAGS
;
310 ldfile_add_arch ("");
311 emulation
= get_emulation (argc
, argv
);
312 ldemul_choose_mode (emulation
);
313 default_target
= ldemul_choose_target (argc
, argv
);
316 ldemul_before_parse ();
317 lang_has_input_file
= FALSE
;
318 parse_args (argc
, argv
);
320 if (config
.hash_table_size
!= 0)
321 bfd_hash_set_default_size (config
.hash_table_size
);
323 #ifdef ENABLE_PLUGINS
324 /* Now all the plugin arguments have been gathered, we can load them. */
325 plugin_load_plugins ();
326 #endif /* ENABLE_PLUGINS */
328 ldemul_set_symbols ();
330 /* If we have not already opened and parsed a linker script,
331 try the default script from command line first. */
332 if (saved_script_handle
== NULL
333 && command_line
.default_script
!= NULL
)
335 ldfile_open_script_file (command_line
.default_script
);
336 parser_input
= input_script
;
340 /* If we have not already opened and parsed a linker script
341 read the emulation's appropriate default script. */
342 if (saved_script_handle
== NULL
)
345 char *s
= ldemul_get_script (&isfile
);
348 ldfile_open_default_command_file (s
);
352 lex_redirect (s
, _("built in linker script"), 1);
354 parser_input
= input_script
;
361 if (saved_script_handle
)
362 info_msg (_("using external linker script:"));
364 info_msg (_("using internal linker script:"));
365 info_msg ("\n==================================================\n");
367 if (saved_script_handle
)
369 static const int ld_bufsz
= 8193;
371 char *buf
= (char *) xmalloc (ld_bufsz
);
373 rewind (saved_script_handle
);
374 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
377 info_msg ("%s", buf
);
379 rewind (saved_script_handle
);
386 info_msg (ldemul_get_script (&isfile
));
389 info_msg ("\n==================================================\n");
392 if (command_line
.force_group_allocation
393 || !bfd_link_relocatable (&link_info
))
394 link_info
.resolve_section_groups
= TRUE
;
396 link_info
.resolve_section_groups
= FALSE
;
398 if (command_line
.print_output_format
)
399 info_msg ("%s\n", lang_get_output_target ());
403 /* If the only command line argument has been -v or --version or --verbose
404 then ignore any input files provided by linker scripts and exit now.
405 We do not want to create an output file when the linker is just invoked
406 to provide version information. */
407 if (argc
== 2 && version_printed
)
410 if (link_info
.inhibit_common_definition
&& !bfd_link_dll (&link_info
))
411 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
413 if (!lang_has_input_file
)
415 if (version_printed
|| command_line
.print_output_format
)
417 einfo (_("%F%P: no input files\n"));
421 info_msg (_("%P: mode %s\n"), emulation
);
423 ldemul_after_parse ();
425 if (config
.map_filename
)
427 if (strcmp (config
.map_filename
, "-") == 0)
429 config
.map_file
= stdout
;
433 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
434 if (config
.map_file
== (FILE *) NULL
)
436 bfd_set_error (bfd_error_system_call
);
437 einfo (_("%F%P: cannot open map file %s: %E\n"),
438 config
.map_filename
);
441 link_info
.has_map_file
= TRUE
;
446 /* Print error messages for any missing symbols, for any warning
447 symbols, and possibly multiple definitions. */
448 if (bfd_link_relocatable (&link_info
))
449 link_info
.output_bfd
->flags
&= ~EXEC_P
;
451 link_info
.output_bfd
->flags
|= EXEC_P
;
453 if ((link_info
.compress_debug
& COMPRESS_DEBUG
))
455 link_info
.output_bfd
->flags
|= BFD_COMPRESS
;
456 if (link_info
.compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
457 link_info
.output_bfd
->flags
|= BFD_COMPRESS_GABI
;
462 if (config
.map_file
!= NULL
)
464 if (command_line
.cref
)
465 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
466 if (nocrossref_list
!= NULL
)
467 check_nocrossrefs ();
468 if (command_line
.print_memory_usage
)
469 lang_print_memory_usage ();
472 struct bfd_link_hash_entry
*h
;
474 h
= bfd_link_hash_lookup (link_info
.hash
, "__image_base__", 0,0,1);
475 fprintf (stderr
, "lookup = %p val %lx\n", h
, h
? h
->u
.def
.value
: 1);
481 /* Even if we're producing relocatable output, some non-fatal errors should
482 be reported in the exit status. (What non-fatal errors, if any, do we
483 want to ignore for relocatable output?) */
484 if (!config
.make_executable
&& !force_make_executable
)
487 einfo (_("%P: link errors found, deleting executable `%s'\n"),
490 /* The file will be removed by ld_cleanup. */
495 if (!bfd_close (link_info
.output_bfd
))
496 einfo (_("%F%P: %pB: final close failed: %E\n"), link_info
.output_bfd
);
498 /* If the --force-exe-suffix is enabled, and we're making an
499 executable file and it doesn't end in .exe, copy it to one
501 if (!bfd_link_relocatable (&link_info
)
502 && command_line
.force_exe_suffix
)
504 int len
= strlen (output_filename
);
507 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
508 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
512 const int bsize
= 4096;
513 char *buf
= (char *) xmalloc (bsize
);
515 char *dst_name
= (char *) xmalloc (len
+ 5);
517 strcpy (dst_name
, output_filename
);
518 strcat (dst_name
, ".exe");
519 src
= fopen (output_filename
, FOPEN_RB
);
520 dst
= fopen (dst_name
, FOPEN_WB
);
523 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
526 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
528 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
530 int done
= fwrite (buf
, 1, l
, dst
);
533 einfo (_("%P: error writing file `%s'\n"), dst_name
);
537 if (fclose (dst
) == EOF
)
538 einfo (_("%P: error closing file `%s'\n"), dst_name
);
545 END_PROGRESS (program_name
);
549 long run_time
= get_run_time () - start_time
;
552 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
553 program_name
, run_time
/ 1000000, run_time
% 1000000);
557 /* Prevent ld_cleanup from doing anything, after a successful link. */
558 output_filename
= NULL
;
564 /* If the configured sysroot is relocatable, try relocating it based on
565 default prefix FROM. Return the relocated directory if it exists,
566 otherwise return null. */
569 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
571 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
575 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
578 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
586 /* Return the sysroot directory. Return "" if no sysroot is being used. */
589 get_sysroot (int argc
, char **argv
)
592 const char *path
= NULL
;
594 for (i
= 1; i
< argc
; i
++)
595 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
596 path
= argv
[i
] + strlen ("--sysroot=");
599 path
= get_relative_sysroot (BINDIR
);
602 path
= get_relative_sysroot (TOOLBINDIR
);
605 path
= TARGET_SYSTEM_ROOT
;
607 if (IS_DIR_SEPARATOR (*path
) && path
[1] == 0)
613 /* We need to find any explicitly given emulation in order to initialize the
614 state that's needed by the lex&yacc argument parser (parse_args). */
617 get_emulation (int argc
, char **argv
)
622 emulation
= getenv (EMULATION_ENVIRON
);
623 if (emulation
== NULL
)
624 emulation
= DEFAULT_EMULATION
;
626 for (i
= 1; i
< argc
; i
++)
628 if (CONST_STRNEQ (argv
[i
], "-m"))
630 if (argv
[i
][2] == '\0')
635 emulation
= argv
[i
+ 1];
639 einfo (_("%F%P: missing argument to -m\n"));
641 else if (strcmp (argv
[i
], "-mips1") == 0
642 || strcmp (argv
[i
], "-mips2") == 0
643 || strcmp (argv
[i
], "-mips3") == 0
644 || strcmp (argv
[i
], "-mips4") == 0
645 || strcmp (argv
[i
], "-mips5") == 0
646 || strcmp (argv
[i
], "-mips32") == 0
647 || strcmp (argv
[i
], "-mips32r2") == 0
648 || strcmp (argv
[i
], "-mips32r6") == 0
649 || strcmp (argv
[i
], "-mips64") == 0
650 || strcmp (argv
[i
], "-mips64r2") == 0
651 || strcmp (argv
[i
], "-mips64r6") == 0)
653 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
654 passed to the linker by some MIPS compilers. They
655 generally tell the linker to use a slightly different
656 library path. Perhaps someday these should be
657 implemented as emulations; until then, we just ignore
658 the arguments and hope that nobody ever creates
659 emulations named ips1, ips2 or ips3. */
661 else if (strcmp (argv
[i
], "-m486") == 0)
663 /* FIXME: The argument -m486 is passed to the linker on
664 some Linux systems. Hope that nobody creates an
665 emulation named 486. */
670 emulation
= &argv
[i
][2];
679 add_ysym (const char *name
)
681 if (link_info
.notice_hash
== NULL
)
683 link_info
.notice_hash
684 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
685 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
687 sizeof (struct bfd_hash_entry
),
689 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
692 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
693 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
697 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
699 if (info
->ignore_hash
== NULL
)
701 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
702 if (!bfd_hash_table_init_n (info
->ignore_hash
,
704 sizeof (struct bfd_hash_entry
),
706 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
709 if (bfd_hash_lookup (info
->ignore_hash
, name
, TRUE
, TRUE
) == NULL
)
710 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
713 /* Record a symbol to be wrapped, from the --wrap option. */
716 add_wrap (const char *name
)
718 if (link_info
.wrap_hash
== NULL
)
721 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
722 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
724 sizeof (struct bfd_hash_entry
),
726 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
729 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
730 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
733 /* Handle the -retain-symbols-file option. */
736 add_keepsyms_file (const char *filename
)
743 if (link_info
.strip
== strip_some
)
744 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
746 file
= fopen (filename
, "r");
749 bfd_set_error (bfd_error_system_call
);
750 einfo ("%X%P: %s: %E\n", filename
);
754 link_info
.keep_hash
= (struct bfd_hash_table
*)
755 xmalloc (sizeof (struct bfd_hash_table
));
756 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
757 sizeof (struct bfd_hash_entry
)))
758 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
761 buf
= (char *) xmalloc (bufsize
);
773 while (!ISSPACE (c
) && c
!= EOF
)
780 buf
= (char *) xrealloc (buf
, bufsize
);
787 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
788 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
792 if (link_info
.strip
!= strip_none
)
793 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
796 link_info
.strip
= strip_some
;
800 /* Callbacks from the BFD linker routines. */
802 /* This is called when BFD has decided to include an archive member in
806 add_archive_element (struct bfd_link_info
*info
,
809 bfd
**subsbfd ATTRIBUTE_UNUSED
)
811 lang_input_statement_type
*input
;
812 lang_input_statement_type
*parent
;
813 lang_input_statement_type orig_input
;
815 input
= (lang_input_statement_type
*)
816 xcalloc (1, sizeof (lang_input_statement_type
));
817 input
->header
.type
= lang_input_statement_enum
;
818 input
->filename
= abfd
->filename
;
819 input
->local_sym_name
= abfd
->filename
;
820 input
->the_bfd
= abfd
;
822 parent
= bfd_usrdata (abfd
->my_archive
);
823 if (parent
!= NULL
&& !parent
->flags
.reload
)
824 parent
->next
= input
;
826 /* Save the original data for trace files/tries below, as plugins
827 (if enabled) may possibly alter it to point to a replacement
828 BFD, but we still want to output the original BFD filename. */
830 #ifdef ENABLE_PLUGINS
831 if (link_info
.lto_plugin_active
)
833 /* We must offer this archive member to the plugins to claim. */
834 plugin_maybe_claim (input
);
835 if (input
->flags
.claimed
)
837 if (no_more_claiming
)
839 /* Don't claim new IR symbols after all IR symbols have
842 info_msg ("%pI: no new IR symbols to claimi\n",
844 input
->flags
.claimed
= 0;
847 input
->flags
.claim_archive
= TRUE
;
848 *subsbfd
= input
->the_bfd
;
851 #endif /* ENABLE_PLUGINS */
853 ldlang_add_file (input
);
855 if (config
.map_file
!= NULL
)
857 static bfd_boolean header_printed
;
858 struct bfd_link_hash_entry
*h
;
862 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
864 && info
->pei386_auto_import
865 && CONST_STRNEQ (name
, "__imp_"))
866 h
= bfd_link_hash_lookup (info
->hash
, name
+ 6, FALSE
, FALSE
, TRUE
);
878 case bfd_link_hash_defined
:
879 case bfd_link_hash_defweak
:
880 from
= h
->u
.def
.section
->owner
;
883 case bfd_link_hash_undefined
:
884 case bfd_link_hash_undefweak
:
885 from
= h
->u
.undef
.abfd
;
888 case bfd_link_hash_common
:
889 from
= h
->u
.c
.p
->section
->owner
;
896 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
897 header_printed
= TRUE
;
900 if (abfd
->my_archive
== NULL
901 || bfd_is_thin_archive (abfd
->my_archive
))
903 minfo ("%s", bfd_get_filename (abfd
));
904 len
= strlen (bfd_get_filename (abfd
));
908 minfo ("%s(%s)", bfd_get_filename (abfd
->my_archive
),
909 bfd_get_filename (abfd
));
910 len
= (strlen (bfd_get_filename (abfd
->my_archive
))
911 + strlen (bfd_get_filename (abfd
))
927 minfo ("%pB ", from
);
929 minfo ("(%pT)\n", h
->root
.string
);
931 minfo ("(%s)\n", name
);
936 || (trace_files
&& bfd_is_thin_archive (orig_input
.the_bfd
->my_archive
)))
937 info_msg ("%pI\n", &orig_input
);
941 /* This is called when BFD has discovered a symbol which is defined
945 multiple_definition (struct bfd_link_info
*info
,
946 struct bfd_link_hash_entry
*h
,
956 if (info
->allow_multiple_definition
)
961 case bfd_link_hash_defined
:
962 osec
= h
->u
.def
.section
;
963 oval
= h
->u
.def
.value
;
964 obfd
= h
->u
.def
.section
->owner
;
966 case bfd_link_hash_indirect
:
967 osec
= bfd_ind_section_ptr
;
975 /* Ignore a redefinition of an absolute symbol to the
976 same value; it's harmless. */
977 if (h
->type
== bfd_link_hash_defined
978 && bfd_is_abs_section (osec
)
979 && bfd_is_abs_section (nsec
)
983 /* If either section has the output_section field set to
984 bfd_abs_section_ptr, it means that the section is being
985 discarded, and this is not really a multiple definition at all.
986 FIXME: It would be cleaner to somehow ignore symbols defined in
987 sections which are being discarded. */
988 if (!info
->prohibit_multiple_definition_absolute
989 && ((osec
->output_section
!= NULL
990 && ! bfd_is_abs_section (osec
)
991 && bfd_is_abs_section (osec
->output_section
))
992 || (nsec
->output_section
!= NULL
993 && !bfd_is_abs_section (nsec
)
994 && bfd_is_abs_section (nsec
->output_section
))))
997 name
= h
->root
.string
;
1005 einfo (_("%X%P: %C: multiple definition of `%pT'"),
1006 nbfd
, nsec
, nval
, name
);
1008 einfo (_("; %D: first defined here"), obfd
, osec
, oval
);
1011 if (RELAXATION_ENABLED_BY_USER
)
1013 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1018 /* This is called when there is a definition of a common symbol, or
1019 when a common symbol is found for a symbol that is already defined,
1020 or when two common symbols are found. We only do something if
1021 -warn-common was used. */
1024 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1025 struct bfd_link_hash_entry
*h
,
1027 enum bfd_link_hash_type ntype
,
1032 enum bfd_link_hash_type otype
;
1035 if (!config
.warn_common
)
1038 name
= h
->root
.string
;
1040 if (otype
== bfd_link_hash_common
)
1042 obfd
= h
->u
.c
.p
->section
->owner
;
1043 osize
= h
->u
.c
.size
;
1045 else if (otype
== bfd_link_hash_defined
1046 || otype
== bfd_link_hash_defweak
)
1048 obfd
= h
->u
.def
.section
->owner
;
1053 /* FIXME: It would nice if we could report the BFD which defined
1054 an indirect symbol, but we don't have anywhere to store the
1060 if (ntype
== bfd_link_hash_defined
1061 || ntype
== bfd_link_hash_defweak
1062 || ntype
== bfd_link_hash_indirect
)
1064 ASSERT (otype
== bfd_link_hash_common
);
1066 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1070 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1073 else if (otype
== bfd_link_hash_defined
1074 || otype
== bfd_link_hash_defweak
1075 || otype
== bfd_link_hash_indirect
)
1077 ASSERT (ntype
== bfd_link_hash_common
);
1079 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1083 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1088 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1092 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1093 " by larger common from %pB\n"),
1096 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1097 " by larger common\n"),
1100 else if (nsize
> osize
)
1103 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1104 " smaller common from %pB\n"),
1107 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1108 " smaller common\n"),
1114 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1117 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1123 /* This is called when BFD has discovered a set element. H is the
1124 entry in the linker hash table for the set. SECTION and VALUE
1125 represent a value which should be added to the set. */
1128 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1129 struct bfd_link_hash_entry
*h
,
1130 bfd_reloc_code_real_type reloc
,
1135 if (config
.warn_constructors
)
1136 einfo (_("%P: warning: global constructor %s used\n"),
1139 if (!config
.build_constructors
)
1142 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1144 if (h
->type
== bfd_link_hash_new
)
1146 h
->type
= bfd_link_hash_undefined
;
1147 h
->u
.undef
.abfd
= abfd
;
1148 /* We don't call bfd_link_add_undef to add this to the list of
1149 undefined symbols because we are going to define it
1154 /* This is called when BFD has discovered a constructor. This is only
1155 called for some object file formats--those which do not handle
1156 constructors in some more clever fashion. This is similar to
1157 adding an element to a set, but less general. */
1160 constructor_callback (struct bfd_link_info
*info
,
1161 bfd_boolean constructor
,
1168 struct bfd_link_hash_entry
*h
;
1169 char set_name
[1 + sizeof "__CTOR_LIST__"];
1171 if (config
.warn_constructors
)
1172 einfo (_("%P: warning: global constructor %s used\n"), name
);
1174 if (!config
.build_constructors
)
1177 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1178 useful error message. */
1179 if (bfd_reloc_type_lookup (info
->output_bfd
, BFD_RELOC_CTOR
) == NULL
1180 && (bfd_link_relocatable (info
)
1181 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1182 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1185 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1186 *s
++ = bfd_get_symbol_leading_char (abfd
);
1188 strcpy (s
, "__CTOR_LIST__");
1190 strcpy (s
, "__DTOR_LIST__");
1192 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1193 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1194 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1195 if (h
->type
== bfd_link_hash_new
)
1197 h
->type
= bfd_link_hash_undefined
;
1198 h
->u
.undef
.abfd
= abfd
;
1199 /* We don't call bfd_link_add_undef to add this to the list of
1200 undefined symbols because we are going to define it
1204 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1207 /* A structure used by warning_callback to pass information through
1208 bfd_map_over_sections. */
1210 struct warning_callback_info
1213 const char *warning
;
1218 /* Look through the relocs to see if we can find a plausible address
1219 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1222 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1224 struct warning_callback_info cinfo
;
1226 if (!bfd_generic_link_read_symbols (abfd
))
1227 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd
);
1229 cinfo
.found
= FALSE
;
1230 cinfo
.warning
= warning
;
1231 cinfo
.symbol
= symbol
;
1232 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1233 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1237 /* This is called when there is a reference to a warning symbol. */
1240 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1241 const char *warning
,
1247 /* This is a hack to support warn_multiple_gp. FIXME: This should
1248 have a cleaner interface, but what? */
1249 if (!config
.warn_multiple_gp
1250 && strcmp (warning
, "using multiple gp values") == 0)
1253 if (section
!= NULL
)
1254 einfo ("%P: %C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1255 else if (abfd
== NULL
)
1256 einfo ("%P: %s%s\n", _("warning: "), warning
);
1257 else if (symbol
== NULL
)
1258 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1259 else if (!symbol_warning (warning
, symbol
, abfd
))
1262 /* Search all input files for a reference to SYMBOL. */
1263 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1264 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1266 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1270 /* This is called by warning_callback for each section. It checks the
1271 relocs of the section to see if it can find a reference to the
1272 symbol which triggered the warning. If it can, it uses the reloc
1273 to give an error message with a file and line number. */
1276 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1278 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1282 arelent
**p
, **pend
;
1287 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1289 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1293 relpp
= (arelent
**) xmalloc (relsize
);
1294 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1296 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1299 pend
= p
+ relcount
;
1300 for (; p
< pend
&& *p
!= NULL
; p
++)
1304 if (q
->sym_ptr_ptr
!= NULL
1305 && *q
->sym_ptr_ptr
!= NULL
1306 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1308 /* We found a reloc for the symbol we are looking for. */
1309 einfo ("%P: %C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1319 /* This is called when an undefined symbol is found. */
1322 undefined_symbol (struct bfd_link_info
*info
,
1329 static char *error_name
;
1330 static unsigned int error_count
;
1332 #define MAX_ERRORS_IN_A_ROW 5
1334 if (info
->ignore_hash
!= NULL
1335 && bfd_hash_lookup (info
->ignore_hash
, name
, FALSE
, FALSE
) != NULL
)
1338 if (config
.warn_once
)
1340 /* Only warn once about a particular undefined symbol. */
1341 add_ignoresym (info
, name
);
1344 /* We never print more than a reasonable number of errors in a row
1345 for a single symbol. */
1346 if (error_name
!= NULL
1347 && strcmp (name
, error_name
) == 0)
1352 if (error_name
!= NULL
)
1354 error_name
= xstrdup (name
);
1357 if (section
!= NULL
)
1359 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1362 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1363 abfd
, section
, address
, name
);
1365 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1366 abfd
, section
, address
, name
);
1368 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1371 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1372 abfd
, section
, address
, name
);
1374 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1375 abfd
, section
, address
, name
);
1382 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1385 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1388 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1391 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1394 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1397 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1405 /* Counter to limit the number of relocation overflow error messages
1406 to print. Errors are printed as it is decremented. When it's
1407 called and the counter is zero, a final message is printed
1408 indicating more relocations were omitted. When it gets to -1, no
1409 such errors are printed. If it's initially set to a value less
1410 than -1, all such errors will be printed (--verbose does this). */
1412 int overflow_cutoff_limit
= 10;
1414 /* This is called when a reloc overflows. */
1417 reloc_overflow (struct bfd_link_info
*info
,
1418 struct bfd_link_hash_entry
*entry
,
1420 const char *reloc_name
,
1426 if (overflow_cutoff_limit
== -1)
1429 einfo ("%X%H:", abfd
, section
, address
);
1431 if (overflow_cutoff_limit
>= 0
1432 && overflow_cutoff_limit
-- == 0)
1434 einfo (_(" additional relocation overflows omitted from the output\n"));
1440 while (entry
->type
== bfd_link_hash_indirect
1441 || entry
->type
== bfd_link_hash_warning
)
1442 entry
= entry
->u
.i
.link
;
1443 switch (entry
->type
)
1445 case bfd_link_hash_undefined
:
1446 case bfd_link_hash_undefweak
:
1447 einfo (_(" relocation truncated to fit: "
1448 "%s against undefined symbol `%pT'"),
1449 reloc_name
, entry
->root
.string
);
1451 case bfd_link_hash_defined
:
1452 case bfd_link_hash_defweak
:
1453 einfo (_(" relocation truncated to fit: "
1454 "%s against symbol `%pT' defined in %pA section in %pB"),
1455 reloc_name
, entry
->root
.string
,
1456 entry
->u
.def
.section
,
1457 entry
->u
.def
.section
== bfd_abs_section_ptr
1458 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1466 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1469 einfo ("+%v", addend
);
1473 /* This is called when a dangerous relocation is made. */
1476 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1477 const char *message
,
1482 einfo (_("%X%H: dangerous relocation: %s\n"),
1483 abfd
, section
, address
, message
);
1486 /* This is called when a reloc is being generated attached to a symbol
1487 that is not being output. */
1490 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1496 einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1497 abfd
, section
, address
, name
);
1500 /* This is called if link_info.notice_all is set, or when a symbol in
1501 link_info.notice_hash is found. Symbols are put in notice_hash
1502 using the -y option, while notice_all is set if the --cref option
1503 has been supplied, or if there are any NOCROSSREFS sections in the
1504 linker script; and if plugins are active, since they need to monitor
1505 all references from non-IR files. */
1508 notice (struct bfd_link_info
*info
,
1509 struct bfd_link_hash_entry
*h
,
1510 struct bfd_link_hash_entry
*inh ATTRIBUTE_UNUSED
,
1514 flagword flags ATTRIBUTE_UNUSED
)
1520 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1521 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1525 name
= h
->root
.string
;
1526 if (info
->notice_hash
!= NULL
1527 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1529 if (bfd_is_und_section (section
))
1530 einfo (_("%P: %pB: reference to %s\n"), abfd
, name
);
1532 einfo (_("%P: %pB: definition of %s\n"), abfd
, name
);
1535 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1536 add_cref (name
, abfd
, section
, value
);