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"),
 486               plugin_error_plugin ());
 487 #endif /* ENABLE_PLUGINS */
 488
 489   /* Even if we're producing relocatable output, some non-fatal errors should
 490      be reported in the exit status.  (What non-fatal errors, if any, do we
 491      want to ignore for relocatable output?)  */
 492   if (!config.make_executable && !force_make_executable)
 493     {
 494       if (trace_files)
 495         einfo (_("%P: link errors found, deleting executable `%s'\n"),
 496                output_filename);
 497
 498       /* The file will be removed by remove_output.  */
 499       xexit (1);
 500     }
 501   else
 502     {
 503       if (! bfd_close (link_info.output_bfd))
 504         einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
 505
 506       /* If the --force-exe-suffix is enabled, and we're making an
 507          executable file and it doesn't end in .exe, copy it to one
 508          which does.  */
 509       if (! link_info.relocatable && command_line.force_exe_suffix)
 510         {
 511           int len = strlen (output_filename);
 512
 513           if (len < 4
 514               || (strcasecmp (output_filename + len - 4, ".exe") != 0
 515                   && strcasecmp (output_filename + len - 4, ".dll") != 0))
 516             {
 517               FILE *src;
 518               FILE *dst;
 519               const int bsize = 4096;
 520               char *buf = (char *) xmalloc (bsize);
 521               int l;
 522               char *dst_name = (char *) xmalloc (len + 5);
 523
 524               strcpy (dst_name, output_filename);
 525               strcat (dst_name, ".exe");
 526               src = fopen (output_filename, FOPEN_RB);
 527               dst = fopen (dst_name, FOPEN_WB);
 528
 529               if (!src)
 530                 einfo (_("%X%P: unable to open for source of copy `%s'\n"),
 531                        output_filename);
 532               if (!dst)
 533                 einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
 534                        dst_name);
 535               while ((l = fread (buf, 1, bsize, src)) > 0)
 536                 {
 537                   int done = fwrite (buf, 1, l, dst);
 538
 539                   if (done != l)
 540                     einfo (_("%P: Error writing file `%s'\n"), dst_name);
 541                 }
 542
 543               fclose (src);
 544               if (fclose (dst) == EOF)
 545                 einfo (_("%P: Error closing file `%s'\n"), dst_name);
 546               free (dst_name);
 547               free (buf);
 548             }
 549         }
 550     }
 551
 552   END_PROGRESS (program_name);
 553
 554   if (config.stats)
 555     {
 556 #ifdef HAVE_SBRK
 557       char *lim = (char *) sbrk (0);
 558 #endif
 559       long run_time = get_run_time () - start_time;
 560
 561       fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
 562                program_name, run_time / 1000000, run_time % 1000000);
 563 #ifdef HAVE_SBRK
 564       fprintf (stderr, _("%s: data size %ld\n"), program_name,
 565                (long) (lim - (char *) &environ));
 566 #endif
 567     }
 568
 569   /* Prevent remove_output from doing anything, after a successful link.  */
 570   output_filename = NULL;
 571
 572   xexit (0);
 573   return 0;
 574 }
 575
 576 /* If the configured sysroot is relocatable, try relocating it based on
 577    default prefix FROM.  Return the relocated directory if it exists,
 578    otherwise return null.  */
 579
 580 static char *
 581 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
 582 {
 583 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 584   char *path;
 585   struct stat s;
 586
 587   path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
 588   if (path)
 589     {
 590       if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
 591         return path;
 592       free (path);
 593     }
 594 #endif
 595   return 0;
 596 }
 597
 598 /* Return the sysroot directory.  Return "" if no sysroot is being used.  */
 599
 600 static const char *
 601 get_sysroot (int argc, char **argv)
 602 {
 603   int i;
 604   const char *path;
 605
 606   for (i = 1; i < argc; i++)
 607     if (CONST_STRNEQ (argv[i], "--sysroot="))
 608       return argv[i] + strlen ("--sysroot=");
 609
 610   path = get_relative_sysroot (BINDIR);
 611   if (path)
 612     return path;
 613
 614   path = get_relative_sysroot (TOOLBINDIR);
 615   if (path)
 616     return path;
 617
 618   return TARGET_SYSTEM_ROOT;
 619 }
 620
 621 /* We need to find any explicitly given emulation in order to initialize the
 622    state that's needed by the lex&yacc argument parser (parse_args).  */
 623
 624 static char *
 625 get_emulation (int argc, char **argv)
 626 {
 627   char *emulation;
 628   int i;
 629
 630   emulation = getenv (EMULATION_ENVIRON);
 631   if (emulation == NULL)
 632     emulation = DEFAULT_EMULATION;
 633
 634   for (i = 1; i < argc; i++)
 635     {
 636       if (CONST_STRNEQ (argv[i], "-m"))
 637         {
 638           if (argv[i][2] == '\0')
 639             {
 640               /* -m EMUL */
 641               if (i < argc - 1)
 642                 {
 643                   emulation = argv[i + 1];
 644                   i++;
 645                 }
 646               else
 647                 einfo (_("%P%F: missing argument to -m\n"));
 648             }
 649           else if (strcmp (argv[i], "-mips1") == 0
 650                    || strcmp (argv[i], "-mips2") == 0
 651                    || strcmp (argv[i], "-mips3") == 0
 652                    || strcmp (argv[i], "-mips4") == 0
 653                    || strcmp (argv[i], "-mips5") == 0
 654                    || strcmp (argv[i], "-mips32") == 0
 655                    || strcmp (argv[i], "-mips32r2") == 0
 656                    || strcmp (argv[i], "-mips64") == 0
 657                    || strcmp (argv[i], "-mips64r2") == 0)
 658             {
 659               /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
 660                  passed to the linker by some MIPS compilers.  They
 661                  generally tell the linker to use a slightly different
 662                  library path.  Perhaps someday these should be
 663                  implemented as emulations; until then, we just ignore
 664                  the arguments and hope that nobody ever creates
 665                  emulations named ips1, ips2 or ips3.  */
 666             }
 667           else if (strcmp (argv[i], "-m486") == 0)
 668             {
 669               /* FIXME: The argument -m486 is passed to the linker on
 670                  some Linux systems.  Hope that nobody creates an
 671                  emulation named 486.  */
 672             }
 673           else
 674             {
 675               /* -mEMUL */
 676               emulation = &argv[i][2];
 677             }
 678         }
 679     }
 680
 681   return emulation;
 682 }
 683
 684 void
 685 add_ysym (const char *name)
 686 {
 687   if (link_info.notice_hash == NULL)
 688     {
 689       link_info.notice_hash =
 690           (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 691       if (!bfd_hash_table_init_n (link_info.notice_hash,
 692                                   bfd_hash_newfunc,
 693                                   sizeof (struct bfd_hash_entry),
 694                                   61))
 695         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 696     }
 697
 698   if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
 699     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 700 }
 701
 702 /* Record a symbol to be wrapped, from the --wrap option.  */
 703
 704 void
 705 add_wrap (const char *name)
 706 {
 707   if (link_info.wrap_hash == NULL)
 708     {
 709       link_info.wrap_hash =
 710           (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 711       if (!bfd_hash_table_init_n (link_info.wrap_hash,
 712                                   bfd_hash_newfunc,
 713                                   sizeof (struct bfd_hash_entry),
 714                                   61))
 715         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 716     }
 717
 718   if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
 719     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 720 }
 721
 722 /* Handle the -retain-symbols-file option.  */
 723
 724 void
 725 add_keepsyms_file (const char *filename)
 726 {
 727   FILE *file;
 728   char *buf;
 729   size_t bufsize;
 730   int c;
 731
 732   if (link_info.strip == strip_some)
 733     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 734
 735   file = fopen (filename, "r");
 736   if (file == NULL)
 737     {
 738       bfd_set_error (bfd_error_system_call);
 739       einfo ("%X%P: %s: %E\n", filename);
 740       return;
 741     }
 742
 743   link_info.keep_hash = (struct bfd_hash_table *)
 744       xmalloc (sizeof (struct bfd_hash_table));
 745   if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
 746                             sizeof (struct bfd_hash_entry)))
 747     einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 748
 749   bufsize = 100;
 750   buf = (char *) xmalloc (bufsize);
 751
 752   c = getc (file);
 753   while (c != EOF)
 754     {
 755       while (ISSPACE (c))
 756         c = getc (file);
 757
 758       if (c != EOF)
 759         {
 760           size_t len = 0;
 761
 762           while (! ISSPACE (c) && c != EOF)
 763             {
 764               buf[len] = c;
 765               ++len;
 766               if (len >= bufsize)
 767                 {
 768                   bufsize *= 2;
 769                   buf = (char *) xrealloc (buf, bufsize);
 770                 }
 771               c = getc (file);
 772             }
 773
 774           buf[len] = '\0';
 775
 776           if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
 777             einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
 778         }
 779     }
 780
 781   if (link_info.strip != strip_none)
 782     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 783
 784   free (buf);
 785   link_info.strip = strip_some;
 786 }
 787 \f
 788 /* Callbacks from the BFD linker routines.  */
 789
 790 /* This is called when BFD has decided to include an archive member in
 791    a link.  */
 792
 793 static bfd_boolean
 794 add_archive_element (struct bfd_link_info *info,
 795                      bfd *abfd,
 796                      const char *name,
 797                      bfd **subsbfd ATTRIBUTE_UNUSED)
 798 {
 799   lang_input_statement_type *input;
 800   lang_input_statement_type orig_input;
 801
 802   input = (lang_input_statement_type *)
 803       xcalloc (1, sizeof (lang_input_statement_type));
 804   input->filename = abfd->filename;
 805   input->local_sym_name = abfd->filename;
 806   input->the_bfd = abfd;
 807
 808   /* Save the original data for trace files/tries below, as plugins
 809      (if enabled) may possibly alter it to point to a replacement
 810      BFD, but we still want to output the original BFD filename.  */
 811   orig_input = *input;
 812 #ifdef ENABLE_PLUGINS
 813   if (bfd_my_archive (abfd) != NULL && plugin_active_plugins_p ())
 814     {
 815       /* We must offer this archive member to the plugins to claim.  */
 816       int fd = open (bfd_my_archive (abfd)->filename, O_RDONLY | O_BINARY);
 817       if (fd >= 0)
 818         {
 819           struct ld_plugin_input_file file;
 820           int claimed = 0;
 821           /* Offset and filesize must refer to the individual archive
 822              member, not the whole file, and must exclude the header.
 823              Fortunately for us, that is how the data is stored in the
 824              origin field of the bfd and in the arelt_data.  */
 825           file.name = bfd_my_archive (abfd)->filename;
 826           file.offset = abfd->origin;
 827           file.filesize = arelt_size (abfd);
 828           file.fd = fd;
 829           /* We create a dummy BFD, initially empty, to house
 830              whatever symbols the plugin may want to add.  */
 831           file.handle = plugin_get_ir_dummy_bfd (abfd->filename, abfd);
 832           if (plugin_call_claim_file (&file, &claimed))
 833             einfo (_("%P%F: %s: plugin reported error claiming file\n"),
 834                    plugin_error_plugin ());
 835           /* fd belongs to us, not the plugin; but we don't need it.  */
 836           close (fd);
 837           if (claimed)
 838             {
 839               /* Substitute the dummy BFD.  */
 840               input->the_bfd = file.handle;
 841               input->claimed = TRUE;
 842               bfd_make_readable (input->the_bfd);
 843               *subsbfd = input->the_bfd;
 844             }
 845           else
 846             {
 847               /* Abandon the dummy BFD.  */
 848               bfd_close_all_done (file.handle);
 849               input->claimed = FALSE;
 850             }
 851         }
 852     }
 853 #endif /* ENABLE_PLUGINS */
 854
 855   ldlang_add_file (input);
 856
 857   if (config.map_file != NULL)
 858     {
 859       static bfd_boolean header_printed;
 860       struct bfd_link_hash_entry *h;
 861       bfd *from;
 862       int len;
 863
 864       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 865
 866       if (h == NULL)
 867         from = NULL;
 868       else
 869         {
 870           switch (h->type)
 871             {
 872             default:
 873               from = NULL;
 874               break;
 875
 876             case bfd_link_hash_defined:
 877             case bfd_link_hash_defweak:
 878               from = h->u.def.section->owner;
 879               break;
 880
 881             case bfd_link_hash_undefined:
 882             case bfd_link_hash_undefweak:
 883               from = h->u.undef.abfd;
 884               break;
 885
 886             case bfd_link_hash_common:
 887               from = h->u.c.p->section->owner;
 888               break;
 889             }
 890         }
 891
 892       if (! header_printed)
 893         {
 894           char buf[100];
 895
 896           sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
 897           minfo ("%s", buf);
 898           header_printed = TRUE;
 899         }
 900
 901       if (bfd_my_archive (abfd) == NULL)
 902         {
 903           minfo ("%s", bfd_get_filename (abfd));
 904           len = strlen (bfd_get_filename (abfd));
 905         }
 906       else
 907         {
 908           minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
 909                  bfd_get_filename (abfd));
 910           len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
 911                  + strlen (bfd_get_filename (abfd))
 912                  + 2);
 913         }
 914
 915       if (len >= 29)
 916         {
 917           print_nl ();
 918           len = 0;
 919         }
 920       while (len < 30)
 921         {
 922           print_space ();
 923           ++len;
 924         }
 925
 926       if (from != NULL)
 927         minfo ("%B ", from);
 928       if (h != NULL)
 929         minfo ("(%T)\n", h->root.string);
 930       else
 931         minfo ("(%s)\n", name);
 932     }
 933
 934   if (trace_files || trace_file_tries)
 935     info_msg ("%I\n", &orig_input);
 936   return TRUE;
 937 }
 938
 939 /* This is called when BFD has discovered a symbol which is defined
 940    multiple times.  */
 941
 942 static bfd_boolean
 943 multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 944                      const char *name,
 945                      bfd *obfd,
 946                      asection *osec,
 947                      bfd_vma oval,
 948                      bfd *nbfd,
 949                      asection *nsec,
 950                      bfd_vma nval)
 951 {
 952 #ifdef ENABLE_PLUGINS
 953   /* We may get called back even when --allow-multiple-definition is in
 954      effect, as the plugin infrastructure needs to use this hook in
 955      order to swap out IR-only symbols for real ones.  In that case,
 956      it will let us know not to continue by returning TRUE even if this
 957      is not an IR-only vs. non-IR symbol conflict.  */
 958   if (plugin_multiple_definition (info, name, obfd, osec, oval, nbfd,
 959                                   nsec, nval))
 960     return TRUE;
 961 #endif /* ENABLE_PLUGINS */
 962
 963   /* If either section has the output_section field set to
 964      bfd_abs_section_ptr, it means that the section is being
 965      discarded, and this is not really a multiple definition at all.
 966 FIXME: It would be cleaner to somehow ignore symbols defined in
 967 sections which are being discarded.  */
 968   if ((osec->output_section != NULL
 969        && ! bfd_is_abs_section (osec)
 970        && bfd_is_abs_section (osec->output_section))
 971       || (nsec->output_section != NULL
 972           && ! bfd_is_abs_section (nsec)
 973           && bfd_is_abs_section (nsec->output_section)))
 974     return TRUE;
 975
 976   einfo (_("%X%C: multiple definition of `%T'\n"),
 977          nbfd, nsec, nval, name);
 978   if (obfd != NULL)
 979     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 980
 981   if (RELAXATION_ENABLED)
 982     {
 983       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 984       command_line.disable_target_specific_optimizations = -1;
 985     }
 986
 987   return TRUE;
 988 }
 989
 990 /* This is called when there is a definition of a common symbol, or
 991    when a common symbol is found for a symbol that is already defined,
 992    or when two common symbols are found.  We only do something if
 993    -warn-common was used.  */
 994
 995 static bfd_boolean
 996 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 997                  const char *name,
 998                  bfd *obfd,
 999                  enum bfd_link_hash_type otype,
1000                  bfd_vma osize,
1001                  bfd *nbfd,
1002                  enum bfd_link_hash_type ntype,
1003                  bfd_vma nsize)
1004 {
1005   if (! config.warn_common)
1006     return TRUE;
1007
1008   if (ntype == bfd_link_hash_defined
1009       || ntype == bfd_link_hash_defweak
1010       || ntype == bfd_link_hash_indirect)
1011     {
1012       ASSERT (otype == bfd_link_hash_common);
1013       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1014              nbfd, name);
1015       if (obfd != NULL)
1016         einfo (_("%B: warning: common is here\n"), obfd);
1017     }
1018   else if (otype == bfd_link_hash_defined
1019            || otype == bfd_link_hash_defweak
1020            || otype == bfd_link_hash_indirect)
1021     {
1022       ASSERT (ntype == bfd_link_hash_common);
1023       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1024              nbfd, name);
1025       if (obfd != NULL)
1026         einfo (_("%B: warning: defined here\n"), obfd);
1027     }
1028   else
1029     {
1030       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1031       if (osize > nsize)
1032         {
1033           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1034                  nbfd, name);
1035           if (obfd != NULL)
1036             einfo (_("%B: warning: larger common is here\n"), obfd);
1037         }
1038       else if (nsize > osize)
1039         {
1040           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1041                  nbfd, name);
1042           if (obfd != NULL)
1043             einfo (_("%B: warning: smaller common is here\n"), obfd);
1044         }
1045       else
1046         {
1047           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1048           if (obfd != NULL)
1049             einfo (_("%B: warning: previous common is here\n"), obfd);
1050         }
1051     }
1052
1053   return TRUE;
1054 }
1055
1056 /* This is called when BFD has discovered a set element.  H is the
1057    entry in the linker hash table for the set.  SECTION and VALUE
1058    represent a value which should be added to the set.  */
1059
1060 static bfd_boolean
1061 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1062             struct bfd_link_hash_entry *h,
1063             bfd_reloc_code_real_type reloc,
1064             bfd *abfd,
1065             asection *section,
1066             bfd_vma value)
1067 {
1068   if (config.warn_constructors)
1069     einfo (_("%P: warning: global constructor %s used\n"),
1070            h->root.string);
1071
1072   if (! config.build_constructors)
1073     return TRUE;
1074
1075   ldctor_add_set_entry (h, reloc, NULL, section, value);
1076
1077   if (h->type == bfd_link_hash_new)
1078     {
1079       h->type = bfd_link_hash_undefined;
1080       h->u.undef.abfd = abfd;
1081       /* We don't call bfd_link_add_undef to add this to the list of
1082          undefined symbols because we are going to define it
1083          ourselves.  */
1084     }
1085
1086   return TRUE;
1087 }
1088
1089 /* This is called when BFD has discovered a constructor.  This is only
1090    called for some object file formats--those which do not handle
1091    constructors in some more clever fashion.  This is similar to
1092    adding an element to a set, but less general.  */
1093
1094 static bfd_boolean
1095 constructor_callback (struct bfd_link_info *info,
1096                       bfd_boolean constructor,
1097                       const char *name,
1098                       bfd *abfd,
1099                       asection *section,
1100                       bfd_vma value)
1101 {
1102   char *s;
1103   struct bfd_link_hash_entry *h;
1104   char set_name[1 + sizeof "__CTOR_LIST__"];
1105
1106   if (config.warn_constructors)
1107     einfo (_("%P: warning: global constructor %s used\n"), name);
1108
1109   if (! config.build_constructors)
1110     return TRUE;
1111
1112   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1113      useful error message.  */
1114   if (bfd_reloc_type_lookup (link_info.output_bfd, BFD_RELOC_CTOR) == NULL
1115       && (info->relocatable
1116           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1117     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1118
1119   s = set_name;
1120   if (bfd_get_symbol_leading_char (abfd) != '\0')
1121     *s++ = bfd_get_symbol_leading_char (abfd);
1122   if (constructor)
1123     strcpy (s, "__CTOR_LIST__");
1124   else
1125     strcpy (s, "__DTOR_LIST__");
1126
1127   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1128   if (h == (struct bfd_link_hash_entry *) NULL)
1129     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1130   if (h->type == bfd_link_hash_new)
1131     {
1132       h->type = bfd_link_hash_undefined;
1133       h->u.undef.abfd = abfd;
1134       /* We don't call bfd_link_add_undef to add this to the list of
1135          undefined symbols because we are going to define it
1136          ourselves.  */
1137     }
1138
1139   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1140   return TRUE;
1141 }
1142
1143 /* A structure used by warning_callback to pass information through
1144    bfd_map_over_sections.  */
1145
1146 struct warning_callback_info
1147 {
1148   bfd_boolean found;
1149   const char *warning;
1150   const char *symbol;
1151   asymbol **asymbols;
1152 };
1153
1154 /* This is called when there is a reference to a warning symbol.  */
1155
1156 static bfd_boolean
1157 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1158                   const char *warning,
1159                   const char *symbol,
1160                   bfd *abfd,
1161                   asection *section,
1162                   bfd_vma address)
1163 {
1164   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1165      have a cleaner interface, but what?  */
1166   if (! config.warn_multiple_gp
1167       && strcmp (warning, "using multiple gp values") == 0)
1168     return TRUE;
1169
1170   if (section != NULL)
1171     einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1172   else if (abfd == NULL)
1173     einfo ("%P: %s%s\n", _("warning: "), warning);
1174   else if (symbol == NULL)
1175     einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1176   else
1177     {
1178       struct warning_callback_info cinfo;
1179
1180       /* Look through the relocs to see if we can find a plausible
1181          address.  */
1182
1183       if (!bfd_generic_link_read_symbols (abfd))
1184         einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1185
1186       cinfo.found = FALSE;
1187       cinfo.warning = warning;
1188       cinfo.symbol = symbol;
1189       cinfo.asymbols = bfd_get_outsymbols (abfd);
1190       bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1191
1192       if (! cinfo.found)
1193         einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1194     }
1195
1196   return TRUE;
1197 }
1198
1199 /* This is called by warning_callback for each section.  It checks the
1200    relocs of the section to see if it can find a reference to the
1201    symbol which triggered the warning.  If it can, it uses the reloc
1202    to give an error message with a file and line number.  */
1203
1204 static void
1205 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1206 {
1207   struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1208   long relsize;
1209   arelent **relpp;
1210   long relcount;
1211   arelent **p, **pend;
1212
1213   if (info->found)
1214     return;
1215
1216   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1217   if (relsize < 0)
1218     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1219   if (relsize == 0)
1220     return;
1221
1222   relpp = (arelent **) xmalloc (relsize);
1223   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1224   if (relcount < 0)
1225     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1226
1227   p = relpp;
1228   pend = p + relcount;
1229   for (; p < pend && *p != NULL; p++)
1230     {
1231       arelent *q = *p;
1232
1233       if (q->sym_ptr_ptr != NULL
1234           && *q->sym_ptr_ptr != NULL
1235           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1236         {
1237           /* We found a reloc for the symbol we are looking for.  */
1238           einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1239                  info->warning);
1240           info->found = TRUE;
1241           break;
1242         }
1243     }
1244
1245   free (relpp);
1246 }
1247
1248 /* This is called when an undefined symbol is found.  */
1249
1250 static bfd_boolean
1251 undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1252                   const char *name,
1253                   bfd *abfd,
1254                   asection *section,
1255                   bfd_vma address,
1256                   bfd_boolean error)
1257 {
1258   static char *error_name;
1259   static unsigned int error_count;
1260
1261 #define MAX_ERRORS_IN_A_ROW 5
1262
1263   if (config.warn_once)
1264     {
1265       static struct bfd_hash_table *hash;
1266
1267       /* Only warn once about a particular undefined symbol.  */
1268       if (hash == NULL)
1269         {
1270           hash = (struct bfd_hash_table *)
1271               xmalloc (sizeof (struct bfd_hash_table));
1272           if (!bfd_hash_table_init (hash, bfd_hash_newfunc,
1273                                     sizeof (struct bfd_hash_entry)))
1274             einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1275         }
1276
1277       if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1278         return TRUE;
1279
1280       if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1281         einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1282     }
1283
1284   /* We never print more than a reasonable number of errors in a row
1285      for a single symbol.  */
1286   if (error_name != NULL
1287       && strcmp (name, error_name) == 0)
1288     ++error_count;
1289   else
1290     {
1291       error_count = 0;
1292       if (error_name != NULL)
1293         free (error_name);
1294       error_name = xstrdup (name);
1295     }
1296
1297   if (section != NULL)
1298     {
1299       if (error_count < MAX_ERRORS_IN_A_ROW)
1300         {
1301           if (error)
1302             einfo (_("%X%C: undefined reference to `%T'\n"),
1303                    abfd, section, address, name);
1304           else
1305             einfo (_("%C: warning: undefined reference to `%T'\n"),
1306                    abfd, section, address, name);
1307         }
1308       else if (error_count == MAX_ERRORS_IN_A_ROW)
1309         {
1310           if (error)
1311             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1312                    abfd, section, address, name);
1313           else
1314             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1315                    abfd, section, address, name);
1316         }
1317       else if (error)
1318         einfo ("%X");
1319     }
1320   else
1321     {
1322       if (error_count < MAX_ERRORS_IN_A_ROW)
1323         {
1324           if (error)
1325             einfo (_("%X%B: undefined reference to `%T'\n"),
1326                    abfd, name);
1327           else
1328             einfo (_("%B: warning: undefined reference to `%T'\n"),
1329                    abfd, name);
1330         }
1331       else if (error_count == MAX_ERRORS_IN_A_ROW)
1332         {
1333           if (error)
1334             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1335                    abfd, name);
1336           else
1337             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1338                    abfd, name);
1339         }
1340       else if (error)
1341         einfo ("%X");
1342     }
1343
1344   return TRUE;
1345 }
1346
1347 /* Counter to limit the number of relocation overflow error messages
1348    to print.  Errors are printed as it is decremented.  When it's
1349    called and the counter is zero, a final message is printed
1350    indicating more relocations were omitted.  When it gets to -1, no
1351    such errors are printed.  If it's initially set to a value less
1352    than -1, all such errors will be printed (--verbose does this).  */
1353
1354 int overflow_cutoff_limit = 10;
1355
1356 /* This is called when a reloc overflows.  */
1357
1358 static bfd_boolean
1359 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1360                 struct bfd_link_hash_entry *entry,
1361                 const char *name,
1362                 const char *reloc_name,
1363                 bfd_vma addend,
1364                 bfd *abfd,
1365                 asection *section,
1366                 bfd_vma address)
1367 {
1368   if (overflow_cutoff_limit == -1)
1369     return TRUE;
1370
1371   einfo ("%X%C:", abfd, section, address);
1372
1373   if (overflow_cutoff_limit >= 0
1374       && overflow_cutoff_limit-- == 0)
1375     {
1376       einfo (_(" additional relocation overflows omitted from the output\n"));
1377       return TRUE;
1378     }
1379
1380   if (entry)
1381     {
1382       while (entry->type == bfd_link_hash_indirect
1383              || entry->type == bfd_link_hash_warning)
1384         entry = entry->u.i.link;
1385       switch (entry->type)
1386         {
1387         case bfd_link_hash_undefined:
1388         case bfd_link_hash_undefweak:
1389           einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1390                  reloc_name, entry->root.string);
1391           break;
1392         case bfd_link_hash_defined:
1393         case bfd_link_hash_defweak:
1394           einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1395                  reloc_name, entry->root.string,
1396                  entry->u.def.section,
1397                  entry->u.def.section == bfd_abs_section_ptr
1398                  ? link_info.output_bfd : entry->u.def.section->owner);
1399           break;
1400         default:
1401           abort ();
1402           break;
1403         }
1404     }
1405   else
1406     einfo (_(" relocation truncated to fit: %s against `%T'"),
1407            reloc_name, name);
1408   if (addend != 0)
1409     einfo ("+%v", addend);
1410   einfo ("\n");
1411   return TRUE;
1412 }
1413
1414 /* This is called when a dangerous relocation is made.  */
1415
1416 static bfd_boolean
1417 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1418                  const char *message,
1419                  bfd *abfd,
1420                  asection *section,
1421                  bfd_vma address)
1422 {
1423   einfo (_("%X%C: dangerous relocation: %s\n"),
1424          abfd, section, address, message);
1425   return TRUE;
1426 }
1427
1428 /* This is called when a reloc is being generated attached to a symbol
1429    that is not being output.  */
1430
1431 static bfd_boolean
1432 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1433                   const char *name,
1434                   bfd *abfd,
1435                   asection *section,
1436                   bfd_vma address)
1437 {
1438   einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1439          abfd, section, address, name);
1440   return TRUE;
1441 }
1442
1443 /* This is called if link_info.notice_all is set, or when a symbol in
1444    link_info.notice_hash is found.  Symbols are put in notice_hash
1445    using the -y option, while notice_all is set if the --cref option
1446    has been supplied, or if there are any NOCROSSREFS sections in the
1447    linker script; and if plugins are active, since they need to monitor
1448    all references from non-IR files.  */
1449
1450 static bfd_boolean
1451 notice (struct bfd_link_info *info,
1452         const char *name,
1453         bfd *abfd,
1454         asection *section,
1455         bfd_vma value)
1456 {
1457   if (name == NULL)
1458     {
1459       if (command_line.cref || nocrossref_list != NULL)
1460         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1461       return TRUE;
1462     }
1463
1464 #ifdef ENABLE_PLUGINS
1465   /* We should hide symbols in the dummy IR BFDs from the nocrossrefs list
1466      and let the real object files that are generated and added later trip
1467      the error instead.  Similarly would be better to trace the real symbol
1468      from the real file than the temporary dummy.  */
1469   if (!plugin_notice (info, name, abfd, section, value))
1470     return TRUE;
1471 #endif /* ENABLE_PLUGINS */
1472
1473   if (info->notice_hash != NULL
1474         && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1475     {
1476       if (bfd_is_und_section (section))
1477         einfo ("%B: reference to %s\n", abfd, name);
1478       else
1479         einfo ("%B: definition of %s\n", abfd, name);
1480     }
1481
1482   if (command_line.cref || nocrossref_list != NULL)
1483     add_cref (name, abfd, section, value);
1484
1485   return TRUE;
1486 }