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