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
   4    Free Software Foundation, Inc.
   5    Written by Steve Chamberlain steve@cygnus.com
   6
   7    This file is part of the GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "safe-ctype.h"
  27 #include "libiberty.h"
  28 #include "progress.h"
  29 #include "bfdlink.h"
  30 #include "filenames.h"
  31
  32 #include "ld.h"
  33 #include "ldmain.h"
  34 #include "ldmisc.h"
  35 #include "ldwrite.h"
  36 #include "ldexp.h"
  37 #include "ldlang.h"
  38 #include <ldgram.h>
  39 #include "ldlex.h"
  40 #include "ldfile.h"
  41 #include "ldemul.h"
  42 #include "ldctor.h"
  43 #ifdef ENABLE_PLUGINS
  44 #include "plugin.h"
  45 #include "plugin-api.h"
  46 #include "libbfd.h"
  47 #endif /* ENABLE_PLUGINS */
  48
  49 /* Somewhere above, sys/stat.h got included.  */
  50 #if !defined(S_ISDIR) && defined(S_IFDIR)
  51 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  52 #endif
  53
  54 #include <string.h>
  55
  56 #ifdef HAVE_SBRK
  57 #if !HAVE_DECL_SBRK
  58 extern void *sbrk ();
  59 #endif
  60 #endif
  61
  62 #ifndef TARGET_SYSTEM_ROOT
  63 #define TARGET_SYSTEM_ROOT ""
  64 #endif
  65
  66 /* EXPORTS */
  67
  68 FILE *saved_script_handle = NULL;
  69 FILE *previous_script_handle = NULL;
  70 bfd_boolean force_make_executable = FALSE;
  71
  72 char *default_target;
  73 const char *output_filename = "a.out";
  74
  75 /* Name this program was invoked by.  */
  76 char *program_name;
  77
  78 /* The prefix for system library directories.  */
  79 const char *ld_sysroot;
  80
  81 /* The canonical representation of ld_sysroot.  */
  82 char * ld_canon_sysroot;
  83 int ld_canon_sysroot_len;
  84
  85 /* Set by -G argument, for MIPS ECOFF target.  */
  86 int g_switch_value = 8;
  87
  88 /* Nonzero means print names of input files as processed.  */
  89 bfd_boolean trace_files;
  90
  91 /* Nonzero means same, but note open failures, too.  */
  92 bfd_boolean trace_file_tries;
  93
  94 /* Nonzero means version number was printed, so exit successfully
  95    instead of complaining if no input files are given.  */
  96 bfd_boolean version_printed;
  97
  98 /* Nonzero means link in every member of an archive.  */
  99 bfd_boolean whole_archive;
 100
 101 /* True means only create DT_NEEDED entries for dynamic libraries
 102    if they actually satisfy some reference in a regular object.  */
 103 bfd_boolean add_DT_NEEDED_for_regular;
 104
 105 /* True means create DT_NEEDED entries for dynamic libraries that
 106    are DT_NEEDED by dynamic libraries specifically mentioned on
 107    the command line.  */
 108 bfd_boolean add_DT_NEEDED_for_dynamic = TRUE;
 109
 110 /* TRUE if we should demangle symbol names.  */
 111 bfd_boolean demangling;
 112
 113 args_type command_line;
 114
 115 ld_config_type config;
 116
 117 sort_type sort_section;
 118
 119 static const char *get_sysroot
 120   (int, char **);
 121 static char *get_emulation
 122   (int, char **);
 123 static bfd_boolean add_archive_element
 124   (struct bfd_link_info *, bfd *, const char *, bfd **);
 125 static bfd_boolean multiple_definition
 126   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 127    bfd *, asection *, bfd_vma);
 128 static bfd_boolean multiple_common
 129   (struct bfd_link_info *, const char *, bfd *, enum bfd_link_hash_type,
 130    bfd_vma, bfd *, enum bfd_link_hash_type, bfd_vma);
 131 static bfd_boolean add_to_set
 132   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 133    bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
 134 static bfd_boolean constructor_callback
 135   (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
 136    asection *, bfd_vma);
 137 static bfd_boolean warning_callback
 138   (struct bfd_link_info *, const char *, const char *, bfd *,
 139    asection *, bfd_vma);
 140 static void warning_find_reloc
 141   (bfd *, asection *, void *);
 142 static bfd_boolean undefined_symbol
 143   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 144    bfd_boolean);
 145 static bfd_boolean reloc_overflow
 146   (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
 147    const char *, bfd_vma, bfd *, asection *, bfd_vma);
 148 static bfd_boolean reloc_dangerous
 149   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 150 static bfd_boolean unattached_reloc
 151   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 152 static bfd_boolean notice
 153   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 154
 155 static struct bfd_link_callbacks link_callbacks =
 156 {
 157   add_archive_element,
 158   multiple_definition,
 159   multiple_common,
 160   add_to_set,
 161   constructor_callback,
 162   warning_callback,
 163   undefined_symbol,
 164   reloc_overflow,
 165   reloc_dangerous,
 166   unattached_reloc,
 167   notice,
 168   einfo,
 169   info_msg,
 170   minfo,
 171   ldlang_override_segment_assignment
 172 };
 173
 174 struct bfd_link_info link_info;
 175 \f
 176 static void
 177 remove_output (void)
 178 {
 179   if (output_filename)
 180     {
 181       if (link_info.output_bfd)
 182         bfd_cache_close (link_info.output_bfd);
 183       if (delete_output_file_on_failure)
 184         unlink_if_ordinary (output_filename);
 185     }
 186 }
 187
 188 int
 189 main (int argc, char **argv)
 190 {
 191   char *emulation;
 192   long start_time = get_run_time ();
 193
 194 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 195   setlocale (LC_MESSAGES, "");
 196 #endif
 197 #if defined (HAVE_SETLOCALE)
 198   setlocale (LC_CTYPE, "");
 199 #endif
 200   bindtextdomain (PACKAGE, LOCALEDIR);
 201   textdomain (PACKAGE);
 202
 203   program_name = argv[0];
 204   xmalloc_set_program_name (program_name);
 205
 206   START_PROGRESS (program_name, 0);
 207
 208   expandargv (&argc, &argv);
 209
 210   bfd_init ();
 211
 212   bfd_set_error_program_name (program_name);
 213
 214   xatexit (remove_output);
 215
 216   /* Set up the sysroot directory.  */
 217   ld_sysroot = get_sysroot (argc, argv);
 218   if (*ld_sysroot)
 219     {
 220       if (*TARGET_SYSTEM_ROOT == 0)
 221         {
 222           einfo ("%P%F: this linker was not configured to use sysroots\n");
 223           ld_sysroot = "";
 224         }
 225       else
 226         ld_canon_sysroot = lrealpath (ld_sysroot);
 227     }
 228   if (ld_canon_sysroot)
 229     ld_canon_sysroot_len = strlen (ld_canon_sysroot);
 230   else
 231     ld_canon_sysroot_len = -1;
 232
 233   /* Set the default BFD target based on the configured target.  Doing
 234      this permits the linker to be configured for a particular target,
 235      and linked against a shared BFD library which was configured for
 236      a different target.  The macro TARGET is defined by Makefile.  */
 237   if (! bfd_set_default_target (TARGET))
 238     {
 239       einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
 240       xexit (1);
 241     }
 242
 243 #if YYDEBUG
 244   {
 245     extern int yydebug;
 246     yydebug = 1;
 247   }
 248 #endif
 249
 250   config.build_constructors = TRUE;
 251   config.rpath_separator = ':';
 252   config.split_by_reloc = (unsigned) -1;
 253   config.split_by_file = (bfd_size_type) -1;
 254   config.make_executable = TRUE;
 255   config.magic_demand_paged = TRUE;
 256   config.text_read_only = TRUE;
 257
 258   command_line.warn_mismatch = TRUE;
 259   command_line.warn_search_mismatch = TRUE;
 260   command_line.check_section_addresses = -1;
 261   command_line.disable_target_specific_optimizations = -1;
 262
 263   /* We initialize DEMANGLING based on the environment variable
 264      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
 265      output of the linker, unless COLLECT_NO_DEMANGLE is set in the
 266      environment.  Acting the same way here lets us provide the same
 267      interface by default.  */
 268   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
 269
 270   link_info.allow_undefined_version = TRUE;
 271   link_info.keep_memory = TRUE;
 272   link_info.combreloc = TRUE;
 273   link_info.strip_discarded = TRUE;
 274   link_info.emit_hash = TRUE;
 275   link_info.callbacks = &link_callbacks;
 276   link_info.input_bfds_tail = &link_info.input_bfds;
 277   /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
 278      and _fini symbols.  We are compatible.  */
 279   link_info.init_function = "_init";
 280   link_info.fini_function = "_fini";
 281   link_info.relax_pass = 1;
 282   link_info.pei386_auto_import = -1;
 283   link_info.spare_dynamic_tags = 5;
 284   link_info.path_separator = ':';
 285
 286   ldfile_add_arch ("");
 287   emulation = get_emulation (argc, argv);
 288   ldemul_choose_mode (emulation);
 289   default_target = ldemul_choose_target (argc, argv);
 290   config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
 291   config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
 292   lang_init ();
 293   ldemul_before_parse ();
 294   lang_has_input_file = FALSE;
 295   parse_args (argc, argv);
 296
 297   if (config.hash_table_size != 0)
 298     bfd_hash_set_default_size (config.hash_table_size);
 299
 300   ldemul_set_symbols ();
 301
 302   if (link_info.relocatable)
 303     {
 304       if (command_line.check_section_addresses < 0)
 305         command_line.check_section_addresses = 0;
 306       if (link_info.shared)
 307         einfo (_("%P%F: -r and -shared may not be used together\n"));
 308     }
 309
 310   /* We may have -Bsymbolic, -Bsymbolic-functions, --dynamic-list-data,
 311      --dynamic-list-cpp-new, --dynamic-list-cpp-typeinfo and
 312      --dynamic-list FILE.  -Bsymbolic and -Bsymbolic-functions are
 313      for shared libraries.  -Bsymbolic overrides all others and vice
 314      versa.  */
 315   switch (command_line.symbolic)
 316     {
 317     case symbolic_unset:
 318       break;
 319     case symbolic:
 320       /* -Bsymbolic is for shared library only.  */
 321       if (link_info.shared)
 322         {
 323           link_info.symbolic = TRUE;
 324           /* Should we free the unused memory?  */
 325           link_info.dynamic_list = NULL;
 326           command_line.dynamic_list = dynamic_list_unset;
 327         }
 328       break;
 329     case symbolic_functions:
 330       /* -Bsymbolic-functions is for shared library only.  */
 331       if (link_info.shared)
 332         command_line.dynamic_list = dynamic_list_data;
 333       break;
 334     }
 335
 336   switch (command_line.dynamic_list)
 337     {
 338     case dynamic_list_unset:
 339       break;
 340     case dynamic_list_data:
 341       link_info.dynamic_data = TRUE;
 342     case dynamic_list:
 343       link_info.dynamic = TRUE;
 344       break;
 345     }
 346
 347   if (! link_info.shared)
 348     {
 349       if (command_line.filter_shlib)
 350         einfo (_("%P%F: -F may not be used without -shared\n"));
 351       if (command_line.auxiliary_filters)
 352         einfo (_("%P%F: -f may not be used without -shared\n"));
 353     }
 354
 355   if (! link_info.shared || link_info.pie)
 356     link_info.executable = TRUE;
 357
 358   /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols).  I
 359      don't see how else this can be handled, since in this case we
 360      must preserve all externally visible symbols.  */
 361   if (link_info.relocatable && link_info.strip == strip_all)
 362     {
 363       link_info.strip = strip_debugger;
 364       if (link_info.discard == discard_sec_merge)
 365         link_info.discard = discard_all;
 366     }
 367
 368   /* If we have not already opened and parsed a linker script,
 369      try the default script from command line first.  */
 370   if (saved_script_handle == NULL
 371       && command_line.default_script != NULL)
 372     {
 373       ldfile_open_command_file (command_line.default_script);
 374       parser_input = input_script;
 375       yyparse ();
 376     }
 377
 378   /* If we have not already opened and parsed a linker script
 379      read the emulation's appropriate default script.  */
 380   if (saved_script_handle == NULL)
 381     {
 382       int isfile;
 383       char *s = ldemul_get_script (&isfile);
 384
 385       if (isfile)
 386         ldfile_open_default_command_file (s);
 387       else
 388         {
 389           lex_string = s;
 390           lex_redirect (s);
 391         }
 392       parser_input = input_script;
 393       yyparse ();
 394       lex_string = NULL;
 395     }
 396
 397   if (trace_file_tries)
 398     {
 399       if (saved_script_handle)
 400         info_msg (_("using external linker script:"));
 401       else
 402         info_msg (_("using internal linker script:"));
 403       info_msg ("\n==================================================\n");
 404
 405       if (saved_script_handle)
 406         {
 407           static const int ld_bufsz = 8193;
 408           size_t n;
 409           char *buf = (char *) xmalloc (ld_bufsz);
 410
 411           rewind (saved_script_handle);
 412           while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
 413             {
 414               buf[n] = 0;
 415               info_msg (buf);
 416             }
 417           rewind (saved_script_handle);
 418           free (buf);
 419         }
 420       else
 421         {
 422           int isfile;
 423
 424           info_msg (ldemul_get_script (&isfile));
 425         }
 426
 427       info_msg ("\n==================================================\n");
 428     }
 429
 430   lang_final ();
 431
 432   if (!lang_has_input_file)
 433     {
 434       if (version_printed)
 435         xexit (0);
 436       einfo (_("%P%F: no input files\n"));
 437     }
 438
 439   if (trace_files)
 440     info_msg (_("%P: mode %s\n"), emulation);
 441
 442   ldemul_after_parse ();
 443
 444   if (config.map_filename)
 445     {
 446       if (strcmp (config.map_filename, "-") == 0)
 447         {
 448           config.map_file = stdout;
 449         }
 450       else
 451         {
 452           config.map_file = fopen (config.map_filename, FOPEN_WT);
 453           if (config.map_file == (FILE *) NULL)
 454             {
 455               bfd_set_error (bfd_error_system_call);
 456               einfo (_("%P%F: cannot open map file %s: %E\n"),
 457                      config.map_filename);
 458             }
 459         }
 460     }
 461
 462   lang_process ();
 463
 464   /* Print error messages for any missing symbols, for any warning
 465      symbols, and possibly multiple definitions.  */
 466   if (link_info.relocatable)
 467     link_info.output_bfd->flags &= ~EXEC_P;
 468   else
 469     link_info.output_bfd->flags |= EXEC_P;
 470
 471   ldwrite ();
 472
 473   if (config.map_file != NULL)
 474     lang_map ();
 475   if (command_line.cref)
 476     output_cref (config.map_file != NULL ? config.map_file : stdout);
 477   if (nocrossref_list != NULL)
 478     check_nocrossrefs ();
 479
 480   lang_finish ();
 481
 482 #ifdef ENABLE_PLUGINS
 483   /* Now everything is finished, we can tell the plugins to clean up.  */
 484   if (plugin_call_cleanup ())
 485     info_msg (_("%P: %s: error in plugin cleanup (ignored)\n"), plugin_error_plugin ());
 486 #endif /* ENABLE_PLUGINS */
 487
 488   /* Even if we're producing relocatable output, some non-fatal errors should
 489      be reported in the exit status.  (What non-fatal errors, if any, do we
 490      want to ignore for relocatable output?)  */
 491   if (!config.make_executable && !force_make_executable)
 492     {
 493       if (trace_files)
 494         einfo (_("%P: link errors found, deleting executable `%s'\n"),
 495                output_filename);
 496
 497       /* The file will be removed by remove_output.  */
 498       xexit (1);
 499     }
 500   else
 501     {
 502       if (! bfd_close (link_info.output_bfd))
 503         einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
 504
 505       /* If the --force-exe-suffix is enabled, and we're making an
 506          executable file and it doesn't end in .exe, copy it to one
 507          which does.  */
 508       if (! link_info.relocatable && command_line.force_exe_suffix)
 509         {
 510           int len = strlen (output_filename);
 511
 512           if (len < 4
 513               || (strcasecmp (output_filename + len - 4, ".exe") != 0
 514                   && strcasecmp (output_filename + len - 4, ".dll") != 0))
 515             {
 516               FILE *src;
 517               FILE *dst;
 518               const int bsize = 4096;
 519               char *buf = (char *) xmalloc (bsize);
 520               int l;
 521               char *dst_name = (char *) xmalloc (len + 5);
 522
 523               strcpy (dst_name, output_filename);
 524               strcat (dst_name, ".exe");
 525               src = fopen (output_filename, FOPEN_RB);
 526               dst = fopen (dst_name, FOPEN_WB);
 527
 528               if (!src)
 529                 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
 530                        output_filename);
 531               if (!dst)
 532                 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
 533                        dst_name);
 534               while ((l = fread (buf, 1, bsize, src)) > 0)
 535                 {
 536                   int done = fwrite (buf, 1, l, dst);
 537
 538                   if (done != l)
 539                     einfo (_("%P: Error writing file `%s'\n"), dst_name);
 540                 }
 541
 542               fclose (src);
 543               if (fclose (dst) == EOF)
 544                 einfo (_("%P: Error closing file `%s'\n"), dst_name);
 545               free (dst_name);
 546               free (buf);
 547             }
 548         }
 549     }
 550
 551   END_PROGRESS (program_name);
 552
 553   if (config.stats)
 554     {
 555 #ifdef HAVE_SBRK
 556       char *lim = (char *) sbrk (0);
 557 #endif
 558       long run_time = get_run_time () - start_time;
 559
 560       fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
 561                program_name, run_time / 1000000, run_time % 1000000);
 562 #ifdef HAVE_SBRK
 563       fprintf (stderr, _("%s: data size %ld\n"), program_name,
 564                (long) (lim - (char *) &environ));
 565 #endif
 566     }
 567
 568   /* Prevent remove_output from doing anything, after a successful link.  */
 569   output_filename = NULL;
 570
 571   xexit (0);
 572   return 0;
 573 }
 574
 575 /* If the configured sysroot is relocatable, try relocating it based on
 576    default prefix FROM.  Return the relocated directory if it exists,
 577    otherwise return null.  */
 578
 579 static char *
 580 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
 581 {
 582 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 583   char *path;
 584   struct stat s;
 585
 586   path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
 587   if (path)
 588     {
 589       if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
 590         return path;
 591       free (path);
 592     }
 593 #endif
 594   return 0;
 595 }
 596
 597 /* Return the sysroot directory.  Return "" if no sysroot is being used.  */
 598
 599 static const char *
 600 get_sysroot (int argc, char **argv)
 601 {
 602   int i;
 603   const char *path;
 604
 605   for (i = 1; i < argc; i++)
 606     if (CONST_STRNEQ (argv[i], "--sysroot="))
 607       return argv[i] + strlen ("--sysroot=");
 608
 609   path = get_relative_sysroot (BINDIR);
 610   if (path)
 611     return path;
 612
 613   path = get_relative_sysroot (TOOLBINDIR);
 614   if (path)
 615     return path;
 616
 617   return TARGET_SYSTEM_ROOT;
 618 }
 619
 620 /* We need to find any explicitly given emulation in order to initialize the
 621    state that's needed by the lex&yacc argument parser (parse_args).  */
 622
 623 static char *
 624 get_emulation (int argc, char **argv)
 625 {
 626   char *emulation;
 627   int i;
 628
 629   emulation = getenv (EMULATION_ENVIRON);
 630   if (emulation == NULL)
 631     emulation = DEFAULT_EMULATION;
 632
 633   for (i = 1; i < argc; i++)
 634     {
 635       if (CONST_STRNEQ (argv[i], "-m"))
 636         {
 637           if (argv[i][2] == '\0')
 638             {
 639               /* -m EMUL */
 640               if (i < argc - 1)
 641                 {
 642                   emulation = argv[i + 1];
 643                   i++;
 644                 }
 645               else
 646                 einfo (_("%P%F: missing argument to -m\n"));
 647             }
 648           else if (strcmp (argv[i], "-mips1") == 0
 649                    || strcmp (argv[i], "-mips2") == 0
 650                    || strcmp (argv[i], "-mips3") == 0
 651                    || strcmp (argv[i], "-mips4") == 0
 652                    || strcmp (argv[i], "-mips5") == 0
 653                    || strcmp (argv[i], "-mips32") == 0
 654                    || strcmp (argv[i], "-mips32r2") == 0
 655                    || strcmp (argv[i], "-mips64") == 0
 656                    || strcmp (argv[i], "-mips64r2") == 0)
 657             {
 658               /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
 659                  passed to the linker by some MIPS compilers.  They
 660                  generally tell the linker to use a slightly different
 661                  library path.  Perhaps someday these should be
 662                  implemented as emulations; until then, we just ignore
 663                  the arguments and hope that nobody ever creates
 664                  emulations named ips1, ips2 or ips3.  */
 665             }
 666           else if (strcmp (argv[i], "-m486") == 0)
 667             {
 668               /* FIXME: The argument -m486 is passed to the linker on
 669                  some Linux systems.  Hope that nobody creates an
 670                  emulation named 486.  */
 671             }
 672           else
 673             {
 674               /* -mEMUL */
 675               emulation = &argv[i][2];
 676             }
 677         }
 678     }
 679
 680   return emulation;
 681 }
 682
 683 void
 684 add_ysym (const char *name)
 685 {
 686   if (link_info.notice_hash == NULL)
 687     {
 688       link_info.notice_hash =
 689           (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 690       if (!bfd_hash_table_init_n (link_info.notice_hash,
 691                                   bfd_hash_newfunc,
 692                                   sizeof (struct bfd_hash_entry),
 693                                   61))
 694         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 695     }
 696
 697   if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
 698     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 699 }
 700
 701 /* Record a symbol to be wrapped, from the --wrap option.  */
 702
 703 void
 704 add_wrap (const char *name)
 705 {
 706   if (link_info.wrap_hash == NULL)
 707     {
 708       link_info.wrap_hash =
 709           (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 710       if (!bfd_hash_table_init_n (link_info.wrap_hash,
 711                                   bfd_hash_newfunc,
 712                                   sizeof (struct bfd_hash_entry),
 713                                   61))
 714         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 715     }
 716
 717   if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
 718     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 719 }
 720
 721 /* Handle the -retain-symbols-file option.  */
 722
 723 void
 724 add_keepsyms_file (const char *filename)
 725 {
 726   FILE *file;
 727   char *buf;
 728   size_t bufsize;
 729   int c;
 730
 731   if (link_info.strip == strip_some)
 732     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 733
 734   file = fopen (filename, "r");
 735   if (file == NULL)
 736     {
 737       bfd_set_error (bfd_error_system_call);
 738       einfo ("%X%P: %s: %E\n", filename);
 739       return;
 740     }
 741
 742   link_info.keep_hash = (struct bfd_hash_table *)
 743       xmalloc (sizeof (struct bfd_hash_table));
 744   if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
 745                             sizeof (struct bfd_hash_entry)))
 746     einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 747
 748   bufsize = 100;
 749   buf = (char *) xmalloc (bufsize);
 750
 751   c = getc (file);
 752   while (c != EOF)
 753     {
 754       while (ISSPACE (c))
 755         c = getc (file);
 756
 757       if (c != EOF)
 758         {
 759           size_t len = 0;
 760
 761           while (! ISSPACE (c) && c != EOF)
 762             {
 763               buf[len] = c;
 764               ++len;
 765               if (len >= bufsize)
 766                 {
 767                   bufsize *= 2;
 768                   buf = (char *) xrealloc (buf, bufsize);
 769                 }
 770               c = getc (file);
 771             }
 772
 773           buf[len] = '\0';
 774
 775           if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
 776             einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
 777         }
 778     }
 779
 780   if (link_info.strip != strip_none)
 781     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 782
 783   free (buf);
 784   link_info.strip = strip_some;
 785 }
 786 \f
 787 /* Callbacks from the BFD linker routines.  */
 788
 789 /* This is called when BFD has decided to include an archive member in
 790    a link.  */
 791
 792 static bfd_boolean
 793 add_archive_element (struct bfd_link_info *info,
 794                      bfd *abfd,
 795                      const char *name,
 796                      bfd **subsbfd ATTRIBUTE_UNUSED)
 797 {
 798   lang_input_statement_type *input;
 799   lang_input_statement_type orig_input;
 800
 801   input = (lang_input_statement_type *)
 802       xcalloc (1, sizeof (lang_input_statement_type));
 803   input->filename = abfd->filename;
 804   input->local_sym_name = abfd->filename;
 805   input->the_bfd = abfd;
 806
 807   /* Save the original data for trace files/tries below, as plugins
 808      (if enabled) may possibly alter it to point to a replacement
 809      BFD, but we still want to output the original BFD filename.  */
 810   orig_input = *input;
 811 #ifdef ENABLE_PLUGINS
 812   if (bfd_my_archive (abfd) != NULL && plugin_active_plugins_p ())
 813     {
 814       /* We must offer this archive member to the plugins to claim.  */
 815       int fd = open (bfd_my_archive (abfd)->filename, O_RDONLY | O_BINARY);
 816       if (fd >= 0)
 817         {
 818           struct ld_plugin_input_file file;
 819           int claimed = 0;
 820           /* Offset and filesize must refer to the individual archive
 821              member, not the whole file, and must exclude the header.
 822              Fortunately for us, that is how the data is stored in the
 823              origin field of the bfd and in the arelt_data.  */
 824           file.name = bfd_my_archive (abfd)->filename;
 825           file.offset = abfd->origin;
 826           file.filesize = arelt_size (abfd);
 827           file.fd = fd;
 828           /* We create a dummy BFD, initially empty, to house
 829              whatever symbols the plugin may want to add.  */
 830           file.handle = plugin_get_ir_dummy_bfd (abfd->filename, abfd);
 831           if (plugin_call_claim_file (&file, &claimed))
 832             einfo (_("%P%F: %s: plugin reported error claiming file\n"),
 833               plugin_error_plugin ());
 834           /* fd belongs to us, not the plugin; but we don't need it.  */
 835           close (fd);
 836           if (claimed)
 837             {
 838               /* Substitute the dummy BFD.  */
 839               input->the_bfd = file.handle;
 840               input->claimed = TRUE;
 841               bfd_make_readable (input->the_bfd);
 842               *subsbfd = input->the_bfd;
 843             }
 844           else
 845             {
 846               /* Abandon the dummy BFD.  */
 847               bfd_close_all_done (file.handle);
 848               input->claimed = FALSE;
 849             }
 850         }
 851     }
 852 #endif /* ENABLE_PLUGINS */
 853
 854   ldlang_add_file (input);
 855
 856   if (config.map_file != NULL)
 857     {
 858       static bfd_boolean header_printed;
 859       struct bfd_link_hash_entry *h;
 860       bfd *from;
 861       int len;
 862
 863       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 864
 865       if (h == NULL)
 866         from = NULL;
 867       else
 868         {
 869           switch (h->type)
 870             {
 871             default:
 872               from = NULL;
 873               break;
 874
 875             case bfd_link_hash_defined:
 876             case bfd_link_hash_defweak:
 877               from = h->u.def.section->owner;
 878               break;
 879
 880             case bfd_link_hash_undefined:
 881             case bfd_link_hash_undefweak:
 882               from = h->u.undef.abfd;
 883               break;
 884
 885             case bfd_link_hash_common:
 886               from = h->u.c.p->section->owner;
 887               break;
 888             }
 889         }
 890
 891       if (! header_printed)
 892         {
 893           char buf[100];
 894
 895           sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
 896           minfo ("%s", buf);
 897           header_printed = TRUE;
 898         }
 899
 900       if (bfd_my_archive (abfd) == NULL)
 901         {
 902           minfo ("%s", bfd_get_filename (abfd));
 903           len = strlen (bfd_get_filename (abfd));
 904         }
 905       else
 906         {
 907           minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
 908                  bfd_get_filename (abfd));
 909           len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
 910                  + strlen (bfd_get_filename (abfd))
 911                  + 2);
 912         }
 913
 914       if (len >= 29)
 915         {
 916           print_nl ();
 917           len = 0;
 918         }
 919       while (len < 30)
 920         {
 921           print_space ();
 922           ++len;
 923         }
 924
 925       if (from != NULL)
 926         minfo ("%B ", from);
 927       if (h != NULL)
 928         minfo ("(%T)\n", h->root.string);
 929       else
 930         minfo ("(%s)\n", name);
 931     }
 932
 933   if (trace_files || trace_file_tries)
 934     info_msg ("%I\n", &orig_input);
 935   return TRUE;
 936 }
 937
 938 /* This is called when BFD has discovered a symbol which is defined
 939    multiple times.  */
 940
 941 static bfd_boolean
 942 multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 943                      const char *name,
 944                      bfd *obfd,
 945                      asection *osec,
 946                      bfd_vma oval,
 947                      bfd *nbfd,
 948                      asection *nsec,
 949                      bfd_vma nval)
 950 {
 951 #ifdef ENABLE_PLUGINS
 952   /* We may get called back even when --allow-multiple-definition is in
 953      effect, as the plugin infrastructure needs to use this hook in
 954      order to swap out IR-only symbols for real ones.  In that case,
 955      it will let us know not to continue by returning TRUE even if this
 956      is not an IR-only vs. non-IR symbol conflict.  */
 957   if (plugin_multiple_definition (info, name, obfd, osec, oval, nbfd,
 958         nsec, nval))
 959     return TRUE;
 960 #endif /* ENABLE_PLUGINS */
 961
 962   /* If either section has the output_section field set to
 963      bfd_abs_section_ptr, it means that the section is being
 964      discarded, and this is not really a multiple definition at all.
 965      FIXME: It would be cleaner to somehow ignore symbols defined in
 966      sections which are being discarded.  */
 967   if ((osec->output_section != NULL
 968        && ! bfd_is_abs_section (osec)
 969        && bfd_is_abs_section (osec->output_section))
 970       || (nsec->output_section != NULL
 971           && ! bfd_is_abs_section (nsec)
 972           && bfd_is_abs_section (nsec->output_section)))
 973     return TRUE;
 974
 975   einfo (_("%X%C: multiple definition of `%T'\n"),
 976          nbfd, nsec, nval, name);
 977   if (obfd != NULL)
 978     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 979
 980   if (RELAXATION_ENABLED)
 981     {
 982       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 983       command_line.disable_target_specific_optimizations = -1;
 984     }
 985
 986   return TRUE;
 987 }
 988
 989 /* This is called when there is a definition of a common symbol, or
 990    when a common symbol is found for a symbol that is already defined,
 991    or when two common symbols are found.  We only do something if
 992    -warn-common was used.  */
 993
 994 static bfd_boolean
 995 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 996                  const char *name,
 997                  bfd *obfd,
 998                  enum bfd_link_hash_type otype,
 999                  bfd_vma osize,
1000                  bfd *nbfd,
1001                  enum bfd_link_hash_type ntype,
1002                  bfd_vma nsize)
1003 {
1004   if (! config.warn_common)
1005     return TRUE;
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 (link_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 ATTRIBUTE_UNUSED,
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 (config.warn_once)
1263     {
1264       static struct bfd_hash_table *hash;
1265
1266       /* Only warn once about a particular undefined symbol.  */
1267       if (hash == NULL)
1268         {
1269           hash = (struct bfd_hash_table *)
1270               xmalloc (sizeof (struct bfd_hash_table));
1271           if (!bfd_hash_table_init (hash, bfd_hash_newfunc,
1272                                     sizeof (struct bfd_hash_entry)))
1273             einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1274         }
1275
1276       if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1277         return TRUE;
1278
1279       if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1280         einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1281     }
1282
1283   /* We never print more than a reasonable number of errors in a row
1284      for a single symbol.  */
1285   if (error_name != NULL
1286       && strcmp (name, error_name) == 0)
1287     ++error_count;
1288   else
1289     {
1290       error_count = 0;
1291       if (error_name != NULL)
1292         free (error_name);
1293       error_name = xstrdup (name);
1294     }
1295
1296   if (section != NULL)
1297     {
1298       if (error_count < MAX_ERRORS_IN_A_ROW)
1299         {
1300           if (error)
1301             einfo (_("%X%C: undefined reference to `%T'\n"),
1302                    abfd, section, address, name);
1303           else
1304             einfo (_("%C: warning: undefined reference to `%T'\n"),
1305                    abfd, section, address, name);
1306         }
1307       else if (error_count == MAX_ERRORS_IN_A_ROW)
1308         {
1309           if (error)
1310             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1311                    abfd, section, address, name);
1312           else
1313             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1314                    abfd, section, address, name);
1315         }
1316       else if (error)
1317         einfo ("%X");
1318     }
1319   else
1320     {
1321       if (error_count < MAX_ERRORS_IN_A_ROW)
1322         {
1323           if (error)
1324             einfo (_("%X%B: undefined reference to `%T'\n"),
1325                    abfd, name);
1326           else
1327             einfo (_("%B: warning: undefined reference to `%T'\n"),
1328                    abfd, name);
1329         }
1330       else if (error_count == MAX_ERRORS_IN_A_ROW)
1331         {
1332           if (error)
1333             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1334                    abfd, name);
1335           else
1336             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1337                    abfd, name);
1338         }
1339       else if (error)
1340         einfo ("%X");
1341     }
1342
1343   return TRUE;
1344 }
1345
1346 /* Counter to limit the number of relocation overflow error messages
1347    to print.  Errors are printed as it is decremented.  When it's
1348    called and the counter is zero, a final message is printed
1349    indicating more relocations were omitted.  When it gets to -1, no
1350    such errors are printed.  If it's initially set to a value less
1351    than -1, all such errors will be printed (--verbose does this).  */
1352
1353 int overflow_cutoff_limit = 10;
1354
1355 /* This is called when a reloc overflows.  */
1356
1357 static bfd_boolean
1358 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1359                 struct bfd_link_hash_entry *entry,
1360                 const char *name,
1361                 const char *reloc_name,
1362                 bfd_vma addend,
1363                 bfd *abfd,
1364                 asection *section,
1365                 bfd_vma address)
1366 {
1367   if (overflow_cutoff_limit == -1)
1368     return TRUE;
1369
1370   einfo ("%X%C:", abfd, section, address);
1371
1372   if (overflow_cutoff_limit >= 0
1373       && overflow_cutoff_limit-- == 0)
1374     {
1375       einfo (_(" additional relocation overflows omitted from the output\n"));
1376       return TRUE;
1377     }
1378
1379   if (entry)
1380     {
1381       while (entry->type == bfd_link_hash_indirect
1382              || entry->type == bfd_link_hash_warning)
1383         entry = entry->u.i.link;
1384       switch (entry->type)
1385         {
1386         case bfd_link_hash_undefined:
1387         case bfd_link_hash_undefweak:
1388           einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1389                  reloc_name, entry->root.string);
1390           break;
1391         case bfd_link_hash_defined:
1392         case bfd_link_hash_defweak:
1393           einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1394                  reloc_name, entry->root.string,
1395                  entry->u.def.section,
1396                  entry->u.def.section == bfd_abs_section_ptr
1397                  ? link_info.output_bfd : entry->u.def.section->owner);
1398           break;
1399         default:
1400           abort ();
1401           break;
1402         }
1403     }
1404   else
1405     einfo (_(" relocation truncated to fit: %s against `%T'"),
1406            reloc_name, name);
1407   if (addend != 0)
1408     einfo ("+%v", addend);
1409   einfo ("\n");
1410   return TRUE;
1411 }
1412
1413 /* This is called when a dangerous relocation is made.  */
1414
1415 static bfd_boolean
1416 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1417                  const char *message,
1418                  bfd *abfd,
1419                  asection *section,
1420                  bfd_vma address)
1421 {
1422   einfo (_("%X%C: dangerous relocation: %s\n"),
1423          abfd, section, address, message);
1424   return TRUE;
1425 }
1426
1427 /* This is called when a reloc is being generated attached to a symbol
1428    that is not being output.  */
1429
1430 static bfd_boolean
1431 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1432                   const char *name,
1433                   bfd *abfd,
1434                   asection *section,
1435                   bfd_vma address)
1436 {
1437   einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1438          abfd, section, address, name);
1439   return TRUE;
1440 }
1441
1442 /* This is called if link_info.notice_all is set, or when a symbol in
1443    link_info.notice_hash is found.  Symbols are put in notice_hash
1444    using the -y option, while notice_all is set if the --cref option
1445    has been supplied, or if there are any NOCROSSREFS sections in the
1446    linker script; and if plugins are active, since they need to monitor
1447    all references from non-IR files.  */
1448
1449 static bfd_boolean
1450 notice (struct bfd_link_info *info,
1451         const char *name,
1452         bfd *abfd,
1453         asection *section,
1454         bfd_vma value)
1455 {
1456   if (name == NULL)
1457     {
1458       if (command_line.cref || nocrossref_list != NULL)
1459         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1460       return TRUE;
1461     }
1462
1463 #ifdef ENABLE_PLUGINS
1464   /* We should hide symbols in the dummy IR BFDs from the nocrossrefs list
1465      and let the real object files that are generated and added later trip
1466      the error instead.  Similarly would be better to trace the real symbol
1467      from the real file than the temporary dummy.  */
1468   if (!plugin_notice (info, name, abfd, section, value))
1469     return TRUE;
1470 #endif /* ENABLE_PLUGINS */
1471
1472   if (info->notice_hash != NULL
1473         && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1474     {
1475       if (bfd_is_und_section (section))
1476         einfo ("%B: reference to %s\n", abfd, name);
1477       else
1478         einfo ("%B: definition of %s\n", abfd, name);
1479     }
1480
1481   if (command_line.cref || nocrossref_list != NULL)
1482     add_cref (name, abfd, section, value);
1483
1484   return TRUE;
1485 }