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"
30 #include "elf/common.h"
43 #if BFD_SUPPORTS_PLUGINS
45 #include "plugin-api.h"
46 #endif /* BFD_SUPPORTS_PLUGINS */
48 /* Somewhere above, sys/stat.h got included. */
49 #if !defined(S_ISDIR) && defined(S_IFDIR)
50 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
55 #ifndef TARGET_SYSTEM_ROOT
56 #define TARGET_SYSTEM_ROOT ""
61 FILE *saved_script_handle
= NULL
;
62 FILE *previous_script_handle
= NULL
;
63 bfd_boolean force_make_executable
= FALSE
;
66 const char *output_filename
= "a.out";
68 /* Name this program was invoked by. */
71 /* The prefix for system library directories. */
72 const char *ld_sysroot
;
74 /* The canonical representation of ld_sysroot. */
75 char *ld_canon_sysroot
;
76 int ld_canon_sysroot_len
;
78 /* Set by -G argument, for targets like MIPS ELF. */
79 int g_switch_value
= 8;
81 /* Nonzero means print names of input files as processed. */
82 unsigned int trace_files
;
84 /* Nonzero means report actions taken by the linker, and describe the linker script in use. */
87 /* Nonzero means version number was printed, so exit successfully
88 instead of complaining if no input files are given. */
89 bfd_boolean version_printed
;
91 /* TRUE if we should demangle symbol names. */
92 bfd_boolean demangling
;
94 args_type command_line
;
96 ld_config_type config
;
98 sort_type sort_section
;
100 static const char *get_sysroot
102 static char *get_emulation
104 static bfd_boolean add_archive_element
105 (struct bfd_link_info
*, bfd
*, const char *, bfd
**);
106 static void multiple_definition
107 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
108 bfd
*, asection
*, bfd_vma
);
109 static void multiple_common
110 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
111 bfd
*, enum bfd_link_hash_type
, bfd_vma
);
112 static void add_to_set
113 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
114 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
115 static void constructor_callback
116 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
117 asection
*, bfd_vma
);
118 static void warning_callback
119 (struct bfd_link_info
*, const char *, const char *, bfd
*,
120 asection
*, bfd_vma
);
121 static void warning_find_reloc
122 (bfd
*, asection
*, void *);
123 static void undefined_symbol
124 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
126 static void reloc_overflow
127 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
128 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
129 static void reloc_dangerous
130 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
131 static void unattached_reloc
132 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
133 static bfd_boolean notice
134 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
135 struct bfd_link_hash_entry
*, bfd
*, asection
*, bfd_vma
, flagword
);
137 static struct bfd_link_callbacks link_callbacks
=
143 constructor_callback
,
153 ldlang_override_segment_assignment
,
154 ldlang_ctf_apply_strsym
,
155 ldlang_write_ctf_late
158 static bfd_assert_handler_type default_bfd_assert_handler
;
159 static bfd_error_handler_type default_bfd_error_handler
;
161 struct bfd_link_info link_info
;
163 struct dependency_file
165 struct dependency_file
*next
;
169 static struct dependency_file
*dependency_files
, *dependency_files_tail
;
172 track_dependency_files (const char *filename
)
174 struct dependency_file
*dep
175 = (struct dependency_file
*) xmalloc (sizeof (*dep
));
176 dep
->name
= xstrdup (filename
);
178 if (dependency_files
== NULL
)
179 dependency_files
= dep
;
181 dependency_files_tail
->next
= dep
;
182 dependency_files_tail
= dep
;
186 write_dependency_file (void)
189 struct dependency_file
*dep
;
191 out
= fopen (config
.dependency_file
, FOPEN_WT
);
194 einfo (_("%F%P: cannot open dependency file %s: %E\n"),
195 config
.dependency_file
);
198 fprintf (out
, "%s:", output_filename
);
200 for (dep
= dependency_files
; dep
!= NULL
; dep
= dep
->next
)
201 fprintf (out
, " \\\n %s", dep
->name
);
204 for (dep
= dependency_files
; dep
!= NULL
; dep
= dep
->next
)
205 fprintf (out
, "\n%s:\n", dep
->name
);
213 bfd_cache_close_all ();
214 #if BFD_SUPPORTS_PLUGINS
215 plugin_call_cleanup ();
217 if (output_filename
&& delete_output_file_on_failure
)
218 unlink_if_ordinary (output_filename
);
221 /* Hook to notice BFD assertions. */
224 ld_bfd_assert_handler (const char *fmt
, const char *bfdver
,
225 const char *file
, int line
)
227 config
.make_executable
= FALSE
;
228 (*default_bfd_assert_handler
) (fmt
, bfdver
, file
, line
);
231 /* Hook the bfd error/warning handler for --fatal-warnings. */
234 ld_bfd_error_handler (const char *fmt
, va_list ap
)
236 if (config
.fatal_warnings
)
237 config
.make_executable
= FALSE
;
238 (*default_bfd_error_handler
) (fmt
, ap
);
242 main (int argc
, char **argv
)
245 long start_time
= get_run_time ();
247 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
248 setlocale (LC_MESSAGES
, "");
250 #if defined (HAVE_SETLOCALE)
251 setlocale (LC_CTYPE
, "");
253 bindtextdomain (PACKAGE
, LOCALEDIR
);
254 textdomain (PACKAGE
);
256 program_name
= argv
[0];
257 xmalloc_set_program_name (program_name
);
259 START_PROGRESS (program_name
, 0);
261 expandargv (&argc
, &argv
);
263 if (bfd_init () != BFD_INIT_MAGIC
)
264 einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
266 bfd_set_error_program_name (program_name
);
268 /* We want to notice and fail on those nasty BFD assertions which are
269 likely to signal incorrect output being generated but otherwise may
271 default_bfd_assert_handler
= bfd_set_assert_handler (ld_bfd_assert_handler
);
273 /* Also hook the bfd error/warning handler for --fatal-warnings. */
274 default_bfd_error_handler
= bfd_set_error_handler (ld_bfd_error_handler
);
276 xatexit (ld_cleanup
);
278 /* Set up the sysroot directory. */
279 ld_sysroot
= get_sysroot (argc
, argv
);
281 ld_canon_sysroot
= lrealpath (ld_sysroot
);
282 if (ld_canon_sysroot
)
284 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
286 /* is_sysrooted_pathname() relies on no trailing dirsep. */
287 if (ld_canon_sysroot_len
> 0
288 && IS_DIR_SEPARATOR (ld_canon_sysroot
[ld_canon_sysroot_len
- 1]))
289 ld_canon_sysroot
[--ld_canon_sysroot_len
] = '\0';
292 ld_canon_sysroot_len
= -1;
294 /* Set the default BFD target based on the configured target. Doing
295 this permits the linker to be configured for a particular target,
296 and linked against a shared BFD library which was configured for
297 a different target. The macro TARGET is defined by Makefile. */
298 if (!bfd_set_default_target (TARGET
))
300 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
311 config
.build_constructors
= TRUE
;
312 config
.rpath_separator
= ':';
313 config
.split_by_reloc
= (unsigned) -1;
314 config
.split_by_file
= (bfd_size_type
) -1;
315 config
.make_executable
= TRUE
;
316 config
.magic_demand_paged
= TRUE
;
317 config
.text_read_only
= TRUE
;
318 config
.print_map_discarded
= TRUE
;
319 link_info
.disable_target_specific_optimizations
= -1;
321 command_line
.warn_mismatch
= TRUE
;
322 command_line
.warn_search_mismatch
= TRUE
;
323 command_line
.check_section_addresses
= -1;
325 /* We initialize DEMANGLING based on the environment variable
326 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
327 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
328 environment. Acting the same way here lets us provide the same
329 interface by default. */
330 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
332 link_info
.allow_undefined_version
= TRUE
;
333 link_info
.keep_memory
= TRUE
;
334 link_info
.combreloc
= TRUE
;
335 link_info
.strip_discarded
= TRUE
;
336 link_info
.prohibit_multiple_definition_absolute
= FALSE
;
337 link_info
.textrel_check
= DEFAULT_LD_TEXTREL_CHECK
;
338 link_info
.emit_hash
= DEFAULT_EMIT_SYSV_HASH
;
339 link_info
.emit_gnu_hash
= DEFAULT_EMIT_GNU_HASH
;
340 link_info
.callbacks
= &link_callbacks
;
341 link_info
.input_bfds_tail
= &link_info
.input_bfds
;
342 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
343 and _fini symbols. We are compatible. */
344 link_info
.init_function
= "_init";
345 link_info
.fini_function
= "_fini";
346 link_info
.relax_pass
= 1;
347 link_info
.extern_protected_data
= -1;
348 link_info
.dynamic_undefined_weak
= -1;
349 link_info
.pei386_auto_import
= -1;
350 link_info
.spare_dynamic_tags
= 5;
351 link_info
.path_separator
= ':';
352 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
353 link_info
.compress_debug
= COMPRESS_DEBUG_GABI_ZLIB
;
355 #ifdef DEFAULT_NEW_DTAGS
356 link_info
.new_dtags
= DEFAULT_NEW_DTAGS
;
358 link_info
.start_stop_visibility
= STV_PROTECTED
;
360 ldfile_add_arch ("");
361 emulation
= get_emulation (argc
, argv
);
362 ldemul_choose_mode (emulation
);
363 default_target
= ldemul_choose_target (argc
, argv
);
366 ldemul_before_parse ();
367 lang_has_input_file
= FALSE
;
368 parse_args (argc
, argv
);
370 if (config
.hash_table_size
!= 0)
371 bfd_hash_set_default_size (config
.hash_table_size
);
373 #if BFD_SUPPORTS_PLUGINS
374 /* Now all the plugin arguments have been gathered, we can load them. */
375 plugin_load_plugins ();
376 #endif /* BFD_SUPPORTS_PLUGINS */
378 ldemul_set_symbols ();
380 /* If we have not already opened and parsed a linker script,
381 try the default script from command line first. */
382 if (saved_script_handle
== NULL
383 && command_line
.default_script
!= NULL
)
385 ldfile_open_script_file (command_line
.default_script
);
386 parser_input
= input_script
;
390 /* If we have not already opened and parsed a linker script
391 read the emulation's appropriate default script. */
392 if (saved_script_handle
== NULL
)
395 char *s
= ldemul_get_script (&isfile
);
398 ldfile_open_default_command_file (s
);
402 lex_redirect (s
, _("built in linker script"), 1);
404 parser_input
= input_script
;
411 if (saved_script_handle
)
412 info_msg (_("using external linker script:"));
414 info_msg (_("using internal linker script:"));
415 info_msg ("\n==================================================\n");
417 if (saved_script_handle
)
419 static const int ld_bufsz
= 8193;
421 char *buf
= (char *) xmalloc (ld_bufsz
);
423 rewind (saved_script_handle
);
424 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
427 info_msg ("%s", buf
);
429 rewind (saved_script_handle
);
436 info_msg (ldemul_get_script (&isfile
));
439 info_msg ("\n==================================================\n");
442 if (command_line
.force_group_allocation
443 || !bfd_link_relocatable (&link_info
))
444 link_info
.resolve_section_groups
= TRUE
;
446 link_info
.resolve_section_groups
= FALSE
;
448 if (command_line
.print_output_format
)
449 info_msg ("%s\n", lang_get_output_target ());
453 /* If the only command line argument has been -v or --version or --verbose
454 then ignore any input files provided by linker scripts and exit now.
455 We do not want to create an output file when the linker is just invoked
456 to provide version information. */
457 if (argc
== 2 && version_printed
)
460 if (link_info
.inhibit_common_definition
&& !bfd_link_dll (&link_info
))
461 einfo (_("%F%P: --no-define-common may not be used without -shared\n"));
463 if (!lang_has_input_file
)
465 if (version_printed
|| command_line
.print_output_format
)
467 einfo (_("%F%P: no input files\n"));
471 info_msg (_("%P: mode %s\n"), emulation
);
473 ldemul_after_parse ();
475 if (config
.map_filename
)
477 if (strcmp (config
.map_filename
, "-") == 0)
479 config
.map_file
= stdout
;
483 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
484 if (config
.map_file
== (FILE *) NULL
)
486 bfd_set_error (bfd_error_system_call
);
487 einfo (_("%F%P: cannot open map file %s: %E\n"),
488 config
.map_filename
);
491 link_info
.has_map_file
= TRUE
;
496 /* Print error messages for any missing symbols, for any warning
497 symbols, and possibly multiple definitions. */
498 if (bfd_link_relocatable (&link_info
))
499 link_info
.output_bfd
->flags
&= ~EXEC_P
;
501 link_info
.output_bfd
->flags
|= EXEC_P
;
503 if ((link_info
.compress_debug
& COMPRESS_DEBUG
))
505 link_info
.output_bfd
->flags
|= BFD_COMPRESS
;
506 if (link_info
.compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
507 link_info
.output_bfd
->flags
|= BFD_COMPRESS_GABI
;
512 if (config
.map_file
!= NULL
)
514 if (command_line
.cref
)
515 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
516 if (nocrossref_list
!= NULL
)
517 check_nocrossrefs ();
518 if (command_line
.print_memory_usage
)
519 lang_print_memory_usage ();
522 struct bfd_link_hash_entry
*h
;
524 h
= bfd_link_hash_lookup (link_info
.hash
, "__image_base__", 0,0,1);
525 fprintf (stderr
, "lookup = %p val %lx\n", h
, h
? h
->u
.def
.value
: 1);
531 if (config
.dependency_file
!= NULL
)
532 write_dependency_file ();
534 /* Even if we're producing relocatable output, some non-fatal errors should
535 be reported in the exit status. (What non-fatal errors, if any, do we
536 want to ignore for relocatable output?) */
537 if (!config
.make_executable
&& !force_make_executable
)
540 einfo (_("%P: link errors found, deleting executable `%s'\n"),
543 /* The file will be removed by ld_cleanup. */
548 if (!bfd_close (link_info
.output_bfd
))
549 einfo (_("%F%P: %pB: final close failed: %E\n"), link_info
.output_bfd
);
551 /* If the --force-exe-suffix is enabled, and we're making an
552 executable file and it doesn't end in .exe, copy it to one
554 if (!bfd_link_relocatable (&link_info
)
555 && command_line
.force_exe_suffix
)
557 int len
= strlen (output_filename
);
560 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
561 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
565 const int bsize
= 4096;
566 char *buf
= (char *) xmalloc (bsize
);
568 char *dst_name
= (char *) xmalloc (len
+ 5);
570 strcpy (dst_name
, output_filename
);
571 strcat (dst_name
, ".exe");
572 src
= fopen (output_filename
, FOPEN_RB
);
573 dst
= fopen (dst_name
, FOPEN_WB
);
576 einfo (_("%F%P: unable to open for source of copy `%s'\n"),
579 einfo (_("%F%P: unable to open for destination of copy `%s'\n"),
581 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
583 int done
= fwrite (buf
, 1, l
, dst
);
586 einfo (_("%P: error writing file `%s'\n"), dst_name
);
590 if (fclose (dst
) == EOF
)
591 einfo (_("%P: error closing file `%s'\n"), dst_name
);
598 END_PROGRESS (program_name
);
602 long run_time
= get_run_time () - start_time
;
605 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
606 program_name
, run_time
/ 1000000, run_time
% 1000000);
610 /* Prevent ld_cleanup from doing anything, after a successful link. */
611 output_filename
= NULL
;
617 /* If the configured sysroot is relocatable, try relocating it based on
618 default prefix FROM. Return the relocated directory if it exists,
619 otherwise return null. */
622 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
624 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
628 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
631 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
639 /* Return the sysroot directory. Return "" if no sysroot is being used. */
642 get_sysroot (int argc
, char **argv
)
645 const char *path
= NULL
;
647 for (i
= 1; i
< argc
; i
++)
648 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
649 path
= argv
[i
] + strlen ("--sysroot=");
652 path
= get_relative_sysroot (BINDIR
);
655 path
= get_relative_sysroot (TOOLBINDIR
);
658 path
= TARGET_SYSTEM_ROOT
;
660 if (IS_DIR_SEPARATOR (*path
) && path
[1] == 0)
666 /* We need to find any explicitly given emulation in order to initialize the
667 state that's needed by the lex&yacc argument parser (parse_args). */
670 get_emulation (int argc
, char **argv
)
675 emulation
= getenv (EMULATION_ENVIRON
);
676 if (emulation
== NULL
)
677 emulation
= DEFAULT_EMULATION
;
679 for (i
= 1; i
< argc
; i
++)
681 if (CONST_STRNEQ (argv
[i
], "-m"))
683 if (argv
[i
][2] == '\0')
688 emulation
= argv
[i
+ 1];
692 einfo (_("%F%P: missing argument to -m\n"));
694 else if (strcmp (argv
[i
], "-mips1") == 0
695 || strcmp (argv
[i
], "-mips2") == 0
696 || strcmp (argv
[i
], "-mips3") == 0
697 || strcmp (argv
[i
], "-mips4") == 0
698 || strcmp (argv
[i
], "-mips5") == 0
699 || strcmp (argv
[i
], "-mips32") == 0
700 || strcmp (argv
[i
], "-mips32r2") == 0
701 || strcmp (argv
[i
], "-mips32r6") == 0
702 || strcmp (argv
[i
], "-mips64") == 0
703 || strcmp (argv
[i
], "-mips64r2") == 0
704 || strcmp (argv
[i
], "-mips64r6") == 0)
706 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
707 passed to the linker by some MIPS compilers. They
708 generally tell the linker to use a slightly different
709 library path. Perhaps someday these should be
710 implemented as emulations; until then, we just ignore
711 the arguments and hope that nobody ever creates
712 emulations named ips1, ips2 or ips3. */
714 else if (strcmp (argv
[i
], "-m486") == 0)
716 /* FIXME: The argument -m486 is passed to the linker on
717 some Linux systems. Hope that nobody creates an
718 emulation named 486. */
723 emulation
= &argv
[i
][2];
732 add_ysym (const char *name
)
734 if (link_info
.notice_hash
== NULL
)
736 link_info
.notice_hash
737 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
738 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
740 sizeof (struct bfd_hash_entry
),
742 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
745 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
746 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
750 add_ignoresym (struct bfd_link_info
*info
, const char *name
)
752 if (info
->ignore_hash
== NULL
)
754 info
->ignore_hash
= xmalloc (sizeof (struct bfd_hash_table
));
755 if (!bfd_hash_table_init_n (info
->ignore_hash
,
757 sizeof (struct bfd_hash_entry
),
759 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
762 if (bfd_hash_lookup (info
->ignore_hash
, name
, TRUE
, TRUE
) == NULL
)
763 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
766 /* Record a symbol to be wrapped, from the --wrap option. */
769 add_wrap (const char *name
)
771 if (link_info
.wrap_hash
== NULL
)
774 = (struct bfd_hash_table
*) xmalloc (sizeof (struct bfd_hash_table
));
775 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
777 sizeof (struct bfd_hash_entry
),
779 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
782 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
783 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
786 /* Handle the -retain-symbols-file option. */
789 add_keepsyms_file (const char *filename
)
796 if (link_info
.strip
== strip_some
)
797 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
799 file
= fopen (filename
, "r");
802 bfd_set_error (bfd_error_system_call
);
803 einfo ("%X%P: %s: %E\n", filename
);
807 link_info
.keep_hash
= (struct bfd_hash_table
*)
808 xmalloc (sizeof (struct bfd_hash_table
));
809 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
810 sizeof (struct bfd_hash_entry
)))
811 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
814 buf
= (char *) xmalloc (bufsize
);
826 while (!ISSPACE (c
) && c
!= EOF
)
833 buf
= (char *) xrealloc (buf
, bufsize
);
840 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
841 einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
845 if (link_info
.strip
!= strip_none
)
846 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
849 link_info
.strip
= strip_some
;
853 /* Callbacks from the BFD linker routines. */
855 /* This is called when BFD has decided to include an archive member in
859 add_archive_element (struct bfd_link_info
*info
,
862 bfd
**subsbfd ATTRIBUTE_UNUSED
)
864 lang_input_statement_type
*input
;
865 lang_input_statement_type
*parent
;
866 lang_input_statement_type orig_input
;
868 input
= (lang_input_statement_type
*)
869 xcalloc (1, sizeof (lang_input_statement_type
));
870 input
->header
.type
= lang_input_statement_enum
;
871 input
->filename
= bfd_get_filename (abfd
);
872 input
->local_sym_name
= bfd_get_filename (abfd
);
873 input
->the_bfd
= abfd
;
875 /* Save the original data for trace files/tries below, as plugins
876 (if enabled) may possibly alter it to point to a replacement
877 BFD, but we still want to output the original BFD filename. */
879 #if BFD_SUPPORTS_PLUGINS
880 if (link_info
.lto_plugin_active
)
882 /* We must offer this archive member to the plugins to claim. */
883 plugin_maybe_claim (input
);
884 if (input
->flags
.claimed
)
886 if (no_more_claiming
)
888 /* Don't claim new IR symbols after all IR symbols have
891 info_msg ("%pI: no new IR symbols to claim\n",
893 input
->flags
.claimed
= 0;
896 input
->flags
.claim_archive
= TRUE
;
897 *subsbfd
= input
->the_bfd
;
900 #endif /* BFD_SUPPORTS_PLUGINS */
902 if (link_info
.input_bfds_tail
== &input
->the_bfd
->link
.next
903 || input
->the_bfd
->link
.next
!= NULL
)
905 /* We have already loaded this element, and are attempting to
906 load it again. This can happen when the archive map doesn't
907 match actual symbols defined by the element. */
909 bfd_set_error (bfd_error_malformed_archive
);
913 /* Set the file_chain pointer of archives to the last element loaded
914 from the archive. See ldlang.c:find_rescan_insertion. */
915 parent
= bfd_usrdata (abfd
->my_archive
);
916 if (parent
!= NULL
&& !parent
->flags
.reload
)
917 parent
->next
= input
;
919 ldlang_add_file (input
);
921 if (config
.map_file
!= NULL
)
923 static bfd_boolean header_printed
;
924 struct bfd_link_hash_entry
*h
;
928 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
930 && info
->pei386_auto_import
931 && CONST_STRNEQ (name
, "__imp_"))
932 h
= bfd_link_hash_lookup (info
->hash
, name
+ 6, FALSE
, FALSE
, TRUE
);
944 case bfd_link_hash_defined
:
945 case bfd_link_hash_defweak
:
946 from
= h
->u
.def
.section
->owner
;
949 case bfd_link_hash_undefined
:
950 case bfd_link_hash_undefweak
:
951 from
= h
->u
.undef
.abfd
;
954 case bfd_link_hash_common
:
955 from
= h
->u
.c
.p
->section
->owner
;
962 minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
963 header_printed
= TRUE
;
966 if (abfd
->my_archive
== NULL
967 || bfd_is_thin_archive (abfd
->my_archive
))
969 minfo ("%s", bfd_get_filename (abfd
));
970 len
= strlen (bfd_get_filename (abfd
));
974 minfo ("%s(%s)", bfd_get_filename (abfd
->my_archive
),
975 bfd_get_filename (abfd
));
976 len
= (strlen (bfd_get_filename (abfd
->my_archive
))
977 + strlen (bfd_get_filename (abfd
))
993 minfo ("%pB ", from
);
995 minfo ("(%pT)\n", h
->root
.string
);
997 minfo ("(%s)\n", name
);
1002 || (trace_files
&& bfd_is_thin_archive (orig_input
.the_bfd
->my_archive
)))
1003 info_msg ("%pI\n", &orig_input
);
1007 /* This is called when BFD has discovered a symbol which is defined
1011 multiple_definition (struct bfd_link_info
*info
,
1012 struct bfd_link_hash_entry
*h
,
1022 if (info
->allow_multiple_definition
)
1027 case bfd_link_hash_defined
:
1028 osec
= h
->u
.def
.section
;
1029 oval
= h
->u
.def
.value
;
1030 obfd
= h
->u
.def
.section
->owner
;
1032 case bfd_link_hash_indirect
:
1033 osec
= bfd_ind_section_ptr
;
1041 /* Ignore a redefinition of an absolute symbol to the
1042 same value; it's harmless. */
1043 if (h
->type
== bfd_link_hash_defined
1044 && bfd_is_abs_section (osec
)
1045 && bfd_is_abs_section (nsec
)
1049 /* If either section has the output_section field set to
1050 bfd_abs_section_ptr, it means that the section is being
1051 discarded, and this is not really a multiple definition at all.
1052 FIXME: It would be cleaner to somehow ignore symbols defined in
1053 sections which are being discarded. */
1054 if (!info
->prohibit_multiple_definition_absolute
1055 && ((osec
->output_section
!= NULL
1056 && ! bfd_is_abs_section (osec
)
1057 && bfd_is_abs_section (osec
->output_section
))
1058 || (nsec
->output_section
!= NULL
1059 && !bfd_is_abs_section (nsec
)
1060 && bfd_is_abs_section (nsec
->output_section
))))
1063 name
= h
->root
.string
;
1071 einfo (_("%X%P: %C: multiple definition of `%pT'"),
1072 nbfd
, nsec
, nval
, name
);
1074 einfo (_("; %D: first defined here"), obfd
, osec
, oval
);
1077 if (RELAXATION_ENABLED_BY_USER
)
1079 einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1084 /* This is called when there is a definition of a common symbol, or
1085 when a common symbol is found for a symbol that is already defined,
1086 or when two common symbols are found. We only do something if
1087 -warn-common was used. */
1090 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1091 struct bfd_link_hash_entry
*h
,
1093 enum bfd_link_hash_type ntype
,
1098 enum bfd_link_hash_type otype
;
1101 if (!config
.warn_common
)
1104 name
= h
->root
.string
;
1106 if (otype
== bfd_link_hash_common
)
1108 obfd
= h
->u
.c
.p
->section
->owner
;
1109 osize
= h
->u
.c
.size
;
1111 else if (otype
== bfd_link_hash_defined
1112 || otype
== bfd_link_hash_defweak
)
1114 obfd
= h
->u
.def
.section
->owner
;
1119 /* FIXME: It would nice if we could report the BFD which defined
1120 an indirect symbol, but we don't have anywhere to store the
1126 if (ntype
== bfd_link_hash_defined
1127 || ntype
== bfd_link_hash_defweak
1128 || ntype
== bfd_link_hash_indirect
)
1130 ASSERT (otype
== bfd_link_hash_common
);
1132 einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1136 einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1139 else if (otype
== bfd_link_hash_defined
1140 || otype
== bfd_link_hash_defweak
1141 || otype
== bfd_link_hash_indirect
)
1143 ASSERT (ntype
== bfd_link_hash_common
);
1145 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1149 einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1154 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1158 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1159 " by larger common from %pB\n"),
1162 einfo (_("%P: %pB: warning: common of `%pT' overridden"
1163 " by larger common\n"),
1166 else if (nsize
> osize
)
1169 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1170 " smaller common from %pB\n"),
1173 einfo (_("%P: %pB: warning: common of `%pT' overriding"
1174 " smaller common\n"),
1180 einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1183 einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1189 /* This is called when BFD has discovered a set element. H is the
1190 entry in the linker hash table for the set. SECTION and VALUE
1191 represent a value which should be added to the set. */
1194 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1195 struct bfd_link_hash_entry
*h
,
1196 bfd_reloc_code_real_type reloc
,
1201 if (config
.warn_constructors
)
1202 einfo (_("%P: warning: global constructor %s used\n"),
1205 if (!config
.build_constructors
)
1208 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1210 if (h
->type
== bfd_link_hash_new
)
1212 h
->type
= bfd_link_hash_undefined
;
1213 h
->u
.undef
.abfd
= abfd
;
1214 /* We don't call bfd_link_add_undef to add this to the list of
1215 undefined symbols because we are going to define it
1220 /* This is called when BFD has discovered a constructor. This is only
1221 called for some object file formats--those which do not handle
1222 constructors in some more clever fashion. This is similar to
1223 adding an element to a set, but less general. */
1226 constructor_callback (struct bfd_link_info
*info
,
1227 bfd_boolean constructor
,
1234 struct bfd_link_hash_entry
*h
;
1235 char set_name
[1 + sizeof "__CTOR_LIST__"];
1237 if (config
.warn_constructors
)
1238 einfo (_("%P: warning: global constructor %s used\n"), name
);
1240 if (!config
.build_constructors
)
1243 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1244 useful error message. */
1245 if (bfd_reloc_type_lookup (info
->output_bfd
, BFD_RELOC_CTOR
) == NULL
1246 && (bfd_link_relocatable (info
)
1247 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1248 einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1251 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1252 *s
++ = bfd_get_symbol_leading_char (abfd
);
1254 strcpy (s
, "__CTOR_LIST__");
1256 strcpy (s
, "__DTOR_LIST__");
1258 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1259 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1260 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1261 if (h
->type
== bfd_link_hash_new
)
1263 h
->type
= bfd_link_hash_undefined
;
1264 h
->u
.undef
.abfd
= abfd
;
1265 /* We don't call bfd_link_add_undef to add this to the list of
1266 undefined symbols because we are going to define it
1270 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1273 /* A structure used by warning_callback to pass information through
1274 bfd_map_over_sections. */
1276 struct warning_callback_info
1279 const char *warning
;
1284 /* Look through the relocs to see if we can find a plausible address
1285 for SYMBOL in ABFD. Return TRUE if found. Otherwise return FALSE. */
1288 symbol_warning (const char *warning
, const char *symbol
, bfd
*abfd
)
1290 struct warning_callback_info cinfo
;
1292 if (!bfd_generic_link_read_symbols (abfd
))
1293 einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd
);
1295 cinfo
.found
= FALSE
;
1296 cinfo
.warning
= warning
;
1297 cinfo
.symbol
= symbol
;
1298 cinfo
.asymbols
= bfd_get_outsymbols (abfd
);
1299 bfd_map_over_sections (abfd
, warning_find_reloc
, &cinfo
);
1303 /* This is called when there is a reference to a warning symbol. */
1306 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1307 const char *warning
,
1313 /* This is a hack to support warn_multiple_gp. FIXME: This should
1314 have a cleaner interface, but what? */
1315 if (!config
.warn_multiple_gp
1316 && strcmp (warning
, "using multiple gp values") == 0)
1319 if (section
!= NULL
)
1320 einfo ("%P: %C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1321 else if (abfd
== NULL
)
1322 einfo ("%P: %s%s\n", _("warning: "), warning
);
1323 else if (symbol
== NULL
)
1324 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1325 else if (!symbol_warning (warning
, symbol
, abfd
))
1328 /* Search all input files for a reference to SYMBOL. */
1329 for (b
= info
->input_bfds
; b
; b
= b
->link
.next
)
1330 if (b
!= abfd
&& symbol_warning (warning
, symbol
, b
))
1332 einfo ("%P: %pB: %s%s\n", abfd
, _("warning: "), warning
);
1336 /* This is called by warning_callback for each section. It checks the
1337 relocs of the section to see if it can find a reference to the
1338 symbol which triggered the warning. If it can, it uses the reloc
1339 to give an error message with a file and line number. */
1342 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1344 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1348 arelent
**p
, **pend
;
1353 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1355 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1359 relpp
= (arelent
**) xmalloc (relsize
);
1360 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1362 einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd
);
1365 pend
= p
+ relcount
;
1366 for (; p
< pend
&& *p
!= NULL
; p
++)
1370 if (q
->sym_ptr_ptr
!= NULL
1371 && *q
->sym_ptr_ptr
!= NULL
1372 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1374 /* We found a reloc for the symbol we are looking for. */
1375 einfo ("%P: %C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1385 /* This is called when an undefined symbol is found. */
1388 undefined_symbol (struct bfd_link_info
*info
,
1395 static char *error_name
;
1396 static unsigned int error_count
;
1398 #define MAX_ERRORS_IN_A_ROW 5
1400 if (info
->ignore_hash
!= NULL
1401 && bfd_hash_lookup (info
->ignore_hash
, name
, FALSE
, FALSE
) != NULL
)
1404 if (config
.warn_once
)
1406 /* Only warn once about a particular undefined symbol. */
1407 add_ignoresym (info
, name
);
1410 /* We never print more than a reasonable number of errors in a row
1411 for a single symbol. */
1412 if (error_name
!= NULL
1413 && strcmp (name
, error_name
) == 0)
1419 error_name
= xstrdup (name
);
1422 if (section
!= NULL
)
1424 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1427 einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1428 abfd
, section
, address
, name
);
1430 einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1431 abfd
, section
, address
, name
);
1433 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1436 einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1437 abfd
, section
, address
, name
);
1439 einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1440 abfd
, section
, address
, name
);
1447 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1450 einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1453 einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1456 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1459 einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1462 einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1470 /* Counter to limit the number of relocation overflow error messages
1471 to print. Errors are printed as it is decremented. When it's
1472 called and the counter is zero, a final message is printed
1473 indicating more relocations were omitted. When it gets to -1, no
1474 such errors are printed. If it's initially set to a value less
1475 than -1, all such errors will be printed (--verbose does this). */
1477 int overflow_cutoff_limit
= 10;
1479 /* This is called when a reloc overflows. */
1482 reloc_overflow (struct bfd_link_info
*info
,
1483 struct bfd_link_hash_entry
*entry
,
1485 const char *reloc_name
,
1491 if (overflow_cutoff_limit
== -1)
1494 einfo ("%X%H:", abfd
, section
, address
);
1496 if (overflow_cutoff_limit
>= 0
1497 && overflow_cutoff_limit
-- == 0)
1499 einfo (_(" additional relocation overflows omitted from the output\n"));
1505 while (entry
->type
== bfd_link_hash_indirect
1506 || entry
->type
== bfd_link_hash_warning
)
1507 entry
= entry
->u
.i
.link
;
1508 switch (entry
->type
)
1510 case bfd_link_hash_undefined
:
1511 case bfd_link_hash_undefweak
:
1512 einfo (_(" relocation truncated to fit: "
1513 "%s against undefined symbol `%pT'"),
1514 reloc_name
, entry
->root
.string
);
1516 case bfd_link_hash_defined
:
1517 case bfd_link_hash_defweak
:
1518 einfo (_(" relocation truncated to fit: "
1519 "%s against symbol `%pT' defined in %pA section in %pB"),
1520 reloc_name
, entry
->root
.string
,
1521 entry
->u
.def
.section
,
1522 entry
->u
.def
.section
== bfd_abs_section_ptr
1523 ? info
->output_bfd
: entry
->u
.def
.section
->owner
);
1531 einfo (_(" relocation truncated to fit: %s against `%pT'"),
1534 einfo ("+%v", addend
);
1538 /* This is called when a dangerous relocation is made. */
1541 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1542 const char *message
,
1547 einfo (_("%X%H: dangerous relocation: %s\n"),
1548 abfd
, section
, address
, message
);
1551 /* This is called when a reloc is being generated attached to a symbol
1552 that is not being output. */
1555 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1561 einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1562 abfd
, section
, address
, name
);
1565 /* This is called if link_info.notice_all is set, or when a symbol in
1566 link_info.notice_hash is found. Symbols are put in notice_hash
1567 using the -y option, while notice_all is set if the --cref option
1568 has been supplied, or if there are any NOCROSSREFS sections in the
1569 linker script; and if plugins are active, since they need to monitor
1570 all references from non-IR files. */
1573 notice (struct bfd_link_info
*info
,
1574 struct bfd_link_hash_entry
*h
,
1575 struct bfd_link_hash_entry
*inh ATTRIBUTE_UNUSED
,
1579 flagword flags ATTRIBUTE_UNUSED
)
1585 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1586 return handle_asneeded_cref (abfd
, (enum notice_asneeded_action
) value
);
1590 name
= h
->root
.string
;
1591 if (info
->notice_hash
!= NULL
1592 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
)
1594 if (bfd_is_und_section (section
))
1595 einfo (_("%P: %pB: reference to %s\n"), abfd
, name
);
1597 einfo (_("%P: %pB: definition of %s\n"), abfd
, name
);
1600 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1601 add_cref (name
, abfd
, section
, value
);