* dwarf2dbg.c (get_filenum): Skip as-yet unassigned file numbers.
[binutils.git] / ld / ldmain.c
blob125dc6a9a79a01141ee3e218cdfa9ece11c08dc7
1 /* Main program of GNU linker.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003
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 PTR sbrk ();
55 #endif
56 #endif
58 #ifndef TARGET_SYSTEM_ROOT
59 #define TARGET_SYSTEM_ROOT ""
60 #endif
62 int main PARAMS ((int, char **));
64 /* EXPORTS */
66 char *default_target;
67 const char *output_filename = "a.out";
69 /* Name this program was invoked by. */
70 char *program_name;
72 /* The prefix for system library directories. */
73 char *ld_sysroot;
75 /* The canonical representation of ld_sysroot. */
76 char * ld_canon_sysroot;
77 int ld_canon_sysroot_len;
79 /* The file that we're creating. */
80 bfd *output_bfd = 0;
82 /* Set by -G argument, for MIPS ECOFF target. */
83 int g_switch_value = 8;
85 /* Nonzero means print names of input files as processed. */
86 bfd_boolean trace_files;
88 /* Nonzero means same, but note open failures, too. */
89 bfd_boolean trace_file_tries;
91 /* Nonzero means version number was printed, so exit successfully
92 instead of complaining if no input files are given. */
93 bfd_boolean version_printed;
95 /* Nonzero means link in every member of an archive. */
96 bfd_boolean whole_archive;
98 /* TRUE if we should demangle symbol names. */
99 bfd_boolean demangling;
101 args_type command_line;
103 ld_config_type config;
105 static char *get_emulation
106 PARAMS ((int, char **));
107 static void set_scripts_dir
108 PARAMS ((void));
109 static void remove_output
110 PARAMS ((void));
111 static bfd_boolean check_for_scripts_dir
112 PARAMS ((char *));
113 static bfd_boolean add_archive_element
114 PARAMS ((struct bfd_link_info *, bfd *, const char *));
115 static bfd_boolean multiple_definition
116 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
117 bfd *, asection *, bfd_vma));
118 static bfd_boolean multiple_common
119 PARAMS ((struct bfd_link_info *, const char *, bfd *,
120 enum bfd_link_hash_type, bfd_vma, bfd *, enum bfd_link_hash_type,
121 bfd_vma));
122 static bfd_boolean add_to_set
123 PARAMS ((struct bfd_link_info *, struct bfd_link_hash_entry *,
124 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma));
125 static bfd_boolean constructor_callback
126 PARAMS ((struct bfd_link_info *, bfd_boolean, const char *, bfd *,
127 asection *, bfd_vma));
128 static bfd_boolean warning_callback
129 PARAMS ((struct bfd_link_info *, const char *, const char *, bfd *,
130 asection *, bfd_vma));
131 static void warning_find_reloc
132 PARAMS ((bfd *, asection *, PTR));
133 static bfd_boolean undefined_symbol
134 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
135 bfd_boolean));
136 static bfd_boolean reloc_overflow
137 PARAMS ((struct bfd_link_info *, const char *, const char *, bfd_vma,
138 bfd *, asection *, bfd_vma));
139 static bfd_boolean reloc_dangerous
140 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma));
141 static bfd_boolean unattached_reloc
142 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma));
143 static bfd_boolean notice
144 PARAMS ((struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma));
146 static struct bfd_link_callbacks link_callbacks =
148 add_archive_element,
149 multiple_definition,
150 multiple_common,
151 add_to_set,
152 constructor_callback,
153 warning_callback,
154 undefined_symbol,
155 reloc_overflow,
156 reloc_dangerous,
157 unattached_reloc,
158 notice
161 struct bfd_link_info link_info;
163 static void
164 remove_output ()
166 if (output_filename)
168 if (output_bfd && output_bfd->iostream)
169 fclose ((FILE *) (output_bfd->iostream));
170 if (delete_output_file_on_failure)
171 unlink (output_filename);
176 main (argc, argv)
177 int argc;
178 char **argv;
180 char *emulation;
181 long start_time = get_run_time ();
183 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
184 setlocale (LC_MESSAGES, "");
185 #endif
186 #if defined (HAVE_SETLOCALE)
187 setlocale (LC_CTYPE, "");
188 #endif
189 bindtextdomain (PACKAGE, LOCALEDIR);
190 textdomain (PACKAGE);
192 program_name = argv[0];
193 xmalloc_set_program_name (program_name);
195 START_PROGRESS (program_name, 0);
197 bfd_init ();
199 bfd_set_error_program_name (program_name);
201 xatexit (remove_output);
203 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
204 ld_sysroot = make_relative_prefix (program_name, BINDIR,
205 TARGET_SYSTEM_ROOT);
207 if (ld_sysroot)
209 struct stat s;
210 int res = stat (ld_sysroot, &s) == 0 && S_ISDIR (s.st_mode);
212 if (!res)
214 free (ld_sysroot);
215 ld_sysroot = NULL;
219 if (! ld_sysroot)
221 ld_sysroot = make_relative_prefix (program_name, TOOLBINDIR,
222 TARGET_SYSTEM_ROOT);
224 if (ld_sysroot)
226 struct stat s;
227 int res = stat (ld_sysroot, &s) == 0 && S_ISDIR (s.st_mode);
229 if (!res)
231 free (ld_sysroot);
232 ld_sysroot = NULL;
237 if (! ld_sysroot)
238 #endif
239 ld_sysroot = TARGET_SYSTEM_ROOT;
241 if (ld_sysroot && *ld_sysroot)
242 ld_canon_sysroot = lrealpath (ld_sysroot);
244 if (ld_canon_sysroot)
245 ld_canon_sysroot_len = strlen (ld_canon_sysroot);
246 else
247 ld_canon_sysroot_len = -1;
249 /* Set the default BFD target based on the configured target. Doing
250 this permits the linker to be configured for a particular target,
251 and linked against a shared BFD library which was configured for
252 a different target. The macro TARGET is defined by Makefile. */
253 if (! bfd_set_default_target (TARGET))
255 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
256 xexit (1);
259 #if YYDEBUG
261 extern int yydebug;
262 yydebug = 1;
264 #endif
266 /* Initialize the data about options. */
267 trace_files = trace_file_tries = version_printed = FALSE;
268 whole_archive = FALSE;
269 config.build_constructors = TRUE;
270 config.dynamic_link = FALSE;
271 config.has_shared = FALSE;
272 config.split_by_reloc = (unsigned) -1;
273 config.split_by_file = (bfd_size_type) -1;
274 command_line.force_common_definition = FALSE;
275 command_line.inhibit_common_definition = FALSE;
276 command_line.interpreter = NULL;
277 command_line.rpath = NULL;
278 command_line.warn_mismatch = TRUE;
279 command_line.check_section_addresses = TRUE;
280 command_line.accept_unknown_input_arch = FALSE;
282 /* We initialize DEMANGLING based on the environment variable
283 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
284 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
285 environment. Acting the same way here lets us provide the same
286 interface by default. */
287 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
289 link_info.relocateable = FALSE;
290 link_info.emitrelocations = FALSE;
291 link_info.task_link = FALSE;
292 link_info.shared = FALSE;
293 link_info.symbolic = FALSE;
294 link_info.export_dynamic = FALSE;
295 link_info.static_link = FALSE;
296 link_info.traditional_format = FALSE;
297 link_info.optimize = FALSE;
298 link_info.no_undefined = FALSE;
299 link_info.allow_shlib_undefined = TRUE;
300 link_info.allow_multiple_definition = FALSE;
301 link_info.allow_undefined_version = TRUE;
302 link_info.keep_memory = TRUE;
303 link_info.notice_all = FALSE;
304 link_info.nocopyreloc = FALSE;
305 link_info.new_dtags = FALSE;
306 link_info.combreloc = TRUE;
307 link_info.eh_frame_hdr = FALSE;
308 link_info.strip_discarded = TRUE;
309 link_info.strip = strip_none;
310 link_info.discard = discard_sec_merge;
311 link_info.common_skip_ar_aymbols = bfd_link_common_skip_none;
312 link_info.callbacks = &link_callbacks;
313 link_info.hash = NULL;
314 link_info.keep_hash = NULL;
315 link_info.notice_hash = NULL;
316 link_info.wrap_hash = NULL;
317 link_info.input_bfds = NULL;
318 link_info.create_object_symbols_section = NULL;
319 link_info.gc_sym_list = NULL;
320 link_info.base_file = NULL;
321 /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
322 and _fini symbols. We are compatible. */
323 link_info.init_function = "_init";
324 link_info.fini_function = "_fini";
325 link_info.mpc860c0 = 0;
326 link_info.pei386_auto_import = -1;
327 link_info.pei386_runtime_pseudo_reloc = FALSE;
328 link_info.spare_dynamic_tags = 5;
329 link_info.flags = (bfd_vma) 0;
330 link_info.flags_1 = (bfd_vma) 0;
332 ldfile_add_arch ("");
334 config.make_executable = TRUE;
335 force_make_executable = FALSE;
336 config.magic_demand_paged = TRUE;
337 config.text_read_only = TRUE;
339 emulation = get_emulation (argc, argv);
340 ldemul_choose_mode (emulation);
341 default_target = ldemul_choose_target (argc, argv);
342 lang_init ();
343 ldemul_before_parse ();
344 lang_has_input_file = FALSE;
345 parse_args (argc, argv);
347 ldemul_set_symbols ();
349 if (link_info.relocateable)
351 if (command_line.gc_sections)
352 einfo ("%P%F: --gc-sections and -r may not be used together\n");
353 if (link_info.mpc860c0)
354 einfo (_("%P%F: -r and --mpc860c0 may not be used together\n"));
355 else if (command_line.relax)
356 einfo (_("%P%F: --relax and -r may not be used together\n"));
357 if (link_info.shared)
358 einfo (_("%P%F: -r and -shared may not be used together\n"));
361 if (! link_info.shared)
363 if (command_line.filter_shlib)
364 einfo (_("%P%F: -F may not be used without -shared\n"));
365 if (command_line.auxiliary_filters)
366 einfo (_("%P%F: -f may not be used without -shared\n"));
369 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
370 don't see how else this can be handled, since in this case we
371 must preserve all externally visible symbols. */
372 if (link_info.relocateable && link_info.strip == strip_all)
374 link_info.strip = strip_debugger;
375 if (link_info.discard == discard_sec_merge)
376 link_info.discard = discard_all;
379 /* This essentially adds another -L directory so this must be done after
380 the -L's in argv have been processed. */
381 set_scripts_dir ();
383 /* If we have not already opened and parsed a linker script
384 read the emulation's appropriate default script. */
385 if (saved_script_handle == NULL)
387 int isfile;
388 char *s = ldemul_get_script (&isfile);
390 if (isfile)
391 ldfile_open_command_file (s);
392 else
394 lex_string = s;
395 lex_redirect (s);
397 parser_input = input_script;
398 yyparse ();
399 lex_string = NULL;
402 if (trace_file_tries)
404 if (saved_script_handle)
405 info_msg (_("using external linker script:"));
406 else
407 info_msg (_("using internal linker script:"));
408 info_msg ("\n==================================================\n");
410 if (saved_script_handle)
412 static const int ld_bufsz = 8193;
413 size_t n;
414 char *buf = xmalloc (ld_bufsz);
416 rewind (saved_script_handle);
417 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
419 buf[n] = 0;
420 info_msg (buf);
422 rewind (saved_script_handle);
423 free (buf);
425 else
427 int isfile;
429 info_msg (ldemul_get_script (&isfile));
432 info_msg ("\n==================================================\n");
435 lang_final ();
437 if (!lang_has_input_file)
439 if (version_printed)
440 xexit (0);
441 einfo (_("%P%F: no input files\n"));
444 if (trace_files)
445 info_msg (_("%P: mode %s\n"), emulation);
447 ldemul_after_parse ();
449 if (config.map_filename)
451 if (strcmp (config.map_filename, "-") == 0)
453 config.map_file = stdout;
455 else
457 config.map_file = fopen (config.map_filename, FOPEN_WT);
458 if (config.map_file == (FILE *) NULL)
460 bfd_set_error (bfd_error_system_call);
461 einfo (_("%P%F: cannot open map file %s: %E\n"),
462 config.map_filename);
467 lang_process ();
469 /* Print error messages for any missing symbols, for any warning
470 symbols, and possibly multiple definitions. */
471 if (link_info.relocateable)
472 output_bfd->flags &= ~EXEC_P;
473 else
474 output_bfd->flags |= EXEC_P;
476 ldwrite ();
478 if (config.map_file != NULL)
479 lang_map ();
480 if (command_line.cref)
481 output_cref (config.map_file != NULL ? config.map_file : stdout);
482 if (nocrossref_list != NULL)
483 check_nocrossrefs ();
485 /* Even if we're producing relocateable output, some non-fatal errors should
486 be reported in the exit status. (What non-fatal errors, if any, do we
487 want to ignore for relocateable output?) */
488 if (!config.make_executable && !force_make_executable)
490 if (trace_files)
491 einfo (_("%P: link errors found, deleting executable `%s'\n"),
492 output_filename);
494 /* The file will be removed by remove_output. */
495 xexit (1);
497 else
499 if (! bfd_close (output_bfd))
500 einfo (_("%F%B: final close failed: %E\n"), output_bfd);
502 /* If the --force-exe-suffix is enabled, and we're making an
503 executable file and it doesn't end in .exe, copy it to one
504 which does. */
505 if (! link_info.relocateable && command_line.force_exe_suffix)
507 int len = strlen (output_filename);
509 if (len < 4
510 || (strcasecmp (output_filename + len - 4, ".exe") != 0
511 && strcasecmp (output_filename + len - 4, ".dll") != 0))
513 FILE *src;
514 FILE *dst;
515 const int bsize = 4096;
516 char *buf = xmalloc (bsize);
517 int l;
518 char *dst_name = xmalloc (len + 5);
520 strcpy (dst_name, output_filename);
521 strcat (dst_name, ".exe");
522 src = fopen (output_filename, FOPEN_RB);
523 dst = fopen (dst_name, FOPEN_WB);
525 if (!src)
526 einfo (_("%X%P: unable to open for source of copy `%s'\n"), output_filename);
527 if (!dst)
528 einfo (_("%X%P: unable to open for destination of copy `%s'\n"), dst_name);
529 while ((l = fread (buf, 1, bsize, src)) > 0)
531 int done = fwrite (buf, 1, l, dst);
533 if (done != l)
534 einfo (_("%P: Error writing file `%s'\n"), dst_name);
537 fclose (src);
538 if (fclose (dst) == EOF)
539 einfo (_("%P: Error closing file `%s'\n"), dst_name);
540 free (dst_name);
541 free (buf);
546 END_PROGRESS (program_name);
548 if (config.stats)
550 #ifdef HAVE_SBRK
551 char *lim = (char *) sbrk (0);
552 #endif
553 long run_time = get_run_time () - start_time;
555 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
556 program_name, run_time / 1000000, run_time % 1000000);
557 #ifdef HAVE_SBRK
558 fprintf (stderr, _("%s: data size %ld\n"), program_name,
559 (long) (lim - (char *) &environ));
560 #endif
563 /* Prevent remove_output from doing anything, after a successful link. */
564 output_filename = NULL;
566 xexit (0);
567 return 0;
570 /* We need to find any explicitly given emulation in order to initialize the
571 state that's needed by the lex&yacc argument parser (parse_args). */
573 static char *
574 get_emulation (argc, argv)
575 int argc;
576 char **argv;
578 char *emulation;
579 int i;
581 emulation = getenv (EMULATION_ENVIRON);
582 if (emulation == NULL)
583 emulation = DEFAULT_EMULATION;
585 for (i = 1; i < argc; i++)
587 if (!strncmp (argv[i], "-m", 2))
589 if (argv[i][2] == '\0')
591 /* -m EMUL */
592 if (i < argc - 1)
594 emulation = argv[i + 1];
595 i++;
597 else
598 einfo (_("%P%F: missing argument to -m\n"));
600 else if (strcmp (argv[i], "-mips1") == 0
601 || strcmp (argv[i], "-mips2") == 0
602 || strcmp (argv[i], "-mips3") == 0
603 || strcmp (argv[i], "-mips4") == 0
604 || strcmp (argv[i], "-mips5") == 0
605 || strcmp (argv[i], "-mips32") == 0
606 || strcmp (argv[i], "-mips32r2") == 0
607 || strcmp (argv[i], "-mips64") == 0)
609 /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
610 passed to the linker by some MIPS compilers. They
611 generally tell the linker to use a slightly different
612 library path. Perhaps someday these should be
613 implemented as emulations; until then, we just ignore
614 the arguments and hope that nobody ever creates
615 emulations named ips1, ips2 or ips3. */
617 else if (strcmp (argv[i], "-m486") == 0)
619 /* FIXME: The argument -m486 is passed to the linker on
620 some Linux systems. Hope that nobody creates an
621 emulation named 486. */
623 else
625 /* -mEMUL */
626 emulation = &argv[i][2];
631 return emulation;
634 /* If directory DIR contains an "ldscripts" subdirectory,
635 add DIR to the library search path and return TRUE,
636 else return FALSE. */
638 static bfd_boolean
639 check_for_scripts_dir (dir)
640 char *dir;
642 size_t dirlen;
643 char *buf;
644 struct stat s;
645 bfd_boolean res;
647 dirlen = strlen (dir);
648 /* sizeof counts the terminating NUL. */
649 buf = (char *) xmalloc (dirlen + sizeof ("/ldscripts"));
650 sprintf (buf, "%s/ldscripts", dir);
652 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
653 free (buf);
654 if (res)
655 ldfile_add_library_path (dir, FALSE);
656 return res;
659 /* Set the default directory for finding script files.
660 Libraries will be searched for here too, but that's ok.
661 We look for the "ldscripts" directory in:
663 SCRIPTDIR (passed from Makefile)
664 (adjusted according to the current location of the binary)
665 SCRIPTDIR (passed from Makefile)
666 the dir where this program is (for using it from the build tree)
667 the dir where this program is/../lib
668 (for installing the tool suite elsewhere). */
670 static void
671 set_scripts_dir ()
673 char *end, *dir;
674 size_t dirlen;
675 bfd_boolean found;
677 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
678 if (dir)
680 found = check_for_scripts_dir (dir);
681 free (dir);
682 if (found)
683 return;
686 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
687 if (dir)
689 found = check_for_scripts_dir (dir);
690 free (dir);
691 if (found)
692 return;
695 if (check_for_scripts_dir (SCRIPTDIR))
696 /* We've been installed normally. */
697 return;
699 /* Look for "ldscripts" in the dir where our binary is. */
700 end = strrchr (program_name, '/');
701 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
703 /* We could have \foo\bar, or /foo\bar. */
704 char *bslash = strrchr (program_name, '\\');
706 if (end == NULL || (bslash != NULL && bslash > end))
707 end = bslash;
709 #endif
711 if (end == NULL)
712 /* Don't look for ldscripts in the current directory. There is
713 too much potential for confusion. */
714 return;
716 dirlen = end - program_name;
717 /* Make a copy of program_name in dir.
718 Leave room for later "/../lib". */
719 dir = (char *) xmalloc (dirlen + 8);
720 strncpy (dir, program_name, dirlen);
721 dir[dirlen] = '\0';
723 if (check_for_scripts_dir (dir))
725 free (dir);
726 return;
729 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
730 strcpy (dir + dirlen, "/../lib");
731 check_for_scripts_dir (dir);
732 free (dir);
735 void
736 add_ysym (name)
737 const char *name;
739 if (link_info.notice_hash == (struct bfd_hash_table *) NULL)
741 link_info.notice_hash = ((struct bfd_hash_table *)
742 xmalloc (sizeof (struct bfd_hash_table)));
743 if (! bfd_hash_table_init_n (link_info.notice_hash,
744 bfd_hash_newfunc,
745 61))
746 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
749 if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE)
750 == (struct bfd_hash_entry *) NULL)
751 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
754 /* Record a symbol to be wrapped, from the --wrap option. */
756 void
757 add_wrap (name)
758 const char *name;
760 if (link_info.wrap_hash == NULL)
762 link_info.wrap_hash = ((struct bfd_hash_table *)
763 xmalloc (sizeof (struct bfd_hash_table)));
764 if (! bfd_hash_table_init_n (link_info.wrap_hash,
765 bfd_hash_newfunc,
766 61))
767 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
770 if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
771 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
774 /* Handle the -retain-symbols-file option. */
776 void
777 add_keepsyms_file (filename)
778 const char *filename;
780 FILE *file;
781 char *buf;
782 size_t bufsize;
783 int c;
785 if (link_info.strip == strip_some)
786 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
788 file = fopen (filename, "r");
789 if (file == (FILE *) NULL)
791 bfd_set_error (bfd_error_system_call);
792 einfo ("%X%P: %s: %E\n", filename);
793 return;
796 link_info.keep_hash = ((struct bfd_hash_table *)
797 xmalloc (sizeof (struct bfd_hash_table)));
798 if (! bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc))
799 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
801 bufsize = 100;
802 buf = (char *) xmalloc (bufsize);
804 c = getc (file);
805 while (c != EOF)
807 while (ISSPACE (c))
808 c = getc (file);
810 if (c != EOF)
812 size_t len = 0;
814 while (! ISSPACE (c) && c != EOF)
816 buf[len] = c;
817 ++len;
818 if (len >= bufsize)
820 bufsize *= 2;
821 buf = xrealloc (buf, bufsize);
823 c = getc (file);
826 buf[len] = '\0';
828 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE)
829 == (struct bfd_hash_entry *) NULL)
830 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
834 if (link_info.strip != strip_none)
835 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
837 free (buf);
838 link_info.strip = strip_some;
841 /* Callbacks from the BFD linker routines. */
843 /* This is called when BFD has decided to include an archive member in
844 a link. */
846 static bfd_boolean
847 add_archive_element (info, abfd, name)
848 struct bfd_link_info *info ATTRIBUTE_UNUSED;
849 bfd *abfd;
850 const char *name;
852 lang_input_statement_type *input;
854 input = ((lang_input_statement_type *)
855 xmalloc (sizeof (lang_input_statement_type)));
856 input->filename = abfd->filename;
857 input->local_sym_name = abfd->filename;
858 input->the_bfd = abfd;
859 input->asymbols = NULL;
860 input->next = NULL;
861 input->just_syms_flag = FALSE;
862 input->loaded = FALSE;
863 input->search_dirs_flag = FALSE;
865 /* FIXME: The following fields are not set: header.next,
866 header.type, closed, passive_position, symbol_count,
867 next_real_file, is_archive, target, real. This bit of code is
868 from the old decode_library_subfile function. I don't know
869 whether any of those fields matters. */
871 ldlang_add_file (input);
873 if (config.map_file != (FILE *) NULL)
875 static bfd_boolean header_printed;
876 struct bfd_link_hash_entry *h;
877 bfd *from;
878 int len;
880 h = bfd_link_hash_lookup (link_info.hash, name, FALSE, FALSE, TRUE);
882 if (h == NULL)
883 from = NULL;
884 else
886 switch (h->type)
888 default:
889 from = NULL;
890 break;
892 case bfd_link_hash_defined:
893 case bfd_link_hash_defweak:
894 from = h->u.def.section->owner;
895 break;
897 case bfd_link_hash_undefined:
898 case bfd_link_hash_undefweak:
899 from = h->u.undef.abfd;
900 break;
902 case bfd_link_hash_common:
903 from = h->u.c.p->section->owner;
904 break;
908 if (! header_printed)
910 char buf[100];
912 sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
913 minfo ("%s", buf);
914 header_printed = TRUE;
917 if (bfd_my_archive (abfd) == NULL)
919 minfo ("%s", bfd_get_filename (abfd));
920 len = strlen (bfd_get_filename (abfd));
922 else
924 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
925 bfd_get_filename (abfd));
926 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
927 + strlen (bfd_get_filename (abfd))
928 + 2);
931 if (len >= 29)
933 print_nl ();
934 len = 0;
936 while (len < 30)
938 print_space ();
939 ++len;
942 if (from != NULL)
943 minfo ("%B ", from);
944 if (h != NULL)
945 minfo ("(%T)\n", h->root.string);
946 else
947 minfo ("(%s)\n", name);
950 if (trace_files || trace_file_tries)
951 info_msg ("%I\n", input);
953 return TRUE;
956 /* This is called when BFD has discovered a symbol which is defined
957 multiple times. */
959 static bfd_boolean
960 multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval)
961 struct bfd_link_info *info ATTRIBUTE_UNUSED;
962 const char *name;
963 bfd *obfd;
964 asection *osec;
965 bfd_vma oval;
966 bfd *nbfd;
967 asection *nsec;
968 bfd_vma nval;
970 /* If either section has the output_section field set to
971 bfd_abs_section_ptr, it means that the section is being
972 discarded, and this is not really a multiple definition at all.
973 FIXME: It would be cleaner to somehow ignore symbols defined in
974 sections which are being discarded. */
975 if ((osec->output_section != NULL
976 && ! bfd_is_abs_section (osec)
977 && bfd_is_abs_section (osec->output_section))
978 || (nsec->output_section != NULL
979 && ! bfd_is_abs_section (nsec)
980 && bfd_is_abs_section (nsec->output_section)))
981 return TRUE;
983 einfo (_("%X%C: multiple definition of `%T'\n"),
984 nbfd, nsec, nval, name);
985 if (obfd != (bfd *) NULL)
986 einfo (_("%D: first defined here\n"), obfd, osec, oval);
988 if (command_line.relax)
990 einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
991 command_line.relax = 0;
994 return TRUE;
997 /* This is called when there is a definition of a common symbol, or
998 when a common symbol is found for a symbol that is already defined,
999 or when two common symbols are found. We only do something if
1000 -warn-common was used. */
1002 static bfd_boolean
1003 multiple_common (info, name, obfd, otype, osize, nbfd, ntype, nsize)
1004 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1005 const char *name;
1006 bfd *obfd;
1007 enum bfd_link_hash_type otype;
1008 bfd_vma osize;
1009 bfd *nbfd;
1010 enum bfd_link_hash_type ntype;
1011 bfd_vma nsize;
1013 if (! config.warn_common)
1014 return TRUE;
1016 if (ntype == bfd_link_hash_defined
1017 || ntype == bfd_link_hash_defweak
1018 || ntype == bfd_link_hash_indirect)
1020 ASSERT (otype == bfd_link_hash_common);
1021 einfo (_("%B: warning: definition of `%T' overriding common\n"),
1022 nbfd, name);
1023 if (obfd != NULL)
1024 einfo (_("%B: warning: common is here\n"), obfd);
1026 else if (otype == bfd_link_hash_defined
1027 || otype == bfd_link_hash_defweak
1028 || otype == bfd_link_hash_indirect)
1030 ASSERT (ntype == bfd_link_hash_common);
1031 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1032 nbfd, name);
1033 if (obfd != NULL)
1034 einfo (_("%B: warning: defined here\n"), obfd);
1036 else
1038 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1039 if (osize > nsize)
1041 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1042 nbfd, name);
1043 if (obfd != NULL)
1044 einfo (_("%B: warning: larger common is here\n"), obfd);
1046 else if (nsize > osize)
1048 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1049 nbfd, name);
1050 if (obfd != NULL)
1051 einfo (_("%B: warning: smaller common is here\n"), obfd);
1053 else
1055 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1056 if (obfd != NULL)
1057 einfo (_("%B: warning: previous common is here\n"), obfd);
1061 return TRUE;
1064 /* This is called when BFD has discovered a set element. H is the
1065 entry in the linker hash table for the set. SECTION and VALUE
1066 represent a value which should be added to the set. */
1068 static bfd_boolean
1069 add_to_set (info, h, reloc, abfd, section, value)
1070 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1071 struct bfd_link_hash_entry *h;
1072 bfd_reloc_code_real_type reloc;
1073 bfd *abfd;
1074 asection *section;
1075 bfd_vma value;
1077 if (config.warn_constructors)
1078 einfo (_("%P: warning: global constructor %s used\n"),
1079 h->root.string);
1081 if (! config.build_constructors)
1082 return TRUE;
1084 ldctor_add_set_entry (h, reloc, (const char *) NULL, section, value);
1086 if (h->type == bfd_link_hash_new)
1088 h->type = bfd_link_hash_undefined;
1089 h->u.undef.abfd = abfd;
1090 /* We don't call bfd_link_add_undef to add this to the list of
1091 undefined symbols because we are going to define it
1092 ourselves. */
1095 return TRUE;
1098 /* This is called when BFD has discovered a constructor. This is only
1099 called for some object file formats--those which do not handle
1100 constructors in some more clever fashion. This is similar to
1101 adding an element to a set, but less general. */
1103 static bfd_boolean
1104 constructor_callback (info, constructor, name, abfd, section, value)
1105 struct bfd_link_info *info;
1106 bfd_boolean constructor;
1107 const char *name;
1108 bfd *abfd;
1109 asection *section;
1110 bfd_vma value;
1112 char *s;
1113 struct bfd_link_hash_entry *h;
1114 char set_name[1 + sizeof "__CTOR_LIST__"];
1116 if (config.warn_constructors)
1117 einfo (_("%P: warning: global constructor %s used\n"), name);
1119 if (! config.build_constructors)
1120 return TRUE;
1122 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1123 useful error message. */
1124 if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL
1125 && (link_info.relocateable
1126 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1127 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1129 s = set_name;
1130 if (bfd_get_symbol_leading_char (abfd) != '\0')
1131 *s++ = bfd_get_symbol_leading_char (abfd);
1132 if (constructor)
1133 strcpy (s, "__CTOR_LIST__");
1134 else
1135 strcpy (s, "__DTOR_LIST__");
1137 h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1138 if (h == (struct bfd_link_hash_entry *) NULL)
1139 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1140 if (h->type == bfd_link_hash_new)
1142 h->type = bfd_link_hash_undefined;
1143 h->u.undef.abfd = abfd;
1144 /* We don't call bfd_link_add_undef to add this to the list of
1145 undefined symbols because we are going to define it
1146 ourselves. */
1149 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1150 return TRUE;
1153 /* A structure used by warning_callback to pass information through
1154 bfd_map_over_sections. */
1156 struct warning_callback_info
1158 bfd_boolean found;
1159 const char *warning;
1160 const char *symbol;
1161 asymbol **asymbols;
1164 /* This is called when there is a reference to a warning symbol. */
1166 static bfd_boolean
1167 warning_callback (info, warning, symbol, abfd, section, address)
1168 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1169 const char *warning;
1170 const char *symbol;
1171 bfd *abfd;
1172 asection *section;
1173 bfd_vma address;
1175 /* This is a hack to support warn_multiple_gp. FIXME: This should
1176 have a cleaner interface, but what? */
1177 if (! config.warn_multiple_gp
1178 && strcmp (warning, "using multiple gp values") == 0)
1179 return TRUE;
1181 if (section != NULL)
1182 einfo ("%C: %s\n", abfd, section, address, warning);
1183 else if (abfd == NULL)
1184 einfo ("%P: %s\n", warning);
1185 else if (symbol == NULL)
1186 einfo ("%B: %s\n", abfd, warning);
1187 else
1189 lang_input_statement_type *entry;
1190 asymbol **asymbols;
1191 struct warning_callback_info info;
1193 /* Look through the relocs to see if we can find a plausible
1194 address. */
1195 entry = (lang_input_statement_type *) abfd->usrdata;
1196 if (entry != NULL && entry->asymbols != NULL)
1197 asymbols = entry->asymbols;
1198 else
1200 long symsize;
1201 long symbol_count;
1203 symsize = bfd_get_symtab_upper_bound (abfd);
1204 if (symsize < 0)
1205 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1206 asymbols = (asymbol **) xmalloc (symsize);
1207 symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
1208 if (symbol_count < 0)
1209 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1210 if (entry != NULL)
1212 entry->asymbols = asymbols;
1213 entry->symbol_count = symbol_count;
1217 info.found = FALSE;
1218 info.warning = warning;
1219 info.symbol = symbol;
1220 info.asymbols = asymbols;
1221 bfd_map_over_sections (abfd, warning_find_reloc, (PTR) &info);
1223 if (! info.found)
1224 einfo ("%B: %s\n", abfd, warning);
1226 if (entry == NULL)
1227 free (asymbols);
1230 return TRUE;
1233 /* This is called by warning_callback for each section. It checks the
1234 relocs of the section to see if it can find a reference to the
1235 symbol which triggered the warning. If it can, it uses the reloc
1236 to give an error message with a file and line number. */
1238 static void
1239 warning_find_reloc (abfd, sec, iarg)
1240 bfd *abfd;
1241 asection *sec;
1242 PTR iarg;
1244 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1245 long relsize;
1246 arelent **relpp;
1247 long relcount;
1248 arelent **p, **pend;
1250 if (info->found)
1251 return;
1253 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1254 if (relsize < 0)
1255 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1256 if (relsize == 0)
1257 return;
1259 relpp = (arelent **) xmalloc (relsize);
1260 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1261 if (relcount < 0)
1262 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1264 p = relpp;
1265 pend = p + relcount;
1266 for (; p < pend && *p != NULL; p++)
1268 arelent *q = *p;
1270 if (q->sym_ptr_ptr != NULL
1271 && *q->sym_ptr_ptr != NULL
1272 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1274 /* We found a reloc for the symbol we are looking for. */
1275 einfo ("%C: %s\n", abfd, sec, q->address, info->warning);
1276 info->found = TRUE;
1277 break;
1281 free (relpp);
1284 /* This is called when an undefined symbol is found. */
1286 static bfd_boolean
1287 undefined_symbol (info, name, abfd, section, address, fatal)
1288 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1289 const char *name;
1290 bfd *abfd;
1291 asection *section;
1292 bfd_vma address;
1293 bfd_boolean fatal ATTRIBUTE_UNUSED;
1295 static char *error_name;
1296 static unsigned int error_count;
1298 #define MAX_ERRORS_IN_A_ROW 5
1300 if (config.warn_once)
1302 static struct bfd_hash_table *hash;
1304 /* Only warn once about a particular undefined symbol. */
1305 if (hash == NULL)
1307 hash = ((struct bfd_hash_table *)
1308 xmalloc (sizeof (struct bfd_hash_table)));
1309 if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
1310 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1313 if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1314 return TRUE;
1316 if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1317 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1320 /* We never print more than a reasonable number of errors in a row
1321 for a single symbol. */
1322 if (error_name != (char *) NULL
1323 && strcmp (name, error_name) == 0)
1324 ++error_count;
1325 else
1327 error_count = 0;
1328 if (error_name != (char *) NULL)
1329 free (error_name);
1330 error_name = xstrdup (name);
1333 if (section != NULL)
1335 if (error_count < MAX_ERRORS_IN_A_ROW)
1337 einfo (_("%C: undefined reference to `%T'\n"),
1338 abfd, section, address, name);
1339 if (fatal)
1340 einfo ("%X");
1342 else if (error_count == MAX_ERRORS_IN_A_ROW)
1343 einfo (_("%D: more undefined references to `%T' follow\n"),
1344 abfd, section, address, name);
1346 else
1348 if (error_count < MAX_ERRORS_IN_A_ROW)
1350 einfo (_("%B: undefined reference to `%T'\n"),
1351 abfd, name);
1352 if (fatal)
1353 einfo ("%X");
1355 else if (error_count == MAX_ERRORS_IN_A_ROW)
1356 einfo (_("%B: more undefined references to `%T' follow\n"),
1357 abfd, name);
1360 return TRUE;
1363 /* This is called when a reloc overflows. */
1365 static bfd_boolean
1366 reloc_overflow (info, name, reloc_name, addend, abfd, section, address)
1367 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1368 const char *name;
1369 const char *reloc_name;
1370 bfd_vma addend;
1371 bfd *abfd;
1372 asection *section;
1373 bfd_vma address;
1375 if (abfd == (bfd *) NULL)
1376 einfo (_("%P%X: generated"));
1377 else
1378 einfo ("%X%C:", abfd, section, address);
1379 einfo (_(" relocation truncated to fit: %s %T"), reloc_name, name);
1380 if (addend != 0)
1381 einfo ("+%v", addend);
1382 einfo ("\n");
1383 return TRUE;
1386 /* This is called when a dangerous relocation is made. */
1388 static bfd_boolean
1389 reloc_dangerous (info, message, abfd, section, address)
1390 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1391 const char *message;
1392 bfd *abfd;
1393 asection *section;
1394 bfd_vma address;
1396 if (abfd == (bfd *) NULL)
1397 einfo (_("%P%X: generated"));
1398 else
1399 einfo ("%X%C:", abfd, section, address);
1400 einfo (_("dangerous relocation: %s\n"), message);
1401 return TRUE;
1404 /* This is called when a reloc is being generated attached to a symbol
1405 that is not being output. */
1407 static bfd_boolean
1408 unattached_reloc (info, name, abfd, section, address)
1409 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1410 const char *name;
1411 bfd *abfd;
1412 asection *section;
1413 bfd_vma address;
1415 if (abfd == (bfd *) NULL)
1416 einfo (_("%P%X: generated"));
1417 else
1418 einfo ("%X%C:", abfd, section, address);
1419 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name);
1420 return TRUE;
1423 /* This is called if link_info.notice_all is set, or when a symbol in
1424 link_info.notice_hash is found. Symbols are put in notice_hash
1425 using the -y option. */
1427 static bfd_boolean
1428 notice (info, name, abfd, section, value)
1429 struct bfd_link_info *info;
1430 const char *name;
1431 bfd *abfd;
1432 asection *section;
1433 bfd_vma value;
1435 if (! info->notice_all
1436 || (info->notice_hash != NULL
1437 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1439 if (bfd_is_und_section (section))
1440 einfo ("%B: reference to %s\n", abfd, name);
1441 else
1442 einfo ("%B: definition of %s\n", abfd, name);
1445 if (command_line.cref || nocrossref_list != NULL)
1446 add_cref (name, abfd, section, value);
1448 return TRUE;