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 int main
PARAMS ((int, char **));
60 static char *get_emulation
PARAMS ((int, char **));
61 static void set_scripts_dir
PARAMS ((void));
66 const char *output_filename
= "a.out";
68 /* Name this program was invoked by. */
71 /* The file that we're creating. */
74 /* Set by -G argument, for MIPS ECOFF target. */
75 int g_switch_value
= 8;
77 /* Nonzero means print names of input files as processed. */
78 bfd_boolean trace_files
;
80 /* Nonzero means same, but note open failures, too. */
81 bfd_boolean trace_file_tries
;
83 /* Nonzero means version number was printed, so exit successfully
84 instead of complaining if no input files are given. */
85 bfd_boolean version_printed
;
87 /* Nonzero means link in every member of an archive. */
88 bfd_boolean whole_archive
;
90 /* TRUE if we should demangle symbol names. */
91 bfd_boolean demangling
;
93 args_type command_line
;
95 ld_config_type config
;
97 static void remove_output
PARAMS ((void));
98 static bfd_boolean check_for_scripts_dir
PARAMS ((char *dir
));
99 static bfd_boolean add_archive_element
PARAMS ((struct bfd_link_info
*, bfd
*,
101 static bfd_boolean multiple_definition
PARAMS ((struct bfd_link_info
*,
103 bfd
*, asection
*, bfd_vma
,
104 bfd
*, asection
*, bfd_vma
));
105 static bfd_boolean multiple_common
PARAMS ((struct bfd_link_info
*,
107 enum bfd_link_hash_type
, bfd_vma
,
108 bfd
*, enum bfd_link_hash_type
,
110 static bfd_boolean add_to_set
PARAMS ((struct bfd_link_info
*,
111 struct bfd_link_hash_entry
*,
112 bfd_reloc_code_real_type
,
113 bfd
*, asection
*, bfd_vma
));
114 static bfd_boolean constructor_callback
PARAMS ((struct bfd_link_info
*,
115 bfd_boolean constructor
,
117 bfd
*, asection
*, bfd_vma
));
118 static bfd_boolean warning_callback
PARAMS ((struct bfd_link_info
*,
119 const char *, const char *, bfd
*,
120 asection
*, bfd_vma
));
121 static void warning_find_reloc
PARAMS ((bfd
*, asection
*, PTR
));
122 static bfd_boolean undefined_symbol
PARAMS ((struct bfd_link_info
*,
124 asection
*, bfd_vma
, bfd_boolean
));
125 static bfd_boolean reloc_overflow
PARAMS ((struct bfd_link_info
*, const char *,
126 const char *, bfd_vma
,
127 bfd
*, asection
*, bfd_vma
));
128 static bfd_boolean reloc_dangerous
PARAMS ((struct bfd_link_info
*, const char *,
129 bfd
*, asection
*, bfd_vma
));
130 static bfd_boolean unattached_reloc
PARAMS ((struct bfd_link_info
*,
131 const char *, bfd
*, asection
*,
133 static bfd_boolean notice
PARAMS ((struct bfd_link_info
*, const char *,
134 bfd
*, asection
*, bfd_vma
));
136 static struct bfd_link_callbacks link_callbacks
= {
141 constructor_callback
,
150 struct bfd_link_info link_info
;
157 if (output_bfd
&& output_bfd
->iostream
)
158 fclose ((FILE *) (output_bfd
->iostream
));
159 if (delete_output_file_on_failure
)
160 unlink (output_filename
);
170 long start_time
= get_run_time ();
172 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
173 setlocale (LC_MESSAGES
, "");
175 #if defined (HAVE_SETLOCALE)
176 setlocale (LC_CTYPE
, "");
178 bindtextdomain (PACKAGE
, LOCALEDIR
);
179 textdomain (PACKAGE
);
181 program_name
= argv
[0];
182 xmalloc_set_program_name (program_name
);
184 START_PROGRESS (program_name
, 0);
188 bfd_set_error_program_name (program_name
);
190 xatexit (remove_output
);
192 /* Set the default BFD target based on the configured target. Doing
193 this permits the linker to be configured for a particular target,
194 and linked against a shared BFD library which was configured for
195 a different target. The macro TARGET is defined by Makefile. */
196 if (! bfd_set_default_target (TARGET
))
198 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
209 /* Initialize the data about options. */
210 trace_files
= trace_file_tries
= version_printed
= FALSE
;
211 whole_archive
= FALSE
;
212 config
.build_constructors
= TRUE
;
213 config
.dynamic_link
= FALSE
;
214 config
.has_shared
= FALSE
;
215 config
.split_by_reloc
= (unsigned) -1;
216 config
.split_by_file
= (bfd_size_type
) -1;
217 command_line
.force_common_definition
= FALSE
;
218 command_line
.inhibit_common_definition
= FALSE
;
219 command_line
.interpreter
= NULL
;
220 command_line
.rpath
= NULL
;
221 command_line
.warn_mismatch
= TRUE
;
222 command_line
.check_section_addresses
= TRUE
;
223 command_line
.accept_unknown_input_arch
= FALSE
;
225 /* We initialize DEMANGLING based on the environment variable
226 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
227 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
228 environment. Acting the same way here lets us provide the same
229 interface by default. */
230 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
232 link_info
.relocateable
= FALSE
;
233 link_info
.emitrelocations
= FALSE
;
234 link_info
.task_link
= FALSE
;
235 link_info
.shared
= FALSE
;
236 link_info
.symbolic
= FALSE
;
237 link_info
.export_dynamic
= FALSE
;
238 link_info
.static_link
= FALSE
;
239 link_info
.traditional_format
= FALSE
;
240 link_info
.optimize
= FALSE
;
241 link_info
.no_undefined
= FALSE
;
242 link_info
.allow_shlib_undefined
= FALSE
;
243 link_info
.allow_multiple_definition
= FALSE
;
244 link_info
.allow_undefined_version
= TRUE
;
245 link_info
.keep_memory
= TRUE
;
246 link_info
.notice_all
= FALSE
;
247 link_info
.nocopyreloc
= FALSE
;
248 link_info
.new_dtags
= FALSE
;
249 link_info
.combreloc
= TRUE
;
250 link_info
.eh_frame_hdr
= FALSE
;
251 link_info
.strip_discarded
= TRUE
;
252 link_info
.strip
= strip_none
;
253 link_info
.discard
= discard_sec_merge
;
254 link_info
.common_skip_ar_aymbols
= bfd_link_common_skip_none
;
255 link_info
.callbacks
= &link_callbacks
;
256 link_info
.hash
= NULL
;
257 link_info
.keep_hash
= NULL
;
258 link_info
.notice_hash
= NULL
;
259 link_info
.wrap_hash
= NULL
;
260 link_info
.input_bfds
= NULL
;
261 link_info
.create_object_symbols_section
= NULL
;
262 link_info
.gc_sym_list
= NULL
;
263 link_info
.base_file
= NULL
;
264 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
265 and _fini symbols. We are compatible. */
266 link_info
.init_function
= "_init";
267 link_info
.fini_function
= "_fini";
268 link_info
.mpc860c0
= 0;
269 link_info
.pei386_auto_import
= -1;
270 link_info
.pei386_runtime_pseudo_reloc
= FALSE
;
271 link_info
.spare_dynamic_tags
= 5;
272 link_info
.flags
= (bfd_vma
) 0;
273 link_info
.flags_1
= (bfd_vma
) 0;
275 ldfile_add_arch ("");
277 config
.make_executable
= TRUE
;
278 force_make_executable
= FALSE
;
279 config
.magic_demand_paged
= TRUE
;
280 config
.text_read_only
= TRUE
;
282 emulation
= get_emulation (argc
, argv
);
283 ldemul_choose_mode (emulation
);
284 default_target
= ldemul_choose_target (argc
, argv
);
286 ldemul_before_parse ();
287 lang_has_input_file
= FALSE
;
288 parse_args (argc
, argv
);
290 ldemul_set_symbols ();
292 if (link_info
.relocateable
)
294 if (command_line
.gc_sections
)
295 einfo ("%P%F: --gc-sections and -r may not be used together\n");
296 if (link_info
.mpc860c0
)
297 einfo (_("%P%F: -r and --mpc860c0 may not be used together\n"));
298 else if (command_line
.relax
)
299 einfo (_("%P%F: --relax and -r may not be used together\n"));
300 if (link_info
.shared
)
301 einfo (_("%P%F: -r and -shared may not be used together\n"));
304 if (! link_info
.shared
)
306 if (command_line
.filter_shlib
)
307 einfo (_("%P%F: -F may not be used without -shared\n"));
308 if (command_line
.auxiliary_filters
)
309 einfo (_("%P%F: -f may not be used without -shared\n"));
312 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
313 don't see how else this can be handled, since in this case we
314 must preserve all externally visible symbols. */
315 if (link_info
.relocateable
&& link_info
.strip
== strip_all
)
317 link_info
.strip
= strip_debugger
;
318 if (link_info
.discard
== discard_sec_merge
)
319 link_info
.discard
= discard_all
;
322 /* This essentially adds another -L directory so this must be done after
323 the -L's in argv have been processed. */
326 /* If we have not already opened and parsed a linker script
327 read the emulation's appropriate default script. */
328 if (saved_script_handle
== NULL
)
331 char *s
= ldemul_get_script (&isfile
);
334 ldfile_open_command_file (s
);
340 parser_input
= input_script
;
345 if (trace_file_tries
)
347 if (saved_script_handle
)
348 info_msg (_("using external linker script:"));
350 info_msg (_("using internal linker script:"));
351 info_msg ("\n==================================================\n");
353 if (saved_script_handle
)
355 static const int ld_bufsz
= 8193;
357 char *buf
= xmalloc (ld_bufsz
);
359 rewind (saved_script_handle
);
360 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
365 rewind (saved_script_handle
);
372 info_msg (ldemul_get_script (&isfile
));
375 info_msg ("\n==================================================\n");
380 if (!lang_has_input_file
)
384 einfo (_("%P%F: no input files\n"));
389 info_msg (_("%P: mode %s\n"), emulation
);
392 ldemul_after_parse ();
394 if (config
.map_filename
)
396 if (strcmp (config
.map_filename
, "-") == 0)
398 config
.map_file
= stdout
;
402 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
403 if (config
.map_file
== (FILE *) NULL
)
405 bfd_set_error (bfd_error_system_call
);
406 einfo (_("%P%F: cannot open map file %s: %E\n"),
407 config
.map_filename
);
414 /* Print error messages for any missing symbols, for any warning
415 symbols, and possibly multiple definitions. */
417 if (link_info
.relocateable
)
418 output_bfd
->flags
&= ~EXEC_P
;
420 output_bfd
->flags
|= EXEC_P
;
424 if (config
.map_file
!= NULL
)
426 if (command_line
.cref
)
427 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
428 if (nocrossref_list
!= NULL
)
429 check_nocrossrefs ();
431 /* Even if we're producing relocateable output, some non-fatal errors should
432 be reported in the exit status. (What non-fatal errors, if any, do we
433 want to ignore for relocateable output?) */
435 if (!config
.make_executable
&& !force_make_executable
)
439 einfo (_("%P: link errors found, deleting executable `%s'\n"),
443 /* The file will be removed by remove_output. */
449 if (! bfd_close (output_bfd
))
450 einfo (_("%F%B: final close failed: %E\n"), output_bfd
);
452 /* If the --force-exe-suffix is enabled, and we're making an
453 executable file and it doesn't end in .exe, copy it to one
455 if (! link_info
.relocateable
&& command_line
.force_exe_suffix
)
457 int len
= strlen (output_filename
);
459 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
460 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
464 const int bsize
= 4096;
465 char *buf
= xmalloc (bsize
);
467 char *dst_name
= xmalloc (len
+ 5);
468 strcpy (dst_name
, output_filename
);
469 strcat (dst_name
, ".exe");
470 src
= fopen (output_filename
, FOPEN_RB
);
471 dst
= fopen (dst_name
, FOPEN_WB
);
474 einfo (_("%X%P: unable to open for source of copy `%s'\n"), output_filename
);
476 einfo (_("%X%P: unable to open for destination of copy `%s'\n"), dst_name
);
477 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
479 int done
= fwrite (buf
, 1, l
, dst
);
482 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
486 if (fclose (dst
) == EOF
)
488 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
496 END_PROGRESS (program_name
);
501 char *lim
= (char *) sbrk (0);
503 long run_time
= get_run_time () - start_time
;
505 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
506 program_name
, run_time
/ 1000000, run_time
% 1000000);
508 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
509 (long) (lim
- (char *) &environ
));
513 /* Prevent remove_output from doing anything, after a successful link. */
514 output_filename
= NULL
;
520 /* We need to find any explicitly given emulation in order to initialize the
521 state that's needed by the lex&yacc argument parser (parse_args). */
524 get_emulation (argc
, argv
)
531 emulation
= getenv (EMULATION_ENVIRON
);
532 if (emulation
== NULL
)
533 emulation
= DEFAULT_EMULATION
;
535 for (i
= 1; i
< argc
; i
++)
537 if (!strncmp (argv
[i
], "-m", 2))
539 if (argv
[i
][2] == '\0')
544 emulation
= argv
[i
+ 1];
549 einfo (_("%P%F: missing argument to -m\n"));
552 else if (strcmp (argv
[i
], "-mips1") == 0
553 || strcmp (argv
[i
], "-mips2") == 0
554 || strcmp (argv
[i
], "-mips3") == 0
555 || strcmp (argv
[i
], "-mips32") == 0
556 || strcmp (argv
[i
], "-mips64") == 0
557 || strcmp (argv
[i
], "-mips4") == 0
558 || strcmp (argv
[i
], "-mips5") == 0)
560 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
561 passed to the linker by some MIPS compilers. They
562 generally tell the linker to use a slightly different
563 library path. Perhaps someday these should be
564 implemented as emulations; until then, we just ignore
565 the arguments and hope that nobody ever creates
566 emulations named ips1, ips2 or ips3. */
568 else if (strcmp (argv
[i
], "-m486") == 0)
570 /* FIXME: The argument -m486 is passed to the linker on
571 some Linux systems. Hope that nobody creates an
572 emulation named 486. */
577 emulation
= &argv
[i
][2];
585 /* If directory DIR contains an "ldscripts" subdirectory,
586 add DIR to the library search path and return TRUE,
587 else return FALSE. */
590 check_for_scripts_dir (dir
)
598 dirlen
= strlen (dir
);
599 /* sizeof counts the terminating NUL. */
600 buf
= (char *) xmalloc (dirlen
+ sizeof ("/ldscripts"));
601 sprintf (buf
, "%s/ldscripts", dir
);
603 res
= stat (buf
, &s
) == 0 && S_ISDIR (s
.st_mode
);
606 ldfile_add_library_path (dir
, FALSE
);
610 /* Set the default directory for finding script files.
611 Libraries will be searched for here too, but that's ok.
612 We look for the "ldscripts" directory in:
614 SCRIPTDIR (passed from Makefile)
615 (adjusted according to the current location of the binary)
616 SCRIPTDIR (passed from Makefile)
617 the dir where this program is (for using it from the build tree)
618 the dir where this program is/../lib
619 (for installing the tool suite elsewhere) */
627 dir
= make_relative_prefix (program_name
, BINDIR
, SCRIPTDIR
);
628 if (dir
&& check_for_scripts_dir (dir
))
629 /* Success. Don't free dir. */
635 if (check_for_scripts_dir (SCRIPTDIR
))
636 /* We've been installed normally. */
639 /* Look for "ldscripts" in the dir where our binary is. */
640 end
= strrchr (program_name
, '/');
641 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
643 /* We could have \foo\bar, or /foo\bar. */
644 char *bslash
= strrchr (program_name
, '\\');
645 if (end
== NULL
|| (bslash
!= NULL
&& bslash
> end
))
652 /* Don't look for ldscripts in the current directory. There is
653 too much potential for confusion. */
657 dirlen
= end
- program_name
;
658 /* Make a copy of program_name in dir.
659 Leave room for later "/../lib". */
660 dir
= (char *) xmalloc (dirlen
+ 8);
661 strncpy (dir
, program_name
, dirlen
);
664 if (check_for_scripts_dir (dir
))
665 /* Don't free dir. */
668 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
669 strcpy (dir
+ dirlen
, "/../lib");
670 if (check_for_scripts_dir (dir
))
673 /* Well, we tried. */
681 if (link_info
.notice_hash
== (struct bfd_hash_table
*) NULL
)
683 link_info
.notice_hash
= ((struct bfd_hash_table
*)
684 xmalloc (sizeof (struct bfd_hash_table
)));
685 if (! bfd_hash_table_init_n (link_info
.notice_hash
,
688 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
691 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
)
692 == (struct bfd_hash_entry
*) NULL
)
693 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
696 /* Record a symbol to be wrapped, from the --wrap option. */
702 if (link_info
.wrap_hash
== NULL
)
704 link_info
.wrap_hash
= ((struct bfd_hash_table
*)
705 xmalloc (sizeof (struct bfd_hash_table
)));
706 if (! bfd_hash_table_init_n (link_info
.wrap_hash
,
709 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
711 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
712 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
715 /* Handle the -retain-symbols-file option. */
718 add_keepsyms_file (filename
)
719 const char *filename
;
726 if (link_info
.strip
== strip_some
)
727 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
729 file
= fopen (filename
, "r");
730 if (file
== (FILE *) NULL
)
732 bfd_set_error (bfd_error_system_call
);
733 einfo ("%X%P: %s: %E\n", filename
);
737 link_info
.keep_hash
= ((struct bfd_hash_table
*)
738 xmalloc (sizeof (struct bfd_hash_table
)));
739 if (! bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
))
740 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
743 buf
= (char *) xmalloc (bufsize
);
755 while (! ISSPACE (c
) && c
!= EOF
)
762 buf
= xrealloc (buf
, bufsize
);
769 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
)
770 == (struct bfd_hash_entry
*) NULL
)
771 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
775 if (link_info
.strip
!= strip_none
)
776 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
778 link_info
.strip
= strip_some
;
781 /* Callbacks from the BFD linker routines. */
783 /* This is called when BFD has decided to include an archive member in
787 add_archive_element (info
, abfd
, name
)
788 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
792 lang_input_statement_type
*input
;
794 input
= ((lang_input_statement_type
*)
795 xmalloc (sizeof (lang_input_statement_type
)));
796 input
->filename
= abfd
->filename
;
797 input
->local_sym_name
= abfd
->filename
;
798 input
->the_bfd
= abfd
;
799 input
->asymbols
= NULL
;
801 input
->just_syms_flag
= FALSE
;
802 input
->loaded
= FALSE
;
803 input
->search_dirs_flag
= FALSE
;
805 /* FIXME: The following fields are not set: header.next,
806 header.type, closed, passive_position, symbol_count,
807 next_real_file, is_archive, target, real. This bit of code is
808 from the old decode_library_subfile function. I don't know
809 whether any of those fields matters. */
811 ldlang_add_file (input
);
813 if (config
.map_file
!= (FILE *) NULL
)
815 static bfd_boolean header_printed
;
816 struct bfd_link_hash_entry
*h
;
820 h
= bfd_link_hash_lookup (link_info
.hash
, name
, FALSE
, FALSE
, TRUE
);
832 case bfd_link_hash_defined
:
833 case bfd_link_hash_defweak
:
834 from
= h
->u
.def
.section
->owner
;
837 case bfd_link_hash_undefined
:
838 case bfd_link_hash_undefweak
:
839 from
= h
->u
.undef
.abfd
;
842 case bfd_link_hash_common
:
843 from
= h
->u
.c
.p
->section
->owner
;
848 if (! header_printed
)
852 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
854 header_printed
= TRUE
;
857 if (bfd_my_archive (abfd
) == NULL
)
859 minfo ("%s", bfd_get_filename (abfd
));
860 len
= strlen (bfd_get_filename (abfd
));
864 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
865 bfd_get_filename (abfd
));
866 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
867 + strlen (bfd_get_filename (abfd
))
885 minfo ("(%T)\n", h
->root
.string
);
887 minfo ("(%s)\n", name
);
890 if (trace_files
|| trace_file_tries
)
891 info_msg ("%I\n", input
);
896 /* This is called when BFD has discovered a symbol which is defined
900 multiple_definition (info
, name
, obfd
, osec
, oval
, nbfd
, nsec
, nval
)
901 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
910 /* If either section has the output_section field set to
911 bfd_abs_section_ptr, it means that the section is being
912 discarded, and this is not really a multiple definition at all.
913 FIXME: It would be cleaner to somehow ignore symbols defined in
914 sections which are being discarded. */
915 if ((osec
->output_section
!= NULL
916 && ! bfd_is_abs_section (osec
)
917 && bfd_is_abs_section (osec
->output_section
))
918 || (nsec
->output_section
!= NULL
919 && ! bfd_is_abs_section (nsec
)
920 && bfd_is_abs_section (nsec
->output_section
)))
923 einfo (_("%X%C: multiple definition of `%T'\n"),
924 nbfd
, nsec
, nval
, name
);
925 if (obfd
!= (bfd
*) NULL
)
926 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
928 if (command_line
.relax
)
930 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
931 command_line
.relax
= 0;
937 /* This is called when there is a definition of a common symbol, or
938 when a common symbol is found for a symbol that is already defined,
939 or when two common symbols are found. We only do something if
940 -warn-common was used. */
943 multiple_common (info
, name
, obfd
, otype
, osize
, nbfd
, ntype
, nsize
)
944 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
947 enum bfd_link_hash_type otype
;
950 enum bfd_link_hash_type ntype
;
953 if (! config
.warn_common
)
956 if (ntype
== bfd_link_hash_defined
957 || ntype
== bfd_link_hash_defweak
958 || ntype
== bfd_link_hash_indirect
)
960 ASSERT (otype
== bfd_link_hash_common
);
961 einfo (_("%B: warning: definition of `%T' overriding common\n"),
964 einfo (_("%B: warning: common is here\n"), obfd
);
966 else if (otype
== bfd_link_hash_defined
967 || otype
== bfd_link_hash_defweak
968 || otype
== bfd_link_hash_indirect
)
970 ASSERT (ntype
== bfd_link_hash_common
);
971 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
974 einfo (_("%B: warning: defined here\n"), obfd
);
978 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
981 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
984 einfo (_("%B: warning: larger common is here\n"), obfd
);
986 else if (nsize
> osize
)
988 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
991 einfo (_("%B: warning: smaller common is here\n"), obfd
);
995 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
997 einfo (_("%B: warning: previous common is here\n"), obfd
);
1004 /* This is called when BFD has discovered a set element. H is the
1005 entry in the linker hash table for the set. SECTION and VALUE
1006 represent a value which should be added to the set. */
1009 add_to_set (info
, h
, reloc
, abfd
, section
, value
)
1010 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1011 struct bfd_link_hash_entry
*h
;
1012 bfd_reloc_code_real_type reloc
;
1017 if (config
.warn_constructors
)
1018 einfo (_("%P: warning: global constructor %s used\n"),
1021 if (! config
.build_constructors
)
1024 ldctor_add_set_entry (h
, reloc
, (const char *) NULL
, section
, value
);
1026 if (h
->type
== bfd_link_hash_new
)
1028 h
->type
= bfd_link_hash_undefined
;
1029 h
->u
.undef
.abfd
= abfd
;
1030 /* We don't call bfd_link_add_undef to add this to the list of
1031 undefined symbols because we are going to define it
1038 /* This is called when BFD has discovered a constructor. This is only
1039 called for some object file formats--those which do not handle
1040 constructors in some more clever fashion. This is similar to
1041 adding an element to a set, but less general. */
1044 constructor_callback (info
, constructor
, name
, abfd
, section
, value
)
1045 struct bfd_link_info
*info
;
1046 bfd_boolean constructor
;
1053 struct bfd_link_hash_entry
*h
;
1054 char set_name
[1 + sizeof "__CTOR_LIST__"];
1056 if (config
.warn_constructors
)
1057 einfo (_("%P: warning: global constructor %s used\n"), name
);
1059 if (! config
.build_constructors
)
1062 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1063 useful error message. */
1064 if (bfd_reloc_type_lookup (output_bfd
, BFD_RELOC_CTOR
) == NULL
1065 && (link_info
.relocateable
1066 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1067 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1070 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1071 *s
++ = bfd_get_symbol_leading_char (abfd
);
1073 strcpy (s
, "__CTOR_LIST__");
1075 strcpy (s
, "__DTOR_LIST__");
1077 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1078 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1079 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1080 if (h
->type
== bfd_link_hash_new
)
1082 h
->type
= bfd_link_hash_undefined
;
1083 h
->u
.undef
.abfd
= abfd
;
1084 /* We don't call bfd_link_add_undef to add this to the list of
1085 undefined symbols because we are going to define it
1089 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1093 /* A structure used by warning_callback to pass information through
1094 bfd_map_over_sections. */
1096 struct warning_callback_info
{
1098 const char *warning
;
1103 /* This is called when there is a reference to a warning symbol. */
1106 warning_callback (info
, warning
, symbol
, abfd
, section
, address
)
1107 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1108 const char *warning
;
1114 /* This is a hack to support warn_multiple_gp. FIXME: This should
1115 have a cleaner interface, but what? */
1116 if (! config
.warn_multiple_gp
1117 && strcmp (warning
, "using multiple gp values") == 0)
1120 if (section
!= NULL
)
1121 einfo ("%C: %s\n", abfd
, section
, address
, warning
);
1122 else if (abfd
== NULL
)
1123 einfo ("%P: %s\n", warning
);
1124 else if (symbol
== NULL
)
1125 einfo ("%B: %s\n", abfd
, warning
);
1128 lang_input_statement_type
*entry
;
1130 struct warning_callback_info info
;
1132 /* Look through the relocs to see if we can find a plausible
1135 entry
= (lang_input_statement_type
*) abfd
->usrdata
;
1136 if (entry
!= NULL
&& entry
->asymbols
!= NULL
)
1137 asymbols
= entry
->asymbols
;
1143 symsize
= bfd_get_symtab_upper_bound (abfd
);
1145 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1146 asymbols
= (asymbol
**) xmalloc (symsize
);
1147 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
1148 if (symbol_count
< 0)
1149 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1152 entry
->asymbols
= asymbols
;
1153 entry
->symbol_count
= symbol_count
;
1158 info
.warning
= warning
;
1159 info
.symbol
= symbol
;
1160 info
.asymbols
= asymbols
;
1161 bfd_map_over_sections (abfd
, warning_find_reloc
, (PTR
) &info
);
1164 einfo ("%B: %s\n", abfd
, warning
);
1173 /* This is called by warning_callback for each section. It checks the
1174 relocs of the section to see if it can find a reference to the
1175 symbol which triggered the warning. If it can, it uses the reloc
1176 to give an error message with a file and line number. */
1179 warning_find_reloc (abfd
, sec
, iarg
)
1184 struct warning_callback_info
*info
= (struct warning_callback_info
*) iarg
;
1188 arelent
**p
, **pend
;
1193 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1195 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1199 relpp
= (arelent
**) xmalloc (relsize
);
1200 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1202 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1205 pend
= p
+ relcount
;
1206 for (; p
< pend
&& *p
!= NULL
; p
++)
1210 if (q
->sym_ptr_ptr
!= NULL
1211 && *q
->sym_ptr_ptr
!= NULL
1212 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1214 /* We found a reloc for the symbol we are looking for. */
1215 einfo ("%C: %s\n", abfd
, sec
, q
->address
, info
->warning
);
1224 /* This is called when an undefined symbol is found. */
1227 undefined_symbol (info
, name
, abfd
, section
, address
, fatal
)
1228 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1233 bfd_boolean fatal ATTRIBUTE_UNUSED
;
1235 static char *error_name
;
1236 static unsigned int error_count
;
1238 #define MAX_ERRORS_IN_A_ROW 5
1240 if (config
.warn_once
)
1242 static struct bfd_hash_table
*hash
;
1244 /* Only warn once about a particular undefined symbol. */
1248 hash
= ((struct bfd_hash_table
*)
1249 xmalloc (sizeof (struct bfd_hash_table
)));
1250 if (! bfd_hash_table_init (hash
, bfd_hash_newfunc
))
1251 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1254 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1257 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1258 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1261 /* We never print more than a reasonable number of errors in a row
1262 for a single symbol. */
1263 if (error_name
!= (char *) NULL
1264 && strcmp (name
, error_name
) == 0)
1269 if (error_name
!= (char *) NULL
)
1271 error_name
= xstrdup (name
);
1274 if (section
!= NULL
)
1276 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1278 einfo (_("%C: undefined reference to `%T'\n"),
1279 abfd
, section
, address
, name
);
1283 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1284 einfo (_("%D: more undefined references to `%T' follow\n"),
1285 abfd
, section
, address
, name
);
1289 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1291 einfo (_("%B: undefined reference to `%T'\n"),
1296 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1297 einfo (_("%B: more undefined references to `%T' follow\n"),
1304 /* This is called when a reloc overflows. */
1307 reloc_overflow (info
, name
, reloc_name
, addend
, abfd
, section
, address
)
1308 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1310 const char *reloc_name
;
1316 if (abfd
== (bfd
*) NULL
)
1317 einfo (_("%P%X: generated"));
1319 einfo ("%X%C:", abfd
, section
, address
);
1320 einfo (_(" relocation truncated to fit: %s %T"), reloc_name
, name
);
1322 einfo ("+%v", addend
);
1327 /* This is called when a dangerous relocation is made. */
1330 reloc_dangerous (info
, message
, abfd
, section
, address
)
1331 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1332 const char *message
;
1337 if (abfd
== (bfd
*) NULL
)
1338 einfo (_("%P%X: generated"));
1340 einfo ("%X%C:", abfd
, section
, address
);
1341 einfo (_("dangerous relocation: %s\n"), message
);
1345 /* This is called when a reloc is being generated attached to a symbol
1346 that is not being output. */
1349 unattached_reloc (info
, name
, abfd
, section
, address
)
1350 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1356 if (abfd
== (bfd
*) NULL
)
1357 einfo (_("%P%X: generated"));
1359 einfo ("%X%C:", abfd
, section
, address
);
1360 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name
);
1364 /* This is called if link_info.notice_all is set, or when a symbol in
1365 link_info.notice_hash is found. Symbols are put in notice_hash
1366 using the -y option. */
1369 notice (info
, name
, abfd
, section
, value
)
1370 struct bfd_link_info
*info
;
1376 if (! info
->notice_all
1377 || (info
->notice_hash
!= NULL
1378 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
))
1380 if (bfd_is_und_section (section
))
1381 einfo ("%B: reference to %s\n", abfd
, name
);
1383 einfo ("%B: definition of %s\n", abfd
, name
);
1386 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1387 add_cref (name
, abfd
, section
, value
);