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