ld/ldmain.c

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