* Makefile.am: Rebuild dependencies.
[binutils.git] / ld / ldmain.c
blob1e710dbb6504cfe0937dd3c8bb294285a47ffaee
1 /* Main program of GNU linker.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
4 Written by Steve Chamberlain steve@cygnus.com
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include <stdio.h>
26 #include <ctype.h>
27 #include "libiberty.h"
28 #include "progress.h"
29 #include "bfdlink.h"
31 #include "ld.h"
32 #include "ldmain.h"
33 #include "ldmisc.h"
34 #include "ldwrite.h"
35 #include "ldgram.h"
36 #include "ldexp.h"
37 #include "ldlang.h"
38 #include "ldemul.h"
39 #include "ldlex.h"
40 #include "ldfile.h"
41 #include "ldctor.h"
43 /* Somewhere above, sys/stat.h got included . . . . */
44 #if !defined(S_ISDIR) && defined(S_IFDIR)
45 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
46 #endif
48 #include <string.h>
50 #ifdef HAVE_SBRK
51 #ifdef NEED_DECLARATION_SBRK
52 extern PTR sbrk ();
53 #endif
54 #endif
56 static char *get_emulation PARAMS ((int, char **));
57 static void set_scripts_dir PARAMS ((void));
59 /* EXPORTS */
61 char *default_target;
62 const char *output_filename = "a.out";
64 /* Name this program was invoked by. */
65 char *program_name;
67 /* The file that we're creating */
68 bfd *output_bfd = 0;
70 /* Set by -G argument, for MIPS ECOFF target. */
71 int g_switch_value = 8;
73 /* Nonzero means print names of input files as processed. */
74 boolean trace_files;
76 /* Nonzero means same, but note open failures, too. */
77 boolean trace_file_tries;
79 /* Nonzero means version number was printed, so exit successfully
80 instead of complaining if no input files are given. */
81 boolean version_printed;
83 /* Nonzero means link in every member of an archive. */
84 boolean whole_archive;
86 /* True if we should demangle symbol names. */
87 boolean demangling;
89 args_type command_line;
91 ld_config_type config;
93 static void remove_output PARAMS ((void));
94 static boolean check_for_scripts_dir PARAMS ((char *dir));
95 static boolean add_archive_element PARAMS ((struct bfd_link_info *, bfd *,
96 const char *));
97 static boolean multiple_definition PARAMS ((struct bfd_link_info *,
98 const char *,
99 bfd *, asection *, bfd_vma,
100 bfd *, asection *, bfd_vma));
101 static boolean multiple_common PARAMS ((struct bfd_link_info *,
102 const char *, bfd *,
103 enum bfd_link_hash_type, bfd_vma,
104 bfd *, enum bfd_link_hash_type,
105 bfd_vma));
106 static boolean add_to_set PARAMS ((struct bfd_link_info *,
107 struct bfd_link_hash_entry *,
108 bfd_reloc_code_real_type,
109 bfd *, asection *, bfd_vma));
110 static boolean constructor_callback PARAMS ((struct bfd_link_info *,
111 boolean constructor,
112 const char *name,
113 bfd *, asection *, bfd_vma));
114 static boolean warning_callback PARAMS ((struct bfd_link_info *,
115 const char *, const char *, bfd *,
116 asection *, bfd_vma));
117 static void warning_find_reloc PARAMS ((bfd *, asection *, PTR));
118 static boolean undefined_symbol PARAMS ((struct bfd_link_info *,
119 const char *, bfd *,
120 asection *, bfd_vma));
121 static boolean reloc_overflow PARAMS ((struct bfd_link_info *, const char *,
122 const char *, bfd_vma,
123 bfd *, asection *, bfd_vma));
124 static boolean reloc_dangerous PARAMS ((struct bfd_link_info *, const char *,
125 bfd *, asection *, bfd_vma));
126 static boolean unattached_reloc PARAMS ((struct bfd_link_info *,
127 const char *, bfd *, asection *,
128 bfd_vma));
129 static boolean notice PARAMS ((struct bfd_link_info *, const char *,
130 bfd *, asection *, bfd_vma));
132 static struct bfd_link_callbacks link_callbacks =
134 add_archive_element,
135 multiple_definition,
136 multiple_common,
137 add_to_set,
138 constructor_callback,
139 warning_callback,
140 undefined_symbol,
141 reloc_overflow,
142 reloc_dangerous,
143 unattached_reloc,
144 notice
147 struct bfd_link_info link_info;
149 static void
150 remove_output ()
152 if (output_filename)
154 if (output_bfd && output_bfd->iostream)
155 fclose((FILE *)(output_bfd->iostream));
156 if (delete_output_file_on_failure)
157 unlink (output_filename);
162 main (argc, argv)
163 int argc;
164 char **argv;
166 char *emulation;
167 long start_time = get_run_time ();
169 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
170 setlocale (LC_MESSAGES, "");
171 #endif
172 bindtextdomain (PACKAGE, LOCALEDIR);
173 textdomain (PACKAGE);
175 program_name = argv[0];
176 xmalloc_set_program_name (program_name);
178 START_PROGRESS (program_name, 0);
180 bfd_init ();
182 bfd_set_error_program_name (program_name);
184 xatexit (remove_output);
186 /* Set the default BFD target based on the configured target. Doing
187 this permits the linker to be configured for a particular target,
188 and linked against a shared BFD library which was configured for
189 a different target. The macro TARGET is defined by Makefile. */
190 if (! bfd_set_default_target (TARGET))
192 einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
193 xexit (1);
196 /* Initialize the data about options. */
197 trace_files = trace_file_tries = version_printed = false;
198 whole_archive = false;
199 config.build_constructors = true;
200 config.dynamic_link = false;
201 config.has_shared = false;
202 command_line.force_common_definition = false;
203 command_line.interpreter = NULL;
204 command_line.rpath = NULL;
205 command_line.warn_mismatch = true;
206 command_line.check_section_addresses = true;
208 /* We initialize DEMANGLING based on the environment variable
209 COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
210 output of the linker, unless COLLECT_NO_DEMANGLE is set in the
211 environment. Acting the same way here lets us provide the same
212 interface by default. */
213 demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
215 link_info.callbacks = &link_callbacks;
216 link_info.relocateable = false;
217 link_info.shared = false;
218 link_info.symbolic = false;
219 link_info.static_link = false;
220 link_info.traditional_format = false;
221 link_info.optimize = false;
222 link_info.no_undefined = false;
223 link_info.strip = strip_none;
224 link_info.discard = discard_none;
225 link_info.keep_memory = true;
226 link_info.input_bfds = NULL;
227 link_info.create_object_symbols_section = NULL;
228 link_info.hash = NULL;
229 link_info.keep_hash = NULL;
230 link_info.notice_all = false;
231 link_info.notice_hash = NULL;
232 link_info.wrap_hash = NULL;
233 link_info.mpc860c0 = 0;
235 ldfile_add_arch ("");
237 config.make_executable = true;
238 force_make_executable = false;
239 config.magic_demand_paged = true;
240 config.text_read_only = true;
241 config.make_executable = true;
243 emulation = get_emulation (argc, argv);
244 ldemul_choose_mode (emulation);
245 default_target = ldemul_choose_target ();
246 lang_init ();
247 ldemul_before_parse ();
248 lang_has_input_file = false;
249 parse_args (argc, argv);
251 ldemul_set_symbols ();
253 if (link_info.relocateable)
255 if (command_line.gc_sections)
256 einfo ("%P%F: --gc-sections and -r may not be used together\n");
257 if (link_info.mpc860c0)
258 einfo (_("%P%F: -r and --mpc860c0 may not be used together\n"));
259 else if (command_line.relax)
260 einfo (_("%P%F: --relax and -r may not be used together\n"));
261 if (link_info.shared)
262 einfo (_("%P%F: -r and -shared may not be used together\n"));
265 /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
266 don't see how else this can be handled, since in this case we
267 must preserve all externally visible symbols. */
268 if (link_info.relocateable && link_info.strip == strip_all)
270 link_info.strip = strip_debugger;
271 if (link_info.discard == discard_none)
272 link_info.discard = discard_all;
275 /* This essentially adds another -L directory so this must be done after
276 the -L's in argv have been processed. */
277 set_scripts_dir ();
279 if (had_script == false)
281 /* Read the emulation's appropriate default script. */
282 int isfile;
283 char *s = ldemul_get_script (&isfile);
285 if (isfile)
286 ldfile_open_command_file (s);
287 else
289 if (trace_file_tries)
291 info_msg (_("using internal linker script:\n"));
292 info_msg ("==================================================\n");
293 info_msg (s);
294 info_msg ("\n==================================================\n");
296 lex_string = s;
297 lex_redirect (s);
299 parser_input = input_script;
300 yyparse ();
301 lex_string = NULL;
304 lang_final ();
306 if (lang_has_input_file == false)
308 if (version_printed)
309 xexit (0);
310 einfo (_("%P%F: no input files\n"));
313 if (trace_files)
315 info_msg (_("%P: mode %s\n"), emulation);
318 ldemul_after_parse ();
321 if (config.map_filename)
323 if (strcmp (config.map_filename, "-") == 0)
325 config.map_file = stdout;
327 else
329 config.map_file = fopen (config.map_filename, FOPEN_WT);
330 if (config.map_file == (FILE *) NULL)
332 bfd_set_error (bfd_error_system_call);
333 einfo (_("%P%F: cannot open map file %s: %E\n"),
334 config.map_filename);
340 lang_process ();
342 /* Print error messages for any missing symbols, for any warning
343 symbols, and possibly multiple definitions */
346 if (config.text_read_only)
348 /* Look for a text section and mark the readonly attribute in it */
349 asection *found = bfd_get_section_by_name (output_bfd, ".text");
351 if (found != (asection *) NULL)
353 found->flags |= SEC_READONLY;
357 if (link_info.relocateable)
358 output_bfd->flags &= ~EXEC_P;
359 else
360 output_bfd->flags |= EXEC_P;
362 ldwrite ();
364 if (config.map_file != NULL)
365 lang_map ();
366 if (command_line.cref)
367 output_cref (config.map_file != NULL ? config.map_file : stdout);
368 if (nocrossref_list != NULL)
369 check_nocrossrefs ();
371 /* Even if we're producing relocateable output, some non-fatal errors should
372 be reported in the exit status. (What non-fatal errors, if any, do we
373 want to ignore for relocateable output?) */
375 if (config.make_executable == false && force_make_executable == false)
377 if (trace_files == true)
379 einfo (_("%P: link errors found, deleting executable `%s'\n"),
380 output_filename);
383 /* The file will be removed by remove_output. */
385 xexit (1);
387 else
389 if (! bfd_close (output_bfd))
390 einfo (_("%F%B: final close failed: %E\n"), output_bfd);
392 /* If the --force-exe-suffix is enabled, and we're making an
393 executable file and it doesn't end in .exe, copy it to one which does. */
395 if (! link_info.relocateable && command_line.force_exe_suffix)
397 int len = strlen (output_filename);
398 if (len < 4
399 || (strcasecmp (output_filename + len - 4, ".exe") != 0
400 && strcasecmp (output_filename + len - 4, ".dll") != 0))
402 FILE *src;
403 FILE *dst;
404 const int bsize = 4096;
405 char *buf = xmalloc (bsize);
406 int l;
407 char *dst_name = xmalloc (len + 5);
408 strcpy (dst_name, output_filename);
409 strcat (dst_name, ".exe");
410 src = fopen (output_filename, FOPEN_RB);
411 dst = fopen (dst_name, FOPEN_WB);
413 if (!src)
414 einfo (_("%X%P: unable to open for source of copy `%s'\n"), output_filename);
415 if (!dst)
416 einfo (_("%X%P: unable to open for destination of copy `%s'\n"), dst_name);
417 while ((l = fread (buf, 1, bsize, src)) > 0)
419 int done = fwrite (buf, 1, l, dst);
420 if (done != l)
422 einfo (_("%P: Error writing file `%s'\n"), dst_name);
425 fclose (src);
426 if (fclose (dst) == EOF)
428 einfo (_("%P: Error closing file `%s'\n"), dst_name);
430 free (dst_name);
431 free (buf);
436 END_PROGRESS (program_name);
438 if (config.stats)
440 #ifdef HAVE_SBRK
441 char *lim = (char *) sbrk (0);
442 #endif
443 long run_time = get_run_time () - start_time;
445 fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
446 program_name, run_time / 1000000, run_time % 1000000);
447 #ifdef HAVE_SBRK
448 fprintf (stderr, _("%s: data size %ld\n"), program_name,
449 (long) (lim - (char *) &environ));
450 #endif
453 /* Prevent remove_output from doing anything, after a successful link. */
454 output_filename = NULL;
456 xexit (0);
457 return 0;
460 /* We need to find any explicitly given emulation in order to initialize the
461 state that's needed by the lex&yacc argument parser (parse_args). */
463 static char *
464 get_emulation (argc, argv)
465 int argc;
466 char **argv;
468 char *emulation;
469 int i;
471 emulation = getenv (EMULATION_ENVIRON);
472 if (emulation == NULL)
473 emulation = DEFAULT_EMULATION;
475 for (i = 1; i < argc; i++)
477 if (!strncmp (argv[i], "-m", 2))
479 if (argv[i][2] == '\0')
481 /* -m EMUL */
482 if (i < argc - 1)
484 emulation = argv[i + 1];
485 i++;
487 else
489 einfo(_("%P%F: missing argument to -m\n"));
492 else if (strcmp (argv[i], "-mips1") == 0
493 || strcmp (argv[i], "-mips2") == 0
494 || strcmp (argv[i], "-mips3") == 0
495 || strcmp (argv[i], "-mips4") == 0)
497 /* FIXME: The arguments -mips1, -mips2 and -mips3 are
498 passed to the linker by some MIPS compilers. They
499 generally tell the linker to use a slightly different
500 library path. Perhaps someday these should be
501 implemented as emulations; until then, we just ignore
502 the arguments and hope that nobody ever creates
503 emulations named ips1, ips2 or ips3. */
505 else if (strcmp (argv[i], "-m486") == 0)
507 /* FIXME: The argument -m486 is passed to the linker on
508 some Linux systems. Hope that nobody creates an
509 emulation named 486. */
511 else
513 /* -mEMUL */
514 emulation = &argv[i][2];
519 return emulation;
522 /* If directory DIR contains an "ldscripts" subdirectory,
523 add DIR to the library search path and return true,
524 else return false. */
526 static boolean
527 check_for_scripts_dir (dir)
528 char *dir;
530 size_t dirlen;
531 char *buf;
532 struct stat s;
533 boolean res;
535 dirlen = strlen (dir);
536 /* sizeof counts the terminating NUL. */
537 buf = (char *) xmalloc (dirlen + sizeof("/ldscripts"));
538 sprintf (buf, "%s/ldscripts", dir);
540 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
541 free (buf);
542 if (res)
543 ldfile_add_library_path (dir, false);
544 return res;
547 /* Set the default directory for finding script files.
548 Libraries will be searched for here too, but that's ok.
549 We look for the "ldscripts" directory in:
551 SCRIPTDIR (passed from Makefile)
552 the dir where this program is (for using it from the build tree)
553 the dir where this program is/../lib (for installing the tool suite elsewhere) */
555 static void
556 set_scripts_dir ()
558 char *end, *dir;
559 size_t dirlen;
561 if (check_for_scripts_dir (SCRIPTDIR))
562 return; /* We've been installed normally. */
564 /* Look for "ldscripts" in the dir where our binary is. */
565 end = strrchr (program_name, '/');
567 if (end == NULL)
569 /* Don't look for ldscripts in the current directory. There is
570 too much potential for confusion. */
571 return;
574 dirlen = end - program_name;
575 /* Make a copy of program_name in dir.
576 Leave room for later "/../lib". */
577 dir = (char *) xmalloc (dirlen + 8);
578 strncpy (dir, program_name, dirlen);
579 dir[dirlen] = '\0';
581 if (check_for_scripts_dir (dir))
582 return; /* Don't free dir. */
584 /* Look for "ldscripts" in <the dir where our binary is>/../lib. */
585 strcpy (dir + dirlen, "/../lib");
586 if (check_for_scripts_dir (dir))
587 return;
589 free (dir); /* Well, we tried. */
592 void
593 add_ysym (name)
594 const char *name;
596 if (link_info.notice_hash == (struct bfd_hash_table *) NULL)
598 link_info.notice_hash = ((struct bfd_hash_table *)
599 xmalloc (sizeof (struct bfd_hash_table)));
600 if (! bfd_hash_table_init_n (link_info.notice_hash,
601 bfd_hash_newfunc,
602 61))
603 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
606 if (bfd_hash_lookup (link_info.notice_hash, name, true, true)
607 == (struct bfd_hash_entry *) NULL)
608 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
611 /* Record a symbol to be wrapped, from the --wrap option. */
613 void
614 add_wrap (name)
615 const char *name;
617 if (link_info.wrap_hash == NULL)
619 link_info.wrap_hash = ((struct bfd_hash_table *)
620 xmalloc (sizeof (struct bfd_hash_table)));
621 if (! bfd_hash_table_init_n (link_info.wrap_hash,
622 bfd_hash_newfunc,
623 61))
624 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
626 if (bfd_hash_lookup (link_info.wrap_hash, name, true, true) == NULL)
627 einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
630 /* Handle the -retain-symbols-file option. */
632 void
633 add_keepsyms_file (filename)
634 const char *filename;
636 FILE *file;
637 char *buf;
638 size_t bufsize;
639 int c;
641 if (link_info.strip == strip_some)
642 einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
644 file = fopen (filename, "r");
645 if (file == (FILE *) NULL)
647 bfd_set_error (bfd_error_system_call);
648 einfo ("%X%P: %s: %E\n", filename);
649 return;
652 link_info.keep_hash = ((struct bfd_hash_table *)
653 xmalloc (sizeof (struct bfd_hash_table)));
654 if (! bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc))
655 einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
657 bufsize = 100;
658 buf = (char *) xmalloc (bufsize);
660 c = getc (file);
661 while (c != EOF)
663 while (isspace (c))
664 c = getc (file);
666 if (c != EOF)
668 size_t len = 0;
670 while (! isspace (c) && c != EOF)
672 buf[len] = c;
673 ++len;
674 if (len >= bufsize)
676 bufsize *= 2;
677 buf = xrealloc (buf, bufsize);
679 c = getc (file);
682 buf[len] = '\0';
684 if (bfd_hash_lookup (link_info.keep_hash, buf, true, true)
685 == (struct bfd_hash_entry *) NULL)
686 einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
690 if (link_info.strip != strip_none)
691 einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
693 link_info.strip = strip_some;
696 /* Callbacks from the BFD linker routines. */
698 /* This is called when BFD has decided to include an archive member in
699 a link. */
701 /*ARGSUSED*/
702 static boolean
703 add_archive_element (info, abfd, name)
704 struct bfd_link_info *info;
705 bfd *abfd;
706 const char *name;
708 lang_input_statement_type *input;
710 input = ((lang_input_statement_type *)
711 xmalloc (sizeof (lang_input_statement_type)));
712 input->filename = abfd->filename;
713 input->local_sym_name = abfd->filename;
714 input->the_bfd = abfd;
715 input->asymbols = NULL;
716 input->next = NULL;
717 input->just_syms_flag = false;
718 input->loaded = false;
719 input->search_dirs_flag = false;
721 /* FIXME: The following fields are not set: header.next,
722 header.type, closed, passive_position, symbol_count,
723 next_real_file, is_archive, target, real. This bit of code is
724 from the old decode_library_subfile function. I don't know
725 whether any of those fields matters. */
727 ldlang_add_file (input);
729 if (config.map_file != (FILE *) NULL)
731 static boolean header_printed;
732 struct bfd_link_hash_entry *h;
733 bfd *from;
734 int len;
736 h = bfd_link_hash_lookup (link_info.hash, name, false, false, true);
738 if (h == NULL)
739 from = NULL;
740 else
742 switch (h->type)
744 default:
745 from = NULL;
746 break;
748 case bfd_link_hash_defined:
749 case bfd_link_hash_defweak:
750 from = h->u.def.section->owner;
751 break;
753 case bfd_link_hash_undefined:
754 case bfd_link_hash_undefweak:
755 from = h->u.undef.abfd;
756 break;
758 case bfd_link_hash_common:
759 from = h->u.c.p->section->owner;
760 break;
764 if (! header_printed)
766 char buf[100];
768 sprintf (buf, "%-29s %s\n\n", _("Archive member included"),
769 _("because of file (symbol)"));
770 minfo ("%s", buf);
771 header_printed = true;
774 if (bfd_my_archive (abfd) == NULL)
776 minfo ("%s", bfd_get_filename (abfd));
777 len = strlen (bfd_get_filename (abfd));
779 else
781 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
782 bfd_get_filename (abfd));
783 len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
784 + strlen (bfd_get_filename (abfd))
785 + 2);
788 if (len >= 29)
790 print_nl ();
791 len = 0;
793 while (len < 30)
795 print_space ();
796 ++len;
799 if (from != NULL)
800 minfo ("%B ", from);
801 if (h != NULL)
802 minfo ("(%T)\n", h->root.string);
803 else
804 minfo ("(%s)\n", name);
807 if (trace_files || trace_file_tries)
808 info_msg ("%I\n", input);
810 return true;
813 /* This is called when BFD has discovered a symbol which is defined
814 multiple times. */
816 /*ARGSUSED*/
817 static boolean
818 multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval)
819 struct bfd_link_info *info;
820 const char *name;
821 bfd *obfd;
822 asection *osec;
823 bfd_vma oval;
824 bfd *nbfd;
825 asection *nsec;
826 bfd_vma nval;
828 /* If either section has the output_section field set to
829 bfd_abs_section_ptr, it means that the section is being
830 discarded, and this is not really a multiple definition at all.
831 FIXME: It would be cleaner to somehow ignore symbols defined in
832 sections which are being discarded. */
833 if ((osec->output_section != NULL
834 && ! bfd_is_abs_section (osec)
835 && bfd_is_abs_section (osec->output_section))
836 || (nsec->output_section != NULL
837 && ! bfd_is_abs_section (nsec)
838 && bfd_is_abs_section (nsec->output_section)))
839 return true;
841 einfo (_("%X%C: multiple definition of `%T'\n"),
842 nbfd, nsec, nval, name);
843 if (obfd != (bfd *) NULL)
844 einfo (_("%D: first defined here\n"), obfd, osec, oval);
845 return true;
848 /* This is called when there is a definition of a common symbol, or
849 when a common symbol is found for a symbol that is already defined,
850 or when two common symbols are found. We only do something if
851 -warn-common was used. */
853 /*ARGSUSED*/
854 static boolean
855 multiple_common (info, name, obfd, otype, osize, nbfd, ntype, nsize)
856 struct bfd_link_info *info;
857 const char *name;
858 bfd *obfd;
859 enum bfd_link_hash_type otype;
860 bfd_vma osize;
861 bfd *nbfd;
862 enum bfd_link_hash_type ntype;
863 bfd_vma nsize;
865 if (! config.warn_common)
866 return true;
868 if (ntype == bfd_link_hash_defined
869 || ntype == bfd_link_hash_defweak
870 || ntype == bfd_link_hash_indirect)
872 ASSERT (otype == bfd_link_hash_common);
873 einfo (_("%B: warning: definition of `%T' overriding common\n"),
874 nbfd, name);
875 if (obfd != NULL)
876 einfo (_("%B: warning: common is here\n"), obfd);
878 else if (otype == bfd_link_hash_defined
879 || otype == bfd_link_hash_defweak
880 || otype == bfd_link_hash_indirect)
882 ASSERT (ntype == bfd_link_hash_common);
883 einfo (_("%B: warning: common of `%T' overridden by definition\n"),
884 nbfd, name);
885 if (obfd != NULL)
886 einfo (_("%B: warning: defined here\n"), obfd);
888 else
890 ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
891 if (osize > nsize)
893 einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
894 nbfd, name);
895 if (obfd != NULL)
896 einfo (_("%B: warning: larger common is here\n"), obfd);
898 else if (nsize > osize)
900 einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
901 nbfd, name);
902 if (obfd != NULL)
903 einfo (_("%B: warning: smaller common is here\n"), obfd);
905 else
907 einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
908 if (obfd != NULL)
909 einfo (_("%B: warning: previous common is here\n"), obfd);
913 return true;
916 /* This is called when BFD has discovered a set element. H is the
917 entry in the linker hash table for the set. SECTION and VALUE
918 represent a value which should be added to the set. */
920 /*ARGSUSED*/
921 static boolean
922 add_to_set (info, h, reloc, abfd, section, value)
923 struct bfd_link_info *info;
924 struct bfd_link_hash_entry *h;
925 bfd_reloc_code_real_type reloc;
926 bfd *abfd;
927 asection *section;
928 bfd_vma value;
930 if (config.warn_constructors)
931 einfo (_("%P: warning: global constructor %s used\n"),
932 h->root.string);
934 if (! config.build_constructors)
935 return true;
937 ldctor_add_set_entry (h, reloc, (const char *) NULL, section, value);
939 if (h->type == bfd_link_hash_new)
941 h->type = bfd_link_hash_undefined;
942 h->u.undef.abfd = abfd;
943 /* We don't call bfd_link_add_undef to add this to the list of
944 undefined symbols because we are going to define it
945 ourselves. */
948 return true;
951 /* This is called when BFD has discovered a constructor. This is only
952 called for some object file formats--those which do not handle
953 constructors in some more clever fashion. This is similar to
954 adding an element to a set, but less general. */
956 static boolean
957 constructor_callback (info, constructor, name, abfd, section, value)
958 struct bfd_link_info *info;
959 boolean constructor;
960 const char *name;
961 bfd *abfd;
962 asection *section;
963 bfd_vma value;
965 char *s;
966 struct bfd_link_hash_entry *h;
967 char set_name[1 + sizeof "__CTOR_LIST__"];
969 if (config.warn_constructors)
970 einfo (_("%P: warning: global constructor %s used\n"), name);
972 if (! config.build_constructors)
973 return true;
975 /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
976 useful error message. */
977 if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL
978 && (link_info.relocateable
979 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
980 einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
982 s = set_name;
983 if (bfd_get_symbol_leading_char (abfd) != '\0')
984 *s++ = bfd_get_symbol_leading_char (abfd);
985 if (constructor)
986 strcpy (s, "__CTOR_LIST__");
987 else
988 strcpy (s, "__DTOR_LIST__");
990 h = bfd_link_hash_lookup (info->hash, set_name, true, true, true);
991 if (h == (struct bfd_link_hash_entry *) NULL)
992 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
993 if (h->type == bfd_link_hash_new)
995 h->type = bfd_link_hash_undefined;
996 h->u.undef.abfd = abfd;
997 /* We don't call bfd_link_add_undef to add this to the list of
998 undefined symbols because we are going to define it
999 ourselves. */
1002 ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1003 return true;
1006 /* A structure used by warning_callback to pass information through
1007 bfd_map_over_sections. */
1009 struct warning_callback_info
1011 boolean found;
1012 const char *warning;
1013 const char *symbol;
1014 asymbol **asymbols;
1017 /* This is called when there is a reference to a warning symbol. */
1019 /*ARGSUSED*/
1020 static boolean
1021 warning_callback (info, warning, symbol, abfd, section, address)
1022 struct bfd_link_info *info;
1023 const char *warning;
1024 const char *symbol;
1025 bfd *abfd;
1026 asection *section;
1027 bfd_vma address;
1029 /* This is a hack to support warn_multiple_gp. FIXME: This should
1030 have a cleaner interface, but what? */
1031 if (! config.warn_multiple_gp
1032 && strcmp (warning, "using multiple gp values") == 0)
1033 return true;
1035 if (section != NULL)
1036 einfo ("%C: %s\n", abfd, section, address, warning);
1037 else if (abfd == NULL)
1038 einfo ("%P: %s\n", warning);
1039 else if (symbol == NULL)
1040 einfo ("%B: %s\n", abfd, warning);
1041 else
1043 lang_input_statement_type *entry;
1044 asymbol **asymbols;
1045 struct warning_callback_info info;
1047 /* Look through the relocs to see if we can find a plausible
1048 address. */
1050 entry = (lang_input_statement_type *) abfd->usrdata;
1051 if (entry != NULL && entry->asymbols != NULL)
1052 asymbols = entry->asymbols;
1053 else
1055 long symsize;
1056 long symbol_count;
1058 symsize = bfd_get_symtab_upper_bound (abfd);
1059 if (symsize < 0)
1060 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1061 asymbols = (asymbol **) xmalloc (symsize);
1062 symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
1063 if (symbol_count < 0)
1064 einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1065 if (entry != NULL)
1067 entry->asymbols = asymbols;
1068 entry->symbol_count = symbol_count;
1072 info.found = false;
1073 info.warning = warning;
1074 info.symbol = symbol;
1075 info.asymbols = asymbols;
1076 bfd_map_over_sections (abfd, warning_find_reloc, (PTR) &info);
1078 if (! info.found)
1079 einfo ("%B: %s\n", abfd, warning);
1081 if (entry == NULL)
1082 free (asymbols);
1085 return true;
1088 /* This is called by warning_callback for each section. It checks the
1089 relocs of the section to see if it can find a reference to the
1090 symbol which triggered the warning. If it can, it uses the reloc
1091 to give an error message with a file and line number. */
1093 static void
1094 warning_find_reloc (abfd, sec, iarg)
1095 bfd *abfd;
1096 asection *sec;
1097 PTR iarg;
1099 struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1100 long relsize;
1101 arelent **relpp;
1102 long relcount;
1103 arelent **p, **pend;
1105 if (info->found)
1106 return;
1108 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1109 if (relsize < 0)
1110 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1111 if (relsize == 0)
1112 return;
1114 relpp = (arelent **) xmalloc (relsize);
1115 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1116 if (relcount < 0)
1117 einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1119 p = relpp;
1120 pend = p + relcount;
1121 for (; p < pend && *p != NULL; p++)
1123 arelent *q = *p;
1125 if (q->sym_ptr_ptr != NULL
1126 && *q->sym_ptr_ptr != NULL
1127 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1129 /* We found a reloc for the symbol we are looking for. */
1130 einfo ("%C: %s\n", abfd, sec, q->address, info->warning);
1131 info->found = true;
1132 break;
1136 free (relpp);
1139 /* This is called when an undefined symbol is found. */
1141 /*ARGSUSED*/
1142 static boolean
1143 undefined_symbol (info, name, abfd, section, address)
1144 struct bfd_link_info *info;
1145 const char *name;
1146 bfd *abfd;
1147 asection *section;
1148 bfd_vma address;
1150 static char *error_name;
1151 static unsigned int error_count;
1153 #define MAX_ERRORS_IN_A_ROW 5
1155 if (config.warn_once)
1157 static struct bfd_hash_table *hash;
1159 /* Only warn once about a particular undefined symbol. */
1161 if (hash == NULL)
1163 hash = ((struct bfd_hash_table *)
1164 xmalloc (sizeof (struct bfd_hash_table)));
1165 if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
1166 einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1169 if (bfd_hash_lookup (hash, name, false, false) != NULL)
1170 return true;
1172 if (bfd_hash_lookup (hash, name, true, true) == NULL)
1173 einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1176 /* We never print more than a reasonable number of errors in a row
1177 for a single symbol. */
1178 if (error_name != (char *) NULL
1179 && strcmp (name, error_name) == 0)
1180 ++error_count;
1181 else
1183 error_count = 0;
1184 if (error_name != (char *) NULL)
1185 free (error_name);
1186 error_name = buystring (name);
1189 if (section != NULL)
1191 if (error_count < MAX_ERRORS_IN_A_ROW)
1192 einfo (_("%X%C: undefined reference to `%T'\n"),
1193 abfd, section, address, name);
1194 else if (error_count == MAX_ERRORS_IN_A_ROW)
1195 einfo (_("%D: more undefined references to `%T' follow\n"),
1196 abfd, section, address, name);
1198 else
1200 if (error_count < MAX_ERRORS_IN_A_ROW)
1201 einfo (_("%X%B: undefined reference to `%T'\n"),
1202 abfd, name);
1203 else if (error_count == MAX_ERRORS_IN_A_ROW)
1204 einfo (_("%B: more undefined references to `%T' follow\n"),
1205 abfd, name);
1208 return true;
1211 /* This is called when a reloc overflows. */
1213 /*ARGSUSED*/
1214 static boolean
1215 reloc_overflow (info, name, reloc_name, addend, abfd, section, address)
1216 struct bfd_link_info *info;
1217 const char *name;
1218 const char *reloc_name;
1219 bfd_vma addend;
1220 bfd *abfd;
1221 asection *section;
1222 bfd_vma address;
1224 if (abfd == (bfd *) NULL)
1225 einfo (_("%P%X: generated"));
1226 else
1227 einfo ("%X%C:", abfd, section, address);
1228 einfo (_(" relocation truncated to fit: %s %T"), reloc_name, name);
1229 if (addend != 0)
1230 einfo ("+%v", addend);
1231 einfo ("\n");
1232 return true;
1235 /* This is called when a dangerous relocation is made. */
1237 /*ARGSUSED*/
1238 static boolean
1239 reloc_dangerous (info, message, abfd, section, address)
1240 struct bfd_link_info *info;
1241 const char *message;
1242 bfd *abfd;
1243 asection *section;
1244 bfd_vma address;
1246 if (abfd == (bfd *) NULL)
1247 einfo (_("%P%X: generated"));
1248 else
1249 einfo ("%X%C:", abfd, section, address);
1250 einfo (_("dangerous relocation: %s\n"), message);
1251 return true;
1254 /* This is called when a reloc is being generated attached to a symbol
1255 that is not being output. */
1257 /*ARGSUSED*/
1258 static boolean
1259 unattached_reloc (info, name, abfd, section, address)
1260 struct bfd_link_info *info;
1261 const char *name;
1262 bfd *abfd;
1263 asection *section;
1264 bfd_vma address;
1266 if (abfd == (bfd *) NULL)
1267 einfo (_("%P%X: generated"));
1268 else
1269 einfo ("%X%C:", abfd, section, address);
1270 einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name);
1271 return true;
1274 /* This is called if link_info.notice_all is set, or when a symbol in
1275 link_info.notice_hash is found. Symbols are put in notice_hash
1276 using the -y option. */
1278 static boolean
1279 notice (info, name, abfd, section, value)
1280 struct bfd_link_info *info;
1281 const char *name;
1282 bfd *abfd;
1283 asection *section;
1284 bfd_vma value;
1286 if (! info->notice_all
1287 || (info->notice_hash != NULL
1288 && bfd_hash_lookup (info->notice_hash, name, false, false) != NULL))
1290 if (bfd_is_und_section (section))
1291 einfo ("%B: reference to %s\n", abfd, name);
1292 else
1293 einfo ("%B: definition of %s\n", abfd, name);
1296 if (command_line.cref || nocrossref_list != NULL)
1297 add_cref (name, abfd, section, value);
1299 return true;