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
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain steve@cygnus.com
7 This file is part of GLD, the Gnu Linker.
9 GLD 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 2, or (at your option)
14 GLD 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 GLD; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
27 #include "safe-ctype.h"
28 #include "libiberty.h"
31 #include "filenames.h"
45 /* Somewhere above, sys/stat.h got included. */
46 #if !defined(S_ISDIR) && defined(S_IFDIR)
47 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
58 #ifndef TARGET_SYSTEM_ROOT
59 #define TARGET_SYSTEM_ROOT ""
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 /* The file that we're creating. */
80 /* Set by -G argument, for MIPS ECOFF target. */
81 int g_switch_value
= 8;
83 /* Nonzero means print names of input files as processed. */
84 bfd_boolean trace_files
;
86 /* Nonzero means same, but note open failures, too. */
87 bfd_boolean trace_file_tries
;
89 /* Nonzero means version number was printed, so exit successfully
90 instead of complaining if no input files are given. */
91 bfd_boolean version_printed
;
93 /* Nonzero means link in every member of an archive. */
94 bfd_boolean whole_archive
;
96 /* Nonzero means create DT_NEEDED entries only if a dynamic library
97 actually satisfies some reference in a regular object. */
98 bfd_boolean as_needed
;
100 /* Nonzero means never create DT_NEEDED entries for dynamic libraries
101 in DT_NEEDED tags. */
102 bfd_boolean add_needed
= TRUE
;
104 /* TRUE if we should demangle symbol names. */
105 bfd_boolean demangling
;
107 args_type command_line
;
109 ld_config_type config
;
111 sort_type sort_section
;
113 static const char *get_sysroot
115 static char *get_emulation
117 static void set_scripts_dir
119 static bfd_boolean add_archive_element
120 (struct bfd_link_info
*, bfd
*, const char *);
121 static bfd_boolean multiple_definition
122 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
123 bfd
*, asection
*, bfd_vma
);
124 static bfd_boolean multiple_common
125 (struct bfd_link_info
*, const char *, bfd
*, enum bfd_link_hash_type
,
126 bfd_vma
, bfd
*, enum bfd_link_hash_type
, bfd_vma
);
127 static bfd_boolean add_to_set
128 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
129 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
130 static bfd_boolean constructor_callback
131 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
132 asection
*, bfd_vma
);
133 static bfd_boolean warning_callback
134 (struct bfd_link_info
*, const char *, const char *, bfd
*,
135 asection
*, bfd_vma
);
136 static void warning_find_reloc
137 (bfd
*, asection
*, void *);
138 static bfd_boolean undefined_symbol
139 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
141 static bfd_boolean reloc_overflow
142 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
143 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
144 static bfd_boolean reloc_dangerous
145 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
146 static bfd_boolean unattached_reloc
147 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
148 static bfd_boolean notice
149 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
151 static struct bfd_link_callbacks link_callbacks
=
157 constructor_callback
,
167 struct bfd_link_info link_info
;
175 bfd_cache_close (output_bfd
);
176 if (delete_output_file_on_failure
)
177 unlink_if_ordinary (output_filename
);
182 main (int argc
, char **argv
)
185 long start_time
= get_run_time ();
187 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
188 setlocale (LC_MESSAGES
, "");
190 #if defined (HAVE_SETLOCALE)
191 setlocale (LC_CTYPE
, "");
193 bindtextdomain (PACKAGE
, LOCALEDIR
);
194 textdomain (PACKAGE
);
196 program_name
= argv
[0];
197 xmalloc_set_program_name (program_name
);
199 START_PROGRESS (program_name
, 0);
201 expandargv (&argc
, &argv
);
205 bfd_set_error_program_name (program_name
);
207 xatexit (remove_output
);
209 /* Set up the sysroot directory. */
210 ld_sysroot
= get_sysroot (argc
, argv
);
213 if (*TARGET_SYSTEM_ROOT
== 0)
215 einfo ("%P%F: this linker was not configured to use sysroots\n");
219 ld_canon_sysroot
= lrealpath (ld_sysroot
);
221 if (ld_canon_sysroot
)
222 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
224 ld_canon_sysroot_len
= -1;
226 /* Set the default BFD target based on the configured target. Doing
227 this permits the linker to be configured for a particular target,
228 and linked against a shared BFD library which was configured for
229 a different target. The macro TARGET is defined by Makefile. */
230 if (! bfd_set_default_target (TARGET
))
232 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
243 /* Initialize the data about options. */
244 trace_files
= trace_file_tries
= version_printed
= FALSE
;
245 whole_archive
= FALSE
;
246 config
.build_constructors
= TRUE
;
247 config
.dynamic_link
= FALSE
;
248 config
.has_shared
= FALSE
;
249 config
.split_by_reloc
= (unsigned) -1;
250 config
.split_by_file
= (bfd_size_type
) -1;
251 config
.hash_table_size
= 0;
252 command_line
.force_common_definition
= FALSE
;
253 command_line
.inhibit_common_definition
= FALSE
;
254 command_line
.interpreter
= NULL
;
255 command_line
.rpath
= NULL
;
256 command_line
.warn_mismatch
= TRUE
;
257 command_line
.check_section_addresses
= TRUE
;
258 command_line
.accept_unknown_input_arch
= FALSE
;
262 /* We initialize DEMANGLING based on the environment variable
263 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
264 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
265 environment. Acting the same way here lets us provide the same
266 interface by default. */
267 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
269 link_info
.relocatable
= FALSE
;
270 link_info
.emitrelocations
= FALSE
;
271 link_info
.task_link
= FALSE
;
272 link_info
.shared
= FALSE
;
273 link_info
.pie
= FALSE
;
274 link_info
.executable
= FALSE
;
275 link_info
.symbolic
= FALSE
;
276 link_info
.export_dynamic
= FALSE
;
277 link_info
.static_link
= FALSE
;
278 link_info
.traditional_format
= FALSE
;
279 link_info
.optimize
= FALSE
;
280 link_info
.unresolved_syms_in_objects
= RM_NOT_YET_SET
;
281 link_info
.unresolved_syms_in_shared_libs
= RM_NOT_YET_SET
;
282 link_info
.allow_multiple_definition
= FALSE
;
283 link_info
.allow_undefined_version
= TRUE
;
284 link_info
.create_default_symver
= FALSE
;
285 link_info
.default_imported_symver
= FALSE
;
286 link_info
.keep_memory
= TRUE
;
287 link_info
.notice_all
= FALSE
;
288 link_info
.nocopyreloc
= FALSE
;
289 link_info
.new_dtags
= FALSE
;
290 link_info
.combreloc
= TRUE
;
291 link_info
.eh_frame_hdr
= FALSE
;
292 link_info
.relro
= FALSE
;
293 link_info
.strip_discarded
= TRUE
;
294 link_info
.strip
= strip_none
;
295 link_info
.discard
= discard_sec_merge
;
296 link_info
.common_skip_ar_aymbols
= bfd_link_common_skip_none
;
297 link_info
.callbacks
= &link_callbacks
;
298 link_info
.hash
= NULL
;
299 link_info
.keep_hash
= NULL
;
300 link_info
.notice_hash
= NULL
;
301 link_info
.wrap_hash
= NULL
;
302 link_info
.input_bfds
= NULL
;
303 link_info
.create_object_symbols_section
= NULL
;
304 link_info
.gc_sym_list
= NULL
;
305 link_info
.base_file
= NULL
;
306 link_info
.emit_hash
= TRUE
;
307 link_info
.emit_gnu_hash
= FALSE
;
308 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
309 and _fini symbols. We are compatible. */
310 link_info
.init_function
= "_init";
311 link_info
.fini_function
= "_fini";
312 link_info
.pei386_auto_import
= -1;
313 link_info
.pei386_runtime_pseudo_reloc
= FALSE
;
314 link_info
.spare_dynamic_tags
= 5;
316 link_info
.flags_1
= 0;
317 link_info
.relax_pass
= 1;
318 link_info
.warn_shared_textrel
= FALSE
;
319 link_info
.gc_sections
= FALSE
;
320 link_info
.print_gc_sections
= FALSE
;
321 link_info
.dynamic
= FALSE
;
322 link_info
.dynamic_list
= NULL
;
323 link_info
.dynamic_data
= FALSE
;
324 link_info
.reduce_memory_overheads
= FALSE
;
326 config
.maxpagesize
= 0;
327 config
.commonpagesize
= 0;
329 ldfile_add_arch ("");
331 config
.make_executable
= TRUE
;
332 force_make_executable
= FALSE
;
333 config
.magic_demand_paged
= TRUE
;
334 config
.text_read_only
= TRUE
;
336 emulation
= get_emulation (argc
, argv
);
337 ldemul_choose_mode (emulation
);
338 default_target
= ldemul_choose_target (argc
, argv
);
340 ldemul_before_parse ();
341 lang_has_input_file
= FALSE
;
342 parse_args (argc
, argv
);
344 if (config
.hash_table_size
!= 0)
345 bfd_hash_set_default_size (config
.hash_table_size
);
347 if (config
.maxpagesize
!= 0)
348 bfd_emul_set_maxpagesize (default_target
, config
.maxpagesize
);
350 if (config
.commonpagesize
!= 0)
351 bfd_emul_set_commonpagesize (default_target
,
352 config
.commonpagesize
);
354 ldemul_set_symbols ();
356 if (link_info
.relocatable
)
358 if (link_info
.gc_sections
)
359 einfo ("%P%F: --gc-sections and -r may not be used together\n");
360 else if (command_line
.relax
)
361 einfo (_("%P%F: --relax and -r may not be used together\n"));
362 if (link_info
.shared
)
363 einfo (_("%P%F: -r and -shared may not be used together\n"));
366 if (! link_info
.shared
)
368 if (command_line
.filter_shlib
)
369 einfo (_("%P%F: -F may not be used without -shared\n"));
370 if (command_line
.auxiliary_filters
)
371 einfo (_("%P%F: -f may not be used without -shared\n"));
374 if (! link_info
.shared
|| link_info
.pie
)
375 link_info
.executable
= TRUE
;
377 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
378 don't see how else this can be handled, since in this case we
379 must preserve all externally visible symbols. */
380 if (link_info
.relocatable
&& link_info
.strip
== strip_all
)
382 link_info
.strip
= strip_debugger
;
383 if (link_info
.discard
== discard_sec_merge
)
384 link_info
.discard
= discard_all
;
387 /* This essentially adds another -L directory so this must be done after
388 the -L's in argv have been processed. */
391 /* If we have not already opened and parsed a linker script,
392 try the default script from command line first. */
393 if (saved_script_handle
== NULL
394 && command_line
.default_script
!= NULL
)
396 ldfile_open_command_file (command_line
.default_script
);
397 parser_input
= input_script
;
401 /* If we have not already opened and parsed a linker script
402 read the emulation's appropriate default script. */
403 if (saved_script_handle
== NULL
)
406 char *s
= ldemul_get_script (&isfile
);
409 ldfile_open_command_file (s
);
415 parser_input
= input_script
;
420 if (trace_file_tries
)
422 if (saved_script_handle
)
423 info_msg (_("using external linker script:"));
425 info_msg (_("using internal linker script:"));
426 info_msg ("\n==================================================\n");
428 if (saved_script_handle
)
430 static const int ld_bufsz
= 8193;
432 char *buf
= xmalloc (ld_bufsz
);
434 rewind (saved_script_handle
);
435 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
440 rewind (saved_script_handle
);
447 info_msg (ldemul_get_script (&isfile
));
450 info_msg ("\n==================================================\n");
455 if (!lang_has_input_file
)
459 einfo (_("%P%F: no input files\n"));
463 info_msg (_("%P: mode %s\n"), emulation
);
465 ldemul_after_parse ();
467 if (config
.map_filename
)
469 if (strcmp (config
.map_filename
, "-") == 0)
471 config
.map_file
= stdout
;
475 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
476 if (config
.map_file
== (FILE *) NULL
)
478 bfd_set_error (bfd_error_system_call
);
479 einfo (_("%P%F: cannot open map file %s: %E\n"),
480 config
.map_filename
);
487 /* Print error messages for any missing symbols, for any warning
488 symbols, and possibly multiple definitions. */
489 if (link_info
.relocatable
)
490 output_bfd
->flags
&= ~EXEC_P
;
492 output_bfd
->flags
|= EXEC_P
;
496 if (config
.map_file
!= NULL
)
498 if (command_line
.cref
)
499 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
500 if (nocrossref_list
!= NULL
)
501 check_nocrossrefs ();
505 /* Even if we're producing relocatable output, some non-fatal errors should
506 be reported in the exit status. (What non-fatal errors, if any, do we
507 want to ignore for relocatable output?) */
508 if (!config
.make_executable
&& !force_make_executable
)
511 einfo (_("%P: link errors found, deleting executable `%s'\n"),
514 /* The file will be removed by remove_output. */
519 if (! bfd_close (output_bfd
))
520 einfo (_("%F%B: final close failed: %E\n"), output_bfd
);
522 /* If the --force-exe-suffix is enabled, and we're making an
523 executable file and it doesn't end in .exe, copy it to one
525 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
527 int len
= strlen (output_filename
);
530 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
531 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
535 const int bsize
= 4096;
536 char *buf
= xmalloc (bsize
);
538 char *dst_name
= xmalloc (len
+ 5);
540 strcpy (dst_name
, output_filename
);
541 strcat (dst_name
, ".exe");
542 src
= fopen (output_filename
, FOPEN_RB
);
543 dst
= fopen (dst_name
, FOPEN_WB
);
546 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
549 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
551 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
553 int done
= fwrite (buf
, 1, l
, dst
);
556 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
560 if (fclose (dst
) == EOF
)
561 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
568 END_PROGRESS (program_name
);
573 char *lim
= sbrk (0);
575 long run_time
= get_run_time () - start_time
;
577 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
578 program_name
, run_time
/ 1000000, run_time
% 1000000);
580 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
581 (long) (lim
- (char *) &environ
));
585 /* Prevent remove_output from doing anything, after a successful link. */
586 output_filename
= NULL
;
592 /* If the configured sysroot is relocatable, try relocating it based on
593 default prefix FROM. Return the relocated directory if it exists,
594 otherwise return null. */
597 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
599 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
603 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
606 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
614 /* Return the sysroot directory. Return "" if no sysroot is being used. */
617 get_sysroot (int argc
, char **argv
)
622 for (i
= 1; i
< argc
; i
++)
623 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
624 return argv
[i
] + strlen ("--sysroot=");
626 path
= get_relative_sysroot (BINDIR
);
630 path
= get_relative_sysroot (TOOLBINDIR
);
634 return TARGET_SYSTEM_ROOT
;
637 /* We need to find any explicitly given emulation in order to initialize the
638 state that's needed by the lex&yacc argument parser (parse_args). */
641 get_emulation (int argc
, char **argv
)
646 emulation
= getenv (EMULATION_ENVIRON
);
647 if (emulation
== NULL
)
648 emulation
= DEFAULT_EMULATION
;
650 for (i
= 1; i
< argc
; i
++)
652 if (CONST_STRNEQ (argv
[i
], "-m"))
654 if (argv
[i
][2] == '\0')
659 emulation
= argv
[i
+ 1];
663 einfo (_("%P%F: missing argument to -m\n"));
665 else if (strcmp (argv
[i
], "-mips1") == 0
666 || strcmp (argv
[i
], "-mips2") == 0
667 || strcmp (argv
[i
], "-mips3") == 0
668 || strcmp (argv
[i
], "-mips4") == 0
669 || strcmp (argv
[i
], "-mips5") == 0
670 || strcmp (argv
[i
], "-mips32") == 0
671 || strcmp (argv
[i
], "-mips32r2") == 0
672 || strcmp (argv
[i
], "-mips64") == 0
673 || strcmp (argv
[i
], "-mips64r2") == 0)
675 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
676 passed to the linker by some MIPS compilers. They
677 generally tell the linker to use a slightly different
678 library path. Perhaps someday these should be
679 implemented as emulations; until then, we just ignore
680 the arguments and hope that nobody ever creates
681 emulations named ips1, ips2 or ips3. */
683 else if (strcmp (argv
[i
], "-m486") == 0)
685 /* FIXME: The argument -m486 is passed to the linker on
686 some Linux systems. Hope that nobody creates an
687 emulation named 486. */
692 emulation
= &argv
[i
][2];
700 /* If directory DIR contains an "ldscripts" subdirectory,
701 add DIR to the library search path and return TRUE,
702 else return FALSE. */
705 check_for_scripts_dir (char *dir
)
712 dirlen
= strlen (dir
);
713 /* sizeof counts the terminating NUL. */
714 buf
= xmalloc (dirlen
+ sizeof ("/ldscripts"));
715 sprintf (buf
, "%s/ldscripts", dir
);
717 res
= stat (buf
, &s
) == 0 && S_ISDIR (s
.st_mode
);
720 ldfile_add_library_path (dir
, FALSE
);
724 /* Set the default directory for finding script files.
725 Libraries will be searched for here too, but that's ok.
726 We look for the "ldscripts" directory in:
728 SCRIPTDIR (passed from Makefile)
729 (adjusted according to the current location of the binary)
730 SCRIPTDIR (passed from Makefile)
731 the dir where this program is (for using it from the build tree)
732 the dir where this program is/../lib
733 (for installing the tool suite elsewhere). */
736 set_scripts_dir (void)
742 dir
= make_relative_prefix (program_name
, BINDIR
, SCRIPTDIR
);
745 found
= check_for_scripts_dir (dir
);
751 dir
= make_relative_prefix (program_name
, TOOLBINDIR
, SCRIPTDIR
);
754 found
= check_for_scripts_dir (dir
);
760 if (check_for_scripts_dir (SCRIPTDIR
))
761 /* We've been installed normally. */
764 /* Look for "ldscripts" in the dir where our binary is. */
765 end
= strrchr (program_name
, '/');
766 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
768 /* We could have \foo\bar, or /foo\bar. */
769 char *bslash
= strrchr (program_name
, '\\');
771 if (end
== NULL
|| (bslash
!= NULL
&& bslash
> end
))
777 /* Don't look for ldscripts in the current directory. There is
778 too much potential for confusion. */
781 dirlen
= end
- program_name
;
782 /* Make a copy of program_name in dir.
783 Leave room for later "/../lib". */
784 dir
= xmalloc (dirlen
+ 8);
785 strncpy (dir
, program_name
, dirlen
);
788 if (check_for_scripts_dir (dir
))
794 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
795 strcpy (dir
+ dirlen
, "/../lib");
796 check_for_scripts_dir (dir
);
801 add_ysym (const char *name
)
803 if (link_info
.notice_hash
== NULL
)
805 link_info
.notice_hash
= xmalloc (sizeof (struct bfd_hash_table
));
806 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
808 sizeof (struct bfd_hash_entry
),
810 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
813 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
814 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
817 /* Record a symbol to be wrapped, from the --wrap option. */
820 add_wrap (const char *name
)
822 if (link_info
.wrap_hash
== NULL
)
824 link_info
.wrap_hash
= xmalloc (sizeof (struct bfd_hash_table
));
825 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
827 sizeof (struct bfd_hash_entry
),
829 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
832 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
833 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
836 /* Handle the -retain-symbols-file option. */
839 add_keepsyms_file (const char *filename
)
846 if (link_info
.strip
== strip_some
)
847 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
849 file
= fopen (filename
, "r");
852 bfd_set_error (bfd_error_system_call
);
853 einfo ("%X%P: %s: %E\n", filename
);
857 link_info
.keep_hash
= xmalloc (sizeof (struct bfd_hash_table
));
858 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
859 sizeof (struct bfd_hash_entry
)))
860 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
863 buf
= xmalloc (bufsize
);
875 while (! ISSPACE (c
) && c
!= EOF
)
882 buf
= xrealloc (buf
, bufsize
);
889 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
890 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
894 if (link_info
.strip
!= strip_none
)
895 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
898 link_info
.strip
= strip_some
;
901 /* Callbacks from the BFD linker routines. */
903 /* This is called when BFD has decided to include an archive member in
907 add_archive_element (struct bfd_link_info
*info
,
911 lang_input_statement_type
*input
;
913 input
= xmalloc (sizeof (lang_input_statement_type
));
914 input
->filename
= abfd
->filename
;
915 input
->local_sym_name
= abfd
->filename
;
916 input
->the_bfd
= abfd
;
917 input
->asymbols
= NULL
;
919 input
->just_syms_flag
= FALSE
;
920 input
->loaded
= FALSE
;
921 input
->search_dirs_flag
= FALSE
;
923 /* FIXME: The following fields are not set: header.next,
924 header.type, closed, passive_position, symbol_count,
925 next_real_file, is_archive, target, real. This bit of code is
926 from the old decode_library_subfile function. I don't know
927 whether any of those fields matters. */
929 ldlang_add_file (input
);
931 if (config
.map_file
!= NULL
)
933 static bfd_boolean header_printed
;
934 struct bfd_link_hash_entry
*h
;
938 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
950 case bfd_link_hash_defined
:
951 case bfd_link_hash_defweak
:
952 from
= h
->u
.def
.section
->owner
;
955 case bfd_link_hash_undefined
:
956 case bfd_link_hash_undefweak
:
957 from
= h
->u
.undef
.abfd
;
960 case bfd_link_hash_common
:
961 from
= h
->u
.c
.p
->section
->owner
;
966 if (! header_printed
)
970 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
972 header_printed
= TRUE
;
975 if (bfd_my_archive (abfd
) == NULL
)
977 minfo ("%s", bfd_get_filename (abfd
));
978 len
= strlen (bfd_get_filename (abfd
));
982 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
983 bfd_get_filename (abfd
));
984 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
985 + strlen (bfd_get_filename (abfd
))
1001 minfo ("%B ", from
);
1003 minfo ("(%T)\n", h
->root
.string
);
1005 minfo ("(%s)\n", name
);
1008 if (trace_files
|| trace_file_tries
)
1009 info_msg ("%I\n", input
);
1014 /* This is called when BFD has discovered a symbol which is defined
1018 multiple_definition (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1027 /* If either section has the output_section field set to
1028 bfd_abs_section_ptr, it means that the section is being
1029 discarded, and this is not really a multiple definition at all.
1030 FIXME: It would be cleaner to somehow ignore symbols defined in
1031 sections which are being discarded. */
1032 if ((osec
->output_section
!= NULL
1033 && ! bfd_is_abs_section (osec
)
1034 && bfd_is_abs_section (osec
->output_section
))
1035 || (nsec
->output_section
!= NULL
1036 && ! bfd_is_abs_section (nsec
)
1037 && bfd_is_abs_section (nsec
->output_section
)))
1040 einfo (_("%X%C: multiple definition of `%T'\n"),
1041 nbfd
, nsec
, nval
, name
);
1043 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
1045 if (command_line
.relax
)
1047 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
1048 command_line
.relax
= 0;
1054 /* This is called when there is a definition of a common symbol, or
1055 when a common symbol is found for a symbol that is already defined,
1056 or when two common symbols are found. We only do something if
1057 -warn-common was used. */
1060 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1063 enum bfd_link_hash_type otype
,
1066 enum bfd_link_hash_type ntype
,
1069 if (! config
.warn_common
)
1072 if (ntype
== bfd_link_hash_defined
1073 || ntype
== bfd_link_hash_defweak
1074 || ntype
== bfd_link_hash_indirect
)
1076 ASSERT (otype
== bfd_link_hash_common
);
1077 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1080 einfo (_("%B: warning: common is here\n"), obfd
);
1082 else if (otype
== bfd_link_hash_defined
1083 || otype
== bfd_link_hash_defweak
1084 || otype
== bfd_link_hash_indirect
)
1086 ASSERT (ntype
== bfd_link_hash_common
);
1087 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1090 einfo (_("%B: warning: defined here\n"), obfd
);
1094 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1097 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1100 einfo (_("%B: warning: larger common is here\n"), obfd
);
1102 else if (nsize
> osize
)
1104 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1107 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1111 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1113 einfo (_("%B: warning: previous common is here\n"), obfd
);
1120 /* This is called when BFD has discovered a set element. H is the
1121 entry in the linker hash table for the set. SECTION and VALUE
1122 represent a value which should be added to the set. */
1125 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1126 struct bfd_link_hash_entry
*h
,
1127 bfd_reloc_code_real_type reloc
,
1132 if (config
.warn_constructors
)
1133 einfo (_("%P: warning: global constructor %s used\n"),
1136 if (! config
.build_constructors
)
1139 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1141 if (h
->type
== bfd_link_hash_new
)
1143 h
->type
= bfd_link_hash_undefined
;
1144 h
->u
.undef
.abfd
= abfd
;
1145 /* We don't call bfd_link_add_undef to add this to the list of
1146 undefined symbols because we are going to define it
1153 /* This is called when BFD has discovered a constructor. This is only
1154 called for some object file formats--those which do not handle
1155 constructors in some more clever fashion. This is similar to
1156 adding an element to a set, but less general. */
1159 constructor_callback (struct bfd_link_info
*info
,
1160 bfd_boolean constructor
,
1167 struct bfd_link_hash_entry
*h
;
1168 char set_name
[1 + sizeof "__CTOR_LIST__"];
1170 if (config
.warn_constructors
)
1171 einfo (_("%P: warning: global constructor %s used\n"), name
);
1173 if (! config
.build_constructors
)
1176 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1177 useful error message. */
1178 if (bfd_reloc_type_lookup (output_bfd
, BFD_RELOC_CTOR
) == NULL
1179 && (info
->relocatable
1180 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1181 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1184 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1185 *s
++ = bfd_get_symbol_leading_char (abfd
);
1187 strcpy (s
, "__CTOR_LIST__");
1189 strcpy (s
, "__DTOR_LIST__");
1191 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1192 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1193 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1194 if (h
->type
== bfd_link_hash_new
)
1196 h
->type
= bfd_link_hash_undefined
;
1197 h
->u
.undef
.abfd
= abfd
;
1198 /* We don't call bfd_link_add_undef to add this to the list of
1199 undefined symbols because we are going to define it
1203 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 /* This is called when there is a reference to a warning symbol. */
1221 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1222 const char *warning
,
1228 /* This is a hack to support warn_multiple_gp. FIXME: This should
1229 have a cleaner interface, but what? */
1230 if (! config
.warn_multiple_gp
1231 && strcmp (warning
, "using multiple gp values") == 0)
1234 if (section
!= NULL
)
1235 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1236 else if (abfd
== NULL
)
1237 einfo ("%P: %s%s\n", _("warning: "), warning
);
1238 else if (symbol
== NULL
)
1239 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1242 lang_input_statement_type
*entry
;
1244 struct warning_callback_info info
;
1246 /* Look through the relocs to see if we can find a plausible
1248 entry
= (lang_input_statement_type
*) abfd
->usrdata
;
1249 if (entry
!= NULL
&& entry
->asymbols
!= NULL
)
1250 asymbols
= entry
->asymbols
;
1256 symsize
= bfd_get_symtab_upper_bound (abfd
);
1258 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1259 asymbols
= xmalloc (symsize
);
1260 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
1261 if (symbol_count
< 0)
1262 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1265 entry
->asymbols
= asymbols
;
1266 entry
->symbol_count
= symbol_count
;
1271 info
.warning
= warning
;
1272 info
.symbol
= symbol
;
1273 info
.asymbols
= asymbols
;
1274 bfd_map_over_sections (abfd
, warning_find_reloc
, &info
);
1277 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1286 /* This is called by warning_callback for each section. It checks the
1287 relocs of the section to see if it can find a reference to the
1288 symbol which triggered the warning. If it can, it uses the reloc
1289 to give an error message with a file and line number. */
1292 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1294 struct warning_callback_info
*info
= iarg
;
1298 arelent
**p
, **pend
;
1303 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1305 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1309 relpp
= xmalloc (relsize
);
1310 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1312 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1315 pend
= p
+ relcount
;
1316 for (; p
< pend
&& *p
!= NULL
; p
++)
1320 if (q
->sym_ptr_ptr
!= NULL
1321 && *q
->sym_ptr_ptr
!= NULL
1322 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1324 /* We found a reloc for the symbol we are looking for. */
1325 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1335 /* This is called when an undefined symbol is found. */
1338 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1345 static char *error_name
;
1346 static unsigned int error_count
;
1348 #define MAX_ERRORS_IN_A_ROW 5
1350 if (config
.warn_once
)
1352 static struct bfd_hash_table
*hash
;
1354 /* Only warn once about a particular undefined symbol. */
1357 hash
= xmalloc (sizeof (struct bfd_hash_table
));
1358 if (!bfd_hash_table_init (hash
, bfd_hash_newfunc
,
1359 sizeof (struct bfd_hash_entry
)))
1360 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1363 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1366 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1367 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1370 /* We never print more than a reasonable number of errors in a row
1371 for a single symbol. */
1372 if (error_name
!= NULL
1373 && strcmp (name
, error_name
) == 0)
1378 if (error_name
!= NULL
)
1380 error_name
= xstrdup (name
);
1383 if (section
!= NULL
)
1385 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1388 einfo (_("%X%C: undefined reference to `%T'\n"),
1389 abfd
, section
, address
, name
);
1391 einfo (_("%C: warning: undefined reference to `%T'\n"),
1392 abfd
, section
, address
, name
);
1394 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1397 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1398 abfd
, section
, address
, name
);
1400 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1401 abfd
, section
, address
, name
);
1408 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1411 einfo (_("%X%B: undefined reference to `%T'\n"),
1414 einfo (_("%B: warning: undefined reference to `%T'\n"),
1417 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1420 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1423 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1433 /* Counter to limit the number of relocation overflow error messages
1434 to print. Errors are printed as it is decremented. When it's
1435 called and the counter is zero, a final message is printed
1436 indicating more relocations were omitted. When it gets to -1, no
1437 such errors are printed. If it's initially set to a value less
1438 than -1, all such errors will be printed (--verbose does this). */
1440 int overflow_cutoff_limit
= 10;
1442 /* This is called when a reloc overflows. */
1445 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1446 struct bfd_link_hash_entry
*entry
,
1448 const char *reloc_name
,
1454 if (overflow_cutoff_limit
== -1)
1457 einfo ("%X%C:", abfd
, section
, address
);
1459 if (overflow_cutoff_limit
>= 0
1460 && overflow_cutoff_limit
-- == 0)
1462 einfo (_(" additional relocation overflows omitted from the output\n"));
1468 while (entry
->type
== bfd_link_hash_indirect
1469 || entry
->type
== bfd_link_hash_warning
)
1470 entry
= entry
->u
.i
.link
;
1471 switch (entry
->type
)
1473 case bfd_link_hash_undefined
:
1474 case bfd_link_hash_undefweak
:
1475 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1476 reloc_name
, entry
->root
.string
);
1478 case bfd_link_hash_defined
:
1479 case bfd_link_hash_defweak
:
1480 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1481 reloc_name
, entry
->root
.string
,
1482 entry
->u
.def
.section
,
1483 entry
->u
.def
.section
== bfd_abs_section_ptr
1484 ? output_bfd
: entry
->u
.def
.section
->owner
);
1492 einfo (_(" relocation truncated to fit: %s against `%T'"),
1495 einfo ("+%v", addend
);
1500 /* This is called when a dangerous relocation is made. */
1503 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1504 const char *message
,
1509 einfo (_("%X%C: dangerous relocation: %s\n"),
1510 abfd
, section
, address
, message
);
1514 /* This is called when a reloc is being generated attached to a symbol
1515 that is not being output. */
1518 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1524 einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1525 abfd
, section
, address
, name
);
1529 /* This is called if link_info.notice_all is set, or when a symbol in
1530 link_info.notice_hash is found. Symbols are put in notice_hash
1531 using the -y option. */
1534 notice (struct bfd_link_info
*info
,
1542 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1543 return handle_asneeded_cref (abfd
, value
);
1547 if (! info
->notice_all
1548 || (info
->notice_hash
!= NULL
1549 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
))
1551 if (bfd_is_und_section (section
))
1552 einfo ("%B: reference to %s\n", abfd
, name
);
1554 einfo ("%B: definition of %s\n", abfd
, name
);
1557 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1558 add_cref (name
, abfd
, section
, value
);