Initialise value to zero to avoid a compile time warning.
[binutils.git] / ld / ldmain.c
blob0fce8bf62addb34074b2e2b1c341aa9f4cc90981
1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005
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)
12 any later version.
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
22 02111-1307, USA. */
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include <stdio.h>
27 #include "safe-ctype.h"
28 #include "libiberty.h"
29 #include "progress.h"
30 #include "bfdlink.h"
31 #include "filenames.h"
33 #include "ld.h"
34 #include "ldmain.h"
35 #include "ldmisc.h"
36 #include "ldwrite.h"
37 #include "ldexp.h"
38 #include "ldlang.h"
39 #include <ldgram.h>
40 #include "ldlex.h"
41 #include "ldfile.h"
42 #include "ldemul.h"
43 #include "ldctor.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)
48 #endif
50 #include <string.h>
52 #ifdef HAVE_SBRK
53 #ifdef NEED_DECLARATION_SBRK
54 extern void *sbrk ();
55 #endif
56 #endif
58 #ifndef TARGET_SYSTEM_ROOT
59 #define TARGET_SYSTEM_ROOT ""
60 #endif
62 /* EXPORTS */
64 char *default_target;
65 const char *output_filename = "a.out";
67 /* Name this program was invoked by. */
68 char *program_name;
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. */
78 bfd *output_bfd = 0;
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
114 (int, char **);
115 static char *get_emulation
116 (int, char **);
117 static void set_scripts_dir
118 (void);
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,
140 bfd_boolean);
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 =
153 add_archive_element,
154 multiple_definition,
155 multiple_common,
156 add_to_set,
157 constructor_callback,
158 warning_callback,
159 undefined_symbol,
160 reloc_overflow,
161 reloc_dangerous,
162 unattached_reloc,
163 notice
166 struct bfd_link_info link_info;
168 static void
169 remove_output (void)
171 if (output_filename)
173 if (output_bfd)
174 bfd_cache_close (output_bfd);
175 if (delete_output_file_on_failure)
176 unlink_if_ordinary (output_filename);
181 main (int argc, char **argv)
183 char *emulation;
184 long start_time = get_run_time ();
186 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
187 setlocale (LC_MESSAGES, "");
188 #endif
189 #if defined (HAVE_SETLOCALE)
190 setlocale (LC_CTYPE, "");
191 #endif
192 bindtextdomain (PACKAGE, LOCALEDIR);
193 textdomain (PACKAGE);
195 program_name = argv[0];
196 xmalloc_set_program_name (program_name);
198 START_PROGRESS (program_name, 0);
200 bfd_init ();
202 bfd_set_error_program_name (program_name);
204 xatexit (remove_output);
206 /* Set up the sysroot directory. */
207 ld_sysroot = get_sysroot (argc, argv);
208 if (*ld_sysroot)
210 if (*TARGET_SYSTEM_ROOT == 0)
212 einfo ("%P%F: this linker was not configured to use sysroots");
213 ld_sysroot = "";
215 else
216 ld_canon_sysroot = lrealpath (ld_sysroot);
218 if (ld_canon_sysroot)
219 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
220 else
221 ld_canon_sysroot_len = -1;
223 /* Set the default BFD target based on the configured target. Doing
224 this permits the linker to be configured for a particular target,
225 and linked against a shared BFD library which was configured for
226 a different target. The macro TARGET is defined by Makefile. */
227 if (! bfd_set_default_target (TARGET))
229 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
230 xexit (1);
233 #if YYDEBUG
235 extern int yydebug;
236 yydebug = 1;
238 #endif
240 /* Initialize the data about options. */
241 trace_files = trace_file_tries = version_printed = FALSE;
242 whole_archive = FALSE;
243 config.build_constructors = TRUE;
244 config.dynamic_link = FALSE;
245 config.has_shared = FALSE;
246 config.split_by_reloc = (unsigned) -1;
247 config.split_by_file = (bfd_size_type) -1;
248 config.hash_table_size = 0;
249 command_line.force_common_definition = FALSE;
250 command_line.inhibit_common_definition = FALSE;
251 command_line.interpreter = NULL;
252 command_line.rpath = NULL;
253 command_line.warn_mismatch = TRUE;
254 command_line.check_section_addresses = TRUE;
255 command_line.accept_unknown_input_arch = FALSE;
256 command_line.reduce_memory_overheads = FALSE;
258 sort_section = none;
260 /* We initialize DEMANGLING based on the environment variable
261 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
262 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
263 environment. Acting the same way here lets us provide the same
264 interface by default. */
265 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
267 link_info.relocatable = FALSE;
268 link_info.emitrelocations = FALSE;
269 link_info.task_link = FALSE;
270 link_info.shared = FALSE;
271 link_info.pie = FALSE;
272 link_info.executable = FALSE;
273 link_info.symbolic = FALSE;
274 link_info.export_dynamic = FALSE;
275 link_info.static_link = FALSE;
276 link_info.traditional_format = FALSE;
277 link_info.optimize = FALSE;
278 link_info.unresolved_syms_in_objects = RM_NOT_YET_SET;
279 link_info.unresolved_syms_in_shared_libs = RM_NOT_YET_SET;
280 link_info.allow_multiple_definition = FALSE;
281 link_info.allow_undefined_version = TRUE;
282 link_info.create_default_symver = FALSE;
283 link_info.default_imported_symver = FALSE;
284 link_info.keep_memory = TRUE;
285 link_info.notice_all = FALSE;
286 link_info.nocopyreloc = FALSE;
287 link_info.new_dtags = FALSE;
288 link_info.combreloc = TRUE;
289 link_info.eh_frame_hdr = FALSE;
290 link_info.relro = FALSE;
291 link_info.strip_discarded = TRUE;
292 link_info.strip = strip_none;
293 link_info.discard = discard_sec_merge;
294 link_info.common_skip_ar_aymbols = bfd_link_common_skip_none;
295 link_info.callbacks = &link_callbacks;
296 link_info.hash = NULL;
297 link_info.keep_hash = NULL;
298 link_info.notice_hash = NULL;
299 link_info.wrap_hash = NULL;
300 link_info.input_bfds = NULL;
301 link_info.create_object_symbols_section = NULL;
302 link_info.gc_sym_list = NULL;
303 link_info.base_file = NULL;
304 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
305 and _fini symbols. We are compatible. */
306 link_info.init_function = "_init";
307 link_info.fini_function = "_fini";
308 link_info.pei386_auto_import = -1;
309 link_info.pei386_runtime_pseudo_reloc = FALSE;
310 link_info.spare_dynamic_tags = 5;
311 link_info.flags = 0;
312 link_info.flags_1 = 0;
313 link_info.need_relax_finalize = FALSE;
314 link_info.warn_shared_textrel = FALSE;
315 link_info.gc_sections = FALSE;
317 ldfile_add_arch ("");
319 config.make_executable = TRUE;
320 force_make_executable = FALSE;
321 config.magic_demand_paged = TRUE;
322 config.text_read_only = TRUE;
324 emulation = get_emulation (argc, argv);
325 ldemul_choose_mode (emulation);
326 default_target = ldemul_choose_target (argc, argv);
327 lang_init ();
328 ldemul_before_parse ();
329 lang_has_input_file = FALSE;
330 parse_args (argc, argv);
332 if (config.hash_table_size != 0)
333 bfd_hash_set_default_size (config.hash_table_size);
335 ldemul_set_symbols ();
337 if (link_info.relocatable)
339 if (link_info.gc_sections)
340 einfo ("%P%F: --gc-sections and -r may not be used together\n");
341 else if (command_line.relax)
342 einfo (_("%P%F: --relax and -r may not be used together\n"));
343 if (link_info.shared)
344 einfo (_("%P%F: -r and -shared may not be used together\n"));
347 if (!config.dynamic_link && link_info.shared)
348 einfo (_("%P%F: -static and -shared may not be used together\n"));
350 if (! link_info.shared)
352 if (command_line.filter_shlib)
353 einfo (_("%P%F: -F may not be used without -shared\n"));
354 if (command_line.auxiliary_filters)
355 einfo (_("%P%F: -f may not be used without -shared\n"));
358 if (! link_info.shared || link_info.pie)
359 link_info.executable = TRUE;
361 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
362 don't see how else this can be handled, since in this case we
363 must preserve all externally visible symbols. */
364 if (link_info.relocatable && link_info.strip == strip_all)
366 link_info.strip = strip_debugger;
367 if (link_info.discard == discard_sec_merge)
368 link_info.discard = discard_all;
371 /* This essentially adds another -L directory so this must be done after
372 the -L's in argv have been processed. */
373 set_scripts_dir ();
375 /* If we have not already opened and parsed a linker script
376 read the emulation's appropriate default script. */
377 if (saved_script_handle == NULL)
379 int isfile;
380 char *s = ldemul_get_script (&isfile);
382 if (isfile)
383 ldfile_open_command_file (s);
384 else
386 lex_string = s;
387 lex_redirect (s);
389 parser_input = input_script;
390 yyparse ();
391 lex_string = NULL;
394 if (trace_file_tries)
396 if (saved_script_handle)
397 info_msg (_("using external linker script:"));
398 else
399 info_msg (_("using internal linker script:"));
400 info_msg ("\n==================================================\n");
402 if (saved_script_handle)
404 static const int ld_bufsz = 8193;
405 size_t n;
406 char *buf = xmalloc (ld_bufsz);
408 rewind (saved_script_handle);
409 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
411 buf[n] = 0;
412 info_msg (buf);
414 rewind (saved_script_handle);
415 free (buf);
417 else
419 int isfile;
421 info_msg (ldemul_get_script (&isfile));
424 info_msg ("\n==================================================\n");
427 lang_final ();
429 if (!lang_has_input_file)
431 if (version_printed)
432 xexit (0);
433 einfo (_("%P%F: no input files\n"));
436 if (trace_files)
437 info_msg (_("%P: mode %s\n"), emulation);
439 ldemul_after_parse ();
441 if (config.map_filename)
443 if (strcmp (config.map_filename, "-") == 0)
445 config.map_file = stdout;
447 else
449 config.map_file = fopen (config.map_filename, FOPEN_WT);
450 if (config.map_file == (FILE *) NULL)
452 bfd_set_error (bfd_error_system_call);
453 einfo (_("%P%F: cannot open map file %s: %E\n"),
454 config.map_filename);
459 lang_process ();
461 /* Print error messages for any missing symbols, for any warning
462 symbols, and possibly multiple definitions. */
463 if (link_info.relocatable)
464 output_bfd->flags &= ~EXEC_P;
465 else
466 output_bfd->flags |= EXEC_P;
468 ldwrite ();
470 if (config.map_file != NULL)
471 lang_map ();
472 if (command_line.cref)
473 output_cref (config.map_file != NULL ? config.map_file : stdout);
474 if (nocrossref_list != NULL)
475 check_nocrossrefs ();
477 /* Even if we're producing relocatable output, some non-fatal errors should
478 be reported in the exit status. (What non-fatal errors, if any, do we
479 want to ignore for relocatable output?) */
480 if (!config.make_executable && !force_make_executable)
482 if (trace_files)
483 einfo (_("%P: link errors found, deleting executable `%s'\n"),
484 output_filename);
486 /* The file will be removed by remove_output. */
487 xexit (1);
489 else
491 if (! bfd_close (output_bfd))
492 einfo (_("%F%B: final close failed: %E\n"), output_bfd);
494 /* If the --force-exe-suffix is enabled, and we're making an
495 executable file and it doesn't end in .exe, copy it to one
496 which does. */
497 if (! link_info.relocatable && command_line.force_exe_suffix)
499 int len = strlen (output_filename);
501 if (len < 4
502 || (strcasecmp (output_filename + len - 4, ".exe") != 0
503 && strcasecmp (output_filename + len - 4, ".dll") != 0))
505 FILE *src;
506 FILE *dst;
507 const int bsize = 4096;
508 char *buf = xmalloc (bsize);
509 int l;
510 char *dst_name = xmalloc (len + 5);
512 strcpy (dst_name, output_filename);
513 strcat (dst_name, ".exe");
514 src = fopen (output_filename, FOPEN_RB);
515 dst = fopen (dst_name, FOPEN_WB);
517 if (!src)
518 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
519 output_filename);
520 if (!dst)
521 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
522 dst_name);
523 while ((l = fread (buf, 1, bsize, src)) > 0)
525 int done = fwrite (buf, 1, l, dst);
527 if (done != l)
528 einfo (_("%P: Error writing file `%s'\n"), dst_name);
531 fclose (src);
532 if (fclose (dst) == EOF)
533 einfo (_("%P: Error closing file `%s'\n"), dst_name);
534 free (dst_name);
535 free (buf);
540 END_PROGRESS (program_name);
542 if (config.stats)
544 #ifdef HAVE_SBRK
545 char *lim = sbrk (0);
546 #endif
547 long run_time = get_run_time () - start_time;
549 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
550 program_name, run_time / 1000000, run_time % 1000000);
551 #ifdef HAVE_SBRK
552 fprintf (stderr, _("%s: data size %ld\n"), program_name,
553 (long) (lim - (char *) &environ));
554 #endif
557 /* Prevent remove_output from doing anything, after a successful link. */
558 output_filename = NULL;
560 xexit (0);
561 return 0;
564 /* If the configured sysroot is relocatable, try relocating it based on
565 default prefix FROM. Return the relocated directory if it exists,
566 otherwise return null. */
568 static char *
569 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
571 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
572 char *path;
573 struct stat s;
575 path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
576 if (path)
578 if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
579 return path;
580 free (path);
582 #endif
583 return 0;
586 /* Return the sysroot directory. Return "" if no sysroot is being used. */
588 static const char *
589 get_sysroot (int argc, char **argv)
591 int i;
592 const char *path;
594 for (i = 1; i < argc; i++)
595 if (strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")) == 0)
596 return argv[i] + strlen ("--sysroot=");
598 path = get_relative_sysroot (BINDIR);
599 if (path)
600 return path;
602 path = get_relative_sysroot (TOOLBINDIR);
603 if (path)
604 return path;
606 return TARGET_SYSTEM_ROOT;
609 /* We need to find any explicitly given emulation in order to initialize the
610 state that's needed by the lex&yacc argument parser (parse_args). */
612 static char *
613 get_emulation (int argc, char **argv)
615 char *emulation;
616 int i;
618 emulation = getenv (EMULATION_ENVIRON);
619 if (emulation == NULL)
620 emulation = DEFAULT_EMULATION;
622 for (i = 1; i < argc; i++)
624 if (!strncmp (argv[i], "-m", 2))
626 if (argv[i][2] == '\0')
628 /* -m EMUL */
629 if (i < argc - 1)
631 emulation = argv[i + 1];
632 i++;
634 else
635 einfo (_("%P%F: missing argument to -m\n"));
637 else if (strcmp (argv[i], "-mips1") == 0
638 || strcmp (argv[i], "-mips2") == 0
639 || strcmp (argv[i], "-mips3") == 0
640 || strcmp (argv[i], "-mips4") == 0
641 || strcmp (argv[i], "-mips5") == 0
642 || strcmp (argv[i], "-mips32") == 0
643 || strcmp (argv[i], "-mips32r2") == 0
644 || strcmp (argv[i], "-mips64") == 0
645 || strcmp (argv[i], "-mips64r2") == 0)
647 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
648 passed to the linker by some MIPS compilers. They
649 generally tell the linker to use a slightly different
650 library path. Perhaps someday these should be
651 implemented as emulations; until then, we just ignore
652 the arguments and hope that nobody ever creates
653 emulations named ips1, ips2 or ips3. */
655 else if (strcmp (argv[i], "-m486") == 0)
657 /* FIXME: The argument -m486 is passed to the linker on
658 some Linux systems. Hope that nobody creates an
659 emulation named 486. */
661 else
663 /* -mEMUL */
664 emulation = &argv[i][2];
669 return emulation;
672 /* If directory DIR contains an "ldscripts" subdirectory,
673 add DIR to the library search path and return TRUE,
674 else return FALSE. */
676 static bfd_boolean
677 check_for_scripts_dir (char *dir)
679 size_t dirlen;
680 char *buf;
681 struct stat s;
682 bfd_boolean res;
684 dirlen = strlen (dir);
685 /* sizeof counts the terminating NUL. */
686 buf = xmalloc (dirlen + sizeof ("/ldscripts"));
687 sprintf (buf, "%s/ldscripts", dir);
689 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
690 free (buf);
691 if (res)
692 ldfile_add_library_path (dir, FALSE);
693 return res;
696 /* Set the default directory for finding script files.
697 Libraries will be searched for here too, but that's ok.
698 We look for the "ldscripts" directory in:
700 SCRIPTDIR (passed from Makefile)
701 (adjusted according to the current location of the binary)
702 SCRIPTDIR (passed from Makefile)
703 the dir where this program is (for using it from the build tree)
704 the dir where this program is/../lib
705 (for installing the tool suite elsewhere). */
707 static void
708 set_scripts_dir (void)
710 char *end, *dir;
711 size_t dirlen;
712 bfd_boolean found;
714 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
715 if (dir)
717 found = check_for_scripts_dir (dir);
718 free (dir);
719 if (found)
720 return;
723 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
724 if (dir)
726 found = check_for_scripts_dir (dir);
727 free (dir);
728 if (found)
729 return;
732 if (check_for_scripts_dir (SCRIPTDIR))
733 /* We've been installed normally. */
734 return;
736 /* Look for "ldscripts" in the dir where our binary is. */
737 end = strrchr (program_name, '/');
738 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
740 /* We could have \foo\bar, or /foo\bar. */
741 char *bslash = strrchr (program_name, '\\');
743 if (end == NULL || (bslash != NULL && bslash > end))
744 end = bslash;
746 #endif
748 if (end == NULL)
749 /* Don't look for ldscripts in the current directory. There is
750 too much potential for confusion. */
751 return;
753 dirlen = end - program_name;
754 /* Make a copy of program_name in dir.
755 Leave room for later "/../lib". */
756 dir = xmalloc (dirlen + 8);
757 strncpy (dir, program_name, dirlen);
758 dir[dirlen] = '\0';
760 if (check_for_scripts_dir (dir))
762 free (dir);
763 return;
766 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
767 strcpy (dir + dirlen, "/../lib");
768 check_for_scripts_dir (dir);
769 free (dir);
772 void
773 add_ysym (const char *name)
775 if (link_info.notice_hash == NULL)
777 link_info.notice_hash = xmalloc (sizeof (struct bfd_hash_table));
778 if (! bfd_hash_table_init_n (link_info.notice_hash,
779 bfd_hash_newfunc,
780 61))
781 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
784 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
785 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
788 /* Record a symbol to be wrapped, from the --wrap option. */
790 void
791 add_wrap (const char *name)
793 if (link_info.wrap_hash == NULL)
795 link_info.wrap_hash = xmalloc (sizeof (struct bfd_hash_table));
796 if (! bfd_hash_table_init_n (link_info.wrap_hash,
797 bfd_hash_newfunc,
798 61))
799 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
802 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
803 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
806 /* Handle the -retain-symbols-file option. */
808 void
809 add_keepsyms_file (const char *filename)
811 FILE *file;
812 char *buf;
813 size_t bufsize;
814 int c;
816 if (link_info.strip == strip_some)
817 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
819 file = fopen (filename, "r");
820 if (file == NULL)
822 bfd_set_error (bfd_error_system_call);
823 einfo ("%X%P: %s: %E\n", filename);
824 return;
827 link_info.keep_hash = xmalloc (sizeof (struct bfd_hash_table));
828 if (! bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc))
829 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
831 bufsize = 100;
832 buf = xmalloc (bufsize);
834 c = getc (file);
835 while (c != EOF)
837 while (ISSPACE (c))
838 c = getc (file);
840 if (c != EOF)
842 size_t len = 0;
844 while (! ISSPACE (c) && c != EOF)
846 buf[len] = c;
847 ++len;
848 if (len >= bufsize)
850 bufsize *= 2;
851 buf = xrealloc (buf, bufsize);
853 c = getc (file);
856 buf[len] = '\0';
858 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
859 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
863 if (link_info.strip != strip_none)
864 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
866 free (buf);
867 link_info.strip = strip_some;
870 /* Callbacks from the BFD linker routines. */
872 /* This is called when BFD has decided to include an archive member in
873 a link. */
875 static bfd_boolean
876 add_archive_element (struct bfd_link_info *info ATTRIBUTE_UNUSED,
877 bfd *abfd,
878 const char *name)
880 lang_input_statement_type *input;
882 input = xmalloc (sizeof (lang_input_statement_type));
883 input->filename = abfd->filename;
884 input->local_sym_name = abfd->filename;
885 input->the_bfd = abfd;
886 input->asymbols = NULL;
887 input->next = NULL;
888 input->just_syms_flag = FALSE;
889 input->loaded = FALSE;
890 input->search_dirs_flag = FALSE;
892 /* FIXME: The following fields are not set: header.next,
893 header.type, closed, passive_position, symbol_count,
894 next_real_file, is_archive, target, real. This bit of code is
895 from the old decode_library_subfile function. I don't know
896 whether any of those fields matters. */
898 ldlang_add_file (input);
900 if (config.map_file != NULL)
902 static bfd_boolean header_printed;
903 struct bfd_link_hash_entry *h;
904 bfd *from;
905 int len;
907 h = bfd_link_hash_lookup (link_info.hash, name, FALSE, FALSE, TRUE);
909 if (h == NULL)
910 from = NULL;
911 else
913 switch (h->type)
915 default:
916 from = NULL;
917 break;
919 case bfd_link_hash_defined:
920 case bfd_link_hash_defweak:
921 from = h->u.def.section->owner;
922 break;
924 case bfd_link_hash_undefined:
925 case bfd_link_hash_undefweak:
926 from = h->u.undef.abfd;
927 break;
929 case bfd_link_hash_common:
930 from = h->u.c.p->section->owner;
931 break;
935 if (! header_printed)
937 char buf[100];
939 sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
940 minfo ("%s", buf);
941 header_printed = TRUE;
944 if (bfd_my_archive (abfd) == NULL)
946 minfo ("%s", bfd_get_filename (abfd));
947 len = strlen (bfd_get_filename (abfd));
949 else
951 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
952 bfd_get_filename (abfd));
953 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
954 + strlen (bfd_get_filename (abfd))
955 + 2);
958 if (len >= 29)
960 print_nl ();
961 len = 0;
963 while (len < 30)
965 print_space ();
966 ++len;
969 if (from != NULL)
970 minfo ("%B ", from);
971 if (h != NULL)
972 minfo ("(%T)\n", h->root.string);
973 else
974 minfo ("(%s)\n", name);
977 if (trace_files || trace_file_tries)
978 info_msg ("%I\n", input);
980 return TRUE;
983 /* This is called when BFD has discovered a symbol which is defined
984 multiple times. */
986 static bfd_boolean
987 multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
988 const char *name,
989 bfd *obfd,
990 asection *osec,
991 bfd_vma oval,
992 bfd *nbfd,
993 asection *nsec,
994 bfd_vma nval)
996 /* If either section has the output_section field set to
997 bfd_abs_section_ptr, it means that the section is being
998 discarded, and this is not really a multiple definition at all.
999 FIXME: It would be cleaner to somehow ignore symbols defined in
1000 sections which are being discarded. */
1001 if ((osec->output_section != NULL
1002 && ! bfd_is_abs_section (osec)
1003 && bfd_is_abs_section (osec->output_section))
1004 || (nsec->output_section != NULL
1005 && ! bfd_is_abs_section (nsec)
1006 && bfd_is_abs_section (nsec->output_section)))
1007 return TRUE;
1009 einfo (_("%X%C: multiple definition of `%T'\n"),
1010 nbfd, nsec, nval, name);
1011 if (obfd != NULL)
1012 einfo (_("%D: first defined here\n"), obfd, osec, oval);
1014 if (command_line.relax)
1016 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
1017 command_line.relax = 0;
1020 return TRUE;
1023 /* This is called when there is a definition of a common symbol, or
1024 when a common symbol is found for a symbol that is already defined,
1025 or when two common symbols are found. We only do something if
1026 -warn-common was used. */
1028 static bfd_boolean
1029 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1030 const char *name,
1031 bfd *obfd,
1032 enum bfd_link_hash_type otype,
1033 bfd_vma osize,
1034 bfd *nbfd,
1035 enum bfd_link_hash_type ntype,
1036 bfd_vma nsize)
1038 if (! config.warn_common)
1039 return TRUE;
1041 if (ntype == bfd_link_hash_defined
1042 || ntype == bfd_link_hash_defweak
1043 || ntype == bfd_link_hash_indirect)
1045 ASSERT (otype == bfd_link_hash_common);
1046 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1047 nbfd, name);
1048 if (obfd != NULL)
1049 einfo (_("%B: warning: common is here\n"), obfd);
1051 else if (otype == bfd_link_hash_defined
1052 || otype == bfd_link_hash_defweak
1053 || otype == bfd_link_hash_indirect)
1055 ASSERT (ntype == bfd_link_hash_common);
1056 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1057 nbfd, name);
1058 if (obfd != NULL)
1059 einfo (_("%B: warning: defined here\n"), obfd);
1061 else
1063 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1064 if (osize > nsize)
1066 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1067 nbfd, name);
1068 if (obfd != NULL)
1069 einfo (_("%B: warning: larger common is here\n"), obfd);
1071 else if (nsize > osize)
1073 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1074 nbfd, name);
1075 if (obfd != NULL)
1076 einfo (_("%B: warning: smaller common is here\n"), obfd);
1078 else
1080 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1081 if (obfd != NULL)
1082 einfo (_("%B: warning: previous common is here\n"), obfd);
1086 return TRUE;
1089 /* This is called when BFD has discovered a set element. H is the
1090 entry in the linker hash table for the set. SECTION and VALUE
1091 represent a value which should be added to the set. */
1093 static bfd_boolean
1094 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1095 struct bfd_link_hash_entry *h,
1096 bfd_reloc_code_real_type reloc,
1097 bfd *abfd,
1098 asection *section,
1099 bfd_vma value)
1101 if (config.warn_constructors)
1102 einfo (_("%P: warning: global constructor %s used\n"),
1103 h->root.string);
1105 if (! config.build_constructors)
1106 return TRUE;
1108 ldctor_add_set_entry (h, reloc, NULL, section, value);
1110 if (h->type == bfd_link_hash_new)
1112 h->type = bfd_link_hash_undefined;
1113 h->u.undef.abfd = abfd;
1114 /* We don't call bfd_link_add_undef to add this to the list of
1115 undefined symbols because we are going to define it
1116 ourselves. */
1119 return TRUE;
1122 /* This is called when BFD has discovered a constructor. This is only
1123 called for some object file formats--those which do not handle
1124 constructors in some more clever fashion. This is similar to
1125 adding an element to a set, but less general. */
1127 static bfd_boolean
1128 constructor_callback (struct bfd_link_info *info,
1129 bfd_boolean constructor,
1130 const char *name,
1131 bfd *abfd,
1132 asection *section,
1133 bfd_vma value)
1135 char *s;
1136 struct bfd_link_hash_entry *h;
1137 char set_name[1 + sizeof "__CTOR_LIST__"];
1139 if (config.warn_constructors)
1140 einfo (_("%P: warning: global constructor %s used\n"), name);
1142 if (! config.build_constructors)
1143 return TRUE;
1145 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1146 useful error message. */
1147 if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL
1148 && (link_info.relocatable
1149 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1150 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1152 s = set_name;
1153 if (bfd_get_symbol_leading_char (abfd) != '\0')
1154 *s++ = bfd_get_symbol_leading_char (abfd);
1155 if (constructor)
1156 strcpy (s, "__CTOR_LIST__");
1157 else
1158 strcpy (s, "__DTOR_LIST__");
1160 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1161 if (h == (struct bfd_link_hash_entry *) NULL)
1162 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1163 if (h->type == bfd_link_hash_new)
1165 h->type = bfd_link_hash_undefined;
1166 h->u.undef.abfd = abfd;
1167 /* We don't call bfd_link_add_undef to add this to the list of
1168 undefined symbols because we are going to define it
1169 ourselves. */
1172 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1173 return TRUE;
1176 /* A structure used by warning_callback to pass information through
1177 bfd_map_over_sections. */
1179 struct warning_callback_info
1181 bfd_boolean found;
1182 const char *warning;
1183 const char *symbol;
1184 asymbol **asymbols;
1187 /* This is called when there is a reference to a warning symbol. */
1189 static bfd_boolean
1190 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1191 const char *warning,
1192 const char *symbol,
1193 bfd *abfd,
1194 asection *section,
1195 bfd_vma address)
1197 /* This is a hack to support warn_multiple_gp. FIXME: This should
1198 have a cleaner interface, but what? */
1199 if (! config.warn_multiple_gp
1200 && strcmp (warning, "using multiple gp values") == 0)
1201 return TRUE;
1203 if (section != NULL)
1204 einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1205 else if (abfd == NULL)
1206 einfo ("%P: %s%s\n", _("warning: "), warning);
1207 else if (symbol == NULL)
1208 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1209 else
1211 lang_input_statement_type *entry;
1212 asymbol **asymbols;
1213 struct warning_callback_info info;
1215 /* Look through the relocs to see if we can find a plausible
1216 address. */
1217 entry = (lang_input_statement_type *) abfd->usrdata;
1218 if (entry != NULL && entry->asymbols != NULL)
1219 asymbols = entry->asymbols;
1220 else
1222 long symsize;
1223 long symbol_count;
1225 symsize = bfd_get_symtab_upper_bound (abfd);
1226 if (symsize < 0)
1227 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1228 asymbols = xmalloc (symsize);
1229 symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
1230 if (symbol_count < 0)
1231 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1232 if (entry != NULL)
1234 entry->asymbols = asymbols;
1235 entry->symbol_count = symbol_count;
1239 info.found = FALSE;
1240 info.warning = warning;
1241 info.symbol = symbol;
1242 info.asymbols = asymbols;
1243 bfd_map_over_sections (abfd, warning_find_reloc, &info);
1245 if (! info.found)
1246 einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1248 if (entry == NULL)
1249 free (asymbols);
1252 return TRUE;
1255 /* This is called by warning_callback for each section. It checks the
1256 relocs of the section to see if it can find a reference to the
1257 symbol which triggered the warning. If it can, it uses the reloc
1258 to give an error message with a file and line number. */
1260 static void
1261 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1263 struct warning_callback_info *info = iarg;
1264 long relsize;
1265 arelent **relpp;
1266 long relcount;
1267 arelent **p, **pend;
1269 if (info->found)
1270 return;
1272 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1273 if (relsize < 0)
1274 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1275 if (relsize == 0)
1276 return;
1278 relpp = xmalloc (relsize);
1279 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1280 if (relcount < 0)
1281 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1283 p = relpp;
1284 pend = p + relcount;
1285 for (; p < pend && *p != NULL; p++)
1287 arelent *q = *p;
1289 if (q->sym_ptr_ptr != NULL
1290 && *q->sym_ptr_ptr != NULL
1291 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1293 /* We found a reloc for the symbol we are looking for. */
1294 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1295 info->warning);
1296 info->found = TRUE;
1297 break;
1301 free (relpp);
1304 /* This is called when an undefined symbol is found. */
1306 static bfd_boolean
1307 undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1308 const char *name,
1309 bfd *abfd,
1310 asection *section,
1311 bfd_vma address,
1312 bfd_boolean error)
1314 static char *error_name;
1315 static unsigned int error_count;
1317 #define MAX_ERRORS_IN_A_ROW 5
1319 if (config.warn_once)
1321 static struct bfd_hash_table *hash;
1323 /* Only warn once about a particular undefined symbol. */
1324 if (hash == NULL)
1326 hash = xmalloc (sizeof (struct bfd_hash_table));
1327 if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
1328 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1331 if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1332 return TRUE;
1334 if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1335 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1338 /* We never print more than a reasonable number of errors in a row
1339 for a single symbol. */
1340 if (error_name != NULL
1341 && strcmp (name, error_name) == 0)
1342 ++error_count;
1343 else
1345 error_count = 0;
1346 if (error_name != NULL)
1347 free (error_name);
1348 error_name = xstrdup (name);
1351 if (section != NULL)
1353 if (error_count < MAX_ERRORS_IN_A_ROW)
1355 if (error)
1356 einfo (_("%X%C: undefined reference to `%T'\n"),
1357 abfd, section, address, name);
1358 else
1359 einfo (_("%C: warning: undefined reference to `%T'\n"),
1360 abfd, section, address, name);
1362 else if (error_count == MAX_ERRORS_IN_A_ROW)
1364 if (error)
1365 einfo (_("%X%D: more undefined references to `%T' follow\n"),
1366 abfd, section, address, name);
1367 else
1368 einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1369 abfd, section, address, name);
1371 else if (error)
1372 einfo ("%X");
1374 else
1376 if (error_count < MAX_ERRORS_IN_A_ROW)
1378 if (error)
1379 einfo (_("%X%B: undefined reference to `%T'\n"),
1380 abfd, name);
1381 else
1382 einfo (_("%B: warning: undefined reference to `%T'\n"),
1383 abfd, name);
1385 else if (error_count == MAX_ERRORS_IN_A_ROW)
1387 if (error)
1388 einfo (_("%X%B: more undefined references to `%T' follow\n"),
1389 abfd, name);
1390 else
1391 einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1392 abfd, name);
1394 else if (error)
1395 einfo ("%X");
1398 return TRUE;
1401 /* Counter to limit the number of relocation overflow error messages
1402 to print. Errors are printed as it is decremented. When it's
1403 called and the counter is zero, a final message is printed
1404 indicating more relocations were omitted. When it gets to -1, no
1405 such errors are printed. If it's initially set to a value less
1406 than -1, all such errors will be printed (--verbose does this). */
1408 int overflow_cutoff_limit = 10;
1410 /* This is called when a reloc overflows. */
1412 static bfd_boolean
1413 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1414 struct bfd_link_hash_entry *entry,
1415 const char *name,
1416 const char *reloc_name,
1417 bfd_vma addend,
1418 bfd *abfd,
1419 asection *section,
1420 bfd_vma address)
1422 if (overflow_cutoff_limit == -1)
1423 return TRUE;
1425 if (abfd == NULL)
1426 einfo (_("%P%X: generated"));
1427 else
1428 einfo ("%X%C:", abfd, section, address);
1430 if (overflow_cutoff_limit >= 0
1431 && overflow_cutoff_limit-- == 0)
1433 einfo (_(" additional relocation overflows omitted from the output\n"));
1434 return TRUE;
1437 if (entry)
1439 while (entry->type == bfd_link_hash_indirect
1440 || entry->type == bfd_link_hash_warning)
1441 entry = entry->u.i.link;
1442 switch (entry->type)
1444 case bfd_link_hash_undefined:
1445 case bfd_link_hash_undefweak:
1446 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1447 reloc_name, entry->root.string);
1448 break;
1449 case bfd_link_hash_defined:
1450 case bfd_link_hash_defweak:
1451 einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1452 reloc_name, entry->root.string,
1453 entry->u.def.section, entry->u.def.section->owner);
1454 break;
1455 default:
1456 abort ();
1457 break;
1460 else
1461 einfo (_(" relocation truncated to fit: %s against `%T'"),
1462 reloc_name, name);
1463 if (addend != 0)
1464 einfo ("+%v", addend);
1465 einfo ("\n");
1466 return TRUE;
1469 /* This is called when a dangerous relocation is made. */
1471 static bfd_boolean
1472 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1473 const char *message,
1474 bfd *abfd,
1475 asection *section,
1476 bfd_vma address)
1478 if (abfd == NULL)
1479 einfo (_("%P%X: generated"));
1480 else
1481 einfo ("%X%C:", abfd, section, address);
1482 einfo (_("dangerous relocation: %s\n"), message);
1483 return TRUE;
1486 /* This is called when a reloc is being generated attached to a symbol
1487 that is not being output. */
1489 static bfd_boolean
1490 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1491 const char *name,
1492 bfd *abfd,
1493 asection *section,
1494 bfd_vma address)
1496 if (abfd == NULL)
1497 einfo (_("%P%X: generated"));
1498 else
1499 einfo ("%X%C:", abfd, section, address);
1500 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name);
1501 return TRUE;
1504 /* This is called if link_info.notice_all is set, or when a symbol in
1505 link_info.notice_hash is found. Symbols are put in notice_hash
1506 using the -y option. */
1508 static bfd_boolean
1509 notice (struct bfd_link_info *info,
1510 const char *name,
1511 bfd *abfd,
1512 asection *section,
1513 bfd_vma value)
1515 if (! info->notice_all
1516 || (info->notice_hash != NULL
1517 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1519 if (bfd_is_und_section (section))
1520 einfo ("%B: reference to %s\n", abfd, name);
1521 else
1522 einfo ("%B: definition of %s\n", abfd, name);
1525 if (command_line.cref || nocrossref_list != NULL)
1526 add_cref (name, abfd, section, value);
1528 return TRUE;