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