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 ""
62 int main
PARAMS ((int, char **));
67 const char *output_filename
= "a.out";
69 /* Name this program was invoked by. */
72 /* The prefix for system library directories. */
75 /* The canonical representation of ld_sysroot. */
76 char * ld_canon_sysroot
;
77 int ld_canon_sysroot_len
;
79 /* The file that we're creating. */
82 /* Set by -G argument, for MIPS ECOFF target. */
83 int g_switch_value
= 8;
85 /* Nonzero means print names of input files as processed. */
86 bfd_boolean trace_files
;
88 /* Nonzero means same, but note open failures, too. */
89 bfd_boolean trace_file_tries
;
91 /* Nonzero means version number was printed, so exit successfully
92 instead of complaining if no input files are given. */
93 bfd_boolean version_printed
;
95 /* Nonzero means link in every member of an archive. */
96 bfd_boolean whole_archive
;
98 /* TRUE if we should demangle symbol names. */
99 bfd_boolean demangling
;
101 args_type command_line
;
103 ld_config_type config
;
105 static char *get_emulation
106 PARAMS ((int, char **));
107 static void set_scripts_dir
109 static void remove_output
111 static bfd_boolean check_for_scripts_dir
113 static bfd_boolean add_archive_element
114 PARAMS ((struct bfd_link_info
*, bfd
*, const char *));
115 static bfd_boolean multiple_definition
116 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
117 bfd
*, asection
*, bfd_vma
));
118 static bfd_boolean multiple_common
119 PARAMS ((struct bfd_link_info
*, const char *, bfd
*,
120 enum bfd_link_hash_type
, bfd_vma
, bfd
*, enum bfd_link_hash_type
,
122 static bfd_boolean add_to_set
123 PARAMS ((struct bfd_link_info
*, struct bfd_link_hash_entry
*,
124 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
));
125 static bfd_boolean constructor_callback
126 PARAMS ((struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
127 asection
*, bfd_vma
));
128 static bfd_boolean warning_callback
129 PARAMS ((struct bfd_link_info
*, const char *, const char *, bfd
*,
130 asection
*, bfd_vma
));
131 static void warning_find_reloc
132 PARAMS ((bfd
*, asection
*, PTR
));
133 static bfd_boolean undefined_symbol
134 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
136 static bfd_boolean reloc_overflow
137 PARAMS ((struct bfd_link_info
*, const char *, const char *, bfd_vma
,
138 bfd
*, asection
*, bfd_vma
));
139 static bfd_boolean reloc_dangerous
140 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
));
141 static bfd_boolean unattached_reloc
142 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
));
143 static bfd_boolean notice
144 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
));
146 static struct bfd_link_callbacks link_callbacks
=
152 constructor_callback
,
162 struct bfd_link_info link_info
;
169 if (output_bfd
&& output_bfd
->iostream
)
170 fclose ((FILE *) (output_bfd
->iostream
));
171 if (delete_output_file_on_failure
)
172 unlink (output_filename
);
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 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
;
283 /* We initialize DEMANGLING based on the environment variable
284 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
285 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
286 environment. Acting the same way here lets us provide the same
287 interface by default. */
288 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
290 link_info
.relocateable
= FALSE
;
291 link_info
.emitrelocations
= FALSE
;
292 link_info
.task_link
= FALSE
;
293 link_info
.shared
= FALSE
;
294 link_info
.pie
= FALSE
;
295 link_info
.executable
= FALSE
;
296 link_info
.symbolic
= FALSE
;
297 link_info
.export_dynamic
= FALSE
;
298 link_info
.static_link
= FALSE
;
299 link_info
.traditional_format
= FALSE
;
300 link_info
.optimize
= FALSE
;
301 link_info
.no_undefined
= FALSE
;
302 link_info
.allow_shlib_undefined
= TRUE
;
303 link_info
.allow_multiple_definition
= FALSE
;
304 link_info
.allow_undefined_version
= TRUE
;
305 link_info
.keep_memory
= TRUE
;
306 link_info
.notice_all
= FALSE
;
307 link_info
.nocopyreloc
= FALSE
;
308 link_info
.new_dtags
= FALSE
;
309 link_info
.combreloc
= TRUE
;
310 link_info
.eh_frame_hdr
= FALSE
;
311 link_info
.strip_discarded
= TRUE
;
312 link_info
.strip
= strip_none
;
313 link_info
.discard
= discard_sec_merge
;
314 link_info
.common_skip_ar_aymbols
= bfd_link_common_skip_none
;
315 link_info
.callbacks
= &link_callbacks
;
316 link_info
.hash
= NULL
;
317 link_info
.keep_hash
= NULL
;
318 link_info
.notice_hash
= NULL
;
319 link_info
.wrap_hash
= NULL
;
320 link_info
.input_bfds
= NULL
;
321 link_info
.create_object_symbols_section
= NULL
;
322 link_info
.gc_sym_list
= NULL
;
323 link_info
.base_file
= NULL
;
324 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
325 and _fini symbols. We are compatible. */
326 link_info
.init_function
= "_init";
327 link_info
.fini_function
= "_fini";
328 link_info
.mpc860c0
= 0;
329 link_info
.pei386_auto_import
= -1;
330 link_info
.pei386_runtime_pseudo_reloc
= FALSE
;
331 link_info
.spare_dynamic_tags
= 5;
332 link_info
.flags
= (bfd_vma
) 0;
333 link_info
.flags_1
= (bfd_vma
) 0;
334 link_info
.relax_finalizing
= FALSE
;
336 ldfile_add_arch ("");
338 config
.make_executable
= TRUE
;
339 force_make_executable
= FALSE
;
340 config
.magic_demand_paged
= TRUE
;
341 config
.text_read_only
= TRUE
;
343 emulation
= get_emulation (argc
, argv
);
344 ldemul_choose_mode (emulation
);
345 default_target
= ldemul_choose_target (argc
, argv
);
347 ldemul_before_parse ();
348 lang_has_input_file
= FALSE
;
349 parse_args (argc
, argv
);
351 ldemul_set_symbols ();
353 if (link_info
.relocateable
)
355 if (command_line
.gc_sections
)
356 einfo ("%P%F: --gc-sections and -r may not be used together\n");
357 if (link_info
.mpc860c0
)
358 einfo (_("%P%F: -r and --mpc860c0 may not be used together\n"));
359 else if (command_line
.relax
)
360 einfo (_("%P%F: --relax and -r may not be used together\n"));
361 if (link_info
.shared
)
362 einfo (_("%P%F: -r and -shared may not be used together\n"));
365 if (! link_info
.shared
)
367 if (command_line
.filter_shlib
)
368 einfo (_("%P%F: -F may not be used without -shared\n"));
369 if (command_line
.auxiliary_filters
)
370 einfo (_("%P%F: -f may not be used without -shared\n"));
373 if (! link_info
.shared
|| link_info
.pie
)
374 link_info
.executable
= TRUE
;
376 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
377 don't see how else this can be handled, since in this case we
378 must preserve all externally visible symbols. */
379 if (link_info
.relocateable
&& link_info
.strip
== strip_all
)
381 link_info
.strip
= strip_debugger
;
382 if (link_info
.discard
== discard_sec_merge
)
383 link_info
.discard
= discard_all
;
386 /* This essentially adds another -L directory so this must be done after
387 the -L's in argv have been processed. */
390 /* If we have not already opened and parsed a linker script
391 read the emulation's appropriate default script. */
392 if (saved_script_handle
== NULL
)
395 char *s
= ldemul_get_script (&isfile
);
398 ldfile_open_command_file (s
);
404 parser_input
= input_script
;
409 if (trace_file_tries
)
411 if (saved_script_handle
)
412 info_msg (_("using external linker script:"));
414 info_msg (_("using internal linker script:"));
415 info_msg ("\n==================================================\n");
417 if (saved_script_handle
)
419 static const int ld_bufsz
= 8193;
421 char *buf
= xmalloc (ld_bufsz
);
423 rewind (saved_script_handle
);
424 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
429 rewind (saved_script_handle
);
436 info_msg (ldemul_get_script (&isfile
));
439 info_msg ("\n==================================================\n");
444 if (!lang_has_input_file
)
448 einfo (_("%P%F: no input files\n"));
452 info_msg (_("%P: mode %s\n"), emulation
);
454 ldemul_after_parse ();
456 if (config
.map_filename
)
458 if (strcmp (config
.map_filename
, "-") == 0)
460 config
.map_file
= stdout
;
464 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
465 if (config
.map_file
== (FILE *) NULL
)
467 bfd_set_error (bfd_error_system_call
);
468 einfo (_("%P%F: cannot open map file %s: %E\n"),
469 config
.map_filename
);
476 /* Print error messages for any missing symbols, for any warning
477 symbols, and possibly multiple definitions. */
478 if (link_info
.relocateable
)
479 output_bfd
->flags
&= ~EXEC_P
;
481 output_bfd
->flags
|= EXEC_P
;
485 if (config
.map_file
!= NULL
)
487 if (command_line
.cref
)
488 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
489 if (nocrossref_list
!= NULL
)
490 check_nocrossrefs ();
492 /* Even if we're producing relocateable output, some non-fatal errors should
493 be reported in the exit status. (What non-fatal errors, if any, do we
494 want to ignore for relocateable output?) */
495 if (!config
.make_executable
&& !force_make_executable
)
498 einfo (_("%P: link errors found, deleting executable `%s'\n"),
501 /* The file will be removed by remove_output. */
506 if (! bfd_close (output_bfd
))
507 einfo (_("%F%B: final close failed: %E\n"), output_bfd
);
509 /* If the --force-exe-suffix is enabled, and we're making an
510 executable file and it doesn't end in .exe, copy it to one
512 if (! link_info
.relocateable
&& command_line
.force_exe_suffix
)
514 int len
= strlen (output_filename
);
517 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
518 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
522 const int bsize
= 4096;
523 char *buf
= xmalloc (bsize
);
525 char *dst_name
= xmalloc (len
+ 5);
527 strcpy (dst_name
, output_filename
);
528 strcat (dst_name
, ".exe");
529 src
= fopen (output_filename
, FOPEN_RB
);
530 dst
= fopen (dst_name
, FOPEN_WB
);
533 einfo (_("%X%P: unable to open for source of copy `%s'\n"), output_filename
);
535 einfo (_("%X%P: unable to open for destination of copy `%s'\n"), dst_name
);
536 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
538 int done
= fwrite (buf
, 1, l
, dst
);
541 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
545 if (fclose (dst
) == EOF
)
546 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
553 END_PROGRESS (program_name
);
558 char *lim
= (char *) sbrk (0);
560 long run_time
= get_run_time () - start_time
;
562 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
563 program_name
, run_time
/ 1000000, run_time
% 1000000);
565 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
566 (long) (lim
- (char *) &environ
));
570 /* Prevent remove_output from doing anything, after a successful link. */
571 output_filename
= NULL
;
577 /* We need to find any explicitly given emulation in order to initialize the
578 state that's needed by the lex&yacc argument parser (parse_args). */
581 get_emulation (argc
, argv
)
588 emulation
= getenv (EMULATION_ENVIRON
);
589 if (emulation
== NULL
)
590 emulation
= DEFAULT_EMULATION
;
592 for (i
= 1; i
< argc
; i
++)
594 if (!strncmp (argv
[i
], "-m", 2))
596 if (argv
[i
][2] == '\0')
601 emulation
= argv
[i
+ 1];
605 einfo (_("%P%F: missing argument to -m\n"));
607 else if (strcmp (argv
[i
], "-mips1") == 0
608 || strcmp (argv
[i
], "-mips2") == 0
609 || strcmp (argv
[i
], "-mips3") == 0
610 || strcmp (argv
[i
], "-mips4") == 0
611 || strcmp (argv
[i
], "-mips5") == 0
612 || strcmp (argv
[i
], "-mips32") == 0
613 || strcmp (argv
[i
], "-mips32r2") == 0
614 || strcmp (argv
[i
], "-mips64") == 0)
616 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
617 passed to the linker by some MIPS compilers. They
618 generally tell the linker to use a slightly different
619 library path. Perhaps someday these should be
620 implemented as emulations; until then, we just ignore
621 the arguments and hope that nobody ever creates
622 emulations named ips1, ips2 or ips3. */
624 else if (strcmp (argv
[i
], "-m486") == 0)
626 /* FIXME: The argument -m486 is passed to the linker on
627 some Linux systems. Hope that nobody creates an
628 emulation named 486. */
633 emulation
= &argv
[i
][2];
641 /* If directory DIR contains an "ldscripts" subdirectory,
642 add DIR to the library search path and return TRUE,
643 else return FALSE. */
646 check_for_scripts_dir (dir
)
654 dirlen
= strlen (dir
);
655 /* sizeof counts the terminating NUL. */
656 buf
= (char *) xmalloc (dirlen
+ sizeof ("/ldscripts"));
657 sprintf (buf
, "%s/ldscripts", dir
);
659 res
= stat (buf
, &s
) == 0 && S_ISDIR (s
.st_mode
);
662 ldfile_add_library_path (dir
, FALSE
);
666 /* Set the default directory for finding script files.
667 Libraries will be searched for here too, but that's ok.
668 We look for the "ldscripts" directory in:
670 SCRIPTDIR (passed from Makefile)
671 (adjusted according to the current location of the binary)
672 SCRIPTDIR (passed from Makefile)
673 the dir where this program is (for using it from the build tree)
674 the dir where this program is/../lib
675 (for installing the tool suite elsewhere). */
684 dir
= make_relative_prefix (program_name
, BINDIR
, SCRIPTDIR
);
687 found
= check_for_scripts_dir (dir
);
693 dir
= make_relative_prefix (program_name
, TOOLBINDIR
, SCRIPTDIR
);
696 found
= check_for_scripts_dir (dir
);
702 if (check_for_scripts_dir (SCRIPTDIR
))
703 /* We've been installed normally. */
706 /* Look for "ldscripts" in the dir where our binary is. */
707 end
= strrchr (program_name
, '/');
708 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
710 /* We could have \foo\bar, or /foo\bar. */
711 char *bslash
= strrchr (program_name
, '\\');
713 if (end
== NULL
|| (bslash
!= NULL
&& bslash
> end
))
719 /* Don't look for ldscripts in the current directory. There is
720 too much potential for confusion. */
723 dirlen
= end
- program_name
;
724 /* Make a copy of program_name in dir.
725 Leave room for later "/../lib". */
726 dir
= (char *) xmalloc (dirlen
+ 8);
727 strncpy (dir
, program_name
, dirlen
);
730 if (check_for_scripts_dir (dir
))
736 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
737 strcpy (dir
+ dirlen
, "/../lib");
738 check_for_scripts_dir (dir
);
746 if (link_info
.notice_hash
== (struct bfd_hash_table
*) NULL
)
748 link_info
.notice_hash
= ((struct bfd_hash_table
*)
749 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
)
757 == (struct bfd_hash_entry
*) NULL
)
758 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
761 /* Record a symbol to be wrapped, from the --wrap option. */
767 if (link_info
.wrap_hash
== NULL
)
769 link_info
.wrap_hash
= ((struct bfd_hash_table
*)
770 xmalloc (sizeof (struct bfd_hash_table
)));
771 if (! bfd_hash_table_init_n (link_info
.wrap_hash
,
774 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
777 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
778 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
781 /* Handle the -retain-symbols-file option. */
784 add_keepsyms_file (filename
)
785 const char *filename
;
792 if (link_info
.strip
== strip_some
)
793 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
795 file
= fopen (filename
, "r");
796 if (file
== (FILE *) NULL
)
798 bfd_set_error (bfd_error_system_call
);
799 einfo ("%X%P: %s: %E\n", filename
);
803 link_info
.keep_hash
= ((struct bfd_hash_table
*)
804 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
= (char *) 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
)
836 == (struct bfd_hash_entry
*) NULL
)
837 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
841 if (link_info
.strip
!= strip_none
)
842 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
845 link_info
.strip
= strip_some
;
848 /* Callbacks from the BFD linker routines. */
850 /* This is called when BFD has decided to include an archive member in
854 add_archive_element (info
, abfd
, name
)
855 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
859 lang_input_statement_type
*input
;
861 input
= ((lang_input_statement_type
*)
862 xmalloc (sizeof (lang_input_statement_type
)));
863 input
->filename
= abfd
->filename
;
864 input
->local_sym_name
= abfd
->filename
;
865 input
->the_bfd
= abfd
;
866 input
->asymbols
= NULL
;
868 input
->just_syms_flag
= FALSE
;
869 input
->loaded
= FALSE
;
870 input
->search_dirs_flag
= FALSE
;
872 /* FIXME: The following fields are not set: header.next,
873 header.type, closed, passive_position, symbol_count,
874 next_real_file, is_archive, target, real. This bit of code is
875 from the old decode_library_subfile function. I don't know
876 whether any of those fields matters. */
878 ldlang_add_file (input
);
880 if (config
.map_file
!= (FILE *) NULL
)
882 static bfd_boolean header_printed
;
883 struct bfd_link_hash_entry
*h
;
887 h
= bfd_link_hash_lookup (link_info
.hash
, name
, FALSE
, FALSE
, TRUE
);
899 case bfd_link_hash_defined
:
900 case bfd_link_hash_defweak
:
901 from
= h
->u
.def
.section
->owner
;
904 case bfd_link_hash_undefined
:
905 case bfd_link_hash_undefweak
:
906 from
= h
->u
.undef
.abfd
;
909 case bfd_link_hash_common
:
910 from
= h
->u
.c
.p
->section
->owner
;
915 if (! header_printed
)
919 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
921 header_printed
= TRUE
;
924 if (bfd_my_archive (abfd
) == NULL
)
926 minfo ("%s", bfd_get_filename (abfd
));
927 len
= strlen (bfd_get_filename (abfd
));
931 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
932 bfd_get_filename (abfd
));
933 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
934 + strlen (bfd_get_filename (abfd
))
952 minfo ("(%T)\n", h
->root
.string
);
954 minfo ("(%s)\n", name
);
957 if (trace_files
|| trace_file_tries
)
958 info_msg ("%I\n", input
);
963 /* This is called when BFD has discovered a symbol which is defined
967 multiple_definition (info
, name
, obfd
, osec
, oval
, nbfd
, nsec
, nval
)
968 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
977 /* If either section has the output_section field set to
978 bfd_abs_section_ptr, it means that the section is being
979 discarded, and this is not really a multiple definition at all.
980 FIXME: It would be cleaner to somehow ignore symbols defined in
981 sections which are being discarded. */
982 if ((osec
->output_section
!= NULL
983 && ! bfd_is_abs_section (osec
)
984 && bfd_is_abs_section (osec
->output_section
))
985 || (nsec
->output_section
!= NULL
986 && ! bfd_is_abs_section (nsec
)
987 && bfd_is_abs_section (nsec
->output_section
)))
990 einfo (_("%X%C: multiple definition of `%T'\n"),
991 nbfd
, nsec
, nval
, name
);
992 if (obfd
!= (bfd
*) NULL
)
993 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
995 if (command_line
.relax
)
997 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
998 command_line
.relax
= 0;
1004 /* This is called when there is a definition of a common symbol, or
1005 when a common symbol is found for a symbol that is already defined,
1006 or when two common symbols are found. We only do something if
1007 -warn-common was used. */
1010 multiple_common (info
, name
, obfd
, otype
, osize
, nbfd
, ntype
, nsize
)
1011 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1014 enum bfd_link_hash_type otype
;
1017 enum bfd_link_hash_type ntype
;
1020 if (! config
.warn_common
)
1023 if (ntype
== bfd_link_hash_defined
1024 || ntype
== bfd_link_hash_defweak
1025 || ntype
== bfd_link_hash_indirect
)
1027 ASSERT (otype
== bfd_link_hash_common
);
1028 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1031 einfo (_("%B: warning: common is here\n"), obfd
);
1033 else if (otype
== bfd_link_hash_defined
1034 || otype
== bfd_link_hash_defweak
1035 || otype
== bfd_link_hash_indirect
)
1037 ASSERT (ntype
== bfd_link_hash_common
);
1038 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1041 einfo (_("%B: warning: defined here\n"), obfd
);
1045 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1048 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1051 einfo (_("%B: warning: larger common is here\n"), obfd
);
1053 else if (nsize
> osize
)
1055 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1058 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1062 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1064 einfo (_("%B: warning: previous common is here\n"), obfd
);
1071 /* This is called when BFD has discovered a set element. H is the
1072 entry in the linker hash table for the set. SECTION and VALUE
1073 represent a value which should be added to the set. */
1076 add_to_set (info
, h
, reloc
, abfd
, section
, value
)
1077 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1078 struct bfd_link_hash_entry
*h
;
1079 bfd_reloc_code_real_type reloc
;
1084 if (config
.warn_constructors
)
1085 einfo (_("%P: warning: global constructor %s used\n"),
1088 if (! config
.build_constructors
)
1091 ldctor_add_set_entry (h
, reloc
, (const char *) NULL
, section
, value
);
1093 if (h
->type
== bfd_link_hash_new
)
1095 h
->type
= bfd_link_hash_undefined
;
1096 h
->u
.undef
.abfd
= abfd
;
1097 /* We don't call bfd_link_add_undef to add this to the list of
1098 undefined symbols because we are going to define it
1105 /* This is called when BFD has discovered a constructor. This is only
1106 called for some object file formats--those which do not handle
1107 constructors in some more clever fashion. This is similar to
1108 adding an element to a set, but less general. */
1111 constructor_callback (info
, constructor
, name
, abfd
, section
, value
)
1112 struct bfd_link_info
*info
;
1113 bfd_boolean constructor
;
1120 struct bfd_link_hash_entry
*h
;
1121 char set_name
[1 + sizeof "__CTOR_LIST__"];
1123 if (config
.warn_constructors
)
1124 einfo (_("%P: warning: global constructor %s used\n"), name
);
1126 if (! config
.build_constructors
)
1129 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1130 useful error message. */
1131 if (bfd_reloc_type_lookup (output_bfd
, BFD_RELOC_CTOR
) == NULL
1132 && (link_info
.relocateable
1133 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1134 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1137 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1138 *s
++ = bfd_get_symbol_leading_char (abfd
);
1140 strcpy (s
, "__CTOR_LIST__");
1142 strcpy (s
, "__DTOR_LIST__");
1144 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1145 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1146 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1147 if (h
->type
== bfd_link_hash_new
)
1149 h
->type
= bfd_link_hash_undefined
;
1150 h
->u
.undef
.abfd
= abfd
;
1151 /* We don't call bfd_link_add_undef to add this to the list of
1152 undefined symbols because we are going to define it
1156 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1160 /* A structure used by warning_callback to pass information through
1161 bfd_map_over_sections. */
1163 struct warning_callback_info
1166 const char *warning
;
1171 /* This is called when there is a reference to a warning symbol. */
1174 warning_callback (info
, warning
, symbol
, abfd
, section
, address
)
1175 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1176 const char *warning
;
1182 /* This is a hack to support warn_multiple_gp. FIXME: This should
1183 have a cleaner interface, but what? */
1184 if (! config
.warn_multiple_gp
1185 && strcmp (warning
, "using multiple gp values") == 0)
1188 if (section
!= NULL
)
1189 einfo ("%C: %s\n", abfd
, section
, address
, warning
);
1190 else if (abfd
== NULL
)
1191 einfo ("%P: %s\n", warning
);
1192 else if (symbol
== NULL
)
1193 einfo ("%B: %s\n", abfd
, warning
);
1196 lang_input_statement_type
*entry
;
1198 struct warning_callback_info info
;
1200 /* Look through the relocs to see if we can find a plausible
1202 entry
= (lang_input_statement_type
*) abfd
->usrdata
;
1203 if (entry
!= NULL
&& entry
->asymbols
!= NULL
)
1204 asymbols
= entry
->asymbols
;
1210 symsize
= bfd_get_symtab_upper_bound (abfd
);
1212 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1213 asymbols
= (asymbol
**) xmalloc (symsize
);
1214 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
1215 if (symbol_count
< 0)
1216 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1219 entry
->asymbols
= asymbols
;
1220 entry
->symbol_count
= symbol_count
;
1225 info
.warning
= warning
;
1226 info
.symbol
= symbol
;
1227 info
.asymbols
= asymbols
;
1228 bfd_map_over_sections (abfd
, warning_find_reloc
, (PTR
) &info
);
1231 einfo ("%B: %s\n", abfd
, warning
);
1240 /* This is called by warning_callback for each section. It checks the
1241 relocs of the section to see if it can find a reference to the
1242 symbol which triggered the warning. If it can, it uses the reloc
1243 to give an error message with a file and line number. */
1246 warning_find_reloc (abfd
, sec
, iarg
)
1251 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1255 arelent
**p
, **pend
;
1260 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1262 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1266 relpp
= (arelent
**) xmalloc (relsize
);
1267 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1269 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1272 pend
= p
+ relcount
;
1273 for (; p
< pend
&& *p
!= NULL
; p
++)
1277 if (q
->sym_ptr_ptr
!= NULL
1278 && *q
->sym_ptr_ptr
!= NULL
1279 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1281 /* We found a reloc for the symbol we are looking for. */
1282 einfo ("%C: %s\n", abfd
, sec
, q
->address
, info
->warning
);
1291 /* This is called when an undefined symbol is found. */
1294 undefined_symbol (info
, name
, abfd
, section
, address
, fatal
)
1295 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1300 bfd_boolean fatal ATTRIBUTE_UNUSED
;
1302 static char *error_name
;
1303 static unsigned int error_count
;
1305 #define MAX_ERRORS_IN_A_ROW 5
1307 if (config
.warn_once
)
1309 static struct bfd_hash_table
*hash
;
1311 /* Only warn once about a particular undefined symbol. */
1314 hash
= ((struct bfd_hash_table
*)
1315 xmalloc (sizeof (struct bfd_hash_table
)));
1316 if (! bfd_hash_table_init (hash
, bfd_hash_newfunc
))
1317 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1320 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1323 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1324 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1327 /* We never print more than a reasonable number of errors in a row
1328 for a single symbol. */
1329 if (error_name
!= (char *) NULL
1330 && strcmp (name
, error_name
) == 0)
1335 if (error_name
!= (char *) NULL
)
1337 error_name
= xstrdup (name
);
1340 if (section
!= NULL
)
1342 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1344 einfo (_("%C: undefined reference to `%T'\n"),
1345 abfd
, section
, address
, name
);
1349 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1350 einfo (_("%D: more undefined references to `%T' follow\n"),
1351 abfd
, section
, address
, name
);
1355 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1357 einfo (_("%B: undefined reference to `%T'\n"),
1362 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1363 einfo (_("%B: more undefined references to `%T' follow\n"),
1370 /* Counter to limit the number of relocation overflow error messages
1371 to print. Errors are printed as it is decremented. When it's
1372 called and the counter is zero, a final message is printed
1373 indicating more relocations were omitted. When it gets to -1, no
1374 such errors are printed. If it's initially set to a value less
1375 than -1, all such errors will be printed (--verbose does this). */
1377 int overflow_cutoff_limit
= 10;
1379 /* This is called when a reloc overflows. */
1382 reloc_overflow (info
, name
, reloc_name
, addend
, abfd
, section
, address
)
1383 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1385 const char *reloc_name
;
1391 if (overflow_cutoff_limit
== -1)
1394 if (abfd
== (bfd
*) NULL
)
1395 einfo (_("%P%X: generated"));
1397 einfo ("%X%C:", abfd
, section
, address
);
1399 if (overflow_cutoff_limit
>= 0
1400 && overflow_cutoff_limit
-- == 0)
1402 einfo (_(" additional relocation overflows omitted from the output\n"));
1406 einfo (_(" relocation truncated to fit: %s %T"), reloc_name
, name
);
1408 einfo ("+%v", addend
);
1413 /* This is called when a dangerous relocation is made. */
1416 reloc_dangerous (info
, message
, abfd
, section
, address
)
1417 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1418 const char *message
;
1423 if (abfd
== (bfd
*) NULL
)
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 (info
, name
, abfd
, section
, address
)
1436 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1442 if (abfd
== (bfd
*) NULL
)
1443 einfo (_("%P%X: generated"));
1445 einfo ("%X%C:", abfd
, section
, address
);
1446 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name
);
1450 /* This is called if link_info.notice_all is set, or when a symbol in
1451 link_info.notice_hash is found. Symbols are put in notice_hash
1452 using the -y option. */
1455 notice (info
, name
, abfd
, section
, value
)
1456 struct bfd_link_info
*info
;
1462 if (! info
->notice_all
1463 || (info
->notice_hash
!= NULL
1464 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
))
1466 if (bfd_is_und_section (section
))
1467 einfo ("%B: reference to %s\n", abfd
, name
);
1469 einfo ("%B: definition of %s\n", abfd
, name
);
1472 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1473 add_cref (name
, abfd
, section
, value
);