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   plugin_load_plugins ();
 312 #endif /* ENABLE_PLUGINS */
 313
 314   ldemul_set_symbols ();
 315
 316   /* If we have not already opened and parsed a linker script,
 317      try the default script from command line first.  */
 318   if (saved_script_handle == NULL
 319       && command_line.default_script != NULL)
 320     {
 321       ldfile_open_command_file (command_line.default_script);
 322       parser_input = input_script;
 323       yyparse ();
 324     }
 325
 326   /* If we have not already opened and parsed a linker script
 327      read the emulation's appropriate default script.  */
 328   if (saved_script_handle == NULL)
 329     {
 330       int isfile;
 331       char *s = ldemul_get_script (&isfile);
 332
 333       if (isfile)
 334         ldfile_open_default_command_file (s);
 335       else
 336         {
 337           lex_string = s;
 338           lex_redirect (s, _("built in linker script"), 1);
 339         }
 340       parser_input = input_script;
 341       yyparse ();
 342       lex_string = NULL;
 343     }
 344
 345   if (verbose)
 346     {
 347       if (saved_script_handle)
 348         info_msg (_("using external linker script:"));
 349       else
 350         info_msg (_("using internal linker script:"));
 351       info_msg ("\n==================================================\n");
 352
 353       if (saved_script_handle)
 354         {
 355           static const int ld_bufsz = 8193;
 356           size_t n;
 357           char *buf = (char *) xmalloc (ld_bufsz);
 358
 359           rewind (saved_script_handle);
 360           while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
 361             {
 362               buf[n] = 0;
 363               info_msg (buf);
 364             }
 365           rewind (saved_script_handle);
 366           free (buf);
 367         }
 368       else
 369         {
 370           int isfile;
 371
 372           info_msg (ldemul_get_script (&isfile));
 373         }
 374
 375       info_msg ("\n==================================================\n");
 376     }
 377
 378   if (command_line.print_output_format)
 379     info_msg ("%s\n", lang_get_output_target ());
 380
 381   lang_final ();
 382
 383   if (!lang_has_input_file)
 384     {
 385       if (version_printed || command_line.print_output_format)
 386         xexit (0);
 387       einfo (_("%P%F: no input files\n"));
 388     }
 389
 390   if (trace_files)
 391     info_msg (_("%P: mode %s\n"), emulation);
 392
 393   ldemul_after_parse ();
 394
 395   if (config.map_filename)
 396     {
 397       if (strcmp (config.map_filename, "-") == 0)
 398         {
 399           config.map_file = stdout;
 400         }
 401       else
 402         {
 403           config.map_file = fopen (config.map_filename, FOPEN_WT);
 404           if (config.map_file == (FILE *) NULL)
 405             {
 406               bfd_set_error (bfd_error_system_call);
 407               einfo (_("%P%F: cannot open map file %s: %E\n"),
 408                      config.map_filename);
 409             }
 410         }
 411     }
 412
 413   lang_process ();
 414
 415   /* Print error messages for any missing symbols, for any warning
 416      symbols, and possibly multiple definitions.  */
 417   if (link_info.relocatable)
 418     link_info.output_bfd->flags &= ~EXEC_P;
 419   else
 420     link_info.output_bfd->flags |= EXEC_P;
 421
 422   ldwrite ();
 423
 424   if (config.map_file != NULL)
 425     lang_map ();
 426   if (command_line.cref)
 427     output_cref (config.map_file != NULL ? config.map_file : stdout);
 428   if (nocrossref_list != NULL)
 429     check_nocrossrefs ();
 430
 431   lang_finish ();
 432
 433   /* Even if we're producing relocatable output, some non-fatal errors should
 434      be reported in the exit status.  (What non-fatal errors, if any, do we
 435      want to ignore for relocatable output?)  */
 436   if (!config.make_executable && !force_make_executable)
 437     {
 438       if (trace_files)
 439         einfo (_("%P: link errors found, deleting executable `%s'\n"),
 440                output_filename);
 441
 442       /* The file will be removed by ld_cleanup.  */
 443       xexit (1);
 444     }
 445   else
 446     {
 447       if (! bfd_close (link_info.output_bfd))
 448         einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
 449
 450       /* If the --force-exe-suffix is enabled, and we're making an
 451          executable file and it doesn't end in .exe, copy it to one
 452          which does.  */
 453       if (! link_info.relocatable && command_line.force_exe_suffix)
 454         {
 455           int len = strlen (output_filename);
 456
 457           if (len < 4
 458               || (strcasecmp (output_filename + len - 4, ".exe") != 0
 459                   && strcasecmp (output_filename + len - 4, ".dll") != 0))
 460             {
 461               FILE *src;
 462               FILE *dst;
 463               const int bsize = 4096;
 464               char *buf = (char *) xmalloc (bsize);
 465               int l;
 466               char *dst_name = (char *) xmalloc (len + 5);
 467
 468               strcpy (dst_name, output_filename);
 469               strcat (dst_name, ".exe");
 470               src = fopen (output_filename, FOPEN_RB);
 471               dst = fopen (dst_name, FOPEN_WB);
 472
 473               if (!src)
 474                 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
 475                        output_filename);
 476               if (!dst)
 477                 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
 478                        dst_name);
 479               while ((l = fread (buf, 1, bsize, src)) > 0)
 480                 {
 481                   int done = fwrite (buf, 1, l, dst);
 482
 483                   if (done != l)
 484                     einfo (_("%P: Error writing file `%s'\n"), dst_name);
 485                 }
 486
 487               fclose (src);
 488               if (fclose (dst) == EOF)
 489                 einfo (_("%P: Error closing file `%s'\n"), dst_name);
 490               free (dst_name);
 491               free (buf);
 492             }
 493         }
 494     }
 495
 496   END_PROGRESS (program_name);
 497
 498   if (config.stats)
 499     {
 500 #ifdef HAVE_SBRK
 501       char *lim = (char *) sbrk (0);
 502 #endif
 503       long run_time = get_run_time () - start_time;
 504
 505       fflush (stdout);
 506       fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
 507                program_name, run_time / 1000000, run_time % 1000000);
 508 #ifdef HAVE_SBRK
 509       fprintf (stderr, _("%s: data size %ld\n"), program_name,
 510                (long) (lim - start_sbrk));
 511 #endif
 512       fflush (stderr);
 513     }
 514
 515   /* Prevent ld_cleanup from doing anything, after a successful link.  */
 516   output_filename = NULL;
 517
 518   xexit (0);
 519   return 0;
 520 }
 521
 522 /* If the configured sysroot is relocatable, try relocating it based on
 523    default prefix FROM.  Return the relocated directory if it exists,
 524    otherwise return null.  */
 525
 526 static char *
 527 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
 528 {
 529 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 530   char *path;
 531   struct stat s;
 532
 533   path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
 534   if (path)
 535     {
 536       if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
 537         return path;
 538       free (path);
 539     }
 540 #endif
 541   return 0;
 542 }
 543
 544 /* Return the sysroot directory.  Return "" if no sysroot is being used.  */
 545
 546 static const char *
 547 get_sysroot (int argc, char **argv)
 548 {
 549   int i;
 550   const char *path;
 551
 552   for (i = 1; i < argc; i++)
 553     if (CONST_STRNEQ (argv[i], "--sysroot="))
 554       return argv[i] + strlen ("--sysroot=");
 555
 556   path = get_relative_sysroot (BINDIR);
 557   if (path)
 558     return path;
 559
 560   path = get_relative_sysroot (TOOLBINDIR);
 561   if (path)
 562     return path;
 563
 564   return TARGET_SYSTEM_ROOT;
 565 }
 566
 567 /* We need to find any explicitly given emulation in order to initialize the
 568    state that's needed by the lex&yacc argument parser (parse_args).  */
 569
 570 static char *
 571 get_emulation (int argc, char **argv)
 572 {
 573   char *emulation;
 574   int i;
 575
 576   emulation = getenv (EMULATION_ENVIRON);
 577   if (emulation == NULL)
 578     emulation = DEFAULT_EMULATION;
 579
 580   for (i = 1; i < argc; i++)
 581     {
 582       if (CONST_STRNEQ (argv[i], "-m"))
 583         {
 584           if (argv[i][2] == '\0')
 585             {
 586               /* -m EMUL */
 587               if (i < argc - 1)
 588                 {
 589                   emulation = argv[i + 1];
 590                   i++;
 591                 }
 592               else
 593                 einfo (_("%P%F: missing argument to -m\n"));
 594             }
 595           else if (strcmp (argv[i], "-mips1") == 0
 596                    || strcmp (argv[i], "-mips2") == 0
 597                    || strcmp (argv[i], "-mips3") == 0
 598                    || strcmp (argv[i], "-mips4") == 0
 599                    || strcmp (argv[i], "-mips5") == 0
 600                    || strcmp (argv[i], "-mips32") == 0
 601                    || strcmp (argv[i], "-mips32r2") == 0
 602                    || strcmp (argv[i], "-mips64") == 0
 603                    || strcmp (argv[i], "-mips64r2") == 0)
 604             {
 605               /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
 606                  passed to the linker by some MIPS compilers.  They
 607                  generally tell the linker to use a slightly different
 608                  library path.  Perhaps someday these should be
 609                  implemented as emulations; until then, we just ignore
 610                  the arguments and hope that nobody ever creates
 611                  emulations named ips1, ips2 or ips3.  */
 612             }
 613           else if (strcmp (argv[i], "-m486") == 0)
 614             {
 615               /* FIXME: The argument -m486 is passed to the linker on
 616                  some Linux systems.  Hope that nobody creates an
 617                  emulation named 486.  */
 618             }
 619           else
 620             {
 621               /* -mEMUL */
 622               emulation = &argv[i][2];
 623             }
 624         }
 625     }
 626
 627   return emulation;
 628 }
 629
 630 void
 631 add_ysym (const char *name)
 632 {
 633   if (link_info.notice_hash == NULL)
 634     {
 635       link_info.notice_hash =
 636           (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 637       if (!bfd_hash_table_init_n (link_info.notice_hash,
 638                                   bfd_hash_newfunc,
 639                                   sizeof (struct bfd_hash_entry),
 640                                   61))
 641         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 642     }
 643
 644   if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
 645     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 646 }
 647
 648 void
 649 add_ignoresym (struct bfd_link_info *info, const char *name)
 650 {
 651   if (info->ignore_hash == NULL)
 652     {
 653       info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
 654       if (! bfd_hash_table_init_n (info->ignore_hash,
 655                                    bfd_hash_newfunc,
 656                                    sizeof (struct bfd_hash_entry),
 657                                    61))
 658         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 659     }
 660
 661   if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
 662     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 663 }
 664
 665 /* Record a symbol to be wrapped, from the --wrap option.  */
 666
 667 void
 668 add_wrap (const char *name)
 669 {
 670   if (link_info.wrap_hash == NULL)
 671     {
 672       link_info.wrap_hash =
 673           (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 674       if (!bfd_hash_table_init_n (link_info.wrap_hash,
 675                                   bfd_hash_newfunc,
 676                                   sizeof (struct bfd_hash_entry),
 677                                   61))
 678         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 679     }
 680
 681   if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
 682     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 683 }
 684
 685 /* Handle the -retain-symbols-file option.  */
 686
 687 void
 688 add_keepsyms_file (const char *filename)
 689 {
 690   FILE *file;
 691   char *buf;
 692   size_t bufsize;
 693   int c;
 694
 695   if (link_info.strip == strip_some)
 696     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 697
 698   file = fopen (filename, "r");
 699   if (file == NULL)
 700     {
 701       bfd_set_error (bfd_error_system_call);
 702       einfo ("%X%P: %s: %E\n", filename);
 703       return;
 704     }
 705
 706   link_info.keep_hash = (struct bfd_hash_table *)
 707       xmalloc (sizeof (struct bfd_hash_table));
 708   if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
 709                             sizeof (struct bfd_hash_entry)))
 710     einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 711
 712   bufsize = 100;
 713   buf = (char *) xmalloc (bufsize);
 714
 715   c = getc (file);
 716   while (c != EOF)
 717     {
 718       while (ISSPACE (c))
 719         c = getc (file);
 720
 721       if (c != EOF)
 722         {
 723           size_t len = 0;
 724
 725           while (! ISSPACE (c) && c != EOF)
 726             {
 727               buf[len] = c;
 728               ++len;
 729               if (len >= bufsize)
 730                 {
 731                   bufsize *= 2;
 732                   buf = (char *) xrealloc (buf, bufsize);
 733                 }
 734               c = getc (file);
 735             }
 736
 737           buf[len] = '\0';
 738
 739           if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
 740             einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
 741         }
 742     }
 743
 744   if (link_info.strip != strip_none)
 745     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 746
 747   free (buf);
 748   link_info.strip = strip_some;
 749 }
 750 \f
 751 /* Callbacks from the BFD linker routines.  */
 752
 753 /* This is called when BFD has decided to include an archive member in
 754    a link.  */
 755
 756 static bfd_boolean
 757 add_archive_element (struct bfd_link_info *info,
 758                      bfd *abfd,
 759                      const char *name,
 760                      bfd **subsbfd ATTRIBUTE_UNUSED)
 761 {
 762   lang_input_statement_type *input;
 763   lang_input_statement_type orig_input;
 764
 765   input = (lang_input_statement_type *)
 766       xcalloc (1, sizeof (lang_input_statement_type));
 767   input->filename = abfd->filename;
 768   input->local_sym_name = abfd->filename;
 769   input->the_bfd = abfd;
 770
 771   /* Save the original data for trace files/tries below, as plugins
 772      (if enabled) may possibly alter it to point to a replacement
 773      BFD, but we still want to output the original BFD filename.  */
 774   orig_input = *input;
 775 #ifdef ENABLE_PLUGINS
 776   if (plugin_active_plugins_p () && !no_more_claiming)
 777     {
 778       /* We must offer this archive member to the plugins to claim.  */
 779       const char *filename = (bfd_my_archive (abfd) != NULL
 780                               ? bfd_my_archive (abfd)->filename : abfd->filename);
 781       int fd = open (filename, O_RDONLY | O_BINARY);
 782       if (fd >= 0)
 783         {
 784           struct ld_plugin_input_file file;
 785
 786           /* Offset and filesize must refer to the individual archive
 787              member, not the whole file, and must exclude the header.
 788              Fortunately for us, that is how the data is stored in the
 789              origin field of the bfd and in the arelt_data.  */
 790           file.name = filename;
 791           file.offset = abfd->origin;
 792           file.filesize = arelt_size (abfd);
 793           file.fd = fd;
 794           plugin_maybe_claim (&file, input);
 795           if (input->flags.claimed)
 796             {
 797               input->flags.claim_archive = TRUE;
 798               *subsbfd = input->the_bfd;
 799             }
 800         }
 801     }
 802 #endif /* ENABLE_PLUGINS */
 803
 804   ldlang_add_file (input);
 805
 806   if (config.map_file != NULL)
 807     {
 808       static bfd_boolean header_printed;
 809       struct bfd_link_hash_entry *h;
 810       bfd *from;
 811       int len;
 812
 813       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 814
 815       if (h == NULL)
 816         from = NULL;
 817       else
 818         {
 819           switch (h->type)
 820             {
 821             default:
 822               from = NULL;
 823               break;
 824
 825             case bfd_link_hash_defined:
 826             case bfd_link_hash_defweak:
 827               from = h->u.def.section->owner;
 828               break;
 829
 830             case bfd_link_hash_undefined:
 831             case bfd_link_hash_undefweak:
 832               from = h->u.undef.abfd;
 833               break;
 834
 835             case bfd_link_hash_common:
 836               from = h->u.c.p->section->owner;
 837               break;
 838             }
 839         }
 840
 841       if (! header_printed)
 842         {
 843           char buf[100];
 844
 845           sprintf (buf, _("Archive member included because of 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)
 957     {
 958       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 959       link_info.disable_target_specific_optimizations = -1;
 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 }