ld/ldmain.c

   1 /* Main program of GNU linker.
   2    Copyright 1991-2013 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain steve@cygnus.com
   4
   5    This file is part of the GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "safe-ctype.h"
  25 #include "libiberty.h"
  26 #include "progress.h"
  27 #include "bfdlink.h"
  28 #include "filenames.h"
  29
  30 #include "ld.h"
  31 #include "ldmain.h"
  32 #include "ldmisc.h"
  33 #include "ldwrite.h"
  34 #include "ldexp.h"
  35 #include "ldlang.h"
  36 #include <ldgram.h>
  37 #include "ldlex.h"
  38 #include "ldfile.h"
  39 #include "ldemul.h"
  40 #include "ldctor.h"
  41 #ifdef ENABLE_PLUGINS
  42 #include "plugin.h"
  43 #include "plugin-api.h"
  44 #include "libbfd.h"
  45 #endif /* ENABLE_PLUGINS */
  46
  47 /* Somewhere above, sys/stat.h got included.  */
  48 #if !defined(S_ISDIR) && defined(S_IFDIR)
  49 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  50 #endif
  51
  52 #include <string.h>
  53
  54 #ifdef HAVE_SBRK
  55 #if !HAVE_DECL_SBRK
  56 extern void *sbrk ();
  57 #endif
  58 #endif
  59
  60 #ifndef TARGET_SYSTEM_ROOT
  61 #define TARGET_SYSTEM_ROOT ""
  62 #endif
  63
  64 /* EXPORTS */
  65
  66 FILE *saved_script_handle = NULL;
  67 FILE *previous_script_handle = NULL;
  68 bfd_boolean force_make_executable = FALSE;
  69
  70 char *default_target;
  71 const char *output_filename = "a.out";
  72
  73 /* Name this program was invoked by.  */
  74 char *program_name;
  75
  76 /* The prefix for system library directories.  */
  77 const char *ld_sysroot;
  78
  79 /* The canonical representation of ld_sysroot.  */
  80 char * ld_canon_sysroot;
  81 int ld_canon_sysroot_len;
  82
  83 /* Set by -G argument, for targets like MIPS ELF.  */
  84 int g_switch_value = 8;
  85
  86 /* Nonzero means print names of input files as processed.  */
  87 bfd_boolean trace_files;
  88
  89 /* Nonzero means report actions taken by the linker, and describe the linker script in use.  */
  90 bfd_boolean verbose;
  91
  92 /* Nonzero means version number was printed, so exit successfully
  93    instead of complaining if no input files are given.  */
  94 bfd_boolean version_printed;
  95
  96 /* TRUE if we should demangle symbol names.  */
  97 bfd_boolean demangling;
  98
  99 args_type command_line;
 100
 101 ld_config_type config;
 102
 103 sort_type sort_section;
 104
 105 static const char *get_sysroot
 106   (int, char **);
 107 static char *get_emulation
 108   (int, char **);
 109 static bfd_boolean add_archive_element
 110   (struct bfd_link_info *, bfd *, const char *, bfd **);
 111 static bfd_boolean multiple_definition
 112   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 113    bfd *, asection *, bfd_vma);
 114 static bfd_boolean multiple_common
 115   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 116    bfd *, enum bfd_link_hash_type, bfd_vma);
 117 static bfd_boolean add_to_set
 118   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 119    bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
 120 static bfd_boolean constructor_callback
 121   (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
 122    asection *, bfd_vma);
 123 static bfd_boolean warning_callback
 124   (struct bfd_link_info *, const char *, const char *, bfd *,
 125    asection *, bfd_vma);
 126 static void warning_find_reloc
 127   (bfd *, asection *, void *);
 128 static bfd_boolean undefined_symbol
 129   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 130    bfd_boolean);
 131 static bfd_boolean reloc_overflow
 132   (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
 133    const char *, bfd_vma, bfd *, asection *, bfd_vma);
 134 static bfd_boolean reloc_dangerous
 135   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 136 static bfd_boolean unattached_reloc
 137   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 138 static bfd_boolean notice
 139   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 140    bfd *, asection *, bfd_vma, flagword, const char *);
 141
 142 static struct bfd_link_callbacks link_callbacks =
 143 {
 144   add_archive_element,
 145   multiple_definition,
 146   multiple_common,
 147   add_to_set,
 148   constructor_callback,
 149   warning_callback,
 150   undefined_symbol,
 151   reloc_overflow,
 152   reloc_dangerous,
 153   unattached_reloc,
 154   notice,
 155   einfo,
 156   info_msg,
 157   minfo,
 158   ldlang_override_segment_assignment
 159 };
 160
 161 static bfd_assert_handler_type default_bfd_assert_handler;
 162
 163 struct bfd_link_info link_info;
 164 \f
 165 static void
 166 ld_cleanup (void)
 167 {
 168   bfd_cache_close_all ();
 169 #ifdef ENABLE_PLUGINS
 170   plugin_call_cleanup ();
 171 #endif
 172   if (output_filename && delete_output_file_on_failure)
 173     unlink_if_ordinary (output_filename);
 174 }
 175
 176 /* If there's a BFD assertion, we'll notice and exit with an error
 177    unless otherwise instructed.  */
 178
 179 static void
 180 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
 181                        const char *file, int line)
 182 {
 183   (*default_bfd_assert_handler) (fmt, bfdver, file, line);
 184   config.make_executable = FALSE;
 185 }
 186
 187 int
 188 main (int argc, char **argv)
 189 {
 190   char *emulation;
 191   long start_time = get_run_time ();
 192 #ifdef HAVE_SBRK
 193   char *start_sbrk = (char *) sbrk (0);
 194 #endif
 195
 196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 197   setlocale (LC_MESSAGES, "");
 198 #endif
 199 #if defined (HAVE_SETLOCALE)
 200   setlocale (LC_CTYPE, "");
 201 #endif
 202   bindtextdomain (PACKAGE, LOCALEDIR);
 203   textdomain (PACKAGE);
 204
 205   program_name = argv[0];
 206   xmalloc_set_program_name (program_name);
 207
 208   START_PROGRESS (program_name, 0);
 209
 210   expandargv (&argc, &argv);
 211
 212   bfd_init ();
 213
 214   bfd_set_error_program_name (program_name);
 215
 216   /* We want to notice and fail on those nasty BFD assertions which are
 217      likely to signal incorrect output being generated but otherwise may
 218      leave no trace.  */
 219   default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
 220
 221   xatexit (ld_cleanup);
 222
 223   /* Set up the sysroot directory.  */
 224   ld_sysroot = get_sysroot (argc, argv);
 225   if (*ld_sysroot)
 226     {
 227       if (*TARGET_SYSTEM_ROOT == 0)
 228         {
 229           einfo ("%P%F: this linker was not configured to use sysroots\n");
 230           ld_sysroot = "";
 231         }
 232       else
 233         ld_canon_sysroot = lrealpath (ld_sysroot);
 234     }
 235   if (ld_canon_sysroot)
 236     ld_canon_sysroot_len = strlen (ld_canon_sysroot);
 237   else
 238     ld_canon_sysroot_len = -1;
 239
 240   /* Set the default BFD target based on the configured target.  Doing
 241      this permits the linker to be configured for a particular target,
 242      and linked against a shared BFD library which was configured for
 243      a different target.  The macro TARGET is defined by Makefile.  */
 244   if (! bfd_set_default_target (TARGET))
 245     {
 246       einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
 247       xexit (1);
 248     }
 249
 250 #if YYDEBUG
 251   {
 252     extern int yydebug;
 253     yydebug = 1;
 254   }
 255 #endif
 256
 257   config.build_constructors = TRUE;
 258   config.rpath_separator = ':';
 259   config.split_by_reloc = (unsigned) -1;
 260   config.split_by_file = (bfd_size_type) -1;
 261   config.make_executable = TRUE;
 262   config.magic_demand_paged = TRUE;
 263   config.text_read_only = TRUE;
 264   link_info.disable_target_specific_optimizations = -1;
 265
 266   command_line.warn_mismatch = TRUE;
 267   command_line.warn_search_mismatch = TRUE;
 268   command_line.check_section_addresses = -1;
 269
 270   /* We initialize DEMANGLING based on the environment variable
 271      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
 272      output of the linker, unless COLLECT_NO_DEMANGLE is set in the
 273      environment.  Acting the same way here lets us provide the same
 274      interface by default.  */
 275   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
 276
 277   link_info.allow_undefined_version = TRUE;
 278   link_info.keep_memory = TRUE;
 279   link_info.combreloc = TRUE;
 280   link_info.strip_discarded = TRUE;
 281   link_info.emit_hash = TRUE;
 282   link_info.callbacks = &link_callbacks;
 283   link_info.input_bfds_tail = &link_info.input_bfds;
 284   /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
 285      and _fini symbols.  We are compatible.  */
 286   link_info.init_function = "_init";
 287   link_info.fini_function = "_fini";
 288   link_info.relax_pass = 1;
 289   link_info.pei386_auto_import = -1;
 290   link_info.spare_dynamic_tags = 5;
 291   link_info.path_separator = ':';
 292
 293   ldfile_add_arch ("");
 294   emulation = get_emulation (argc, argv);
 295   ldemul_choose_mode (emulation);
 296   default_target = ldemul_choose_target (argc, argv);
 297   config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
 298   config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
 299   lang_init ();
 300   ldemul_before_parse ();
 301   lang_has_input_file = FALSE;
 302   parse_args (argc, argv);
 303
 304   if (config.hash_table_size != 0)
 305     bfd_hash_set_default_size (config.hash_table_size);
 306
 307 #ifdef ENABLE_PLUGINS
 308   /* Now all the plugin arguments have been gathered, we can load them.  */
 309   plugin_load_plugins ();
 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 - start_sbrk));
 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 void
 647 add_ignoresym (struct bfd_link_info *info, const char *name)
 648 {
 649   if (info->ignore_hash == NULL)
 650     {
 651       info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
 652       if (! bfd_hash_table_init_n (info->ignore_hash,
 653                                    bfd_hash_newfunc,
 654                                    sizeof (struct bfd_hash_entry),
 655                                    61))
 656         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 657     }
 658
 659   if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
 660     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 661 }
 662
 663 /* Record a symbol to be wrapped, from the --wrap option.  */
 664
 665 void
 666 add_wrap (const char *name)
 667 {
 668   if (link_info.wrap_hash == NULL)
 669     {
 670       link_info.wrap_hash =
 671           (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 672       if (!bfd_hash_table_init_n (link_info.wrap_hash,
 673                                   bfd_hash_newfunc,
 674                                   sizeof (struct bfd_hash_entry),
 675                                   61))
 676         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 677     }
 678
 679   if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
 680     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 681 }
 682
 683 /* Handle the -retain-symbols-file option.  */
 684
 685 void
 686 add_keepsyms_file (const char *filename)
 687 {
 688   FILE *file;
 689   char *buf;
 690   size_t bufsize;
 691   int c;
 692
 693   if (link_info.strip == strip_some)
 694     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 695
 696   file = fopen (filename, "r");
 697   if (file == NULL)
 698     {
 699       bfd_set_error (bfd_error_system_call);
 700       einfo ("%X%P: %s: %E\n", filename);
 701       return;
 702     }
 703
 704   link_info.keep_hash = (struct bfd_hash_table *)
 705       xmalloc (sizeof (struct bfd_hash_table));
 706   if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
 707                             sizeof (struct bfd_hash_entry)))
 708     einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 709
 710   bufsize = 100;
 711   buf = (char *) xmalloc (bufsize);
 712
 713   c = getc (file);
 714   while (c != EOF)
 715     {
 716       while (ISSPACE (c))
 717         c = getc (file);
 718
 719       if (c != EOF)
 720         {
 721           size_t len = 0;
 722
 723           while (! ISSPACE (c) && c != EOF)
 724             {
 725               buf[len] = c;
 726               ++len;
 727               if (len >= bufsize)
 728                 {
 729                   bufsize *= 2;
 730                   buf = (char *) xrealloc (buf, bufsize);
 731                 }
 732               c = getc (file);
 733             }
 734
 735           buf[len] = '\0';
 736
 737           if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
 738             einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
 739         }
 740     }
 741
 742   if (link_info.strip != strip_none)
 743     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 744
 745   free (buf);
 746   link_info.strip = strip_some;
 747   fclose (file);
 748 }
 749 \f
 750 /* Callbacks from the BFD linker routines.  */
 751
 752 /* This is called when BFD has decided to include an archive member in
 753    a link.  */
 754
 755 static bfd_boolean
 756 add_archive_element (struct bfd_link_info *info,
 757                      bfd *abfd,
 758                      const char *name,
 759                      bfd **subsbfd ATTRIBUTE_UNUSED)
 760 {
 761   lang_input_statement_type *input;
 762   lang_input_statement_type orig_input;
 763
 764   input = (lang_input_statement_type *)
 765       xcalloc (1, sizeof (lang_input_statement_type));
 766   input->filename = abfd->filename;
 767   input->local_sym_name = abfd->filename;
 768   input->the_bfd = abfd;
 769
 770   /* Save the original data for trace files/tries below, as plugins
 771      (if enabled) may possibly alter it to point to a replacement
 772      BFD, but we still want to output the original BFD filename.  */
 773   orig_input = *input;
 774 #ifdef ENABLE_PLUGINS
 775   if (plugin_active_plugins_p () && !no_more_claiming)
 776     {
 777       /* We must offer this archive member to the plugins to claim.  */
 778       const char *filename = (bfd_my_archive (abfd) != NULL
 779                               ? bfd_my_archive (abfd)->filename : abfd->filename);
 780       int fd = open (filename, O_RDONLY | O_BINARY);
 781       if (fd >= 0)
 782         {
 783           struct ld_plugin_input_file file;
 784
 785           /* Offset and filesize must refer to the individual archive
 786              member, not the whole file, and must exclude the header.
 787              Fortunately for us, that is how the data is stored in the
 788              origin field of the bfd and in the arelt_data.  */
 789           file.name = filename;
 790           file.offset = abfd->origin;
 791           file.filesize = arelt_size (abfd);
 792           file.fd = fd;
 793           plugin_maybe_claim (&file, input);
 794           if (input->flags.claimed)
 795             {
 796               input->flags.claim_archive = TRUE;
 797               *subsbfd = input->the_bfd;
 798             }
 799         }
 800     }
 801 #endif /* ENABLE_PLUGINS */
 802
 803   ldlang_add_file (input);
 804
 805   if (config.map_file != NULL)
 806     {
 807       static bfd_boolean header_printed;
 808       struct bfd_link_hash_entry *h;
 809       bfd *from;
 810       int len;
 811
 812       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 813
 814       if (h == NULL)
 815         from = NULL;
 816       else
 817         {
 818           switch (h->type)
 819             {
 820             default:
 821               from = NULL;
 822               break;
 823
 824             case bfd_link_hash_defined:
 825             case bfd_link_hash_defweak:
 826               from = h->u.def.section->owner;
 827               break;
 828
 829             case bfd_link_hash_undefined:
 830             case bfd_link_hash_undefweak:
 831               from = h->u.undef.abfd;
 832               break;
 833
 834             case bfd_link_hash_common:
 835               from = h->u.c.p->section->owner;
 836               break;
 837             }
 838         }
 839
 840       if (! header_printed)
 841         {
 842           char buf[100];
 843
 844           sprintf (buf, _("Archive member included "
 845                           "to satisfy reference by file (symbol)\n\n"));
 846           minfo ("%s", buf);
 847           header_printed = TRUE;
 848         }
 849
 850       if (bfd_my_archive (abfd) == NULL)
 851         {
 852           minfo ("%s", bfd_get_filename (abfd));
 853           len = strlen (bfd_get_filename (abfd));
 854         }
 855       else
 856         {
 857           minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
 858                  bfd_get_filename (abfd));
 859           len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
 860                  + strlen (bfd_get_filename (abfd))
 861                  + 2);
 862         }
 863
 864       if (len >= 29)
 865         {
 866           print_nl ();
 867           len = 0;
 868         }
 869       while (len < 30)
 870         {
 871           print_space ();
 872           ++len;
 873         }
 874
 875       if (from != NULL)
 876         minfo ("%B ", from);
 877       if (h != NULL)
 878         minfo ("(%T)\n", h->root.string);
 879       else
 880         minfo ("(%s)\n", name);
 881     }
 882
 883   if (trace_files || verbose)
 884     info_msg ("%I\n", &orig_input);
 885   return TRUE;
 886 }
 887
 888 /* This is called when BFD has discovered a symbol which is defined
 889    multiple times.  */
 890
 891 static bfd_boolean
 892 multiple_definition (struct bfd_link_info *info,
 893                      struct bfd_link_hash_entry *h,
 894                      bfd *nbfd,
 895                      asection *nsec,
 896                      bfd_vma nval)
 897 {
 898   const char *name;
 899   bfd *obfd;
 900   asection *osec;
 901   bfd_vma oval;
 902
 903   if (info->allow_multiple_definition)
 904     return TRUE;
 905
 906   switch (h->type)
 907     {
 908     case bfd_link_hash_defined:
 909       osec = h->u.def.section;
 910       oval = h->u.def.value;
 911       obfd = h->u.def.section->owner;
 912       break;
 913     case bfd_link_hash_indirect:
 914       osec = bfd_ind_section_ptr;
 915       oval = 0;
 916       obfd = NULL;
 917       break;
 918     default:
 919       abort ();
 920     }
 921
 922   /* Ignore a redefinition of an absolute symbol to the
 923      same value; it's harmless.  */
 924   if (h->type == bfd_link_hash_defined
 925       && bfd_is_abs_section (osec)
 926       && bfd_is_abs_section (nsec)
 927       && nval == oval)
 928     return TRUE;
 929
 930   /* If either section has the output_section field set to
 931      bfd_abs_section_ptr, it means that the section is being
 932      discarded, and this is not really a multiple definition at all.
 933      FIXME: It would be cleaner to somehow ignore symbols defined in
 934      sections which are being discarded.  */
 935   if ((osec->output_section != NULL
 936        && ! bfd_is_abs_section (osec)
 937        && bfd_is_abs_section (osec->output_section))
 938       || (nsec->output_section != NULL
 939           && ! bfd_is_abs_section (nsec)
 940           && bfd_is_abs_section (nsec->output_section)))
 941     return TRUE;
 942
 943   name = h->root.string;
 944   if (nbfd == NULL)
 945     {
 946       nbfd = obfd;
 947       nsec = osec;
 948       nval = oval;
 949       obfd = NULL;
 950     }
 951   einfo (_("%X%C: multiple definition of `%T'\n"),
 952          nbfd, nsec, nval, name);
 953   if (obfd != NULL)
 954     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 955
 956   if (RELAXATION_ENABLED_BY_USER)
 957     {
 958       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 959       DISABLE_RELAXATION;
 960     }
 961
 962   return TRUE;
 963 }
 964
 965 /* This is called when there is a definition of a common symbol, or
 966    when a common symbol is found for a symbol that is already defined,
 967    or when two common symbols are found.  We only do something if
 968    -warn-common was used.  */
 969
 970 static bfd_boolean
 971 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 972                  struct bfd_link_hash_entry *h,
 973                  bfd *nbfd,
 974                  enum bfd_link_hash_type ntype,
 975                  bfd_vma nsize)
 976 {
 977   const char *name;
 978   bfd *obfd;
 979   enum bfd_link_hash_type otype;
 980   bfd_vma osize;
 981
 982   if (!config.warn_common)
 983     return TRUE;
 984
 985   name = h->root.string;
 986   otype = h->type;
 987   if (otype == bfd_link_hash_common)
 988     {
 989       obfd = h->u.c.p->section->owner;
 990       osize = h->u.c.size;
 991     }
 992   else if (otype == bfd_link_hash_defined
 993            || otype == bfd_link_hash_defweak)
 994     {
 995       obfd = h->u.def.section->owner;
 996       osize = 0;
 997     }
 998   else
 999     {
1000       /* FIXME: It would nice if we could report the BFD which defined
1001          an indirect symbol, but we don't have anywhere to store the
1002          information.  */
1003       obfd = NULL;
1004       osize = 0;
1005     }
1006
1007   if (ntype == bfd_link_hash_defined
1008       || ntype == bfd_link_hash_defweak
1009       || ntype == bfd_link_hash_indirect)
1010     {
1011       ASSERT (otype == bfd_link_hash_common);
1012       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1013              nbfd, name);
1014       if (obfd != NULL)
1015         einfo (_("%B: warning: common is here\n"), obfd);
1016     }
1017   else if (otype == bfd_link_hash_defined
1018            || otype == bfd_link_hash_defweak
1019            || otype == bfd_link_hash_indirect)
1020     {
1021       ASSERT (ntype == bfd_link_hash_common);
1022       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1023              nbfd, name);
1024       if (obfd != NULL)
1025         einfo (_("%B: warning: defined here\n"), obfd);
1026     }
1027   else
1028     {
1029       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1030       if (osize > nsize)
1031         {
1032           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1033                  nbfd, name);
1034           if (obfd != NULL)
1035             einfo (_("%B: warning: larger common is here\n"), obfd);
1036         }
1037       else if (nsize > osize)
1038         {
1039           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1040                  nbfd, name);
1041           if (obfd != NULL)
1042             einfo (_("%B: warning: smaller common is here\n"), obfd);
1043         }
1044       else
1045         {
1046           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1047           if (obfd != NULL)
1048             einfo (_("%B: warning: previous common is here\n"), obfd);
1049         }
1050     }
1051
1052   return TRUE;
1053 }
1054
1055 /* This is called when BFD has discovered a set element.  H is the
1056    entry in the linker hash table for the set.  SECTION and VALUE
1057    represent a value which should be added to the set.  */
1058
1059 static bfd_boolean
1060 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1061             struct bfd_link_hash_entry *h,
1062             bfd_reloc_code_real_type reloc,
1063             bfd *abfd,
1064             asection *section,
1065             bfd_vma value)
1066 {
1067   if (config.warn_constructors)
1068     einfo (_("%P: warning: global constructor %s used\n"),
1069            h->root.string);
1070
1071   if (! config.build_constructors)
1072     return TRUE;
1073
1074   ldctor_add_set_entry (h, reloc, NULL, section, value);
1075
1076   if (h->type == bfd_link_hash_new)
1077     {
1078       h->type = bfd_link_hash_undefined;
1079       h->u.undef.abfd = abfd;
1080       /* We don't call bfd_link_add_undef to add this to the list of
1081          undefined symbols because we are going to define it
1082          ourselves.  */
1083     }
1084
1085   return TRUE;
1086 }
1087
1088 /* This is called when BFD has discovered a constructor.  This is only
1089    called for some object file formats--those which do not handle
1090    constructors in some more clever fashion.  This is similar to
1091    adding an element to a set, but less general.  */
1092
1093 static bfd_boolean
1094 constructor_callback (struct bfd_link_info *info,
1095                       bfd_boolean constructor,
1096                       const char *name,
1097                       bfd *abfd,
1098                       asection *section,
1099                       bfd_vma value)
1100 {
1101   char *s;
1102   struct bfd_link_hash_entry *h;
1103   char set_name[1 + sizeof "__CTOR_LIST__"];
1104
1105   if (config.warn_constructors)
1106     einfo (_("%P: warning: global constructor %s used\n"), name);
1107
1108   if (! config.build_constructors)
1109     return TRUE;
1110
1111   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1112      useful error message.  */
1113   if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1114       && (info->relocatable
1115           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1116     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1117
1118   s = set_name;
1119   if (bfd_get_symbol_leading_char (abfd) != '\0')
1120     *s++ = bfd_get_symbol_leading_char (abfd);
1121   if (constructor)
1122     strcpy (s, "__CTOR_LIST__");
1123   else
1124     strcpy (s, "__DTOR_LIST__");
1125
1126   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1127   if (h == (struct bfd_link_hash_entry *) NULL)
1128     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1129   if (h->type == bfd_link_hash_new)
1130     {
1131       h->type = bfd_link_hash_undefined;
1132       h->u.undef.abfd = abfd;
1133       /* We don't call bfd_link_add_undef to add this to the list of
1134          undefined symbols because we are going to define it
1135          ourselves.  */
1136     }
1137
1138   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1139   return TRUE;
1140 }
1141
1142 /* A structure used by warning_callback to pass information through
1143    bfd_map_over_sections.  */
1144
1145 struct warning_callback_info
1146 {
1147   bfd_boolean found;
1148   const char *warning;
1149   const char *symbol;
1150   asymbol **asymbols;
1151 };
1152
1153 /* This is called when there is a reference to a warning symbol.  */
1154
1155 static bfd_boolean
1156 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1157                   const char *warning,
1158                   const char *symbol,
1159                   bfd *abfd,
1160                   asection *section,
1161                   bfd_vma address)
1162 {
1163   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1164      have a cleaner interface, but what?  */
1165   if (! config.warn_multiple_gp
1166       && strcmp (warning, "using multiple gp values") == 0)
1167     return TRUE;
1168
1169   if (section != NULL)
1170     einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1171   else if (abfd == NULL)
1172     einfo ("%P: %s%s\n", _("warning: "), warning);
1173   else if (symbol == NULL)
1174     einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1175   else
1176     {
1177       struct warning_callback_info cinfo;
1178
1179       /* Look through the relocs to see if we can find a plausible
1180          address.  */
1181
1182       if (!bfd_generic_link_read_symbols (abfd))
1183         einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1184
1185       cinfo.found = FALSE;
1186       cinfo.warning = warning;
1187       cinfo.symbol = symbol;
1188       cinfo.asymbols = bfd_get_outsymbols (abfd);
1189       bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1190
1191       if (! cinfo.found)
1192         einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1193     }
1194
1195   return TRUE;
1196 }
1197
1198 /* This is called by warning_callback for each section.  It checks the
1199    relocs of the section to see if it can find a reference to the
1200    symbol which triggered the warning.  If it can, it uses the reloc
1201    to give an error message with a file and line number.  */
1202
1203 static void
1204 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1205 {
1206   struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1207   long relsize;
1208   arelent **relpp;
1209   long relcount;
1210   arelent **p, **pend;
1211
1212   if (info->found)
1213     return;
1214
1215   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1216   if (relsize < 0)
1217     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1218   if (relsize == 0)
1219     return;
1220
1221   relpp = (arelent **) xmalloc (relsize);
1222   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1223   if (relcount < 0)
1224     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1225
1226   p = relpp;
1227   pend = p + relcount;
1228   for (; p < pend && *p != NULL; p++)
1229     {
1230       arelent *q = *p;
1231
1232       if (q->sym_ptr_ptr != NULL
1233           && *q->sym_ptr_ptr != NULL
1234           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1235         {
1236           /* We found a reloc for the symbol we are looking for.  */
1237           einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1238                  info->warning);
1239           info->found = TRUE;
1240           break;
1241         }
1242     }
1243
1244   free (relpp);
1245 }
1246
1247 /* This is called when an undefined symbol is found.  */
1248
1249 static bfd_boolean
1250 undefined_symbol (struct bfd_link_info *info,
1251                   const char *name,
1252                   bfd *abfd,
1253                   asection *section,
1254                   bfd_vma address,
1255                   bfd_boolean error)
1256 {
1257   static char *error_name;
1258   static unsigned int error_count;
1259
1260 #define MAX_ERRORS_IN_A_ROW 5
1261
1262   if (info->ignore_hash != NULL
1263       && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1264     return TRUE;
1265
1266   if (config.warn_once)
1267     {
1268       /* Only warn once about a particular undefined symbol.  */
1269       add_ignoresym (info, name);
1270     }
1271
1272   /* We never print more than a reasonable number of errors in a row
1273      for a single symbol.  */
1274   if (error_name != NULL
1275       && strcmp (name, error_name) == 0)
1276     ++error_count;
1277   else
1278     {
1279       error_count = 0;
1280       if (error_name != NULL)
1281         free (error_name);
1282       error_name = xstrdup (name);
1283     }
1284
1285   if (section != NULL)
1286     {
1287       if (error_count < MAX_ERRORS_IN_A_ROW)
1288         {
1289           if (error)
1290             einfo (_("%X%C: undefined reference to `%T'\n"),
1291                    abfd, section, address, name);
1292           else
1293             einfo (_("%C: warning: undefined reference to `%T'\n"),
1294                    abfd, section, address, name);
1295         }
1296       else if (error_count == MAX_ERRORS_IN_A_ROW)
1297         {
1298           if (error)
1299             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1300                    abfd, section, address, name);
1301           else
1302             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1303                    abfd, section, address, name);
1304         }
1305       else if (error)
1306         einfo ("%X");
1307     }
1308   else
1309     {
1310       if (error_count < MAX_ERRORS_IN_A_ROW)
1311         {
1312           if (error)
1313             einfo (_("%X%B: undefined reference to `%T'\n"),
1314                    abfd, name);
1315           else
1316             einfo (_("%B: warning: undefined reference to `%T'\n"),
1317                    abfd, name);
1318         }
1319       else if (error_count == MAX_ERRORS_IN_A_ROW)
1320         {
1321           if (error)
1322             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1323                    abfd, name);
1324           else
1325             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1326                    abfd, name);
1327         }
1328       else if (error)
1329         einfo ("%X");
1330     }
1331
1332   return TRUE;
1333 }
1334
1335 /* Counter to limit the number of relocation overflow error messages
1336    to print.  Errors are printed as it is decremented.  When it's
1337    called and the counter is zero, a final message is printed
1338    indicating more relocations were omitted.  When it gets to -1, no
1339    such errors are printed.  If it's initially set to a value less
1340    than -1, all such errors will be printed (--verbose does this).  */
1341
1342 int overflow_cutoff_limit = 10;
1343
1344 /* This is called when a reloc overflows.  */
1345
1346 static bfd_boolean
1347 reloc_overflow (struct bfd_link_info *info,
1348                 struct bfd_link_hash_entry *entry,
1349                 const char *name,
1350                 const char *reloc_name,
1351                 bfd_vma addend,
1352                 bfd *abfd,
1353                 asection *section,
1354                 bfd_vma address)
1355 {
1356   if (overflow_cutoff_limit == -1)
1357     return TRUE;
1358
1359   einfo ("%X%H:", abfd, section, address);
1360
1361   if (overflow_cutoff_limit >= 0
1362       && overflow_cutoff_limit-- == 0)
1363     {
1364       einfo (_(" additional relocation overflows omitted from the output\n"));
1365       return TRUE;
1366     }
1367
1368   if (entry)
1369     {
1370       while (entry->type == bfd_link_hash_indirect
1371              || entry->type == bfd_link_hash_warning)
1372         entry = entry->u.i.link;
1373       switch (entry->type)
1374         {
1375         case bfd_link_hash_undefined:
1376         case bfd_link_hash_undefweak:
1377           einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1378                  reloc_name, entry->root.string);
1379           break;
1380         case bfd_link_hash_defined:
1381         case bfd_link_hash_defweak:
1382           einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1383                  reloc_name, entry->root.string,
1384                  entry->u.def.section,
1385                  entry->u.def.section == bfd_abs_section_ptr
1386                  ? info->output_bfd : entry->u.def.section->owner);
1387           break;
1388         default:
1389           abort ();
1390           break;
1391         }
1392     }
1393   else
1394     einfo (_(" relocation truncated to fit: %s against `%T'"),
1395            reloc_name, name);
1396   if (addend != 0)
1397     einfo ("+%v", addend);
1398   einfo ("\n");
1399   return TRUE;
1400 }
1401
1402 /* This is called when a dangerous relocation is made.  */
1403
1404 static bfd_boolean
1405 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1406                  const char *message,
1407                  bfd *abfd,
1408                  asection *section,
1409                  bfd_vma address)
1410 {
1411   einfo (_("%X%H: dangerous relocation: %s\n"),
1412          abfd, section, address, message);
1413   return TRUE;
1414 }
1415
1416 /* This is called when a reloc is being generated attached to a symbol
1417    that is not being output.  */
1418
1419 static bfd_boolean
1420 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1421                   const char *name,
1422                   bfd *abfd,
1423                   asection *section,
1424                   bfd_vma address)
1425 {
1426   einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1427          abfd, section, address, name);
1428   return TRUE;
1429 }
1430
1431 /* This is called if link_info.notice_all is set, or when a symbol in
1432    link_info.notice_hash is found.  Symbols are put in notice_hash
1433    using the -y option, while notice_all is set if the --cref option
1434    has been supplied, or if there are any NOCROSSREFS sections in the
1435    linker script; and if plugins are active, since they need to monitor
1436    all references from non-IR files.  */
1437
1438 static bfd_boolean
1439 notice (struct bfd_link_info *info,
1440         struct bfd_link_hash_entry *h,
1441         bfd *abfd,
1442         asection *section,
1443         bfd_vma value,
1444         flagword flags ATTRIBUTE_UNUSED,
1445         const char *string ATTRIBUTE_UNUSED)
1446 {
1447   const char *name;
1448
1449   if (h == NULL)
1450     {
1451       if (command_line.cref || nocrossref_list != NULL)
1452         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1453       return TRUE;
1454     }
1455
1456   name = h->root.string;
1457   if (info->notice_hash != NULL
1458       && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1459     {
1460       if (bfd_is_und_section (section))
1461         einfo ("%B: reference to %s\n", abfd, name);
1462       else
1463         einfo ("%B: definition of %s\n", abfd, name);
1464     }
1465
1466   if (command_line.cref || nocrossref_list != NULL)
1467     add_cref (name, abfd, section, value);
1468
1469   return TRUE;
1470 }