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