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
;
259 command_line
.symbolic
= symbolic_unset
;
260 command_line
.dynamic_list
= dynamic_list_unset
;
264 /* We initialize DEMANGLING based on the environment variable
265 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
266 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
267 environment. Acting the same way here lets us provide the same
268 interface by default. */
269 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
271 link_info
.relocatable
= FALSE
;
272 link_info
.emitrelocations
= FALSE
;
273 link_info
.task_link
= FALSE
;
274 link_info
.shared
= FALSE
;
275 link_info
.pie
= FALSE
;
276 link_info
.executable
= FALSE
;
277 link_info
.symbolic
= FALSE
;
278 link_info
.export_dynamic
= FALSE
;
279 link_info
.static_link
= FALSE
;
280 link_info
.traditional_format
= FALSE
;
281 link_info
.optimize
= FALSE
;
282 link_info
.unresolved_syms_in_objects
= RM_NOT_YET_SET
;
283 link_info
.unresolved_syms_in_shared_libs
= RM_NOT_YET_SET
;
284 link_info
.allow_multiple_definition
= FALSE
;
285 link_info
.allow_undefined_version
= TRUE
;
286 link_info
.create_default_symver
= FALSE
;
287 link_info
.default_imported_symver
= FALSE
;
288 link_info
.keep_memory
= TRUE
;
289 link_info
.notice_all
= FALSE
;
290 link_info
.nocopyreloc
= FALSE
;
291 link_info
.new_dtags
= FALSE
;
292 link_info
.combreloc
= TRUE
;
293 link_info
.eh_frame_hdr
= FALSE
;
294 link_info
.relro
= FALSE
;
295 link_info
.strip_discarded
= TRUE
;
296 link_info
.strip
= strip_none
;
297 link_info
.discard
= discard_sec_merge
;
298 link_info
.common_skip_ar_aymbols
= bfd_link_common_skip_none
;
299 link_info
.callbacks
= &link_callbacks
;
300 link_info
.hash
= NULL
;
301 link_info
.keep_hash
= NULL
;
302 link_info
.notice_hash
= NULL
;
303 link_info
.wrap_hash
= NULL
;
304 link_info
.input_bfds
= NULL
;
305 link_info
.create_object_symbols_section
= NULL
;
306 link_info
.gc_sym_list
= NULL
;
307 link_info
.base_file
= NULL
;
308 link_info
.emit_hash
= TRUE
;
309 link_info
.emit_gnu_hash
= FALSE
;
310 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
311 and _fini symbols. We are compatible. */
312 link_info
.init_function
= "_init";
313 link_info
.fini_function
= "_fini";
314 link_info
.pei386_auto_import
= -1;
315 link_info
.pei386_runtime_pseudo_reloc
= FALSE
;
316 link_info
.spare_dynamic_tags
= 5;
318 link_info
.flags_1
= 0;
319 link_info
.relax_pass
= 1;
320 link_info
.warn_shared_textrel
= FALSE
;
321 link_info
.gc_sections
= FALSE
;
322 link_info
.print_gc_sections
= FALSE
;
323 link_info
.dynamic
= FALSE
;
324 link_info
.dynamic_list
= NULL
;
325 link_info
.dynamic_data
= FALSE
;
326 link_info
.reduce_memory_overheads
= FALSE
;
328 config
.maxpagesize
= 0;
329 config
.commonpagesize
= 0;
331 ldfile_add_arch ("");
333 config
.make_executable
= TRUE
;
334 force_make_executable
= FALSE
;
335 config
.magic_demand_paged
= TRUE
;
336 config
.text_read_only
= TRUE
;
338 emulation
= get_emulation (argc
, argv
);
339 ldemul_choose_mode (emulation
);
340 default_target
= ldemul_choose_target (argc
, argv
);
342 ldemul_before_parse ();
343 lang_has_input_file
= FALSE
;
344 parse_args (argc
, argv
);
346 if (config
.hash_table_size
!= 0)
347 bfd_hash_set_default_size (config
.hash_table_size
);
349 ldemul_set_symbols ();
351 if (link_info
.relocatable
)
353 if (link_info
.gc_sections
)
354 einfo ("%P%F: --gc-sections and -r may not be used together\n");
355 else if (command_line
.relax
)
356 einfo (_("%P%F: --relax and -r may not be used together\n"));
357 if (link_info
.shared
)
358 einfo (_("%P%F: -r and -shared may not be used together\n"));
361 /* We may have -Bsymbolic, -Bsymbolic-functions, --dynamic-list-data,
362 --dynamic-list-cpp-new, --dynamic-list-cpp-typeinfo and
363 --dynamic-list FILE. -Bsymbolic and -Bsymbolic-functions are
364 for shared libraries. -Bsymbolic overrides all others and vice
366 switch (command_line
.symbolic
)
371 /* -Bsymbolic is for shared library only. */
372 if (link_info
.shared
)
374 link_info
.symbolic
= TRUE
;
375 /* Should we free the unused memory? */
376 link_info
.dynamic_list
= NULL
;
377 command_line
.dynamic_list
= dynamic_list_unset
;
380 case symbolic_functions
:
381 /* -Bsymbolic-functions is for shared library only. */
382 if (link_info
.shared
)
383 command_line
.dynamic_list
= dynamic_list_data
;
387 switch (command_line
.dynamic_list
)
389 case dynamic_list_unset
:
391 case dynamic_list_data
:
392 link_info
.dynamic_data
= TRUE
;
394 link_info
.dynamic
= TRUE
;
398 if (! link_info
.shared
)
400 if (command_line
.filter_shlib
)
401 einfo (_("%P%F: -F may not be used without -shared\n"));
402 if (command_line
.auxiliary_filters
)
403 einfo (_("%P%F: -f may not be used without -shared\n"));
406 if (! link_info
.shared
|| link_info
.pie
)
407 link_info
.executable
= TRUE
;
409 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
410 don't see how else this can be handled, since in this case we
411 must preserve all externally visible symbols. */
412 if (link_info
.relocatable
&& link_info
.strip
== strip_all
)
414 link_info
.strip
= strip_debugger
;
415 if (link_info
.discard
== discard_sec_merge
)
416 link_info
.discard
= discard_all
;
419 /* This essentially adds another -L directory so this must be done after
420 the -L's in argv have been processed. */
423 /* If we have not already opened and parsed a linker script,
424 try the default script from command line first. */
425 if (saved_script_handle
== NULL
426 && command_line
.default_script
!= NULL
)
428 ldfile_open_command_file (command_line
.default_script
);
429 parser_input
= input_script
;
433 /* If we have not already opened and parsed a linker script
434 read the emulation's appropriate default script. */
435 if (saved_script_handle
== NULL
)
438 char *s
= ldemul_get_script (&isfile
);
441 ldfile_open_command_file (s
);
447 parser_input
= input_script
;
452 if (trace_file_tries
)
454 if (saved_script_handle
)
455 info_msg (_("using external linker script:"));
457 info_msg (_("using internal linker script:"));
458 info_msg ("\n==================================================\n");
460 if (saved_script_handle
)
462 static const int ld_bufsz
= 8193;
464 char *buf
= xmalloc (ld_bufsz
);
466 rewind (saved_script_handle
);
467 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
472 rewind (saved_script_handle
);
479 info_msg (ldemul_get_script (&isfile
));
482 info_msg ("\n==================================================\n");
487 if (!lang_has_input_file
)
491 einfo (_("%P%F: no input files\n"));
495 info_msg (_("%P: mode %s\n"), emulation
);
497 ldemul_after_parse ();
499 if (config
.map_filename
)
501 if (strcmp (config
.map_filename
, "-") == 0)
503 config
.map_file
= stdout
;
507 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
508 if (config
.map_file
== (FILE *) NULL
)
510 bfd_set_error (bfd_error_system_call
);
511 einfo (_("%P%F: cannot open map file %s: %E\n"),
512 config
.map_filename
);
519 /* Print error messages for any missing symbols, for any warning
520 symbols, and possibly multiple definitions. */
521 if (link_info
.relocatable
)
522 output_bfd
->flags
&= ~EXEC_P
;
524 output_bfd
->flags
|= EXEC_P
;
528 if (config
.map_file
!= NULL
)
530 if (command_line
.cref
)
531 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
532 if (nocrossref_list
!= NULL
)
533 check_nocrossrefs ();
537 /* Even if we're producing relocatable output, some non-fatal errors should
538 be reported in the exit status. (What non-fatal errors, if any, do we
539 want to ignore for relocatable output?) */
540 if (!config
.make_executable
&& !force_make_executable
)
543 einfo (_("%P: link errors found, deleting executable `%s'\n"),
546 /* The file will be removed by remove_output. */
551 if (! bfd_close (output_bfd
))
552 einfo (_("%F%B: final close failed: %E\n"), output_bfd
);
554 /* If the --force-exe-suffix is enabled, and we're making an
555 executable file and it doesn't end in .exe, copy it to one
557 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
559 int len
= strlen (output_filename
);
562 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
563 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
567 const int bsize
= 4096;
568 char *buf
= xmalloc (bsize
);
570 char *dst_name
= xmalloc (len
+ 5);
572 strcpy (dst_name
, output_filename
);
573 strcat (dst_name
, ".exe");
574 src
= fopen (output_filename
, FOPEN_RB
);
575 dst
= fopen (dst_name
, FOPEN_WB
);
578 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
581 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
583 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
585 int done
= fwrite (buf
, 1, l
, dst
);
588 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
592 if (fclose (dst
) == EOF
)
593 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
600 END_PROGRESS (program_name
);
605 char *lim
= sbrk (0);
607 long run_time
= get_run_time () - start_time
;
609 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
610 program_name
, run_time
/ 1000000, run_time
% 1000000);
612 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
613 (long) (lim
- (char *) &environ
));
617 /* Prevent remove_output from doing anything, after a successful link. */
618 output_filename
= NULL
;
624 /* If the configured sysroot is relocatable, try relocating it based on
625 default prefix FROM. Return the relocated directory if it exists,
626 otherwise return null. */
629 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
631 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
635 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
638 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
646 /* Return the sysroot directory. Return "" if no sysroot is being used. */
649 get_sysroot (int argc
, char **argv
)
654 for (i
= 1; i
< argc
; i
++)
655 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
656 return argv
[i
] + strlen ("--sysroot=");
658 path
= get_relative_sysroot (BINDIR
);
662 path
= get_relative_sysroot (TOOLBINDIR
);
666 return TARGET_SYSTEM_ROOT
;
669 /* We need to find any explicitly given emulation in order to initialize the
670 state that's needed by the lex&yacc argument parser (parse_args). */
673 get_emulation (int argc
, char **argv
)
678 emulation
= getenv (EMULATION_ENVIRON
);
679 if (emulation
== NULL
)
680 emulation
= DEFAULT_EMULATION
;
682 for (i
= 1; i
< argc
; i
++)
684 if (CONST_STRNEQ (argv
[i
], "-m"))
686 if (argv
[i
][2] == '\0')
691 emulation
= argv
[i
+ 1];
695 einfo (_("%P%F: missing argument to -m\n"));
697 else if (strcmp (argv
[i
], "-mips1") == 0
698 || strcmp (argv
[i
], "-mips2") == 0
699 || strcmp (argv
[i
], "-mips3") == 0
700 || strcmp (argv
[i
], "-mips4") == 0
701 || strcmp (argv
[i
], "-mips5") == 0
702 || strcmp (argv
[i
], "-mips32") == 0
703 || strcmp (argv
[i
], "-mips32r2") == 0
704 || strcmp (argv
[i
], "-mips64") == 0
705 || strcmp (argv
[i
], "-mips64r2") == 0)
707 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
708 passed to the linker by some MIPS compilers. They
709 generally tell the linker to use a slightly different
710 library path. Perhaps someday these should be
711 implemented as emulations; until then, we just ignore
712 the arguments and hope that nobody ever creates
713 emulations named ips1, ips2 or ips3. */
715 else if (strcmp (argv
[i
], "-m486") == 0)
717 /* FIXME: The argument -m486 is passed to the linker on
718 some Linux systems. Hope that nobody creates an
719 emulation named 486. */
724 emulation
= &argv
[i
][2];
732 /* If directory DIR contains an "ldscripts" subdirectory,
733 add DIR to the library search path and return TRUE,
734 else return FALSE. */
737 check_for_scripts_dir (char *dir
)
744 dirlen
= strlen (dir
);
745 /* sizeof counts the terminating NUL. */
746 buf
= xmalloc (dirlen
+ sizeof ("/ldscripts"));
747 sprintf (buf
, "%s/ldscripts", dir
);
749 res
= stat (buf
, &s
) == 0 && S_ISDIR (s
.st_mode
);
752 ldfile_add_library_path (dir
, FALSE
);
756 /* Set the default directory for finding script files.
757 Libraries will be searched for here too, but that's ok.
758 We look for the "ldscripts" directory in:
760 SCRIPTDIR (passed from Makefile)
761 (adjusted according to the current location of the binary)
762 SCRIPTDIR (passed from Makefile)
763 the dir where this program is (for using it from the build tree)
764 the dir where this program is/../lib
765 (for installing the tool suite elsewhere). */
768 set_scripts_dir (void)
774 dir
= make_relative_prefix (program_name
, BINDIR
, SCRIPTDIR
);
777 found
= check_for_scripts_dir (dir
);
783 dir
= make_relative_prefix (program_name
, TOOLBINDIR
, SCRIPTDIR
);
786 found
= check_for_scripts_dir (dir
);
792 if (check_for_scripts_dir (SCRIPTDIR
))
793 /* We've been installed normally. */
796 /* Look for "ldscripts" in the dir where our binary is. */
797 end
= strrchr (program_name
, '/');
798 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
800 /* We could have \foo\bar, or /foo\bar. */
801 char *bslash
= strrchr (program_name
, '\\');
803 if (end
== NULL
|| (bslash
!= NULL
&& bslash
> end
))
809 /* Don't look for ldscripts in the current directory. There is
810 too much potential for confusion. */
813 dirlen
= end
- program_name
;
814 /* Make a copy of program_name in dir.
815 Leave room for later "/../lib". */
816 dir
= xmalloc (dirlen
+ 8);
817 strncpy (dir
, program_name
, dirlen
);
820 if (check_for_scripts_dir (dir
))
826 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
827 strcpy (dir
+ dirlen
, "/../lib");
828 check_for_scripts_dir (dir
);
833 add_ysym (const char *name
)
835 if (link_info
.notice_hash
== NULL
)
837 link_info
.notice_hash
= xmalloc (sizeof (struct bfd_hash_table
));
838 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
840 sizeof (struct bfd_hash_entry
),
842 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
845 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
846 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
849 /* Record a symbol to be wrapped, from the --wrap option. */
852 add_wrap (const char *name
)
854 if (link_info
.wrap_hash
== NULL
)
856 link_info
.wrap_hash
= xmalloc (sizeof (struct bfd_hash_table
));
857 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
859 sizeof (struct bfd_hash_entry
),
861 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
864 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
865 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
868 /* Handle the -retain-symbols-file option. */
871 add_keepsyms_file (const char *filename
)
878 if (link_info
.strip
== strip_some
)
879 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
881 file
= fopen (filename
, "r");
884 bfd_set_error (bfd_error_system_call
);
885 einfo ("%X%P: %s: %E\n", filename
);
889 link_info
.keep_hash
= xmalloc (sizeof (struct bfd_hash_table
));
890 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
891 sizeof (struct bfd_hash_entry
)))
892 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
895 buf
= xmalloc (bufsize
);
907 while (! ISSPACE (c
) && c
!= EOF
)
914 buf
= xrealloc (buf
, bufsize
);
921 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
922 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
926 if (link_info
.strip
!= strip_none
)
927 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
930 link_info
.strip
= strip_some
;
933 /* Callbacks from the BFD linker routines. */
935 /* This is called when BFD has decided to include an archive member in
939 add_archive_element (struct bfd_link_info
*info
,
943 lang_input_statement_type
*input
;
945 input
= xmalloc (sizeof (lang_input_statement_type
));
946 input
->filename
= abfd
->filename
;
947 input
->local_sym_name
= abfd
->filename
;
948 input
->the_bfd
= abfd
;
949 input
->asymbols
= NULL
;
951 input
->just_syms_flag
= FALSE
;
952 input
->loaded
= FALSE
;
953 input
->search_dirs_flag
= FALSE
;
955 /* FIXME: The following fields are not set: header.next,
956 header.type, closed, passive_position, symbol_count,
957 next_real_file, is_archive, target, real. This bit of code is
958 from the old decode_library_subfile function. I don't know
959 whether any of those fields matters. */
961 ldlang_add_file (input
);
963 if (config
.map_file
!= NULL
)
965 static bfd_boolean header_printed
;
966 struct bfd_link_hash_entry
*h
;
970 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
982 case bfd_link_hash_defined
:
983 case bfd_link_hash_defweak
:
984 from
= h
->u
.def
.section
->owner
;
987 case bfd_link_hash_undefined
:
988 case bfd_link_hash_undefweak
:
989 from
= h
->u
.undef
.abfd
;
992 case bfd_link_hash_common
:
993 from
= h
->u
.c
.p
->section
->owner
;
998 if (! header_printed
)
1002 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
1004 header_printed
= TRUE
;
1007 if (bfd_my_archive (abfd
) == NULL
)
1009 minfo ("%s", bfd_get_filename (abfd
));
1010 len
= strlen (bfd_get_filename (abfd
));
1014 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
1015 bfd_get_filename (abfd
));
1016 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
1017 + strlen (bfd_get_filename (abfd
))
1033 minfo ("%B ", from
);
1035 minfo ("(%T)\n", h
->root
.string
);
1037 minfo ("(%s)\n", name
);
1040 if (trace_files
|| trace_file_tries
)
1041 info_msg ("%I\n", input
);
1046 /* This is called when BFD has discovered a symbol which is defined
1050 multiple_definition (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1059 /* If either section has the output_section field set to
1060 bfd_abs_section_ptr, it means that the section is being
1061 discarded, and this is not really a multiple definition at all.
1062 FIXME: It would be cleaner to somehow ignore symbols defined in
1063 sections which are being discarded. */
1064 if ((osec
->output_section
!= NULL
1065 && ! bfd_is_abs_section (osec
)
1066 && bfd_is_abs_section (osec
->output_section
))
1067 || (nsec
->output_section
!= NULL
1068 && ! bfd_is_abs_section (nsec
)
1069 && bfd_is_abs_section (nsec
->output_section
)))
1072 einfo (_("%X%C: multiple definition of `%T'\n"),
1073 nbfd
, nsec
, nval
, name
);
1075 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
1077 if (command_line
.relax
)
1079 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
1080 command_line
.relax
= 0;
1086 /* This is called when there is a definition of a common symbol, or
1087 when a common symbol is found for a symbol that is already defined,
1088 or when two common symbols are found. We only do something if
1089 -warn-common was used. */
1092 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1095 enum bfd_link_hash_type otype
,
1098 enum bfd_link_hash_type ntype
,
1101 if (! config
.warn_common
)
1104 if (ntype
== bfd_link_hash_defined
1105 || ntype
== bfd_link_hash_defweak
1106 || ntype
== bfd_link_hash_indirect
)
1108 ASSERT (otype
== bfd_link_hash_common
);
1109 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1112 einfo (_("%B: warning: common is here\n"), obfd
);
1114 else if (otype
== bfd_link_hash_defined
1115 || otype
== bfd_link_hash_defweak
1116 || otype
== bfd_link_hash_indirect
)
1118 ASSERT (ntype
== bfd_link_hash_common
);
1119 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1122 einfo (_("%B: warning: defined here\n"), obfd
);
1126 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1129 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1132 einfo (_("%B: warning: larger common is here\n"), obfd
);
1134 else if (nsize
> osize
)
1136 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1139 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1143 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1145 einfo (_("%B: warning: previous common is here\n"), obfd
);
1152 /* This is called when BFD has discovered a set element. H is the
1153 entry in the linker hash table for the set. SECTION and VALUE
1154 represent a value which should be added to the set. */
1157 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1158 struct bfd_link_hash_entry
*h
,
1159 bfd_reloc_code_real_type reloc
,
1164 if (config
.warn_constructors
)
1165 einfo (_("%P: warning: global constructor %s used\n"),
1168 if (! config
.build_constructors
)
1171 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1173 if (h
->type
== bfd_link_hash_new
)
1175 h
->type
= bfd_link_hash_undefined
;
1176 h
->u
.undef
.abfd
= abfd
;
1177 /* We don't call bfd_link_add_undef to add this to the list of
1178 undefined symbols because we are going to define it
1185 /* This is called when BFD has discovered a constructor. This is only
1186 called for some object file formats--those which do not handle
1187 constructors in some more clever fashion. This is similar to
1188 adding an element to a set, but less general. */
1191 constructor_callback (struct bfd_link_info
*info
,
1192 bfd_boolean constructor
,
1199 struct bfd_link_hash_entry
*h
;
1200 char set_name
[1 + sizeof "__CTOR_LIST__"];
1202 if (config
.warn_constructors
)
1203 einfo (_("%P: warning: global constructor %s used\n"), name
);
1205 if (! config
.build_constructors
)
1208 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1209 useful error message. */
1210 if (bfd_reloc_type_lookup (output_bfd
, BFD_RELOC_CTOR
) == NULL
1211 && (info
->relocatable
1212 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1213 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1216 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1217 *s
++ = bfd_get_symbol_leading_char (abfd
);
1219 strcpy (s
, "__CTOR_LIST__");
1221 strcpy (s
, "__DTOR_LIST__");
1223 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1224 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1225 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1226 if (h
->type
== bfd_link_hash_new
)
1228 h
->type
= bfd_link_hash_undefined
;
1229 h
->u
.undef
.abfd
= abfd
;
1230 /* We don't call bfd_link_add_undef to add this to the list of
1231 undefined symbols because we are going to define it
1235 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1239 /* A structure used by warning_callback to pass information through
1240 bfd_map_over_sections. */
1242 struct warning_callback_info
1245 const char *warning
;
1250 /* This is called when there is a reference to a warning symbol. */
1253 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1254 const char *warning
,
1260 /* This is a hack to support warn_multiple_gp. FIXME: This should
1261 have a cleaner interface, but what? */
1262 if (! config
.warn_multiple_gp
1263 && strcmp (warning
, "using multiple gp values") == 0)
1266 if (section
!= NULL
)
1267 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1268 else if (abfd
== NULL
)
1269 einfo ("%P: %s%s\n", _("warning: "), warning
);
1270 else if (symbol
== NULL
)
1271 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1274 lang_input_statement_type
*entry
;
1276 struct warning_callback_info info
;
1278 /* Look through the relocs to see if we can find a plausible
1280 entry
= (lang_input_statement_type
*) abfd
->usrdata
;
1281 if (entry
!= NULL
&& entry
->asymbols
!= NULL
)
1282 asymbols
= entry
->asymbols
;
1288 symsize
= bfd_get_symtab_upper_bound (abfd
);
1290 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1291 asymbols
= xmalloc (symsize
);
1292 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
1293 if (symbol_count
< 0)
1294 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1297 entry
->asymbols
= asymbols
;
1298 entry
->symbol_count
= symbol_count
;
1303 info
.warning
= warning
;
1304 info
.symbol
= symbol
;
1305 info
.asymbols
= asymbols
;
1306 bfd_map_over_sections (abfd
, warning_find_reloc
, &info
);
1309 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1318 /* This is called by warning_callback for each section. It checks the
1319 relocs of the section to see if it can find a reference to the
1320 symbol which triggered the warning. If it can, it uses the reloc
1321 to give an error message with a file and line number. */
1324 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1326 struct warning_callback_info
*info
= iarg
;
1330 arelent
**p
, **pend
;
1335 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1337 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1341 relpp
= xmalloc (relsize
);
1342 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1344 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1347 pend
= p
+ relcount
;
1348 for (; p
< pend
&& *p
!= NULL
; p
++)
1352 if (q
->sym_ptr_ptr
!= NULL
1353 && *q
->sym_ptr_ptr
!= NULL
1354 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1356 /* We found a reloc for the symbol we are looking for. */
1357 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1367 /* This is called when an undefined symbol is found. */
1370 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1377 static char *error_name
;
1378 static unsigned int error_count
;
1380 #define MAX_ERRORS_IN_A_ROW 5
1382 if (config
.warn_once
)
1384 static struct bfd_hash_table
*hash
;
1386 /* Only warn once about a particular undefined symbol. */
1389 hash
= xmalloc (sizeof (struct bfd_hash_table
));
1390 if (!bfd_hash_table_init (hash
, bfd_hash_newfunc
,
1391 sizeof (struct bfd_hash_entry
)))
1392 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1395 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1398 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1399 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1402 /* We never print more than a reasonable number of errors in a row
1403 for a single symbol. */
1404 if (error_name
!= NULL
1405 && strcmp (name
, error_name
) == 0)
1410 if (error_name
!= NULL
)
1412 error_name
= xstrdup (name
);
1415 if (section
!= NULL
)
1417 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1420 einfo (_("%X%C: undefined reference to `%T'\n"),
1421 abfd
, section
, address
, name
);
1423 einfo (_("%C: warning: undefined reference to `%T'\n"),
1424 abfd
, section
, address
, name
);
1426 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1429 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1430 abfd
, section
, address
, name
);
1432 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1433 abfd
, section
, address
, name
);
1440 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1443 einfo (_("%X%B: undefined reference to `%T'\n"),
1446 einfo (_("%B: warning: undefined reference to `%T'\n"),
1449 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1452 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1455 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1465 /* Counter to limit the number of relocation overflow error messages
1466 to print. Errors are printed as it is decremented. When it's
1467 called and the counter is zero, a final message is printed
1468 indicating more relocations were omitted. When it gets to -1, no
1469 such errors are printed. If it's initially set to a value less
1470 than -1, all such errors will be printed (--verbose does this). */
1472 int overflow_cutoff_limit
= 10;
1474 /* This is called when a reloc overflows. */
1477 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1478 struct bfd_link_hash_entry
*entry
,
1480 const char *reloc_name
,
1486 if (overflow_cutoff_limit
== -1)
1489 einfo ("%X%C:", abfd
, section
, address
);
1491 if (overflow_cutoff_limit
>= 0
1492 && overflow_cutoff_limit
-- == 0)
1494 einfo (_(" additional relocation overflows omitted from the output\n"));
1500 while (entry
->type
== bfd_link_hash_indirect
1501 || entry
->type
== bfd_link_hash_warning
)
1502 entry
= entry
->u
.i
.link
;
1503 switch (entry
->type
)
1505 case bfd_link_hash_undefined
:
1506 case bfd_link_hash_undefweak
:
1507 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1508 reloc_name
, entry
->root
.string
);
1510 case bfd_link_hash_defined
:
1511 case bfd_link_hash_defweak
:
1512 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1513 reloc_name
, entry
->root
.string
,
1514 entry
->u
.def
.section
,
1515 entry
->u
.def
.section
== bfd_abs_section_ptr
1516 ? output_bfd
: entry
->u
.def
.section
->owner
);
1524 einfo (_(" relocation truncated to fit: %s against `%T'"),
1527 einfo ("+%v", addend
);
1532 /* This is called when a dangerous relocation is made. */
1535 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1536 const char *message
,
1541 einfo (_("%X%C: dangerous relocation: %s\n"),
1542 abfd
, section
, address
, message
);
1546 /* This is called when a reloc is being generated attached to a symbol
1547 that is not being output. */
1550 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1556 einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1557 abfd
, section
, address
, name
);
1561 /* This is called if link_info.notice_all is set, or when a symbol in
1562 link_info.notice_hash is found. Symbols are put in notice_hash
1563 using the -y option. */
1566 notice (struct bfd_link_info
*info
,
1574 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1575 return handle_asneeded_cref (abfd
, value
);
1579 if (! info
->notice_all
1580 || (info
->notice_hash
!= NULL
1581 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
))
1583 if (bfd_is_und_section (section
))
1584 einfo ("%B: reference to %s\n", abfd
, name
);
1586 einfo ("%B: definition of %s\n", abfd
, name
);
1589 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1590 add_cref (name
, abfd
, section
, value
);