1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
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, 59 Temple Place - Suite 330, 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)
53 #ifdef NEED_DECLARATION_SBRK
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. */
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 static char *get_emulation
113 static void set_scripts_dir
115 static bfd_boolean add_archive_element
116 (struct bfd_link_info
*, bfd
*, const char *);
117 static bfd_boolean multiple_definition
118 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
119 bfd
*, asection
*, bfd_vma
);
120 static bfd_boolean multiple_common
121 (struct bfd_link_info
*, const char *, bfd
*, enum bfd_link_hash_type
,
122 bfd_vma
, bfd
*, enum bfd_link_hash_type
, bfd_vma
);
123 static bfd_boolean add_to_set
124 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
125 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
126 static bfd_boolean constructor_callback
127 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
128 asection
*, bfd_vma
);
129 static bfd_boolean warning_callback
130 (struct bfd_link_info
*, const char *, const char *, bfd
*,
131 asection
*, bfd_vma
);
132 static void warning_find_reloc
133 (bfd
*, asection
*, void *);
134 static bfd_boolean undefined_symbol
135 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
137 static bfd_boolean reloc_overflow
138 (struct bfd_link_info
*, const char *, const char *, bfd_vma
,
139 bfd
*, asection
*, bfd_vma
);
140 static bfd_boolean reloc_dangerous
141 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
142 static bfd_boolean unattached_reloc
143 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
144 static bfd_boolean notice
145 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
147 static struct bfd_link_callbacks link_callbacks
=
153 constructor_callback
,
163 struct bfd_link_info link_info
;
171 bfd_cache_close (output_bfd
);
172 if (delete_output_file_on_failure
)
173 unlink (output_filename
);
178 main (int argc
, char **argv
)
181 long start_time
= get_run_time ();
183 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
184 setlocale (LC_MESSAGES
, "");
186 #if defined (HAVE_SETLOCALE)
187 setlocale (LC_CTYPE
, "");
189 bindtextdomain (PACKAGE
, LOCALEDIR
);
190 textdomain (PACKAGE
);
192 program_name
= argv
[0];
193 xmalloc_set_program_name (program_name
);
195 START_PROGRESS (program_name
, 0);
199 bfd_set_error_program_name (program_name
);
201 xatexit (remove_output
);
203 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
204 ld_sysroot
= make_relative_prefix (program_name
, BINDIR
,
210 int res
= stat (ld_sysroot
, &s
) == 0 && S_ISDIR (s
.st_mode
);
221 ld_sysroot
= make_relative_prefix (program_name
, TOOLBINDIR
,
227 int res
= stat (ld_sysroot
, &s
) == 0 && S_ISDIR (s
.st_mode
);
239 ld_sysroot
= TARGET_SYSTEM_ROOT
;
241 if (ld_sysroot
&& *ld_sysroot
)
242 ld_canon_sysroot
= lrealpath (ld_sysroot
);
244 if (ld_canon_sysroot
)
245 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
247 ld_canon_sysroot_len
= -1;
249 /* Set the default BFD target based on the configured target. Doing
250 this permits the linker to be configured for a particular target,
251 and linked against a shared BFD library which was configured for
252 a different target. The macro TARGET is defined by Makefile. */
253 if (! bfd_set_default_target (TARGET
))
255 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
266 /* Initialize the data about options. */
267 trace_files
= trace_file_tries
= version_printed
= FALSE
;
268 whole_archive
= FALSE
;
269 config
.build_constructors
= TRUE
;
270 config
.dynamic_link
= FALSE
;
271 config
.has_shared
= FALSE
;
272 config
.split_by_reloc
= (unsigned) -1;
273 config
.split_by_file
= (bfd_size_type
) -1;
274 config
.hash_table_size
= 0;
275 command_line
.force_common_definition
= FALSE
;
276 command_line
.inhibit_common_definition
= FALSE
;
277 command_line
.interpreter
= NULL
;
278 command_line
.rpath
= NULL
;
279 command_line
.warn_mismatch
= TRUE
;
280 command_line
.check_section_addresses
= TRUE
;
281 command_line
.accept_unknown_input_arch
= FALSE
;
282 command_line
.reduce_memory_overheads
= FALSE
;
284 /* We initialize DEMANGLING based on the environment variable
285 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
286 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
287 environment. Acting the same way here lets us provide the same
288 interface by default. */
289 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
291 link_info
.relocatable
= FALSE
;
292 link_info
.emitrelocations
= FALSE
;
293 link_info
.task_link
= FALSE
;
294 link_info
.shared
= FALSE
;
295 link_info
.pie
= FALSE
;
296 link_info
.executable
= FALSE
;
297 link_info
.symbolic
= FALSE
;
298 link_info
.export_dynamic
= FALSE
;
299 link_info
.static_link
= FALSE
;
300 link_info
.traditional_format
= FALSE
;
301 link_info
.optimize
= FALSE
;
302 link_info
.unresolved_syms_in_objects
= RM_NOT_YET_SET
;
303 link_info
.unresolved_syms_in_shared_libs
= RM_NOT_YET_SET
;
304 link_info
.allow_multiple_definition
= FALSE
;
305 link_info
.allow_undefined_version
= TRUE
;
306 link_info
.keep_memory
= TRUE
;
307 link_info
.notice_all
= FALSE
;
308 link_info
.nocopyreloc
= FALSE
;
309 link_info
.new_dtags
= FALSE
;
310 link_info
.combreloc
= TRUE
;
311 link_info
.eh_frame_hdr
= FALSE
;
312 link_info
.relro
= FALSE
;
313 link_info
.strip_discarded
= TRUE
;
314 link_info
.strip
= strip_none
;
315 link_info
.discard
= discard_sec_merge
;
316 link_info
.common_skip_ar_aymbols
= bfd_link_common_skip_none
;
317 link_info
.callbacks
= &link_callbacks
;
318 link_info
.hash
= NULL
;
319 link_info
.keep_hash
= NULL
;
320 link_info
.notice_hash
= NULL
;
321 link_info
.wrap_hash
= NULL
;
322 link_info
.input_bfds
= NULL
;
323 link_info
.create_object_symbols_section
= NULL
;
324 link_info
.gc_sym_list
= NULL
;
325 link_info
.base_file
= NULL
;
326 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
327 and _fini symbols. We are compatible. */
328 link_info
.init_function
= "_init";
329 link_info
.fini_function
= "_fini";
330 link_info
.pei386_auto_import
= -1;
331 link_info
.pei386_runtime_pseudo_reloc
= FALSE
;
332 link_info
.spare_dynamic_tags
= 5;
334 link_info
.flags_1
= 0;
335 link_info
.need_relax_finalize
= FALSE
;
337 ldfile_add_arch ("");
339 config
.make_executable
= TRUE
;
340 force_make_executable
= FALSE
;
341 config
.magic_demand_paged
= TRUE
;
342 config
.text_read_only
= TRUE
;
344 emulation
= get_emulation (argc
, argv
);
345 ldemul_choose_mode (emulation
);
346 default_target
= ldemul_choose_target (argc
, argv
);
348 ldemul_before_parse ();
349 lang_has_input_file
= FALSE
;
350 parse_args (argc
, argv
);
352 if (config
.hash_table_size
!= 0)
353 bfd_hash_set_default_size (config
.hash_table_size
);
355 ldemul_set_symbols ();
357 if (link_info
.relocatable
)
359 if (command_line
.gc_sections
)
360 einfo ("%P%F: --gc-sections and -r may not be used together\n");
361 else if (command_line
.relax
)
362 einfo (_("%P%F: --relax and -r may not be used together\n"));
363 if (link_info
.shared
)
364 einfo (_("%P%F: -r and -shared may not be used together\n"));
367 if (! link_info
.shared
)
369 if (command_line
.filter_shlib
)
370 einfo (_("%P%F: -F may not be used without -shared\n"));
371 if (command_line
.auxiliary_filters
)
372 einfo (_("%P%F: -f may not be used without -shared\n"));
375 if (! link_info
.shared
|| link_info
.pie
)
376 link_info
.executable
= TRUE
;
378 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
379 don't see how else this can be handled, since in this case we
380 must preserve all externally visible symbols. */
381 if (link_info
.relocatable
&& link_info
.strip
== strip_all
)
383 link_info
.strip
= strip_debugger
;
384 if (link_info
.discard
== discard_sec_merge
)
385 link_info
.discard
= discard_all
;
388 /* This essentially adds another -L directory so this must be done after
389 the -L's in argv have been processed. */
392 /* If we have not already opened and parsed a linker script
393 read the emulation's appropriate default script. */
394 if (saved_script_handle
== NULL
)
397 char *s
= ldemul_get_script (&isfile
);
400 ldfile_open_command_file (s
);
406 parser_input
= input_script
;
411 if (trace_file_tries
)
413 if (saved_script_handle
)
414 info_msg (_("using external linker script:"));
416 info_msg (_("using internal linker script:"));
417 info_msg ("\n==================================================\n");
419 if (saved_script_handle
)
421 static const int ld_bufsz
= 8193;
423 char *buf
= xmalloc (ld_bufsz
);
425 rewind (saved_script_handle
);
426 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
431 rewind (saved_script_handle
);
438 info_msg (ldemul_get_script (&isfile
));
441 info_msg ("\n==================================================\n");
446 if (!lang_has_input_file
)
450 einfo (_("%P%F: no input files\n"));
454 info_msg (_("%P: mode %s\n"), emulation
);
456 ldemul_after_parse ();
458 if (config
.map_filename
)
460 if (strcmp (config
.map_filename
, "-") == 0)
462 config
.map_file
= stdout
;
466 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
467 if (config
.map_file
== (FILE *) NULL
)
469 bfd_set_error (bfd_error_system_call
);
470 einfo (_("%P%F: cannot open map file %s: %E\n"),
471 config
.map_filename
);
478 /* Print error messages for any missing symbols, for any warning
479 symbols, and possibly multiple definitions. */
480 if (link_info
.relocatable
)
481 output_bfd
->flags
&= ~EXEC_P
;
483 output_bfd
->flags
|= EXEC_P
;
487 if (config
.map_file
!= NULL
)
489 if (command_line
.cref
)
490 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
491 if (nocrossref_list
!= NULL
)
492 check_nocrossrefs ();
494 /* Even if we're producing relocatable output, some non-fatal errors should
495 be reported in the exit status. (What non-fatal errors, if any, do we
496 want to ignore for relocatable output?) */
497 if (!config
.make_executable
&& !force_make_executable
)
500 einfo (_("%P: link errors found, deleting executable `%s'\n"),
503 /* The file will be removed by remove_output. */
508 if (! bfd_close (output_bfd
))
509 einfo (_("%F%B: final close failed: %E\n"), output_bfd
);
511 /* If the --force-exe-suffix is enabled, and we're making an
512 executable file and it doesn't end in .exe, copy it to one
514 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
516 int len
= strlen (output_filename
);
519 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
520 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
524 const int bsize
= 4096;
525 char *buf
= xmalloc (bsize
);
527 char *dst_name
= xmalloc (len
+ 5);
529 strcpy (dst_name
, output_filename
);
530 strcat (dst_name
, ".exe");
531 src
= fopen (output_filename
, FOPEN_RB
);
532 dst
= fopen (dst_name
, FOPEN_WB
);
535 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
538 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
540 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
542 int done
= fwrite (buf
, 1, l
, dst
);
545 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
549 if (fclose (dst
) == EOF
)
550 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
557 END_PROGRESS (program_name
);
562 char *lim
= sbrk (0);
564 long run_time
= get_run_time () - start_time
;
566 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
567 program_name
, run_time
/ 1000000, run_time
% 1000000);
569 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
570 (long) (lim
- (char *) &environ
));
574 /* Prevent remove_output from doing anything, after a successful link. */
575 output_filename
= NULL
;
581 /* We need to find any explicitly given emulation in order to initialize the
582 state that's needed by the lex&yacc argument parser (parse_args). */
585 get_emulation (int argc
, char **argv
)
590 emulation
= getenv (EMULATION_ENVIRON
);
591 if (emulation
== NULL
)
592 emulation
= DEFAULT_EMULATION
;
594 for (i
= 1; i
< argc
; i
++)
596 if (!strncmp (argv
[i
], "-m", 2))
598 if (argv
[i
][2] == '\0')
603 emulation
= argv
[i
+ 1];
607 einfo (_("%P%F: missing argument to -m\n"));
609 else if (strcmp (argv
[i
], "-mips1") == 0
610 || strcmp (argv
[i
], "-mips2") == 0
611 || strcmp (argv
[i
], "-mips3") == 0
612 || strcmp (argv
[i
], "-mips4") == 0
613 || strcmp (argv
[i
], "-mips5") == 0
614 || strcmp (argv
[i
], "-mips32") == 0
615 || strcmp (argv
[i
], "-mips32r2") == 0
616 || strcmp (argv
[i
], "-mips64") == 0
617 || strcmp (argv
[i
], "-mips64r2") == 0)
619 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
620 passed to the linker by some MIPS compilers. They
621 generally tell the linker to use a slightly different
622 library path. Perhaps someday these should be
623 implemented as emulations; until then, we just ignore
624 the arguments and hope that nobody ever creates
625 emulations named ips1, ips2 or ips3. */
627 else if (strcmp (argv
[i
], "-m486") == 0)
629 /* FIXME: The argument -m486 is passed to the linker on
630 some Linux systems. Hope that nobody creates an
631 emulation named 486. */
636 emulation
= &argv
[i
][2];
644 /* If directory DIR contains an "ldscripts" subdirectory,
645 add DIR to the library search path and return TRUE,
646 else return FALSE. */
649 check_for_scripts_dir (char *dir
)
656 dirlen
= strlen (dir
);
657 /* sizeof counts the terminating NUL. */
658 buf
= xmalloc (dirlen
+ sizeof ("/ldscripts"));
659 sprintf (buf
, "%s/ldscripts", dir
);
661 res
= stat (buf
, &s
) == 0 && S_ISDIR (s
.st_mode
);
664 ldfile_add_library_path (dir
, FALSE
);
668 /* Set the default directory for finding script files.
669 Libraries will be searched for here too, but that's ok.
670 We look for the "ldscripts" directory in:
672 SCRIPTDIR (passed from Makefile)
673 (adjusted according to the current location of the binary)
674 SCRIPTDIR (passed from Makefile)
675 the dir where this program is (for using it from the build tree)
676 the dir where this program is/../lib
677 (for installing the tool suite elsewhere). */
680 set_scripts_dir (void)
686 dir
= make_relative_prefix (program_name
, BINDIR
, SCRIPTDIR
);
689 found
= check_for_scripts_dir (dir
);
695 dir
= make_relative_prefix (program_name
, TOOLBINDIR
, SCRIPTDIR
);
698 found
= check_for_scripts_dir (dir
);
704 if (check_for_scripts_dir (SCRIPTDIR
))
705 /* We've been installed normally. */
708 /* Look for "ldscripts" in the dir where our binary is. */
709 end
= strrchr (program_name
, '/');
710 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
712 /* We could have \foo\bar, or /foo\bar. */
713 char *bslash
= strrchr (program_name
, '\\');
715 if (end
== NULL
|| (bslash
!= NULL
&& bslash
> end
))
721 /* Don't look for ldscripts in the current directory. There is
722 too much potential for confusion. */
725 dirlen
= end
- program_name
;
726 /* Make a copy of program_name in dir.
727 Leave room for later "/../lib". */
728 dir
= xmalloc (dirlen
+ 8);
729 strncpy (dir
, program_name
, dirlen
);
732 if (check_for_scripts_dir (dir
))
738 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
739 strcpy (dir
+ dirlen
, "/../lib");
740 check_for_scripts_dir (dir
);
745 add_ysym (const char *name
)
747 if (link_info
.notice_hash
== NULL
)
749 link_info
.notice_hash
= xmalloc (sizeof (struct bfd_hash_table
));
750 if (! bfd_hash_table_init_n (link_info
.notice_hash
,
753 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
756 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
757 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
760 /* Record a symbol to be wrapped, from the --wrap option. */
763 add_wrap (const char *name
)
765 if (link_info
.wrap_hash
== NULL
)
767 link_info
.wrap_hash
= xmalloc (sizeof (struct bfd_hash_table
));
768 if (! bfd_hash_table_init_n (link_info
.wrap_hash
,
771 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
774 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
775 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
778 /* Handle the -retain-symbols-file option. */
781 add_keepsyms_file (const char *filename
)
788 if (link_info
.strip
== strip_some
)
789 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
791 file
= fopen (filename
, "r");
794 bfd_set_error (bfd_error_system_call
);
795 einfo ("%X%P: %s: %E\n", filename
);
799 link_info
.keep_hash
= xmalloc (sizeof (struct bfd_hash_table
));
800 if (! bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
))
801 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
804 buf
= xmalloc (bufsize
);
816 while (! ISSPACE (c
) && c
!= EOF
)
823 buf
= xrealloc (buf
, bufsize
);
830 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
831 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
835 if (link_info
.strip
!= strip_none
)
836 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
839 link_info
.strip
= strip_some
;
842 /* Callbacks from the BFD linker routines. */
844 /* This is called when BFD has decided to include an archive member in
848 add_archive_element (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
852 lang_input_statement_type
*input
;
854 input
= xmalloc (sizeof (lang_input_statement_type
));
855 input
->filename
= abfd
->filename
;
856 input
->local_sym_name
= abfd
->filename
;
857 input
->the_bfd
= abfd
;
858 input
->asymbols
= NULL
;
860 input
->just_syms_flag
= FALSE
;
861 input
->loaded
= FALSE
;
862 input
->search_dirs_flag
= FALSE
;
864 /* FIXME: The following fields are not set: header.next,
865 header.type, closed, passive_position, symbol_count,
866 next_real_file, is_archive, target, real. This bit of code is
867 from the old decode_library_subfile function. I don't know
868 whether any of those fields matters. */
870 ldlang_add_file (input
);
872 if (config
.map_file
!= NULL
)
874 static bfd_boolean header_printed
;
875 struct bfd_link_hash_entry
*h
;
879 h
= bfd_link_hash_lookup (link_info
.hash
, name
, FALSE
, FALSE
, TRUE
);
891 case bfd_link_hash_defined
:
892 case bfd_link_hash_defweak
:
893 from
= h
->u
.def
.section
->owner
;
896 case bfd_link_hash_undefined
:
897 case bfd_link_hash_undefweak
:
898 from
= h
->u
.undef
.abfd
;
901 case bfd_link_hash_common
:
902 from
= h
->u
.c
.p
->section
->owner
;
907 if (! header_printed
)
911 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
913 header_printed
= TRUE
;
916 if (bfd_my_archive (abfd
) == NULL
)
918 minfo ("%s", bfd_get_filename (abfd
));
919 len
= strlen (bfd_get_filename (abfd
));
923 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
924 bfd_get_filename (abfd
));
925 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
926 + strlen (bfd_get_filename (abfd
))
944 minfo ("(%T)\n", h
->root
.string
);
946 minfo ("(%s)\n", name
);
949 if (trace_files
|| trace_file_tries
)
950 info_msg ("%I\n", input
);
955 /* This is called when BFD has discovered a symbol which is defined
959 multiple_definition (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
968 /* If either section has the output_section field set to
969 bfd_abs_section_ptr, it means that the section is being
970 discarded, and this is not really a multiple definition at all.
971 FIXME: It would be cleaner to somehow ignore symbols defined in
972 sections which are being discarded. */
973 if ((osec
->output_section
!= NULL
974 && ! bfd_is_abs_section (osec
)
975 && bfd_is_abs_section (osec
->output_section
))
976 || (nsec
->output_section
!= NULL
977 && ! bfd_is_abs_section (nsec
)
978 && bfd_is_abs_section (nsec
->output_section
)))
981 einfo (_("%X%C: multiple definition of `%T'\n"),
982 nbfd
, nsec
, nval
, name
);
984 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
986 if (command_line
.relax
)
988 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
989 command_line
.relax
= 0;
995 /* This is called when there is a definition of a common symbol, or
996 when a common symbol is found for a symbol that is already defined,
997 or when two common symbols are found. We only do something if
998 -warn-common was used. */
1001 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1004 enum bfd_link_hash_type otype
,
1007 enum bfd_link_hash_type ntype
,
1010 if (! config
.warn_common
)
1013 if (ntype
== bfd_link_hash_defined
1014 || ntype
== bfd_link_hash_defweak
1015 || ntype
== bfd_link_hash_indirect
)
1017 ASSERT (otype
== bfd_link_hash_common
);
1018 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1021 einfo (_("%B: warning: common is here\n"), obfd
);
1023 else if (otype
== bfd_link_hash_defined
1024 || otype
== bfd_link_hash_defweak
1025 || otype
== bfd_link_hash_indirect
)
1027 ASSERT (ntype
== bfd_link_hash_common
);
1028 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1031 einfo (_("%B: warning: defined here\n"), obfd
);
1035 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1038 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1041 einfo (_("%B: warning: larger common is here\n"), obfd
);
1043 else if (nsize
> osize
)
1045 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1048 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1052 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1054 einfo (_("%B: warning: previous common is here\n"), obfd
);
1061 /* This is called when BFD has discovered a set element. H is the
1062 entry in the linker hash table for the set. SECTION and VALUE
1063 represent a value which should be added to the set. */
1066 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1067 struct bfd_link_hash_entry
*h
,
1068 bfd_reloc_code_real_type reloc
,
1073 if (config
.warn_constructors
)
1074 einfo (_("%P: warning: global constructor %s used\n"),
1077 if (! config
.build_constructors
)
1080 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1082 if (h
->type
== bfd_link_hash_new
)
1084 h
->type
= bfd_link_hash_undefined
;
1085 h
->u
.undef
.abfd
= abfd
;
1086 /* We don't call bfd_link_add_undef to add this to the list of
1087 undefined symbols because we are going to define it
1094 /* This is called when BFD has discovered a constructor. This is only
1095 called for some object file formats--those which do not handle
1096 constructors in some more clever fashion. This is similar to
1097 adding an element to a set, but less general. */
1100 constructor_callback (struct bfd_link_info
*info
,
1101 bfd_boolean constructor
,
1108 struct bfd_link_hash_entry
*h
;
1109 char set_name
[1 + sizeof "__CTOR_LIST__"];
1111 if (config
.warn_constructors
)
1112 einfo (_("%P: warning: global constructor %s used\n"), name
);
1114 if (! config
.build_constructors
)
1117 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1118 useful error message. */
1119 if (bfd_reloc_type_lookup (output_bfd
, BFD_RELOC_CTOR
) == NULL
1120 && (link_info
.relocatable
1121 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1122 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1125 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1126 *s
++ = bfd_get_symbol_leading_char (abfd
);
1128 strcpy (s
, "__CTOR_LIST__");
1130 strcpy (s
, "__DTOR_LIST__");
1132 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1133 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1134 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1135 if (h
->type
== bfd_link_hash_new
)
1137 h
->type
= bfd_link_hash_undefined
;
1138 h
->u
.undef
.abfd
= abfd
;
1139 /* We don't call bfd_link_add_undef to add this to the list of
1140 undefined symbols because we are going to define it
1144 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1148 /* A structure used by warning_callback to pass information through
1149 bfd_map_over_sections. */
1151 struct warning_callback_info
1154 const char *warning
;
1159 /* This is called when there is a reference to a warning symbol. */
1162 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1163 const char *warning
,
1169 /* This is a hack to support warn_multiple_gp. FIXME: This should
1170 have a cleaner interface, but what? */
1171 if (! config
.warn_multiple_gp
1172 && strcmp (warning
, "using multiple gp values") == 0)
1175 if (section
!= NULL
)
1176 einfo ("%C: %s\n", abfd
, section
, address
, warning
);
1177 else if (abfd
== NULL
)
1178 einfo ("%P: %s\n", warning
);
1179 else if (symbol
== NULL
)
1180 einfo ("%B: %s\n", abfd
, warning
);
1183 lang_input_statement_type
*entry
;
1185 struct warning_callback_info info
;
1187 /* Look through the relocs to see if we can find a plausible
1189 entry
= (lang_input_statement_type
*) abfd
->usrdata
;
1190 if (entry
!= NULL
&& entry
->asymbols
!= NULL
)
1191 asymbols
= entry
->asymbols
;
1197 symsize
= bfd_get_symtab_upper_bound (abfd
);
1199 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1200 asymbols
= xmalloc (symsize
);
1201 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
1202 if (symbol_count
< 0)
1203 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1206 entry
->asymbols
= asymbols
;
1207 entry
->symbol_count
= symbol_count
;
1212 info
.warning
= warning
;
1213 info
.symbol
= symbol
;
1214 info
.asymbols
= asymbols
;
1215 bfd_map_over_sections (abfd
, warning_find_reloc
, &info
);
1218 einfo ("%B: %s\n", abfd
, warning
);
1227 /* This is called by warning_callback for each section. It checks the
1228 relocs of the section to see if it can find a reference to the
1229 symbol which triggered the warning. If it can, it uses the reloc
1230 to give an error message with a file and line number. */
1233 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1235 struct warning_callback_info
*info
= iarg
;
1239 arelent
**p
, **pend
;
1244 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1246 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1250 relpp
= xmalloc (relsize
);
1251 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1253 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1256 pend
= p
+ relcount
;
1257 for (; p
< pend
&& *p
!= NULL
; p
++)
1261 if (q
->sym_ptr_ptr
!= NULL
1262 && *q
->sym_ptr_ptr
!= NULL
1263 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1265 /* We found a reloc for the symbol we are looking for. */
1266 einfo ("%C: %s\n", abfd
, sec
, q
->address
, info
->warning
);
1275 /* This is called when an undefined symbol is found. */
1278 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1285 static char *error_name
;
1286 static unsigned int error_count
;
1288 #define MAX_ERRORS_IN_A_ROW 5
1290 if (config
.warn_once
)
1292 static struct bfd_hash_table
*hash
;
1294 /* Only warn once about a particular undefined symbol. */
1297 hash
= xmalloc (sizeof (struct bfd_hash_table
));
1298 if (! bfd_hash_table_init (hash
, bfd_hash_newfunc
))
1299 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1302 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1305 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1306 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1309 /* We never print more than a reasonable number of errors in a row
1310 for a single symbol. */
1311 if (error_name
!= NULL
1312 && strcmp (name
, error_name
) == 0)
1317 if (error_name
!= NULL
)
1319 error_name
= xstrdup (name
);
1322 if (section
!= NULL
)
1324 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1327 einfo (_("%X%C: undefined reference to `%T'\n"),
1328 abfd
, section
, address
, name
);
1330 einfo (_("%C: warning: undefined reference to `%T'\n"),
1331 abfd
, section
, address
, name
);
1333 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1336 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1337 abfd
, section
, address
, name
);
1339 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1340 abfd
, section
, address
, name
);
1347 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1350 einfo (_("%X%B: undefined reference to `%T'\n"),
1353 einfo (_("%B: warning: undefined reference to `%T'\n"),
1356 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1359 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1362 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1372 /* Counter to limit the number of relocation overflow error messages
1373 to print. Errors are printed as it is decremented. When it's
1374 called and the counter is zero, a final message is printed
1375 indicating more relocations were omitted. When it gets to -1, no
1376 such errors are printed. If it's initially set to a value less
1377 than -1, all such errors will be printed (--verbose does this). */
1379 int overflow_cutoff_limit
= 10;
1381 /* This is called when a reloc overflows. */
1384 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1386 const char *reloc_name
,
1392 if (overflow_cutoff_limit
== -1)
1396 einfo (_("%P%X: generated"));
1398 einfo ("%X%C:", abfd
, section
, address
);
1400 if (overflow_cutoff_limit
>= 0
1401 && overflow_cutoff_limit
-- == 0)
1403 einfo (_(" additional relocation overflows omitted from the output\n"));
1407 einfo (_(" relocation truncated to fit: %s %T"), reloc_name
, name
);
1409 einfo ("+%v", addend
);
1414 /* This is called when a dangerous relocation is made. */
1417 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1418 const char *message
,
1424 einfo (_("%P%X: generated"));
1426 einfo ("%X%C:", abfd
, section
, address
);
1427 einfo (_("dangerous relocation: %s\n"), message
);
1431 /* This is called when a reloc is being generated attached to a symbol
1432 that is not being output. */
1435 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1442 einfo (_("%P%X: generated"));
1444 einfo ("%X%C:", abfd
, section
, address
);
1445 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name
);
1449 /* This is called if link_info.notice_all is set, or when a symbol in
1450 link_info.notice_hash is found. Symbols are put in notice_hash
1451 using the -y option. */
1454 notice (struct bfd_link_info
*info
,
1460 if (! info
->notice_all
1461 || (info
->notice_hash
!= NULL
1462 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
))
1464 if (bfd_is_und_section (section
))
1465 einfo ("%B: reference to %s\n", abfd
, name
);
1467 einfo ("%B: definition of %s\n", abfd
, name
);
1470 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1471 add_cref (name
, abfd
, section
, value
);