bfd/
[platform/upstream/binutils.git] / ld / ldmain.c
1 /* Main program of GNU linker.
2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3    2002, 2003, 2004
4    Free Software Foundation, Inc.
5    Written by Steve Chamberlain steve@cygnus.com
6
7    This file is part of GLD, the Gnu Linker.
8
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.
13
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.
18
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.  */
23
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"
32
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"
44
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
49
50 #include <string.h>
51
52 #ifdef HAVE_SBRK
53 #ifdef NEED_DECLARATION_SBRK
54 extern void *sbrk ();
55 #endif
56 #endif
57
58 #ifndef TARGET_SYSTEM_ROOT
59 #define TARGET_SYSTEM_ROOT ""
60 #endif
61
62 /* EXPORTS */
63
64 char *default_target;
65 const char *output_filename = "a.out";
66
67 /* Name this program was invoked by.  */
68 char *program_name;
69
70 /* The prefix for system library directories.  */
71 char *ld_sysroot;
72
73 /* The canonical representation of ld_sysroot.  */
74 char * ld_canon_sysroot;
75 int ld_canon_sysroot_len;
76
77 /* The file that we're creating.  */
78 bfd *output_bfd = 0;
79
80 /* Set by -G argument, for MIPS ECOFF target.  */
81 int g_switch_value = 8;
82
83 /* Nonzero means print names of input files as processed.  */
84 bfd_boolean trace_files;
85
86 /* Nonzero means same, but note open failures, too.  */
87 bfd_boolean trace_file_tries;
88
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;
92
93 /* Nonzero means link in every member of an archive.  */
94 bfd_boolean whole_archive;
95
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;
99
100 /* Nonzero means never create DT_NEEDED entries for dynamic libraries
101    in DT_NEEDED tags.  */
102 bfd_boolean add_needed = TRUE;
103
104 /* TRUE if we should demangle symbol names.  */
105 bfd_boolean demangling;
106
107 args_type command_line;
108
109 ld_config_type config;
110
111 sort_type sort_section;
112
113 static char *get_emulation
114   (int, char **);
115 static void set_scripts_dir
116   (void);
117 static bfd_boolean add_archive_element
118   (struct bfd_link_info *, bfd *, const char *);
119 static bfd_boolean multiple_definition
120   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
121    bfd *, asection *, bfd_vma);
122 static bfd_boolean multiple_common
123   (struct bfd_link_info *, const char *, bfd *, enum bfd_link_hash_type,
124    bfd_vma, bfd *, enum bfd_link_hash_type, bfd_vma);
125 static bfd_boolean add_to_set
126   (struct bfd_link_info *, struct bfd_link_hash_entry *,
127    bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
128 static bfd_boolean constructor_callback
129   (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
130    asection *, bfd_vma);
131 static bfd_boolean warning_callback
132   (struct bfd_link_info *, const char *, const char *, bfd *,
133    asection *, bfd_vma);
134 static void warning_find_reloc
135   (bfd *, asection *, void *);
136 static bfd_boolean undefined_symbol
137   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
138    bfd_boolean);
139 static bfd_boolean reloc_overflow
140   (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
141    const char *, bfd_vma, bfd *, asection *, bfd_vma);
142 static bfd_boolean reloc_dangerous
143   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
144 static bfd_boolean unattached_reloc
145   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
146 static bfd_boolean notice
147   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
148
149 static struct bfd_link_callbacks link_callbacks =
150 {
151   add_archive_element,
152   multiple_definition,
153   multiple_common,
154   add_to_set,
155   constructor_callback,
156   warning_callback,
157   undefined_symbol,
158   reloc_overflow,
159   reloc_dangerous,
160   unattached_reloc,
161   notice
162 };
163
164 struct bfd_link_info link_info;
165 \f
166 static void
167 remove_output (void)
168 {
169   if (output_filename)
170     {
171       if (output_bfd)
172         bfd_cache_close (output_bfd);
173       if (delete_output_file_on_failure)
174         unlink (output_filename);
175     }
176 }
177
178 int
179 main (int argc, char **argv)
180 {
181   char *emulation;
182   long start_time = get_run_time ();
183
184 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
185   setlocale (LC_MESSAGES, "");
186 #endif
187 #if defined (HAVE_SETLOCALE)
188   setlocale (LC_CTYPE, "");
189 #endif
190   bindtextdomain (PACKAGE, LOCALEDIR);
191   textdomain (PACKAGE);
192
193   program_name = argv[0];
194   xmalloc_set_program_name (program_name);
195
196   START_PROGRESS (program_name, 0);
197
198   bfd_init ();
199
200   bfd_set_error_program_name (program_name);
201
202   xatexit (remove_output);
203
204 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
205   ld_sysroot = make_relative_prefix (program_name, BINDIR,
206                                      TARGET_SYSTEM_ROOT);
207
208   if (ld_sysroot)
209     {
210       struct stat s;
211       int res = stat (ld_sysroot, &s) == 0 && S_ISDIR (s.st_mode);
212
213       if (!res)
214         {
215           free (ld_sysroot);
216           ld_sysroot = NULL;
217         }
218     }
219
220   if (! ld_sysroot)
221     {
222       ld_sysroot = make_relative_prefix (program_name, TOOLBINDIR,
223                                          TARGET_SYSTEM_ROOT);
224
225       if (ld_sysroot)
226         {
227           struct stat s;
228           int res = stat (ld_sysroot, &s) == 0 && S_ISDIR (s.st_mode);
229
230           if (!res)
231             {
232               free (ld_sysroot);
233               ld_sysroot = NULL;
234             }
235         }
236     }
237
238   if (! ld_sysroot)
239 #endif
240     ld_sysroot = TARGET_SYSTEM_ROOT;
241
242   if (ld_sysroot && *ld_sysroot)
243     ld_canon_sysroot = lrealpath (ld_sysroot);
244
245   if (ld_canon_sysroot)
246     ld_canon_sysroot_len = strlen (ld_canon_sysroot);
247   else
248     ld_canon_sysroot_len = -1;
249
250   /* Set the default BFD target based on the configured target.  Doing
251      this permits the linker to be configured for a particular target,
252      and linked against a shared BFD library which was configured for
253      a different target.  The macro TARGET is defined by Makefile.  */
254   if (! bfd_set_default_target (TARGET))
255     {
256       einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
257       xexit (1);
258     }
259
260 #if YYDEBUG
261   {
262     extern int yydebug;
263     yydebug = 1;
264   }
265 #endif
266
267   /* Initialize the data about options.  */
268   trace_files = trace_file_tries = version_printed = FALSE;
269   whole_archive = FALSE;
270   config.build_constructors = TRUE;
271   config.dynamic_link = FALSE;
272   config.has_shared = FALSE;
273   config.split_by_reloc = (unsigned) -1;
274   config.split_by_file = (bfd_size_type) -1;
275   config.hash_table_size = 0;
276   command_line.force_common_definition = FALSE;
277   command_line.inhibit_common_definition = FALSE;
278   command_line.interpreter = NULL;
279   command_line.rpath = NULL;
280   command_line.warn_mismatch = TRUE;
281   command_line.check_section_addresses = TRUE;
282   command_line.accept_unknown_input_arch = FALSE;
283   command_line.reduce_memory_overheads = FALSE;
284
285   sort_section = none;
286
287   /* We initialize DEMANGLING based on the environment variable
288      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
289      output of the linker, unless COLLECT_NO_DEMANGLE is set in the
290      environment.  Acting the same way here lets us provide the same
291      interface by default.  */
292   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
293
294   link_info.relocatable = FALSE;
295   link_info.emitrelocations = FALSE;
296   link_info.task_link = FALSE;
297   link_info.shared = FALSE;
298   link_info.pie = FALSE;
299   link_info.executable = FALSE;
300   link_info.symbolic = FALSE;
301   link_info.export_dynamic = FALSE;
302   link_info.static_link = FALSE;
303   link_info.traditional_format = FALSE;
304   link_info.optimize = FALSE;
305   link_info.unresolved_syms_in_objects = RM_NOT_YET_SET;
306   link_info.unresolved_syms_in_shared_libs = RM_NOT_YET_SET;
307   link_info.allow_multiple_definition = FALSE;
308   link_info.allow_undefined_version = TRUE;
309   link_info.create_default_symver = FALSE;
310   link_info.default_imported_symver = FALSE;
311   link_info.keep_memory = TRUE;
312   link_info.notice_all = FALSE;
313   link_info.nocopyreloc = FALSE;
314   link_info.new_dtags = FALSE;
315   link_info.combreloc = TRUE;
316   link_info.eh_frame_hdr = FALSE;
317   link_info.relro = FALSE;
318   link_info.strip_discarded = TRUE;
319   link_info.strip = strip_none;
320   link_info.discard = discard_sec_merge;
321   link_info.common_skip_ar_aymbols = bfd_link_common_skip_none;
322   link_info.callbacks = &link_callbacks;
323   link_info.hash = NULL;
324   link_info.keep_hash = NULL;
325   link_info.notice_hash = NULL;
326   link_info.wrap_hash = NULL;
327   link_info.input_bfds = NULL;
328   link_info.create_object_symbols_section = NULL;
329   link_info.gc_sym_list = NULL;
330   link_info.base_file = NULL;
331   /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
332      and _fini symbols.  We are compatible.  */
333   link_info.init_function = "_init";
334   link_info.fini_function = "_fini";
335   link_info.pei386_auto_import = -1;
336   link_info.pei386_runtime_pseudo_reloc = FALSE;
337   link_info.spare_dynamic_tags = 5;
338   link_info.flags = 0;
339   link_info.flags_1 = 0;
340   link_info.need_relax_finalize = FALSE;
341   link_info.warn_shared_textrel = FALSE;
342
343   ldfile_add_arch ("");
344
345   config.make_executable = TRUE;
346   force_make_executable = FALSE;
347   config.magic_demand_paged = TRUE;
348   config.text_read_only = TRUE;
349
350   emulation = get_emulation (argc, argv);
351   ldemul_choose_mode (emulation);
352   default_target = ldemul_choose_target (argc, argv);
353   lang_init ();
354   ldemul_before_parse ();
355   lang_has_input_file = FALSE;
356   parse_args (argc, argv);
357
358   if (config.hash_table_size != 0)
359     bfd_hash_set_default_size (config.hash_table_size);
360
361   ldemul_set_symbols ();
362
363   if (link_info.relocatable)
364     {
365       if (command_line.gc_sections)
366         einfo ("%P%F: --gc-sections and -r may not be used together\n");
367       else if (command_line.relax)
368         einfo (_("%P%F: --relax and -r may not be used together\n"));
369       if (link_info.shared)
370         einfo (_("%P%F: -r and -shared may not be used together\n"));
371     }
372
373   if (! link_info.shared)
374     {
375       if (command_line.filter_shlib)
376         einfo (_("%P%F: -F may not be used without -shared\n"));
377       if (command_line.auxiliary_filters)
378         einfo (_("%P%F: -f may not be used without -shared\n"));
379     }
380
381   if (! link_info.shared || link_info.pie)
382     link_info.executable = TRUE;
383
384   /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols).  I
385      don't see how else this can be handled, since in this case we
386      must preserve all externally visible symbols.  */
387   if (link_info.relocatable && link_info.strip == strip_all)
388     {
389       link_info.strip = strip_debugger;
390       if (link_info.discard == discard_sec_merge)
391         link_info.discard = discard_all;
392     }
393
394   /* This essentially adds another -L directory so this must be done after
395      the -L's in argv have been processed.  */
396   set_scripts_dir ();
397
398   /* If we have not already opened and parsed a linker script
399      read the emulation's appropriate default script.  */
400   if (saved_script_handle == NULL)
401     {
402       int isfile;
403       char *s = ldemul_get_script (&isfile);
404
405       if (isfile)
406         ldfile_open_command_file (s);
407       else
408         {
409           lex_string = s;
410           lex_redirect (s);
411         }
412       parser_input = input_script;
413       yyparse ();
414       lex_string = NULL;
415     }
416
417   if (trace_file_tries)
418     {
419       if (saved_script_handle)
420         info_msg (_("using external linker script:"));
421       else
422         info_msg (_("using internal linker script:"));
423       info_msg ("\n==================================================\n");
424
425       if (saved_script_handle)
426         {
427           static const int ld_bufsz = 8193;
428           size_t n;
429           char *buf = xmalloc (ld_bufsz);
430
431           rewind (saved_script_handle);
432           while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
433             {
434               buf[n] = 0;
435               info_msg (buf);
436             }
437           rewind (saved_script_handle);
438           free (buf);
439         }
440       else
441         {
442           int isfile;
443
444           info_msg (ldemul_get_script (&isfile));
445         }
446
447       info_msg ("\n==================================================\n");
448     }
449
450   lang_final ();
451
452   if (!lang_has_input_file)
453     {
454       if (version_printed)
455         xexit (0);
456       einfo (_("%P%F: no input files\n"));
457     }
458
459   if (trace_files)
460     info_msg (_("%P: mode %s\n"), emulation);
461
462   ldemul_after_parse ();
463
464   if (config.map_filename)
465     {
466       if (strcmp (config.map_filename, "-") == 0)
467         {
468           config.map_file = stdout;
469         }
470       else
471         {
472           config.map_file = fopen (config.map_filename, FOPEN_WT);
473           if (config.map_file == (FILE *) NULL)
474             {
475               bfd_set_error (bfd_error_system_call);
476               einfo (_("%P%F: cannot open map file %s: %E\n"),
477                      config.map_filename);
478             }
479         }
480     }
481
482   lang_process ();
483
484   /* Print error messages for any missing symbols, for any warning
485      symbols, and possibly multiple definitions.  */
486   if (link_info.relocatable)
487     output_bfd->flags &= ~EXEC_P;
488   else
489     output_bfd->flags |= EXEC_P;
490
491   ldwrite ();
492
493   if (config.map_file != NULL)
494     lang_map ();
495   if (command_line.cref)
496     output_cref (config.map_file != NULL ? config.map_file : stdout);
497   if (nocrossref_list != NULL)
498     check_nocrossrefs ();
499
500   /* Even if we're producing relocatable output, some non-fatal errors should
501      be reported in the exit status.  (What non-fatal errors, if any, do we
502      want to ignore for relocatable output?)  */
503   if (!config.make_executable && !force_make_executable)
504     {
505       if (trace_files)
506         einfo (_("%P: link errors found, deleting executable `%s'\n"),
507                output_filename);
508
509       /* The file will be removed by remove_output.  */
510       xexit (1);
511     }
512   else
513     {
514       if (! bfd_close (output_bfd))
515         einfo (_("%F%B: final close failed: %E\n"), output_bfd);
516
517       /* If the --force-exe-suffix is enabled, and we're making an
518          executable file and it doesn't end in .exe, copy it to one
519          which does.  */
520       if (! link_info.relocatable && command_line.force_exe_suffix)
521         {
522           int len = strlen (output_filename);
523
524           if (len < 4
525               || (strcasecmp (output_filename + len - 4, ".exe") != 0
526                   && strcasecmp (output_filename + len - 4, ".dll") != 0))
527             {
528               FILE *src;
529               FILE *dst;
530               const int bsize = 4096;
531               char *buf = xmalloc (bsize);
532               int l;
533               char *dst_name = xmalloc (len + 5);
534
535               strcpy (dst_name, output_filename);
536               strcat (dst_name, ".exe");
537               src = fopen (output_filename, FOPEN_RB);
538               dst = fopen (dst_name, FOPEN_WB);
539
540               if (!src)
541                 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
542                        output_filename);
543               if (!dst)
544                 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
545                        dst_name);
546               while ((l = fread (buf, 1, bsize, src)) > 0)
547                 {
548                   int done = fwrite (buf, 1, l, dst);
549
550                   if (done != l)
551                     einfo (_("%P: Error writing file `%s'\n"), dst_name);
552                 }
553
554               fclose (src);
555               if (fclose (dst) == EOF)
556                 einfo (_("%P: Error closing file `%s'\n"), dst_name);
557               free (dst_name);
558               free (buf);
559             }
560         }
561     }
562
563   END_PROGRESS (program_name);
564
565   if (config.stats)
566     {
567 #ifdef HAVE_SBRK
568       char *lim = sbrk (0);
569 #endif
570       long run_time = get_run_time () - start_time;
571
572       fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
573                program_name, run_time / 1000000, run_time % 1000000);
574 #ifdef HAVE_SBRK
575       fprintf (stderr, _("%s: data size %ld\n"), program_name,
576                (long) (lim - (char *) &environ));
577 #endif
578     }
579
580   /* Prevent remove_output from doing anything, after a successful link.  */
581   output_filename = NULL;
582
583   xexit (0);
584   return 0;
585 }
586
587 /* We need to find any explicitly given emulation in order to initialize the
588    state that's needed by the lex&yacc argument parser (parse_args).  */
589
590 static char *
591 get_emulation (int argc, char **argv)
592 {
593   char *emulation;
594   int i;
595
596   emulation = getenv (EMULATION_ENVIRON);
597   if (emulation == NULL)
598     emulation = DEFAULT_EMULATION;
599
600   for (i = 1; i < argc; i++)
601     {
602       if (!strncmp (argv[i], "-m", 2))
603         {
604           if (argv[i][2] == '\0')
605             {
606               /* -m EMUL */
607               if (i < argc - 1)
608                 {
609                   emulation = argv[i + 1];
610                   i++;
611                 }
612               else
613                 einfo (_("%P%F: missing argument to -m\n"));
614             }
615           else if (strcmp (argv[i], "-mips1") == 0
616                    || strcmp (argv[i], "-mips2") == 0
617                    || strcmp (argv[i], "-mips3") == 0
618                    || strcmp (argv[i], "-mips4") == 0
619                    || strcmp (argv[i], "-mips5") == 0
620                    || strcmp (argv[i], "-mips32") == 0
621                    || strcmp (argv[i], "-mips32r2") == 0
622                    || strcmp (argv[i], "-mips64") == 0
623                    || strcmp (argv[i], "-mips64r2") == 0)
624             {
625               /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
626                  passed to the linker by some MIPS compilers.  They
627                  generally tell the linker to use a slightly different
628                  library path.  Perhaps someday these should be
629                  implemented as emulations; until then, we just ignore
630                  the arguments and hope that nobody ever creates
631                  emulations named ips1, ips2 or ips3.  */
632             }
633           else if (strcmp (argv[i], "-m486") == 0)
634             {
635               /* FIXME: The argument -m486 is passed to the linker on
636                  some Linux systems.  Hope that nobody creates an
637                  emulation named 486.  */
638             }
639           else
640             {
641               /* -mEMUL */
642               emulation = &argv[i][2];
643             }
644         }
645     }
646
647   return emulation;
648 }
649
650 /* If directory DIR contains an "ldscripts" subdirectory,
651    add DIR to the library search path and return TRUE,
652    else return FALSE.  */
653
654 static bfd_boolean
655 check_for_scripts_dir (char *dir)
656 {
657   size_t dirlen;
658   char *buf;
659   struct stat s;
660   bfd_boolean res;
661
662   dirlen = strlen (dir);
663   /* sizeof counts the terminating NUL.  */
664   buf = xmalloc (dirlen + sizeof ("/ldscripts"));
665   sprintf (buf, "%s/ldscripts", dir);
666
667   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
668   free (buf);
669   if (res)
670     ldfile_add_library_path (dir, FALSE);
671   return res;
672 }
673
674 /* Set the default directory for finding script files.
675    Libraries will be searched for here too, but that's ok.
676    We look for the "ldscripts" directory in:
677
678    SCRIPTDIR (passed from Makefile)
679              (adjusted according to the current location of the binary)
680    SCRIPTDIR (passed from Makefile)
681    the dir where this program is (for using it from the build tree)
682    the dir where this program is/../lib
683              (for installing the tool suite elsewhere).  */
684
685 static void
686 set_scripts_dir (void)
687 {
688   char *end, *dir;
689   size_t dirlen;
690   bfd_boolean found;
691
692   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
693   if (dir)
694     {
695       found = check_for_scripts_dir (dir);
696       free (dir);
697       if (found)
698         return;
699     }
700
701   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
702   if (dir)
703     {
704       found = check_for_scripts_dir (dir);
705       free (dir);
706       if (found)
707         return;
708     }
709
710   if (check_for_scripts_dir (SCRIPTDIR))
711     /* We've been installed normally.  */
712     return;
713
714   /* Look for "ldscripts" in the dir where our binary is.  */
715   end = strrchr (program_name, '/');
716 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
717   {
718     /* We could have \foo\bar, or /foo\bar.  */
719     char *bslash = strrchr (program_name, '\\');
720
721     if (end == NULL || (bslash != NULL && bslash > end))
722       end = bslash;
723   }
724 #endif
725
726   if (end == NULL)
727     /* Don't look for ldscripts in the current directory.  There is
728        too much potential for confusion.  */
729     return;
730
731   dirlen = end - program_name;
732   /* Make a copy of program_name in dir.
733      Leave room for later "/../lib".  */
734   dir = xmalloc (dirlen + 8);
735   strncpy (dir, program_name, dirlen);
736   dir[dirlen] = '\0';
737
738   if (check_for_scripts_dir (dir))
739     {
740       free (dir);
741       return;
742     }
743
744   /* Look for "ldscripts" in <the dir where our binary is>/../lib.  */
745   strcpy (dir + dirlen, "/../lib");
746   check_for_scripts_dir (dir);
747   free (dir);
748 }
749
750 void
751 add_ysym (const char *name)
752 {
753   if (link_info.notice_hash == NULL)
754     {
755       link_info.notice_hash = xmalloc (sizeof (struct bfd_hash_table));
756       if (! bfd_hash_table_init_n (link_info.notice_hash,
757                                    bfd_hash_newfunc,
758                                    61))
759         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
760     }
761
762   if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
763     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
764 }
765
766 /* Record a symbol to be wrapped, from the --wrap option.  */
767
768 void
769 add_wrap (const char *name)
770 {
771   if (link_info.wrap_hash == NULL)
772     {
773       link_info.wrap_hash = xmalloc (sizeof (struct bfd_hash_table));
774       if (! bfd_hash_table_init_n (link_info.wrap_hash,
775                                    bfd_hash_newfunc,
776                                    61))
777         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
778     }
779
780   if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
781     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
782 }
783
784 /* Handle the -retain-symbols-file option.  */
785
786 void
787 add_keepsyms_file (const char *filename)
788 {
789   FILE *file;
790   char *buf;
791   size_t bufsize;
792   int c;
793
794   if (link_info.strip == strip_some)
795     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
796
797   file = fopen (filename, "r");
798   if (file == NULL)
799     {
800       bfd_set_error (bfd_error_system_call);
801       einfo ("%X%P: %s: %E\n", filename);
802       return;
803     }
804
805   link_info.keep_hash = xmalloc (sizeof (struct bfd_hash_table));
806   if (! bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc))
807     einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
808
809   bufsize = 100;
810   buf = xmalloc (bufsize);
811
812   c = getc (file);
813   while (c != EOF)
814     {
815       while (ISSPACE (c))
816         c = getc (file);
817
818       if (c != EOF)
819         {
820           size_t len = 0;
821
822           while (! ISSPACE (c) && c != EOF)
823             {
824               buf[len] = c;
825               ++len;
826               if (len >= bufsize)
827                 {
828                   bufsize *= 2;
829                   buf = xrealloc (buf, bufsize);
830                 }
831               c = getc (file);
832             }
833
834           buf[len] = '\0';
835
836           if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
837             einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
838         }
839     }
840
841   if (link_info.strip != strip_none)
842     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
843
844   free (buf);
845   link_info.strip = strip_some;
846 }
847 \f
848 /* Callbacks from the BFD linker routines.  */
849
850 /* This is called when BFD has decided to include an archive member in
851    a link.  */
852
853 static bfd_boolean
854 add_archive_element (struct bfd_link_info *info ATTRIBUTE_UNUSED,
855                      bfd *abfd,
856                      const char *name)
857 {
858   lang_input_statement_type *input;
859
860   input = xmalloc (sizeof (lang_input_statement_type));
861   input->filename = abfd->filename;
862   input->local_sym_name = abfd->filename;
863   input->the_bfd = abfd;
864   input->asymbols = NULL;
865   input->next = NULL;
866   input->just_syms_flag = FALSE;
867   input->loaded = FALSE;
868   input->search_dirs_flag = FALSE;
869
870   /* FIXME: The following fields are not set: header.next,
871      header.type, closed, passive_position, symbol_count,
872      next_real_file, is_archive, target, real.  This bit of code is
873      from the old decode_library_subfile function.  I don't know
874      whether any of those fields matters.  */
875
876   ldlang_add_file (input);
877
878   if (config.map_file != NULL)
879     {
880       static bfd_boolean header_printed;
881       struct bfd_link_hash_entry *h;
882       bfd *from;
883       int len;
884
885       h = bfd_link_hash_lookup (link_info.hash, name, FALSE, FALSE, TRUE);
886
887       if (h == NULL)
888         from = NULL;
889       else
890         {
891           switch (h->type)
892             {
893             default:
894               from = NULL;
895               break;
896
897             case bfd_link_hash_defined:
898             case bfd_link_hash_defweak:
899               from = h->u.def.section->owner;
900               break;
901
902             case bfd_link_hash_undefined:
903             case bfd_link_hash_undefweak:
904               from = h->u.undef.abfd;
905               break;
906
907             case bfd_link_hash_common:
908               from = h->u.c.p->section->owner;
909               break;
910             }
911         }
912
913       if (! header_printed)
914         {
915           char buf[100];
916
917           sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
918           minfo ("%s", buf);
919           header_printed = TRUE;
920         }
921
922       if (bfd_my_archive (abfd) == NULL)
923         {
924           minfo ("%s", bfd_get_filename (abfd));
925           len = strlen (bfd_get_filename (abfd));
926         }
927       else
928         {
929           minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
930                  bfd_get_filename (abfd));
931           len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
932                  + strlen (bfd_get_filename (abfd))
933                  + 2);
934         }
935
936       if (len >= 29)
937         {
938           print_nl ();
939           len = 0;
940         }
941       while (len < 30)
942         {
943           print_space ();
944           ++len;
945         }
946
947       if (from != NULL)
948         minfo ("%B ", from);
949       if (h != NULL)
950         minfo ("(%T)\n", h->root.string);
951       else
952         minfo ("(%s)\n", name);
953     }
954
955   if (trace_files || trace_file_tries)
956     info_msg ("%I\n", input);
957
958   return TRUE;
959 }
960
961 /* This is called when BFD has discovered a symbol which is defined
962    multiple times.  */
963
964 static bfd_boolean
965 multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
966                      const char *name,
967                      bfd *obfd,
968                      asection *osec,
969                      bfd_vma oval,
970                      bfd *nbfd,
971                      asection *nsec,
972                      bfd_vma nval)
973 {
974   /* If either section has the output_section field set to
975      bfd_abs_section_ptr, it means that the section is being
976      discarded, and this is not really a multiple definition at all.
977      FIXME: It would be cleaner to somehow ignore symbols defined in
978      sections which are being discarded.  */
979   if ((osec->output_section != NULL
980        && ! bfd_is_abs_section (osec)
981        && bfd_is_abs_section (osec->output_section))
982       || (nsec->output_section != NULL
983           && ! bfd_is_abs_section (nsec)
984           && bfd_is_abs_section (nsec->output_section)))
985     return TRUE;
986
987   einfo (_("%X%C: multiple definition of `%T'\n"),
988          nbfd, nsec, nval, name);
989   if (obfd != NULL)
990     einfo (_("%D: first defined here\n"), obfd, osec, oval);
991
992   if (command_line.relax)
993     {
994       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
995       command_line.relax = 0;
996     }
997
998   return TRUE;
999 }
1000
1001 /* This is called when there is a definition of a common symbol, or
1002    when a common symbol is found for a symbol that is already defined,
1003    or when two common symbols are found.  We only do something if
1004    -warn-common was used.  */
1005
1006 static bfd_boolean
1007 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1008                  const char *name,
1009                  bfd *obfd,
1010                  enum bfd_link_hash_type otype,
1011                  bfd_vma osize,
1012                  bfd *nbfd,
1013                  enum bfd_link_hash_type ntype,
1014                  bfd_vma nsize)
1015 {
1016   if (! config.warn_common)
1017     return TRUE;
1018
1019   if (ntype == bfd_link_hash_defined
1020       || ntype == bfd_link_hash_defweak
1021       || ntype == bfd_link_hash_indirect)
1022     {
1023       ASSERT (otype == bfd_link_hash_common);
1024       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1025              nbfd, name);
1026       if (obfd != NULL)
1027         einfo (_("%B: warning: common is here\n"), obfd);
1028     }
1029   else if (otype == bfd_link_hash_defined
1030            || otype == bfd_link_hash_defweak
1031            || otype == bfd_link_hash_indirect)
1032     {
1033       ASSERT (ntype == bfd_link_hash_common);
1034       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1035              nbfd, name);
1036       if (obfd != NULL)
1037         einfo (_("%B: warning: defined here\n"), obfd);
1038     }
1039   else
1040     {
1041       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1042       if (osize > nsize)
1043         {
1044           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1045                  nbfd, name);
1046           if (obfd != NULL)
1047             einfo (_("%B: warning: larger common is here\n"), obfd);
1048         }
1049       else if (nsize > osize)
1050         {
1051           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1052                  nbfd, name);
1053           if (obfd != NULL)
1054             einfo (_("%B: warning: smaller common is here\n"), obfd);
1055         }
1056       else
1057         {
1058           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1059           if (obfd != NULL)
1060             einfo (_("%B: warning: previous common is here\n"), obfd);
1061         }
1062     }
1063
1064   return TRUE;
1065 }
1066
1067 /* This is called when BFD has discovered a set element.  H is the
1068    entry in the linker hash table for the set.  SECTION and VALUE
1069    represent a value which should be added to the set.  */
1070
1071 static bfd_boolean
1072 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1073             struct bfd_link_hash_entry *h,
1074             bfd_reloc_code_real_type reloc,
1075             bfd *abfd,
1076             asection *section,
1077             bfd_vma value)
1078 {
1079   if (config.warn_constructors)
1080     einfo (_("%P: warning: global constructor %s used\n"),
1081            h->root.string);
1082
1083   if (! config.build_constructors)
1084     return TRUE;
1085
1086   ldctor_add_set_entry (h, reloc, NULL, section, value);
1087
1088   if (h->type == bfd_link_hash_new)
1089     {
1090       h->type = bfd_link_hash_undefined;
1091       h->u.undef.abfd = abfd;
1092       /* We don't call bfd_link_add_undef to add this to the list of
1093          undefined symbols because we are going to define it
1094          ourselves.  */
1095     }
1096
1097   return TRUE;
1098 }
1099
1100 /* This is called when BFD has discovered a constructor.  This is only
1101    called for some object file formats--those which do not handle
1102    constructors in some more clever fashion.  This is similar to
1103    adding an element to a set, but less general.  */
1104
1105 static bfd_boolean
1106 constructor_callback (struct bfd_link_info *info,
1107                       bfd_boolean constructor,
1108                       const char *name,
1109                       bfd *abfd,
1110                       asection *section,
1111                       bfd_vma value)
1112 {
1113   char *s;
1114   struct bfd_link_hash_entry *h;
1115   char set_name[1 + sizeof "__CTOR_LIST__"];
1116
1117   if (config.warn_constructors)
1118     einfo (_("%P: warning: global constructor %s used\n"), name);
1119
1120   if (! config.build_constructors)
1121     return TRUE;
1122
1123   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1124      useful error message.  */
1125   if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL
1126       && (link_info.relocatable
1127           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1128     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1129
1130   s = set_name;
1131   if (bfd_get_symbol_leading_char (abfd) != '\0')
1132     *s++ = bfd_get_symbol_leading_char (abfd);
1133   if (constructor)
1134     strcpy (s, "__CTOR_LIST__");
1135   else
1136     strcpy (s, "__DTOR_LIST__");
1137
1138   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1139   if (h == (struct bfd_link_hash_entry *) NULL)
1140     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1141   if (h->type == bfd_link_hash_new)
1142     {
1143       h->type = bfd_link_hash_undefined;
1144       h->u.undef.abfd = abfd;
1145       /* We don't call bfd_link_add_undef to add this to the list of
1146          undefined symbols because we are going to define it
1147          ourselves.  */
1148     }
1149
1150   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1151   return TRUE;
1152 }
1153
1154 /* A structure used by warning_callback to pass information through
1155    bfd_map_over_sections.  */
1156
1157 struct warning_callback_info
1158 {
1159   bfd_boolean found;
1160   const char *warning;
1161   const char *symbol;
1162   asymbol **asymbols;
1163 };
1164
1165 /* This is called when there is a reference to a warning symbol.  */
1166
1167 static bfd_boolean
1168 warning_callback (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)
1174 {
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;
1180
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
1188     {
1189       lang_input_statement_type *entry;
1190       asymbol **asymbols;
1191       struct warning_callback_info info;
1192
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
1199         {
1200           long symsize;
1201           long symbol_count;
1202
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 = 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)
1211             {
1212               entry->asymbols = asymbols;
1213               entry->symbol_count = symbol_count;
1214             }
1215         }
1216
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, &info);
1222
1223       if (! info.found)
1224         einfo ("%B: %s\n", abfd, warning);
1225
1226       if (entry == NULL)
1227         free (asymbols);
1228     }
1229
1230   return TRUE;
1231 }
1232
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.  */
1237
1238 static void
1239 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1240 {
1241   struct warning_callback_info *info = iarg;
1242   long relsize;
1243   arelent **relpp;
1244   long relcount;
1245   arelent **p, **pend;
1246
1247   if (info->found)
1248     return;
1249
1250   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1251   if (relsize < 0)
1252     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1253   if (relsize == 0)
1254     return;
1255
1256   relpp = xmalloc (relsize);
1257   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1258   if (relcount < 0)
1259     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1260
1261   p = relpp;
1262   pend = p + relcount;
1263   for (; p < pend && *p != NULL; p++)
1264     {
1265       arelent *q = *p;
1266
1267       if (q->sym_ptr_ptr != NULL
1268           && *q->sym_ptr_ptr != NULL
1269           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1270         {
1271           /* We found a reloc for the symbol we are looking for.  */
1272           einfo ("%C: %s\n", abfd, sec, q->address, info->warning);
1273           info->found = TRUE;
1274           break;
1275         }
1276     }
1277
1278   free (relpp);
1279 }
1280
1281 /* This is called when an undefined symbol is found.  */
1282
1283 static bfd_boolean
1284 undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1285                   const char *name,
1286                   bfd *abfd,
1287                   asection *section,
1288                   bfd_vma address,
1289                   bfd_boolean error)
1290 {
1291   static char *error_name;
1292   static unsigned int error_count;
1293
1294 #define MAX_ERRORS_IN_A_ROW 5
1295
1296   if (config.warn_once)
1297     {
1298       static struct bfd_hash_table *hash;
1299
1300       /* Only warn once about a particular undefined symbol.  */
1301       if (hash == NULL)
1302         {
1303           hash = xmalloc (sizeof (struct bfd_hash_table));
1304           if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
1305             einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1306         }
1307
1308       if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1309         return TRUE;
1310
1311       if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1312         einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1313     }
1314
1315   /* We never print more than a reasonable number of errors in a row
1316      for a single symbol.  */
1317   if (error_name != NULL
1318       && strcmp (name, error_name) == 0)
1319     ++error_count;
1320   else
1321     {
1322       error_count = 0;
1323       if (error_name != NULL)
1324         free (error_name);
1325       error_name = xstrdup (name);
1326     }
1327
1328   if (section != NULL)
1329     {
1330       if (error_count < MAX_ERRORS_IN_A_ROW)
1331         {
1332           if (error)
1333             einfo (_("%X%C: undefined reference to `%T'\n"),
1334                    abfd, section, address, name);
1335           else
1336             einfo (_("%C: warning: undefined reference to `%T'\n"),
1337                    abfd, section, address, name);
1338         }
1339       else if (error_count == MAX_ERRORS_IN_A_ROW)
1340         {
1341           if (error)
1342             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1343                    abfd, section, address, name);
1344           else
1345             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1346                    abfd, section, address, name);
1347         }
1348       else if (error)
1349         einfo ("%X");
1350     }
1351   else
1352     {
1353       if (error_count < MAX_ERRORS_IN_A_ROW)
1354         {
1355           if (error)
1356             einfo (_("%X%B: undefined reference to `%T'\n"),
1357                    abfd, name);
1358           else
1359             einfo (_("%B: warning: undefined reference to `%T'\n"),
1360                    abfd, name);
1361         }
1362       else if (error_count == MAX_ERRORS_IN_A_ROW)
1363         {
1364           if (error)
1365             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1366                    abfd, name);
1367           else
1368             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1369                    abfd, name);
1370         }
1371       else if (error)
1372         einfo ("%X");
1373     }
1374
1375   return TRUE;
1376 }
1377
1378 /* Counter to limit the number of relocation overflow error messages
1379    to print.  Errors are printed as it is decremented.  When it's
1380    called and the counter is zero, a final message is printed
1381    indicating more relocations were omitted.  When it gets to -1, no
1382    such errors are printed.  If it's initially set to a value less
1383    than -1, all such errors will be printed (--verbose does this).  */
1384
1385 int overflow_cutoff_limit = 10;
1386
1387 /* This is called when a reloc overflows.  */
1388
1389 static bfd_boolean
1390 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1391                 struct bfd_link_hash_entry *entry,
1392                 const char *name,
1393                 const char *reloc_name,
1394                 bfd_vma addend,
1395                 bfd *abfd,
1396                 asection *section,
1397                 bfd_vma address)
1398 {
1399   if (overflow_cutoff_limit == -1)
1400     return TRUE;
1401
1402   if (abfd == NULL)
1403     einfo (_("%P%X: generated"));
1404   else
1405     einfo ("%X%C:", abfd, section, address);
1406
1407   if (overflow_cutoff_limit >= 0
1408       && overflow_cutoff_limit-- == 0)
1409     {
1410       einfo (_(" additional relocation overflows omitted from the output\n"));
1411       return TRUE;
1412     }
1413
1414   if (entry)
1415     {
1416       while (entry->type == bfd_link_hash_indirect
1417              || entry->type == bfd_link_hash_warning)
1418         entry = entry->u.i.link;
1419       switch (entry->type)
1420         {
1421         case bfd_link_hash_undefined:
1422         case bfd_link_hash_undefweak:
1423           einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1424                  reloc_name, entry->root.string);
1425           break;
1426         case bfd_link_hash_defined:
1427         case bfd_link_hash_defweak:
1428           einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1429                  reloc_name, entry->root.string,
1430                  entry->u.def.section, entry->u.def.section->owner);
1431           break;
1432         default:
1433           abort ();
1434           break;
1435         }
1436     }
1437   else
1438     einfo (_(" relocation truncated to fit: %s against `%T'"),
1439            reloc_name, name);
1440   if (addend != 0)
1441     einfo ("+%v", addend);
1442   einfo ("\n");
1443   return TRUE;
1444 }
1445
1446 /* This is called when a dangerous relocation is made.  */
1447
1448 static bfd_boolean
1449 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1450                  const char *message,
1451                  bfd *abfd,
1452                  asection *section,
1453                  bfd_vma address)
1454 {
1455   if (abfd == NULL)
1456     einfo (_("%P%X: generated"));
1457   else
1458     einfo ("%X%C:", abfd, section, address);
1459   einfo (_("dangerous relocation: %s\n"), message);
1460   return TRUE;
1461 }
1462
1463 /* This is called when a reloc is being generated attached to a symbol
1464    that is not being output.  */
1465
1466 static bfd_boolean
1467 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1468                   const char *name,
1469                   bfd *abfd,
1470                   asection *section,
1471                   bfd_vma address)
1472 {
1473   if (abfd == NULL)
1474     einfo (_("%P%X: generated"));
1475   else
1476     einfo ("%X%C:", abfd, section, address);
1477   einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name);
1478   return TRUE;
1479 }
1480
1481 /* This is called if link_info.notice_all is set, or when a symbol in
1482    link_info.notice_hash is found.  Symbols are put in notice_hash
1483    using the -y option.  */
1484
1485 static bfd_boolean
1486 notice (struct bfd_link_info *info,
1487         const char *name,
1488         bfd *abfd,
1489         asection *section,
1490         bfd_vma value)
1491 {
1492   if (! info->notice_all
1493       || (info->notice_hash != NULL
1494           && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1495     {
1496       if (bfd_is_und_section (section))
1497         einfo ("%B: reference to %s\n", abfd, name);
1498       else
1499         einfo ("%B: definition of %s\n", abfd, name);
1500     }
1501
1502   if (command_line.cref || nocrossref_list != NULL)
1503     add_cref (name, abfd, section, value);
1504
1505   return TRUE;
1506 }