1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain steve@cygnus.com
7 This file is part of GLD, the Gnu Linker.
9 GLD is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GLD is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GLD; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
27 #include "safe-ctype.h"
28 #include "libiberty.h"
31 #include "filenames.h"
45 /* Somewhere above, sys/stat.h got included. */
46 #if !defined(S_ISDIR) && defined(S_IFDIR)
47 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
58 #ifndef TARGET_SYSTEM_ROOT
59 #define TARGET_SYSTEM_ROOT ""
65 const char *output_filename
= "a.out";
67 /* Name this program was invoked by. */
70 /* The prefix for system library directories. */
71 const char *ld_sysroot
;
73 /* The canonical representation of ld_sysroot. */
74 char * ld_canon_sysroot
;
75 int ld_canon_sysroot_len
;
77 /* The file that we're creating. */
80 /* Set by -G argument, for MIPS ECOFF target. */
81 int g_switch_value
= 8;
83 /* Nonzero means print names of input files as processed. */
84 bfd_boolean trace_files
;
86 /* Nonzero means same, but note open failures, too. */
87 bfd_boolean trace_file_tries
;
89 /* Nonzero means version number was printed, so exit successfully
90 instead of complaining if no input files are given. */
91 bfd_boolean version_printed
;
93 /* Nonzero means link in every member of an archive. */
94 bfd_boolean whole_archive
;
96 /* Nonzero means create DT_NEEDED entries only if a dynamic library
97 actually satisfies some reference in a regular object. */
98 bfd_boolean as_needed
;
100 /* Nonzero means never create DT_NEEDED entries for dynamic libraries
101 in DT_NEEDED tags. */
102 bfd_boolean add_needed
= TRUE
;
104 /* TRUE if we should demangle symbol names. */
105 bfd_boolean demangling
;
107 args_type command_line
;
109 ld_config_type config
;
111 sort_type sort_section
;
113 static const char *get_sysroot
115 static char *get_emulation
117 static void set_scripts_dir
119 static bfd_boolean add_archive_element
120 (struct bfd_link_info
*, bfd
*, const char *);
121 static bfd_boolean multiple_definition
122 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
123 bfd
*, asection
*, bfd_vma
);
124 static bfd_boolean multiple_common
125 (struct bfd_link_info
*, const char *, bfd
*, enum bfd_link_hash_type
,
126 bfd_vma
, bfd
*, enum bfd_link_hash_type
, bfd_vma
);
127 static bfd_boolean add_to_set
128 (struct bfd_link_info
*, struct bfd_link_hash_entry
*,
129 bfd_reloc_code_real_type
, bfd
*, asection
*, bfd_vma
);
130 static bfd_boolean constructor_callback
131 (struct bfd_link_info
*, bfd_boolean
, const char *, bfd
*,
132 asection
*, bfd_vma
);
133 static bfd_boolean warning_callback
134 (struct bfd_link_info
*, const char *, const char *, bfd
*,
135 asection
*, bfd_vma
);
136 static void warning_find_reloc
137 (bfd
*, asection
*, void *);
138 static bfd_boolean undefined_symbol
139 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
,
141 static bfd_boolean reloc_overflow
142 (struct bfd_link_info
*, struct bfd_link_hash_entry
*, const char *,
143 const char *, bfd_vma
, bfd
*, asection
*, bfd_vma
);
144 static bfd_boolean reloc_dangerous
145 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
146 static bfd_boolean unattached_reloc
147 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
148 static bfd_boolean notice
149 (struct bfd_link_info
*, const char *, bfd
*, asection
*, bfd_vma
);
151 static struct bfd_link_callbacks link_callbacks
=
157 constructor_callback
,
167 struct bfd_link_info link_info
;
175 bfd_cache_close (output_bfd
);
176 if (delete_output_file_on_failure
)
177 unlink_if_ordinary (output_filename
);
182 main (int argc
, char **argv
)
185 long start_time
= get_run_time ();
187 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
188 setlocale (LC_MESSAGES
, "");
190 #if defined (HAVE_SETLOCALE)
191 setlocale (LC_CTYPE
, "");
193 bindtextdomain (PACKAGE
, LOCALEDIR
);
194 textdomain (PACKAGE
);
196 program_name
= argv
[0];
197 xmalloc_set_program_name (program_name
);
199 START_PROGRESS (program_name
, 0);
201 expandargv (&argc
, &argv
);
205 bfd_set_error_program_name (program_name
);
207 xatexit (remove_output
);
209 /* Set up the sysroot directory. */
210 ld_sysroot
= get_sysroot (argc
, argv
);
213 if (*TARGET_SYSTEM_ROOT
== 0)
215 einfo ("%P%F: this linker was not configured to use sysroots\n");
219 ld_canon_sysroot
= lrealpath (ld_sysroot
);
221 if (ld_canon_sysroot
)
222 ld_canon_sysroot_len
= strlen (ld_canon_sysroot
);
224 ld_canon_sysroot_len
= -1;
226 /* Set the default BFD target based on the configured target. Doing
227 this permits the linker to be configured for a particular target,
228 and linked against a shared BFD library which was configured for
229 a different target. The macro TARGET is defined by Makefile. */
230 if (! bfd_set_default_target (TARGET
))
232 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET
);
243 /* Initialize the data about options. */
244 trace_files
= trace_file_tries
= version_printed
= FALSE
;
245 whole_archive
= FALSE
;
246 config
.build_constructors
= TRUE
;
247 config
.dynamic_link
= FALSE
;
248 config
.has_shared
= FALSE
;
249 config
.split_by_reloc
= (unsigned) -1;
250 config
.split_by_file
= (bfd_size_type
) -1;
251 config
.hash_table_size
= 0;
252 command_line
.force_common_definition
= FALSE
;
253 command_line
.inhibit_common_definition
= FALSE
;
254 command_line
.interpreter
= NULL
;
255 command_line
.rpath
= NULL
;
256 command_line
.warn_mismatch
= TRUE
;
257 command_line
.check_section_addresses
= TRUE
;
258 command_line
.accept_unknown_input_arch
= FALSE
;
262 /* We initialize DEMANGLING based on the environment variable
263 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
264 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
265 environment. Acting the same way here lets us provide the same
266 interface by default. */
267 demangling
= getenv ("COLLECT_NO_DEMANGLE") == NULL
;
269 link_info
.relocatable
= FALSE
;
270 link_info
.emitrelocations
= FALSE
;
271 link_info
.task_link
= FALSE
;
272 link_info
.shared
= FALSE
;
273 link_info
.pie
= FALSE
;
274 link_info
.executable
= FALSE
;
275 link_info
.symbolic
= FALSE
;
276 link_info
.export_dynamic
= FALSE
;
277 link_info
.static_link
= FALSE
;
278 link_info
.traditional_format
= FALSE
;
279 link_info
.optimize
= FALSE
;
280 link_info
.unresolved_syms_in_objects
= RM_NOT_YET_SET
;
281 link_info
.unresolved_syms_in_shared_libs
= RM_NOT_YET_SET
;
282 link_info
.allow_multiple_definition
= FALSE
;
283 link_info
.allow_undefined_version
= TRUE
;
284 link_info
.create_default_symver
= FALSE
;
285 link_info
.default_imported_symver
= FALSE
;
286 link_info
.keep_memory
= TRUE
;
287 link_info
.notice_all
= FALSE
;
288 link_info
.nocopyreloc
= FALSE
;
289 link_info
.new_dtags
= FALSE
;
290 link_info
.combreloc
= TRUE
;
291 link_info
.eh_frame_hdr
= FALSE
;
292 link_info
.relro
= FALSE
;
293 link_info
.strip_discarded
= TRUE
;
294 link_info
.strip
= strip_none
;
295 link_info
.discard
= discard_sec_merge
;
296 link_info
.common_skip_ar_aymbols
= bfd_link_common_skip_none
;
297 link_info
.callbacks
= &link_callbacks
;
298 link_info
.hash
= NULL
;
299 link_info
.keep_hash
= NULL
;
300 link_info
.notice_hash
= NULL
;
301 link_info
.wrap_hash
= NULL
;
302 link_info
.input_bfds
= NULL
;
303 link_info
.create_object_symbols_section
= NULL
;
304 link_info
.gc_sym_list
= NULL
;
305 link_info
.base_file
= NULL
;
306 link_info
.emit_hash
= TRUE
;
307 link_info
.emit_gnu_hash
= FALSE
;
308 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
309 and _fini symbols. We are compatible. */
310 link_info
.init_function
= "_init";
311 link_info
.fini_function
= "_fini";
312 link_info
.pei386_auto_import
= -1;
313 link_info
.pei386_runtime_pseudo_reloc
= FALSE
;
314 link_info
.spare_dynamic_tags
= 5;
316 link_info
.flags_1
= 0;
317 link_info
.relax_pass
= 1;
318 link_info
.warn_shared_textrel
= FALSE
;
319 link_info
.gc_sections
= FALSE
;
320 link_info
.print_gc_sections
= FALSE
;
321 link_info
.dynamic
= FALSE
;
322 link_info
.dynamic_list
= NULL
;
323 link_info
.dynamic_data
= FALSE
;
324 link_info
.reduce_memory_overheads
= FALSE
;
326 config
.maxpagesize
= 0;
327 config
.commonpagesize
= 0;
329 ldfile_add_arch ("");
331 config
.make_executable
= TRUE
;
332 force_make_executable
= FALSE
;
333 config
.magic_demand_paged
= TRUE
;
334 config
.text_read_only
= TRUE
;
336 emulation
= get_emulation (argc
, argv
);
337 ldemul_choose_mode (emulation
);
338 default_target
= ldemul_choose_target (argc
, argv
);
340 ldemul_before_parse ();
341 lang_has_input_file
= FALSE
;
342 parse_args (argc
, argv
);
344 if (config
.hash_table_size
!= 0)
345 bfd_hash_set_default_size (config
.hash_table_size
);
347 ldemul_set_symbols ();
349 if (link_info
.relocatable
)
351 if (link_info
.gc_sections
)
352 einfo ("%P%F: --gc-sections and -r may not be used together\n");
353 else if (command_line
.relax
)
354 einfo (_("%P%F: --relax and -r may not be used together\n"));
355 if (link_info
.shared
)
356 einfo (_("%P%F: -r and -shared may not be used together\n"));
359 if (! link_info
.shared
)
361 if (command_line
.filter_shlib
)
362 einfo (_("%P%F: -F may not be used without -shared\n"));
363 if (command_line
.auxiliary_filters
)
364 einfo (_("%P%F: -f may not be used without -shared\n"));
367 if (! link_info
.shared
|| link_info
.pie
)
368 link_info
.executable
= TRUE
;
370 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
371 don't see how else this can be handled, since in this case we
372 must preserve all externally visible symbols. */
373 if (link_info
.relocatable
&& link_info
.strip
== strip_all
)
375 link_info
.strip
= strip_debugger
;
376 if (link_info
.discard
== discard_sec_merge
)
377 link_info
.discard
= discard_all
;
380 /* This essentially adds another -L directory so this must be done after
381 the -L's in argv have been processed. */
384 /* If we have not already opened and parsed a linker script,
385 try the default script from command line first. */
386 if (saved_script_handle
== NULL
387 && command_line
.default_script
!= NULL
)
389 ldfile_open_command_file (command_line
.default_script
);
390 parser_input
= input_script
;
394 /* If we have not already opened and parsed a linker script
395 read the emulation's appropriate default script. */
396 if (saved_script_handle
== NULL
)
399 char *s
= ldemul_get_script (&isfile
);
402 ldfile_open_command_file (s
);
408 parser_input
= input_script
;
413 if (trace_file_tries
)
415 if (saved_script_handle
)
416 info_msg (_("using external linker script:"));
418 info_msg (_("using internal linker script:"));
419 info_msg ("\n==================================================\n");
421 if (saved_script_handle
)
423 static const int ld_bufsz
= 8193;
425 char *buf
= xmalloc (ld_bufsz
);
427 rewind (saved_script_handle
);
428 while ((n
= fread (buf
, 1, ld_bufsz
- 1, saved_script_handle
)) > 0)
433 rewind (saved_script_handle
);
440 info_msg (ldemul_get_script (&isfile
));
443 info_msg ("\n==================================================\n");
448 if (!lang_has_input_file
)
452 einfo (_("%P%F: no input files\n"));
456 info_msg (_("%P: mode %s\n"), emulation
);
458 ldemul_after_parse ();
460 if (config
.map_filename
)
462 if (strcmp (config
.map_filename
, "-") == 0)
464 config
.map_file
= stdout
;
468 config
.map_file
= fopen (config
.map_filename
, FOPEN_WT
);
469 if (config
.map_file
== (FILE *) NULL
)
471 bfd_set_error (bfd_error_system_call
);
472 einfo (_("%P%F: cannot open map file %s: %E\n"),
473 config
.map_filename
);
480 /* Print error messages for any missing symbols, for any warning
481 symbols, and possibly multiple definitions. */
482 if (link_info
.relocatable
)
483 output_bfd
->flags
&= ~EXEC_P
;
485 output_bfd
->flags
|= EXEC_P
;
489 if (config
.map_file
!= NULL
)
491 if (command_line
.cref
)
492 output_cref (config
.map_file
!= NULL
? config
.map_file
: stdout
);
493 if (nocrossref_list
!= NULL
)
494 check_nocrossrefs ();
498 /* Even if we're producing relocatable output, some non-fatal errors should
499 be reported in the exit status. (What non-fatal errors, if any, do we
500 want to ignore for relocatable output?) */
501 if (!config
.make_executable
&& !force_make_executable
)
504 einfo (_("%P: link errors found, deleting executable `%s'\n"),
507 /* The file will be removed by remove_output. */
512 if (! bfd_close (output_bfd
))
513 einfo (_("%F%B: final close failed: %E\n"), output_bfd
);
515 /* If the --force-exe-suffix is enabled, and we're making an
516 executable file and it doesn't end in .exe, copy it to one
518 if (! link_info
.relocatable
&& command_line
.force_exe_suffix
)
520 int len
= strlen (output_filename
);
523 || (strcasecmp (output_filename
+ len
- 4, ".exe") != 0
524 && strcasecmp (output_filename
+ len
- 4, ".dll") != 0))
528 const int bsize
= 4096;
529 char *buf
= xmalloc (bsize
);
531 char *dst_name
= xmalloc (len
+ 5);
533 strcpy (dst_name
, output_filename
);
534 strcat (dst_name
, ".exe");
535 src
= fopen (output_filename
, FOPEN_RB
);
536 dst
= fopen (dst_name
, FOPEN_WB
);
539 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
542 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
544 while ((l
= fread (buf
, 1, bsize
, src
)) > 0)
546 int done
= fwrite (buf
, 1, l
, dst
);
549 einfo (_("%P: Error writing file `%s'\n"), dst_name
);
553 if (fclose (dst
) == EOF
)
554 einfo (_("%P: Error closing file `%s'\n"), dst_name
);
561 END_PROGRESS (program_name
);
566 char *lim
= sbrk (0);
568 long run_time
= get_run_time () - start_time
;
570 fprintf (stderr
, _("%s: total time in link: %ld.%06ld\n"),
571 program_name
, run_time
/ 1000000, run_time
% 1000000);
573 fprintf (stderr
, _("%s: data size %ld\n"), program_name
,
574 (long) (lim
- (char *) &environ
));
578 /* Prevent remove_output from doing anything, after a successful link. */
579 output_filename
= NULL
;
585 /* If the configured sysroot is relocatable, try relocating it based on
586 default prefix FROM. Return the relocated directory if it exists,
587 otherwise return null. */
590 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED
)
592 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
596 path
= make_relative_prefix (program_name
, from
, TARGET_SYSTEM_ROOT
);
599 if (stat (path
, &s
) == 0 && S_ISDIR (s
.st_mode
))
607 /* Return the sysroot directory. Return "" if no sysroot is being used. */
610 get_sysroot (int argc
, char **argv
)
615 for (i
= 1; i
< argc
; i
++)
616 if (CONST_STRNEQ (argv
[i
], "--sysroot="))
617 return argv
[i
] + strlen ("--sysroot=");
619 path
= get_relative_sysroot (BINDIR
);
623 path
= get_relative_sysroot (TOOLBINDIR
);
627 return TARGET_SYSTEM_ROOT
;
630 /* We need to find any explicitly given emulation in order to initialize the
631 state that's needed by the lex&yacc argument parser (parse_args). */
634 get_emulation (int argc
, char **argv
)
639 emulation
= getenv (EMULATION_ENVIRON
);
640 if (emulation
== NULL
)
641 emulation
= DEFAULT_EMULATION
;
643 for (i
= 1; i
< argc
; i
++)
645 if (CONST_STRNEQ (argv
[i
], "-m"))
647 if (argv
[i
][2] == '\0')
652 emulation
= argv
[i
+ 1];
656 einfo (_("%P%F: missing argument to -m\n"));
658 else if (strcmp (argv
[i
], "-mips1") == 0
659 || strcmp (argv
[i
], "-mips2") == 0
660 || strcmp (argv
[i
], "-mips3") == 0
661 || strcmp (argv
[i
], "-mips4") == 0
662 || strcmp (argv
[i
], "-mips5") == 0
663 || strcmp (argv
[i
], "-mips32") == 0
664 || strcmp (argv
[i
], "-mips32r2") == 0
665 || strcmp (argv
[i
], "-mips64") == 0
666 || strcmp (argv
[i
], "-mips64r2") == 0)
668 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
669 passed to the linker by some MIPS compilers. They
670 generally tell the linker to use a slightly different
671 library path. Perhaps someday these should be
672 implemented as emulations; until then, we just ignore
673 the arguments and hope that nobody ever creates
674 emulations named ips1, ips2 or ips3. */
676 else if (strcmp (argv
[i
], "-m486") == 0)
678 /* FIXME: The argument -m486 is passed to the linker on
679 some Linux systems. Hope that nobody creates an
680 emulation named 486. */
685 emulation
= &argv
[i
][2];
693 /* If directory DIR contains an "ldscripts" subdirectory,
694 add DIR to the library search path and return TRUE,
695 else return FALSE. */
698 check_for_scripts_dir (char *dir
)
705 dirlen
= strlen (dir
);
706 /* sizeof counts the terminating NUL. */
707 buf
= xmalloc (dirlen
+ sizeof ("/ldscripts"));
708 sprintf (buf
, "%s/ldscripts", dir
);
710 res
= stat (buf
, &s
) == 0 && S_ISDIR (s
.st_mode
);
713 ldfile_add_library_path (dir
, FALSE
);
717 /* Set the default directory for finding script files.
718 Libraries will be searched for here too, but that's ok.
719 We look for the "ldscripts" directory in:
721 SCRIPTDIR (passed from Makefile)
722 (adjusted according to the current location of the binary)
723 SCRIPTDIR (passed from Makefile)
724 the dir where this program is (for using it from the build tree)
725 the dir where this program is/../lib
726 (for installing the tool suite elsewhere). */
729 set_scripts_dir (void)
735 dir
= make_relative_prefix (program_name
, BINDIR
, SCRIPTDIR
);
738 found
= check_for_scripts_dir (dir
);
744 dir
= make_relative_prefix (program_name
, TOOLBINDIR
, SCRIPTDIR
);
747 found
= check_for_scripts_dir (dir
);
753 if (check_for_scripts_dir (SCRIPTDIR
))
754 /* We've been installed normally. */
757 /* Look for "ldscripts" in the dir where our binary is. */
758 end
= strrchr (program_name
, '/');
759 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
761 /* We could have \foo\bar, or /foo\bar. */
762 char *bslash
= strrchr (program_name
, '\\');
764 if (end
== NULL
|| (bslash
!= NULL
&& bslash
> end
))
770 /* Don't look for ldscripts in the current directory. There is
771 too much potential for confusion. */
774 dirlen
= end
- program_name
;
775 /* Make a copy of program_name in dir.
776 Leave room for later "/../lib". */
777 dir
= xmalloc (dirlen
+ 8);
778 strncpy (dir
, program_name
, dirlen
);
781 if (check_for_scripts_dir (dir
))
787 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
788 strcpy (dir
+ dirlen
, "/../lib");
789 check_for_scripts_dir (dir
);
794 add_ysym (const char *name
)
796 if (link_info
.notice_hash
== NULL
)
798 link_info
.notice_hash
= xmalloc (sizeof (struct bfd_hash_table
));
799 if (!bfd_hash_table_init_n (link_info
.notice_hash
,
801 sizeof (struct bfd_hash_entry
),
803 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
806 if (bfd_hash_lookup (link_info
.notice_hash
, name
, TRUE
, TRUE
) == NULL
)
807 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
810 /* Record a symbol to be wrapped, from the --wrap option. */
813 add_wrap (const char *name
)
815 if (link_info
.wrap_hash
== NULL
)
817 link_info
.wrap_hash
= xmalloc (sizeof (struct bfd_hash_table
));
818 if (!bfd_hash_table_init_n (link_info
.wrap_hash
,
820 sizeof (struct bfd_hash_entry
),
822 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
825 if (bfd_hash_lookup (link_info
.wrap_hash
, name
, TRUE
, TRUE
) == NULL
)
826 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
829 /* Handle the -retain-symbols-file option. */
832 add_keepsyms_file (const char *filename
)
839 if (link_info
.strip
== strip_some
)
840 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
842 file
= fopen (filename
, "r");
845 bfd_set_error (bfd_error_system_call
);
846 einfo ("%X%P: %s: %E\n", filename
);
850 link_info
.keep_hash
= xmalloc (sizeof (struct bfd_hash_table
));
851 if (!bfd_hash_table_init (link_info
.keep_hash
, bfd_hash_newfunc
,
852 sizeof (struct bfd_hash_entry
)))
853 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
856 buf
= xmalloc (bufsize
);
868 while (! ISSPACE (c
) && c
!= EOF
)
875 buf
= xrealloc (buf
, bufsize
);
882 if (bfd_hash_lookup (link_info
.keep_hash
, buf
, TRUE
, TRUE
) == NULL
)
883 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
887 if (link_info
.strip
!= strip_none
)
888 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
891 link_info
.strip
= strip_some
;
894 /* Callbacks from the BFD linker routines. */
896 /* This is called when BFD has decided to include an archive member in
900 add_archive_element (struct bfd_link_info
*info
,
904 lang_input_statement_type
*input
;
906 input
= xmalloc (sizeof (lang_input_statement_type
));
907 input
->filename
= abfd
->filename
;
908 input
->local_sym_name
= abfd
->filename
;
909 input
->the_bfd
= abfd
;
910 input
->asymbols
= NULL
;
912 input
->just_syms_flag
= FALSE
;
913 input
->loaded
= FALSE
;
914 input
->search_dirs_flag
= FALSE
;
916 /* FIXME: The following fields are not set: header.next,
917 header.type, closed, passive_position, symbol_count,
918 next_real_file, is_archive, target, real. This bit of code is
919 from the old decode_library_subfile function. I don't know
920 whether any of those fields matters. */
922 ldlang_add_file (input
);
924 if (config
.map_file
!= NULL
)
926 static bfd_boolean header_printed
;
927 struct bfd_link_hash_entry
*h
;
931 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
943 case bfd_link_hash_defined
:
944 case bfd_link_hash_defweak
:
945 from
= h
->u
.def
.section
->owner
;
948 case bfd_link_hash_undefined
:
949 case bfd_link_hash_undefweak
:
950 from
= h
->u
.undef
.abfd
;
953 case bfd_link_hash_common
:
954 from
= h
->u
.c
.p
->section
->owner
;
959 if (! header_printed
)
963 sprintf (buf
, _("Archive member included because of file (symbol)\n\n"));
965 header_printed
= TRUE
;
968 if (bfd_my_archive (abfd
) == NULL
)
970 minfo ("%s", bfd_get_filename (abfd
));
971 len
= strlen (bfd_get_filename (abfd
));
975 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd
)),
976 bfd_get_filename (abfd
));
977 len
= (strlen (bfd_get_filename (bfd_my_archive (abfd
)))
978 + strlen (bfd_get_filename (abfd
))
996 minfo ("(%T)\n", h
->root
.string
);
998 minfo ("(%s)\n", name
);
1001 if (trace_files
|| trace_file_tries
)
1002 info_msg ("%I\n", input
);
1007 /* This is called when BFD has discovered a symbol which is defined
1011 multiple_definition (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1020 /* If either section has the output_section field set to
1021 bfd_abs_section_ptr, it means that the section is being
1022 discarded, and this is not really a multiple definition at all.
1023 FIXME: It would be cleaner to somehow ignore symbols defined in
1024 sections which are being discarded. */
1025 if ((osec
->output_section
!= NULL
1026 && ! bfd_is_abs_section (osec
)
1027 && bfd_is_abs_section (osec
->output_section
))
1028 || (nsec
->output_section
!= NULL
1029 && ! bfd_is_abs_section (nsec
)
1030 && bfd_is_abs_section (nsec
->output_section
)))
1033 einfo (_("%X%C: multiple definition of `%T'\n"),
1034 nbfd
, nsec
, nval
, name
);
1036 einfo (_("%D: first defined here\n"), obfd
, osec
, oval
);
1038 if (command_line
.relax
)
1040 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
1041 command_line
.relax
= 0;
1047 /* This is called when there is a definition of a common symbol, or
1048 when a common symbol is found for a symbol that is already defined,
1049 or when two common symbols are found. We only do something if
1050 -warn-common was used. */
1053 multiple_common (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1056 enum bfd_link_hash_type otype
,
1059 enum bfd_link_hash_type ntype
,
1062 if (! config
.warn_common
)
1065 if (ntype
== bfd_link_hash_defined
1066 || ntype
== bfd_link_hash_defweak
1067 || ntype
== bfd_link_hash_indirect
)
1069 ASSERT (otype
== bfd_link_hash_common
);
1070 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1073 einfo (_("%B: warning: common is here\n"), obfd
);
1075 else if (otype
== bfd_link_hash_defined
1076 || otype
== bfd_link_hash_defweak
1077 || otype
== bfd_link_hash_indirect
)
1079 ASSERT (ntype
== bfd_link_hash_common
);
1080 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1083 einfo (_("%B: warning: defined here\n"), obfd
);
1087 ASSERT (otype
== bfd_link_hash_common
&& ntype
== bfd_link_hash_common
);
1090 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1093 einfo (_("%B: warning: larger common is here\n"), obfd
);
1095 else if (nsize
> osize
)
1097 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1100 einfo (_("%B: warning: smaller common is here\n"), obfd
);
1104 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd
, name
);
1106 einfo (_("%B: warning: previous common is here\n"), obfd
);
1113 /* This is called when BFD has discovered a set element. H is the
1114 entry in the linker hash table for the set. SECTION and VALUE
1115 represent a value which should be added to the set. */
1118 add_to_set (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1119 struct bfd_link_hash_entry
*h
,
1120 bfd_reloc_code_real_type reloc
,
1125 if (config
.warn_constructors
)
1126 einfo (_("%P: warning: global constructor %s used\n"),
1129 if (! config
.build_constructors
)
1132 ldctor_add_set_entry (h
, reloc
, NULL
, section
, value
);
1134 if (h
->type
== bfd_link_hash_new
)
1136 h
->type
= bfd_link_hash_undefined
;
1137 h
->u
.undef
.abfd
= abfd
;
1138 /* We don't call bfd_link_add_undef to add this to the list of
1139 undefined symbols because we are going to define it
1146 /* This is called when BFD has discovered a constructor. This is only
1147 called for some object file formats--those which do not handle
1148 constructors in some more clever fashion. This is similar to
1149 adding an element to a set, but less general. */
1152 constructor_callback (struct bfd_link_info
*info
,
1153 bfd_boolean constructor
,
1160 struct bfd_link_hash_entry
*h
;
1161 char set_name
[1 + sizeof "__CTOR_LIST__"];
1163 if (config
.warn_constructors
)
1164 einfo (_("%P: warning: global constructor %s used\n"), name
);
1166 if (! config
.build_constructors
)
1169 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1170 useful error message. */
1171 if (bfd_reloc_type_lookup (output_bfd
, BFD_RELOC_CTOR
) == NULL
1172 && (info
->relocatable
1173 || bfd_reloc_type_lookup (abfd
, BFD_RELOC_CTOR
) == NULL
))
1174 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1177 if (bfd_get_symbol_leading_char (abfd
) != '\0')
1178 *s
++ = bfd_get_symbol_leading_char (abfd
);
1180 strcpy (s
, "__CTOR_LIST__");
1182 strcpy (s
, "__DTOR_LIST__");
1184 h
= bfd_link_hash_lookup (info
->hash
, set_name
, TRUE
, TRUE
, TRUE
);
1185 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1186 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1187 if (h
->type
== bfd_link_hash_new
)
1189 h
->type
= bfd_link_hash_undefined
;
1190 h
->u
.undef
.abfd
= abfd
;
1191 /* We don't call bfd_link_add_undef to add this to the list of
1192 undefined symbols because we are going to define it
1196 ldctor_add_set_entry (h
, BFD_RELOC_CTOR
, name
, section
, value
);
1200 /* A structure used by warning_callback to pass information through
1201 bfd_map_over_sections. */
1203 struct warning_callback_info
1206 const char *warning
;
1211 /* This is called when there is a reference to a warning symbol. */
1214 warning_callback (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1215 const char *warning
,
1221 /* This is a hack to support warn_multiple_gp. FIXME: This should
1222 have a cleaner interface, but what? */
1223 if (! config
.warn_multiple_gp
1224 && strcmp (warning
, "using multiple gp values") == 0)
1227 if (section
!= NULL
)
1228 einfo ("%C: %s%s\n", abfd
, section
, address
, _("warning: "), warning
);
1229 else if (abfd
== NULL
)
1230 einfo ("%P: %s%s\n", _("warning: "), warning
);
1231 else if (symbol
== NULL
)
1232 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1235 lang_input_statement_type
*entry
;
1237 struct warning_callback_info info
;
1239 /* Look through the relocs to see if we can find a plausible
1241 entry
= (lang_input_statement_type
*) abfd
->usrdata
;
1242 if (entry
!= NULL
&& entry
->asymbols
!= NULL
)
1243 asymbols
= entry
->asymbols
;
1249 symsize
= bfd_get_symtab_upper_bound (abfd
);
1251 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1252 asymbols
= xmalloc (symsize
);
1253 symbol_count
= bfd_canonicalize_symtab (abfd
, asymbols
);
1254 if (symbol_count
< 0)
1255 einfo (_("%B%F: could not read symbols: %E\n"), abfd
);
1258 entry
->asymbols
= asymbols
;
1259 entry
->symbol_count
= symbol_count
;
1264 info
.warning
= warning
;
1265 info
.symbol
= symbol
;
1266 info
.asymbols
= asymbols
;
1267 bfd_map_over_sections (abfd
, warning_find_reloc
, &info
);
1270 einfo ("%B: %s%s\n", abfd
, _("warning: "), warning
);
1279 /* This is called by warning_callback for each section. It checks the
1280 relocs of the section to see if it can find a reference to the
1281 symbol which triggered the warning. If it can, it uses the reloc
1282 to give an error message with a file and line number. */
1285 warning_find_reloc (bfd
*abfd
, asection
*sec
, void *iarg
)
1287 struct warning_callback_info
*info
= iarg
;
1291 arelent
**p
, **pend
;
1296 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
1298 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1302 relpp
= xmalloc (relsize
);
1303 relcount
= bfd_canonicalize_reloc (abfd
, sec
, relpp
, info
->asymbols
);
1305 einfo (_("%B%F: could not read relocs: %E\n"), abfd
);
1308 pend
= p
+ relcount
;
1309 for (; p
< pend
&& *p
!= NULL
; p
++)
1313 if (q
->sym_ptr_ptr
!= NULL
1314 && *q
->sym_ptr_ptr
!= NULL
1315 && strcmp (bfd_asymbol_name (*q
->sym_ptr_ptr
), info
->symbol
) == 0)
1317 /* We found a reloc for the symbol we are looking for. */
1318 einfo ("%C: %s%s\n", abfd
, sec
, q
->address
, _("warning: "),
1328 /* This is called when an undefined symbol is found. */
1331 undefined_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1338 static char *error_name
;
1339 static unsigned int error_count
;
1341 #define MAX_ERRORS_IN_A_ROW 5
1343 if (config
.warn_once
)
1345 static struct bfd_hash_table
*hash
;
1347 /* Only warn once about a particular undefined symbol. */
1350 hash
= xmalloc (sizeof (struct bfd_hash_table
));
1351 if (!bfd_hash_table_init (hash
, bfd_hash_newfunc
,
1352 sizeof (struct bfd_hash_entry
)))
1353 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1356 if (bfd_hash_lookup (hash
, name
, FALSE
, FALSE
) != NULL
)
1359 if (bfd_hash_lookup (hash
, name
, TRUE
, TRUE
) == NULL
)
1360 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1363 /* We never print more than a reasonable number of errors in a row
1364 for a single symbol. */
1365 if (error_name
!= NULL
1366 && strcmp (name
, error_name
) == 0)
1371 if (error_name
!= NULL
)
1373 error_name
= xstrdup (name
);
1376 if (section
!= NULL
)
1378 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1381 einfo (_("%X%C: undefined reference to `%T'\n"),
1382 abfd
, section
, address
, name
);
1384 einfo (_("%C: warning: undefined reference to `%T'\n"),
1385 abfd
, section
, address
, name
);
1387 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1390 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1391 abfd
, section
, address
, name
);
1393 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1394 abfd
, section
, address
, name
);
1401 if (error_count
< MAX_ERRORS_IN_A_ROW
)
1404 einfo (_("%X%B: undefined reference to `%T'\n"),
1407 einfo (_("%B: warning: undefined reference to `%T'\n"),
1410 else if (error_count
== MAX_ERRORS_IN_A_ROW
)
1413 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1416 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1426 /* Counter to limit the number of relocation overflow error messages
1427 to print. Errors are printed as it is decremented. When it's
1428 called and the counter is zero, a final message is printed
1429 indicating more relocations were omitted. When it gets to -1, no
1430 such errors are printed. If it's initially set to a value less
1431 than -1, all such errors will be printed (--verbose does this). */
1433 int overflow_cutoff_limit
= 10;
1435 /* This is called when a reloc overflows. */
1438 reloc_overflow (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1439 struct bfd_link_hash_entry
*entry
,
1441 const char *reloc_name
,
1447 if (overflow_cutoff_limit
== -1)
1450 einfo ("%X%C:", abfd
, section
, address
);
1452 if (overflow_cutoff_limit
>= 0
1453 && overflow_cutoff_limit
-- == 0)
1455 einfo (_(" additional relocation overflows omitted from the output\n"));
1461 while (entry
->type
== bfd_link_hash_indirect
1462 || entry
->type
== bfd_link_hash_warning
)
1463 entry
= entry
->u
.i
.link
;
1464 switch (entry
->type
)
1466 case bfd_link_hash_undefined
:
1467 case bfd_link_hash_undefweak
:
1468 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1469 reloc_name
, entry
->root
.string
);
1471 case bfd_link_hash_defined
:
1472 case bfd_link_hash_defweak
:
1473 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1474 reloc_name
, entry
->root
.string
,
1475 entry
->u
.def
.section
,
1476 entry
->u
.def
.section
== bfd_abs_section_ptr
1477 ? output_bfd
: entry
->u
.def
.section
->owner
);
1485 einfo (_(" relocation truncated to fit: %s against `%T'"),
1488 einfo ("+%v", addend
);
1493 /* This is called when a dangerous relocation is made. */
1496 reloc_dangerous (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1497 const char *message
,
1502 einfo (_("%X%C: dangerous relocation: %s\n"),
1503 abfd
, section
, address
, message
);
1507 /* This is called when a reloc is being generated attached to a symbol
1508 that is not being output. */
1511 unattached_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1517 einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1518 abfd
, section
, address
, name
);
1522 /* This is called if link_info.notice_all is set, or when a symbol in
1523 link_info.notice_hash is found. Symbols are put in notice_hash
1524 using the -y option. */
1527 notice (struct bfd_link_info
*info
,
1535 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1536 return handle_asneeded_cref (abfd
, value
);
1540 if (! info
->notice_all
1541 || (info
->notice_hash
!= NULL
1542 && bfd_hash_lookup (info
->notice_hash
, name
, FALSE
, FALSE
) != NULL
))
1544 if (bfd_is_und_section (section
))
1545 einfo ("%B: reference to %s\n", abfd
, name
);
1547 einfo ("%B: definition of %s\n", abfd
, name
);
1550 if (command_line
.cref
|| nocrossref_list
!= NULL
)
1551 add_cref (name
, abfd
, section
, value
);