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 sort_type sort_section
;
113 static char *get_emulation
115 static void set_scripts_dir
117 static bfd_boolean add_archive_element
118 (struct bfd_link_info
*, bfd
*, const char *);
119 static bfd_boolean multiple_definition
120 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
121 bfd
*, asection
*, bfd_vma
);
122 static bfd_boolean multiple_common
123 (struct bfd_link_info
*, const char *, bfd
*, enum bfd_link_hash_type
,
124 bfd_vma
, bfd
*, enum bfd_link_hash_type
, bfd_vma
);
125 static bfd_boolean add_to_set
126 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
127 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
128 static bfd_boolean constructor_callback
129 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
130 asection
*, bfd_vma
);
131 static bfd_boolean warning_callback
132 (struct bfd_link_info
*, const char *, const char *, bfd
*,
133 asection
*, bfd_vma
);
134 static void warning_find_reloc
135 (bfd
*, asection
*, void *);
136 static bfd_boolean undefined_symbol
137 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
139 static bfd_boolean reloc_overflow
140 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
141 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
142 static bfd_boolean reloc_dangerous
143 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
144 static bfd_boolean unattached_reloc
145 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
146 static bfd_boolean notice
147 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
149 static struct bfd_link_callbacks link_callbacks
=
155 constructor_callback
,
164 struct bfd_link_info link_info
;
172 bfd_cache_close (output_bfd
);
173 if (delete_output_file_on_failure
)
174 unlink (output_filename
);
179 main (int argc
, char **argv
)
182 long start_time
= get_run_time ();
184 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
185 setlocale (LC_MESSAGES
, "");
187 #if defined (HAVE_SETLOCALE)
188 setlocale (LC_CTYPE
, "");
190 bindtextdomain (PACKAGE
, LOCALEDIR
);
191 textdomain (PACKAGE
);
193 program_name
= argv
[0];
194 xmalloc_set_program_name (program_name
);
196 START_PROGRESS (program_name
, 0);
200 bfd_set_error_program_name (program_name
);
202 xatexit (remove_output
);
204 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
205 ld_sysroot
= make_relative_prefix (program_name
, BINDIR
,
211 int res
= stat (ld_sysroot
, &s
) == 0 && S_ISDIR (s
.st_mode
);
222 ld_sysroot
= make_relative_prefix (program_name
, TOOLBINDIR
,
228 int res
= stat (ld_sysroot
, &s
) == 0 && S_ISDIR (s
.st_mode
);
240 ld_sysroot
= TARGET_SYSTEM_ROOT
;
242 if (ld_sysroot
&& *ld_sysroot
)
243 ld_canon_sysroot
= lrealpath (ld_sysroot
);
245 if (ld_canon_sysroot
)
246 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
248 ld_canon_sysroot_len
= -1;
250 /* Set the default BFD target based on the configured target. Doing
251 this permits the linker to be configured for a particular target,
252 and linked against a shared BFD library which was configured for
253 a different target. The macro TARGET is defined by Makefile. */
254 if (! bfd_set_default_target (TARGET
))
256 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
267 /* Initialize the data about options. */
268 trace_files
= trace_file_tries
= version_printed
= FALSE
;
269 whole_archive
= FALSE
;
270 config
.build_constructors
= TRUE
;
271 config
.dynamic_link
= FALSE
;
272 config
.has_shared
= FALSE
;
273 config
.split_by_reloc
= (unsigned) -1;
274 config
.split_by_file
= (bfd_size_type
) -1;
275 config
.hash_table_size
= 0;
276 command_line
.force_common_definition
= FALSE
;
277 command_line
.inhibit_common_definition
= FALSE
;
278 command_line
.interpreter
= NULL
;
279 command_line
.rpath
= NULL
;
280 command_line
.warn_mismatch
= TRUE
;
281 command_line
.check_section_addresses
= TRUE
;
282 command_line
.accept_unknown_input_arch
= FALSE
;
283 command_line
.reduce_memory_overheads
= FALSE
;
287 /* We initialize DEMANGLING based on the environment variable
288 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
289 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
290 environment. Acting the same way here lets us provide the same
291 interface by default. */
292 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
294 link_info
.relocatable
= FALSE
;
295 link_info
.emitrelocations
= FALSE
;
296 link_info
.task_link
= FALSE
;
297 link_info
.shared
= FALSE
;
298 link_info
.pie
= FALSE
;
299 link_info
.executable
= FALSE
;
300 link_info
.symbolic
= FALSE
;
301 link_info
.export_dynamic
= FALSE
;
302 link_info
.static_link
= FALSE
;
303 link_info
.traditional_format
= FALSE
;
304 link_info
.optimize
= FALSE
;
305 link_info
.unresolved_syms_in_objects
= RM_NOT_YET_SET
;
306 link_info
.unresolved_syms_in_shared_libs
= RM_NOT_YET_SET
;
307 link_info
.allow_multiple_definition
= FALSE
;
308 link_info
.allow_undefined_version
= TRUE
;
309 link_info
.create_default_symver
= FALSE
;
310 link_info
.keep_memory
= TRUE
;
311 link_info
.notice_all
= FALSE
;
312 link_info
.nocopyreloc
= FALSE
;
313 link_info
.new_dtags
= FALSE
;
314 link_info
.combreloc
= TRUE
;
315 link_info
.eh_frame_hdr
= FALSE
;
316 link_info
.relro
= FALSE
;
317 link_info
.strip_discarded
= TRUE
;
318 link_info
.strip
= strip_none
;
319 link_info
.discard
= discard_sec_merge
;
320 link_info
.common_skip_ar_aymbols
= bfd_link_common_skip_none
;
321 link_info
.callbacks
= &link_callbacks
;
322 link_info
.hash
= NULL
;
323 link_info
.keep_hash
= NULL
;
324 link_info
.notice_hash
= NULL
;
325 link_info
.wrap_hash
= NULL
;
326 link_info
.input_bfds
= NULL
;
327 link_info
.create_object_symbols_section
= NULL
;
328 link_info
.gc_sym_list
= NULL
;
329 link_info
.base_file
= NULL
;
330 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
331 and _fini symbols. We are compatible. */
332 link_info
.init_function
= "_init";
333 link_info
.fini_function
= "_fini";
334 link_info
.pei386_auto_import
= -1;
335 link_info
.pei386_runtime_pseudo_reloc
= FALSE
;
336 link_info
.spare_dynamic_tags
= 5;
338 link_info
.flags_1
= 0;
339 link_info
.need_relax_finalize
= FALSE
;
340 link_info
.warn_shared_textrel
= FALSE
;
342 ldfile_add_arch ("");
344 config
.make_executable
= TRUE
;
345 force_make_executable
= FALSE
;
346 config
.magic_demand_paged
= TRUE
;
347 config
.text_read_only
= TRUE
;
349 emulation
= get_emulation (argc
, argv
);
350 ldemul_choose_mode (emulation
);
351 default_target
= ldemul_choose_target (argc
, argv
);
353 ldemul_before_parse ();
354 lang_has_input_file
= FALSE
;
355 parse_args (argc
, argv
);
357 if (config
.hash_table_size
!= 0)
358 bfd_hash_set_default_size (config
.hash_table_size
);
360 ldemul_set_symbols ();
362 if (link_info
.relocatable
)
364 if (command_line
.gc_sections
)
365 einfo ("%P%F: --gc-sections and -r may not be used together\n");
366 else if (command_line
.relax
)
367 einfo (_("%P%F: --relax and -r may not be used together\n"));
368 if (link_info
.shared
)
369 einfo (_("%P%F: -r and -shared may not be used together\n"));
372 if (! link_info
.shared
)
374 if (command_line
.filter_shlib
)
375 einfo (_("%P%F: -F may not be used without -shared\n"));
376 if (command_line
.auxiliary_filters
)
377 einfo (_("%P%F: -f may not be used without -shared\n"));
380 if (! link_info
.shared
|| link_info
.pie
)
381 link_info
.executable
= TRUE
;
383 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
384 don't see how else this can be handled, since in this case we
385 must preserve all externally visible symbols. */
386 if (link_info
.relocatable
&& link_info
.strip
== strip_all
)
388 link_info
.strip
= strip_debugger
;
389 if (link_info
.discard
== discard_sec_merge
)
390 link_info
.discard
= discard_all
;
393 /* This essentially adds another -L directory so this must be done after
394 the -L's in argv have been processed. */
397 /* If we have not already opened and parsed a linker script
398 read the emulation's appropriate default script. */
399 if (saved_script_handle
== NULL
)
402 char *s
= ldemul_get_script (&isfile
);
405 ldfile_open_command_file (s
);
411 parser_input
= input_script
;
416 if (trace_file_tries
)
418 if (saved_script_handle
)
419 info_msg (_("using external linker script:"));
421 info_msg (_("using internal linker script:"));
422 info_msg ("\n==================================================\n");
424 if (saved_script_handle
)
426 static const int ld_bufsz
= 8193;
428 char *buf
= xmalloc (ld_bufsz
);
430 rewind (saved_script_handle
);
431 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
436 rewind (saved_script_handle
);
443 info_msg (ldemul_get_script (&isfile
));
446 info_msg ("\n==================================================\n");
451 if (!lang_has_input_file
)
455 einfo (_("%P%F: no input files\n"));
459 info_msg (_("%P: mode %s\n"), emulation
);
461 ldemul_after_parse ();
463 if (config
.map_filename
)
465 if (strcmp (config
.map_filename
, "-") == 0)
467 config
.map_file
= stdout
;
471 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
472 if (config
.map_file
== (FILE *) NULL
)
474 bfd_set_error (bfd_error_system_call
);
475 einfo (_("%P%F: cannot open map file %s: %E\n"),
476 config
.map_filename
);
483 /* Print error messages for any missing symbols, for any warning
484 symbols, and possibly multiple definitions. */
485 if (link_info
.relocatable
)
486 output_bfd
->flags
&= ~EXEC_P
;
488 output_bfd
->flags
|= EXEC_P
;
492 if (config
.map_file
!= NULL
)
494 if (command_line
.cref
)
495 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
496 if (nocrossref_list
!= NULL
)
497 check_nocrossrefs ();
499 /* Even if we're producing relocatable output, some non-fatal errors should
500 be reported in the exit status. (What non-fatal errors, if any, do we
501 want to ignore for relocatable output?) */
502 if (!config
.make_executable
&& !force_make_executable
)
505 einfo (_("%P: link errors found, deleting executable `%s'\n"),
508 /* The file will be removed by remove_output. */
513 if (! bfd_close (output_bfd
))
514 einfo (_("%F%B: final close failed: %E\n"), output_bfd
);
516 /* If the --force-exe-suffix is enabled, and we're making an
517 executable file and it doesn't end in .exe, copy it to one
519 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
521 int len
= strlen (output_filename
);
524 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
525 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
529 const int bsize
= 4096;
530 char *buf
= xmalloc (bsize
);
532 char *dst_name
= xmalloc (len
+ 5);
534 strcpy (dst_name
, output_filename
);
535 strcat (dst_name
, ".exe");
536 src
= fopen (output_filename
, FOPEN_RB
);
537 dst
= fopen (dst_name
, FOPEN_WB
);
540 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
543 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
545 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
547 int done
= fwrite (buf
, 1, l
, dst
);
550 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
554 if (fclose (dst
) == EOF
)
555 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
562 END_PROGRESS (program_name
);
567 char *lim
= sbrk (0);
569 long run_time
= get_run_time () - start_time
;
571 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
572 program_name
, run_time
/ 1000000, run_time
% 1000000);
574 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
575 (long) (lim
- (char *) &environ
));
579 /* Prevent remove_output from doing anything, after a successful link. */
580 output_filename
= NULL
;
586 /* We need to find any explicitly given emulation in order to initialize the
587 state that's needed by the lex&yacc argument parser (parse_args). */
590 get_emulation (int argc
, char **argv
)
595 emulation
= getenv (EMULATION_ENVIRON
);
596 if (emulation
== NULL
)
597 emulation
= DEFAULT_EMULATION
;
599 for (i
= 1; i
< argc
; i
++)
601 if (!strncmp (argv
[i
], "-m", 2))
603 if (argv
[i
][2] == '\0')
608 emulation
= argv
[i
+ 1];
612 einfo (_("%P%F: missing argument to -m\n"));
614 else if (strcmp (argv
[i
], "-mips1") == 0
615 || strcmp (argv
[i
], "-mips2") == 0
616 || strcmp (argv
[i
], "-mips3") == 0
617 || strcmp (argv
[i
], "-mips4") == 0
618 || strcmp (argv
[i
], "-mips5") == 0
619 || strcmp (argv
[i
], "-mips32") == 0
620 || strcmp (argv
[i
], "-mips32r2") == 0
621 || strcmp (argv
[i
], "-mips64") == 0
622 || strcmp (argv
[i
], "-mips64r2") == 0)
624 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
625 passed to the linker by some MIPS compilers. They
626 generally tell the linker to use a slightly different
627 library path. Perhaps someday these should be
628 implemented as emulations; until then, we just ignore
629 the arguments and hope that nobody ever creates
630 emulations named ips1, ips2 or ips3. */
632 else if (strcmp (argv
[i
], "-m486") == 0)
634 /* FIXME: The argument -m486 is passed to the linker on
635 some Linux systems. Hope that nobody creates an
636 emulation named 486. */
641 emulation
= &argv
[i
][2];
649 /* If directory DIR contains an "ldscripts" subdirectory,
650 add DIR to the library search path and return TRUE,
651 else return FALSE. */
654 check_for_scripts_dir (char *dir
)
661 dirlen
= strlen (dir
);
662 /* sizeof counts the terminating NUL. */
663 buf
= xmalloc (dirlen
+ sizeof ("/ldscripts"));
664 sprintf (buf
, "%s/ldscripts", dir
);
666 res
= stat (buf
, &s
) == 0 && S_ISDIR (s
.st_mode
);
669 ldfile_add_library_path (dir
, FALSE
);
673 /* Set the default directory for finding script files.
674 Libraries will be searched for here too, but that's ok.
675 We look for the "ldscripts" directory in:
677 SCRIPTDIR (passed from Makefile)
678 (adjusted according to the current location of the binary)
679 SCRIPTDIR (passed from Makefile)
680 the dir where this program is (for using it from the build tree)
681 the dir where this program is/../lib
682 (for installing the tool suite elsewhere). */
685 set_scripts_dir (void)
691 dir
= make_relative_prefix (program_name
, BINDIR
, SCRIPTDIR
);
694 found
= check_for_scripts_dir (dir
);
700 dir
= make_relative_prefix (program_name
, TOOLBINDIR
, SCRIPTDIR
);
703 found
= check_for_scripts_dir (dir
);
709 if (check_for_scripts_dir (SCRIPTDIR
))
710 /* We've been installed normally. */
713 /* Look for "ldscripts" in the dir where our binary is. */
714 end
= strrchr (program_name
, '/');
715 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
717 /* We could have \foo\bar, or /foo\bar. */
718 char *bslash
= strrchr (program_name
, '\\');
720 if (end
== NULL
|| (bslash
!= NULL
&& bslash
> end
))
726 /* Don't look for ldscripts in the current directory. There is
727 too much potential for confusion. */
730 dirlen
= end
- program_name
;
731 /* Make a copy of program_name in dir.
732 Leave room for later "/../lib". */
733 dir
= xmalloc (dirlen
+ 8);
734 strncpy (dir
, program_name
, dirlen
);
737 if (check_for_scripts_dir (dir
))
743 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
744 strcpy (dir
+ dirlen
, "/../lib");
745 check_for_scripts_dir (dir
);
750 add_ysym (const char *name
)
752 if (link_info
.notice_hash
== NULL
)
754 link_info
.notice_hash
= xmalloc (sizeof (struct bfd_hash_table
));
755 if (! bfd_hash_table_init_n (link_info
.notice_hash
,
758 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
761 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
762 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
765 /* Record a symbol to be wrapped, from the --wrap option. */
768 add_wrap (const char *name
)
770 if (link_info
.wrap_hash
== NULL
)
772 link_info
.wrap_hash
= xmalloc (sizeof (struct bfd_hash_table
));
773 if (! bfd_hash_table_init_n (link_info
.wrap_hash
,
776 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
779 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
780 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
783 /* Handle the -retain-symbols-file option. */
786 add_keepsyms_file (const char *filename
)
793 if (link_info
.strip
== strip_some
)
794 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
796 file
= fopen (filename
, "r");
799 bfd_set_error (bfd_error_system_call
);
800 einfo ("%X%P: %s: %E\n", filename
);
804 link_info
.keep_hash
= xmalloc (sizeof (struct bfd_hash_table
));
805 if (! bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
))
806 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
809 buf
= xmalloc (bufsize
);
821 while (! ISSPACE (c
) && c
!= EOF
)
828 buf
= xrealloc (buf
, bufsize
);
835 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
836 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
840 if (link_info
.strip
!= strip_none
)
841 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
844 link_info
.strip
= strip_some
;
847 /* Callbacks from the BFD linker routines. */
849 /* This is called when BFD has decided to include an archive member in
853 add_archive_element (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
857 lang_input_statement_type
*input
;
859 input
= xmalloc (sizeof (lang_input_statement_type
));
860 input
->filename
= abfd
->filename
;
861 input
->local_sym_name
= abfd
->filename
;
862 input
->the_bfd
= abfd
;
863 input
->asymbols
= NULL
;
865 input
->just_syms_flag
= FALSE
;
866 input
->loaded
= FALSE
;
867 input
->search_dirs_flag
= FALSE
;
869 /* FIXME: The following fields are not set: header.next,
870 header.type, closed, passive_position, symbol_count,
871 next_real_file, is_archive, target, real. This bit of code is
872 from the old decode_library_subfile function. I don't know
873 whether any of those fields matters. */
875 ldlang_add_file (input
);
877 if (config
.map_file
!= NULL
)
879 static bfd_boolean header_printed
;
880 struct bfd_link_hash_entry
*h
;
884 h
= bfd_link_hash_lookup (link_info
.hash
, name
, FALSE
, FALSE
, TRUE
);
896 case bfd_link_hash_defined
:
897 case bfd_link_hash_defweak
:
898 from
= h
->u
.def
.section
->owner
;
901 case bfd_link_hash_undefined
:
902 case bfd_link_hash_undefweak
:
903 from
= h
->u
.undef
.abfd
;
906 case bfd_link_hash_common
:
907 from
= h
->u
.c
.p
->section
->owner
;
912 if (! header_printed
)
916 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
918 header_printed
= TRUE
;
921 if (bfd_my_archive (abfd
) == NULL
)
923 minfo ("%s", bfd_get_filename (abfd
));
924 len
= strlen (bfd_get_filename (abfd
));
928 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
929 bfd_get_filename (abfd
));
930 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
931 + strlen (bfd_get_filename (abfd
))
949 minfo ("(%T)\n", h
->root
.string
);
951 minfo ("(%s)\n", name
);
954 if (trace_files
|| trace_file_tries
)
955 info_msg ("%I\n", input
);
960 /* This is called when BFD has discovered a symbol which is defined
964 multiple_definition (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
973 /* If either section has the output_section field set to
974 bfd_abs_section_ptr, it means that the section is being
975 discarded, and this is not really a multiple definition at all.
976 FIXME: It would be cleaner to somehow ignore symbols defined in
977 sections which are being discarded. */
978 if ((osec
->output_section
!= NULL
979 && ! bfd_is_abs_section (osec
)
980 && bfd_is_abs_section (osec
->output_section
))
981 || (nsec
->output_section
!= NULL
982 && ! bfd_is_abs_section (nsec
)
983 && bfd_is_abs_section (nsec
->output_section
)))
986 einfo (_("%X%C: multiple definition of `%T'\n"),
987 nbfd
, nsec
, nval
, name
);
989 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
991 if (command_line
.relax
)
993 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
994 command_line
.relax
= 0;
1000 /* This is called when there is a definition of a common symbol, or
1001 when a common symbol is found for a symbol that is already defined,
1002 or when two common symbols are found. We only do something if
1003 -warn-common was used. */
1006 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1009 enum bfd_link_hash_type otype
,
1012 enum bfd_link_hash_type ntype
,
1015 if (! config
.warn_common
)
1018 if (ntype
== bfd_link_hash_defined
1019 || ntype
== bfd_link_hash_defweak
1020 || ntype
== bfd_link_hash_indirect
)
1022 ASSERT (otype
== bfd_link_hash_common
);
1023 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1026 einfo (_("%B: warning: common is here\n"), obfd
);
1028 else if (otype
== bfd_link_hash_defined
1029 || otype
== bfd_link_hash_defweak
1030 || otype
== bfd_link_hash_indirect
)
1032 ASSERT (ntype
== bfd_link_hash_common
);
1033 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1036 einfo (_("%B: warning: defined here\n"), obfd
);
1040 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1043 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1046 einfo (_("%B: warning: larger common is here\n"), obfd
);
1048 else if (nsize
> osize
)
1050 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1053 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1057 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1059 einfo (_("%B: warning: previous common is here\n"), obfd
);
1066 /* This is called when BFD has discovered a set element. H is the
1067 entry in the linker hash table for the set. SECTION and VALUE
1068 represent a value which should be added to the set. */
1071 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1072 struct bfd_link_hash_entry
*h
,
1073 bfd_reloc_code_real_type reloc
,
1078 if (config
.warn_constructors
)
1079 einfo (_("%P: warning: global constructor %s used\n"),
1082 if (! config
.build_constructors
)
1085 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1087 if (h
->type
== bfd_link_hash_new
)
1089 h
->type
= bfd_link_hash_undefined
;
1090 h
->u
.undef
.abfd
= abfd
;
1091 /* We don't call bfd_link_add_undef to add this to the list of
1092 undefined symbols because we are going to define it
1099 /* This is called when BFD has discovered a constructor. This is only
1100 called for some object file formats--those which do not handle
1101 constructors in some more clever fashion. This is similar to
1102 adding an element to a set, but less general. */
1105 constructor_callback (struct bfd_link_info
*info
,
1106 bfd_boolean constructor
,
1113 struct bfd_link_hash_entry
*h
;
1114 char set_name
[1 + sizeof "__CTOR_LIST__"];
1116 if (config
.warn_constructors
)
1117 einfo (_("%P: warning: global constructor %s used\n"), name
);
1119 if (! config
.build_constructors
)
1122 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1123 useful error message. */
1124 if (bfd_reloc_type_lookup (output_bfd
, BFD_RELOC_CTOR
) == NULL
1125 && (link_info
.relocatable
1126 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1127 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1130 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1131 *s
++ = bfd_get_symbol_leading_char (abfd
);
1133 strcpy (s
, "__CTOR_LIST__");
1135 strcpy (s
, "__DTOR_LIST__");
1137 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1138 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1139 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1140 if (h
->type
== bfd_link_hash_new
)
1142 h
->type
= bfd_link_hash_undefined
;
1143 h
->u
.undef
.abfd
= abfd
;
1144 /* We don't call bfd_link_add_undef to add this to the list of
1145 undefined symbols because we are going to define it
1149 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1153 /* A structure used by warning_callback to pass information through
1154 bfd_map_over_sections. */
1156 struct warning_callback_info
1159 const char *warning
;
1164 /* This is called when there is a reference to a warning symbol. */
1167 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1168 const char *warning
,
1174 /* This is a hack to support warn_multiple_gp. FIXME: This should
1175 have a cleaner interface, but what? */
1176 if (! config
.warn_multiple_gp
1177 && strcmp (warning
, "using multiple gp values") == 0)
1180 if (section
!= NULL
)
1181 einfo ("%C: %s\n", abfd
, section
, address
, warning
);
1182 else if (abfd
== NULL
)
1183 einfo ("%P: %s\n", warning
);
1184 else if (symbol
== NULL
)
1185 einfo ("%B: %s\n", abfd
, warning
);
1188 lang_input_statement_type
*entry
;
1190 struct warning_callback_info info
;
1192 /* Look through the relocs to see if we can find a plausible
1194 entry
= (lang_input_statement_type
*) abfd
->usrdata
;
1195 if (entry
!= NULL
&& entry
->asymbols
!= NULL
)
1196 asymbols
= entry
->asymbols
;
1202 symsize
= bfd_get_symtab_upper_bound (abfd
);
1204 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1205 asymbols
= xmalloc (symsize
);
1206 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
1207 if (symbol_count
< 0)
1208 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1211 entry
->asymbols
= asymbols
;
1212 entry
->symbol_count
= symbol_count
;
1217 info
.warning
= warning
;
1218 info
.symbol
= symbol
;
1219 info
.asymbols
= asymbols
;
1220 bfd_map_over_sections (abfd
, warning_find_reloc
, &info
);
1223 einfo ("%B: %s\n", abfd
, warning
);
1232 /* This is called by warning_callback for each section. It checks the
1233 relocs of the section to see if it can find a reference to the
1234 symbol which triggered the warning. If it can, it uses the reloc
1235 to give an error message with a file and line number. */
1238 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1240 struct warning_callback_info
*info
= iarg
;
1244 arelent
**p
, **pend
;
1249 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1251 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1255 relpp
= xmalloc (relsize
);
1256 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1258 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1261 pend
= p
+ relcount
;
1262 for (; p
< pend
&& *p
!= NULL
; p
++)
1266 if (q
->sym_ptr_ptr
!= NULL
1267 && *q
->sym_ptr_ptr
!= NULL
1268 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1270 /* We found a reloc for the symbol we are looking for. */
1271 einfo ("%C: %s\n", abfd
, sec
, q
->address
, info
->warning
);
1280 /* This is called when an undefined symbol is found. */
1283 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1290 static char *error_name
;
1291 static unsigned int error_count
;
1293 #define MAX_ERRORS_IN_A_ROW 5
1295 if (config
.warn_once
)
1297 static struct bfd_hash_table
*hash
;
1299 /* Only warn once about a particular undefined symbol. */
1302 hash
= xmalloc (sizeof (struct bfd_hash_table
));
1303 if (! bfd_hash_table_init (hash
, bfd_hash_newfunc
))
1304 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1307 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1310 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1311 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1314 /* We never print more than a reasonable number of errors in a row
1315 for a single symbol. */
1316 if (error_name
!= NULL
1317 && strcmp (name
, error_name
) == 0)
1322 if (error_name
!= NULL
)
1324 error_name
= xstrdup (name
);
1327 if (section
!= NULL
)
1329 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1332 einfo (_("%X%C: undefined reference to `%T'\n"),
1333 abfd
, section
, address
, name
);
1335 einfo (_("%C: warning: undefined reference to `%T'\n"),
1336 abfd
, section
, address
, name
);
1338 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1341 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1342 abfd
, section
, address
, name
);
1344 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1345 abfd
, section
, address
, name
);
1352 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1355 einfo (_("%X%B: undefined reference to `%T'\n"),
1358 einfo (_("%B: warning: undefined reference to `%T'\n"),
1361 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1364 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1367 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1377 /* Counter to limit the number of relocation overflow error messages
1378 to print. Errors are printed as it is decremented. When it's
1379 called and the counter is zero, a final message is printed
1380 indicating more relocations were omitted. When it gets to -1, no
1381 such errors are printed. If it's initially set to a value less
1382 than -1, all such errors will be printed (--verbose does this). */
1384 int overflow_cutoff_limit
= 10;
1386 /* This is called when a reloc overflows. */
1389 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1390 struct bfd_link_hash_entry
*entry
,
1392 const char *reloc_name
,
1398 if (overflow_cutoff_limit
== -1)
1402 einfo (_("%P%X: generated"));
1404 einfo ("%X%C:", abfd
, section
, address
);
1406 if (overflow_cutoff_limit
>= 0
1407 && overflow_cutoff_limit
-- == 0)
1409 einfo (_(" additional relocation overflows omitted from the output\n"));
1415 while (entry
->type
== bfd_link_hash_indirect
1416 || entry
->type
== bfd_link_hash_warning
)
1417 entry
= entry
->u
.i
.link
;
1418 switch (entry
->type
)
1420 case bfd_link_hash_undefined
:
1421 case bfd_link_hash_undefweak
:
1422 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1423 reloc_name
, entry
->root
.string
);
1425 case bfd_link_hash_defined
:
1426 case bfd_link_hash_defweak
:
1427 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1428 reloc_name
, entry
->root
.string
,
1429 entry
->u
.def
.section
, entry
->u
.def
.section
->owner
);
1437 einfo (_(" relocation truncated to fit: %s against `%T'"),
1440 einfo ("+%v", addend
);
1445 /* This is called when a dangerous relocation is made. */
1448 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1449 const char *message
,
1455 einfo (_("%P%X: generated"));
1457 einfo ("%X%C:", abfd
, section
, address
);
1458 einfo (_("dangerous relocation: %s\n"), message
);
1462 /* This is called when a reloc is being generated attached to a symbol
1463 that is not being output. */
1466 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1473 einfo (_("%P%X: generated"));
1475 einfo ("%X%C:", abfd
, section
, address
);
1476 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name
);
1480 /* This is called if link_info.notice_all is set, or when a symbol in
1481 link_info.notice_hash is found. Symbols are put in notice_hash
1482 using the -y option. */
1485 notice (struct bfd_link_info
*info
,
1491 if (! info
->notice_all
1492 || (info
->notice_hash
!= NULL
1493 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
))
1495 if (bfd_is_und_section (section
))
1496 einfo ("%B: reference to %s\n", abfd
, name
);
1498 einfo ("%B: definition of %s\n", abfd
, name
);
1501 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1502 add_cref (name
, abfd
, section
, value
);