ld/ldmain.c

   1 /* Main program of GNU linker.
   2    Copyright (C) 1991-2014 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 #include "libbfd.h"
  45 #endif /* ENABLE_PLUGINS */
  46
  47 /* Somewhere above, sys/stat.h got included.  */
  48 #if !defined(S_ISDIR) && defined(S_IFDIR)
  49 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  50 #endif
  51
  52 #include <string.h>
  53
  54 #ifdef HAVE_SBRK
  55 #if !HAVE_DECL_SBRK
  56 extern void *sbrk ();
  57 #endif
  58 #endif
  59
  60 #ifndef TARGET_SYSTEM_ROOT
  61 #define TARGET_SYSTEM_ROOT ""
  62 #endif
  63
  64 /* EXPORTS */
  65
  66 FILE *saved_script_handle = NULL;
  67 FILE *previous_script_handle = NULL;
  68 bfd_boolean force_make_executable = FALSE;
  69
  70 char *default_target;
  71 const char *output_filename = "a.out";
  72
  73 /* Name this program was invoked by.  */
  74 char *program_name;
  75
  76 /* The prefix for system library directories.  */
  77 const char *ld_sysroot;
  78
  79 /* The canonical representation of ld_sysroot.  */
  80 char * ld_canon_sysroot;
  81 int ld_canon_sysroot_len;
  82
  83 /* Set by -G argument, for targets like MIPS ELF.  */
  84 int g_switch_value = 8;
  85
  86 /* Nonzero means print names of input files as processed.  */
  87 bfd_boolean trace_files;
  88
  89 /* Nonzero means report actions taken by the linker, and describe the linker script in use.  */
  90 bfd_boolean verbose;
  91
  92 /* Nonzero means version number was printed, so exit successfully
  93    instead of complaining if no input files are given.  */
  94 bfd_boolean version_printed;
  95
  96 /* TRUE if we should demangle symbol names.  */
  97 bfd_boolean demangling;
  98
  99 args_type command_line;
 100
 101 ld_config_type config;
 102
 103 sort_type sort_section;
 104
 105 static const char *get_sysroot
 106   (int, char **);
 107 static char *get_emulation
 108   (int, char **);
 109 static bfd_boolean add_archive_element
 110   (struct bfd_link_info *, bfd *, const char *, bfd **);
 111 static bfd_boolean multiple_definition
 112   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 113    bfd *, asection *, bfd_vma);
 114 static bfd_boolean multiple_common
 115   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 116    bfd *, enum bfd_link_hash_type, bfd_vma);
 117 static bfd_boolean add_to_set
 118   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 119    bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
 120 static bfd_boolean constructor_callback
 121   (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
 122    asection *, bfd_vma);
 123 static bfd_boolean warning_callback
 124   (struct bfd_link_info *, const char *, const char *, bfd *,
 125    asection *, bfd_vma);
 126 static void warning_find_reloc
 127   (bfd *, asection *, void *);
 128 static bfd_boolean undefined_symbol
 129   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 130    bfd_boolean);
 131 static bfd_boolean reloc_overflow
 132   (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
 133    const char *, bfd_vma, bfd *, asection *, bfd_vma);
 134 static bfd_boolean reloc_dangerous
 135   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 136 static bfd_boolean unattached_reloc
 137   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 138 static bfd_boolean notice
 139   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 140    struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
 141
 142 static struct bfd_link_callbacks link_callbacks =
 143 {
 144   add_archive_element,
 145   multiple_definition,
 146   multiple_common,
 147   add_to_set,
 148   constructor_callback,
 149   warning_callback,
 150   undefined_symbol,
 151   reloc_overflow,
 152   reloc_dangerous,
 153   unattached_reloc,
 154   notice,
 155   einfo,
 156   info_msg,
 157   minfo,
 158   ldlang_override_segment_assignment
 159 };
 160
 161 static bfd_assert_handler_type default_bfd_assert_handler;
 162
 163 struct bfd_link_info link_info;
 164 \f
 165 static void
 166 ld_cleanup (void)
 167 {
 168   bfd_cache_close_all ();
 169 #ifdef ENABLE_PLUGINS
 170   plugin_call_cleanup ();
 171 #endif
 172   if (output_filename && delete_output_file_on_failure)
 173     unlink_if_ordinary (output_filename);
 174 }
 175
 176 /* If there's a BFD assertion, we'll notice and exit with an error
 177    unless otherwise instructed.  */
 178
 179 static void
 180 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
 181                        const char *file, int line)
 182 {
 183   (*default_bfd_assert_handler) (fmt, bfdver, file, line);
 184   config.make_executable = FALSE;
 185 }
 186
 187 int
 188 main (int argc, char **argv)
 189 {
 190   char *emulation;
 191   long start_time = get_run_time ();
 192 #ifdef HAVE_SBRK
 193   char *start_sbrk = (char *) sbrk (0);
 194 #endif
 195
 196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 197   setlocale (LC_MESSAGES, "");
 198 #endif
 199 #if defined (HAVE_SETLOCALE)
 200   setlocale (LC_CTYPE, "");
 201 #endif
 202   bindtextdomain (PACKAGE, LOCALEDIR);
 203   textdomain (PACKAGE);
 204
 205   program_name = argv[0];
 206   xmalloc_set_program_name (program_name);
 207
 208   START_PROGRESS (program_name, 0);
 209
 210   expandargv (&argc, &argv);
 211
 212   bfd_init ();
 213
 214   bfd_set_error_program_name (program_name);
 215
 216   /* We want to notice and fail on those nasty BFD assertions which are
 217      likely to signal incorrect output being generated but otherwise may
 218      leave no trace.  */
 219   default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
 220
 221   xatexit (ld_cleanup);
 222
 223   /* Set up the sysroot directory.  */
 224   ld_sysroot = get_sysroot (argc, argv);
 225   if (*ld_sysroot)
 226     {
 227       if (*TARGET_SYSTEM_ROOT == 0)
 228         {
 229           einfo ("%P%F: this linker was not configured to use sysroots\n");
 230           ld_sysroot = "";
 231         }
 232       else
 233         ld_canon_sysroot = lrealpath (ld_sysroot);
 234     }
 235   if (ld_canon_sysroot)
 236     ld_canon_sysroot_len = strlen (ld_canon_sysroot);
 237   else
 238     ld_canon_sysroot_len = -1;
 239
 240   /* Set the default BFD target based on the configured target.  Doing
 241      this permits the linker to be configured for a particular target,
 242      and linked against a shared BFD library which was configured for
 243      a different target.  The macro TARGET is defined by Makefile.  */
 244   if (! bfd_set_default_target (TARGET))
 245     {
 246       einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
 247       xexit (1);
 248     }
 249
 250 #if YYDEBUG
 251   {
 252     extern int yydebug;
 253     yydebug = 1;
 254   }
 255 #endif
 256
 257   config.build_constructors = TRUE;
 258   config.rpath_separator = ':';
 259   config.split_by_reloc = (unsigned) -1;
 260   config.split_by_file = (bfd_size_type) -1;
 261   config.make_executable = TRUE;
 262   config.magic_demand_paged = TRUE;
 263   config.text_read_only = TRUE;
 264   link_info.disable_target_specific_optimizations = -1;
 265
 266   command_line.warn_mismatch = TRUE;
 267   command_line.warn_search_mismatch = TRUE;
 268   command_line.check_section_addresses = -1;
 269
 270   /* We initialize DEMANGLING based on the environment variable
 271      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
 272      output of the linker, unless COLLECT_NO_DEMANGLE is set in the
 273      environment.  Acting the same way here lets us provide the same
 274      interface by default.  */
 275   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
 276
 277   link_info.allow_undefined_version = TRUE;
 278   link_info.keep_memory = TRUE;
 279   link_info.new_dtags = TRUE;
 280   link_info.combreloc = TRUE;
 281   link_info.strip_discarded = TRUE;
 282   link_info.emit_hash = TRUE;
 283   link_info.emit_gnu_hash = TRUE;
 284   link_info.callbacks = &link_callbacks;
 285   link_info.input_bfds_tail = &link_info.input_bfds;
 286   /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
 287      and _fini symbols.  We are compatible.  */
 288   link_info.init_function = "_init";
 289   link_info.fini_function = "_fini";
 290   link_info.relax_pass = 1;
 291   link_info.pei386_auto_import = -1;
 292   link_info.spare_dynamic_tags = 5;
 293   link_info.path_separator = ':';
 294   if (getenv ("LD_AS_NEEDED") && atoi(getenv ("LD_AS_NEEDED")) > 0)
 295     input_flags.add_DT_NEEDED_for_regular = TRUE;
 296
 297   ldfile_add_arch ("");
 298   emulation = get_emulation (argc, argv);
 299   ldemul_choose_mode (emulation);
 300   default_target = ldemul_choose_target (argc, argv);
 301   config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
 302   config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
 303   lang_init ();
 304   ldemul_before_parse ();
 305   lang_has_input_file = FALSE;
 306   parse_args (argc, argv);
 307
 308   if (config.hash_table_size != 0)
 309     bfd_hash_set_default_size (config.hash_table_size);
 310
 311 #ifdef ENABLE_PLUGINS
 312   /* Now all the plugin arguments have been gathered, we can load them.  */
 313   plugin_load_plugins ();
 314 #endif /* ENABLE_PLUGINS */
 315
 316   ldemul_set_symbols ();
 317
 318   /* If we have not already opened and parsed a linker script,
 319      try the default script from command line first.  */
 320   if (saved_script_handle == NULL
 321       && command_line.default_script != NULL)
 322     {
 323       ldfile_open_command_file (command_line.default_script);
 324       parser_input = input_script;
 325       yyparse ();
 326     }
 327
 328   /* If we have not already opened and parsed a linker script
 329      read the emulation's appropriate default script.  */
 330   if (saved_script_handle == NULL)
 331     {
 332       int isfile;
 333       char *s = ldemul_get_script (&isfile);
 334
 335       if (isfile)
 336         ldfile_open_default_command_file (s);
 337       else
 338         {
 339           lex_string = s;
 340           lex_redirect (s, _("built in linker script"), 1);
 341         }
 342       parser_input = input_script;
 343       yyparse ();
 344       lex_string = NULL;
 345     }
 346
 347   if (verbose)
 348     {
 349       if (saved_script_handle)
 350         info_msg (_("using external linker script:"));
 351       else
 352         info_msg (_("using internal linker script:"));
 353       info_msg ("\n==================================================\n");
 354
 355       if (saved_script_handle)
 356         {
 357           static const int ld_bufsz = 8193;
 358           size_t n;
 359           char *buf = (char *) xmalloc (ld_bufsz);
 360
 361           rewind (saved_script_handle);
 362           while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
 363             {
 364               buf[n] = 0;
 365               info_msg (buf);
 366             }
 367           rewind (saved_script_handle);
 368           free (buf);
 369         }
 370       else
 371         {
 372           int isfile;
 373
 374           info_msg (ldemul_get_script (&isfile));
 375         }
 376
 377       info_msg ("\n==================================================\n");
 378     }
 379
 380   if (command_line.print_output_format)
 381     info_msg ("%s\n", lang_get_output_target ());
 382
 383   lang_final ();
 384
 385   /* If the only command line argument has been -v or --version or --verbose
 386      then ignore any input files provided by linker scripts and exit now.
 387      We do not want to create an output file when the linker is just invoked
 388      to provide version information.  */
 389   if (argc == 2 && version_printed)
 390     xexit (0);
 391
 392   if (!lang_has_input_file)
 393     {
 394       if (version_printed || command_line.print_output_format)
 395         xexit (0);
 396       einfo (_("%P%F: no input files\n"));
 397     }
 398
 399   if (trace_files)
 400     info_msg (_("%P: mode %s\n"), emulation);
 401
 402   ldemul_after_parse ();
 403
 404   if (config.map_filename)
 405     {
 406       if (strcmp (config.map_filename, "-") == 0)
 407         {
 408           config.map_file = stdout;
 409         }
 410       else
 411         {
 412           config.map_file = fopen (config.map_filename, FOPEN_WT);
 413           if (config.map_file == (FILE *) NULL)
 414             {
 415               bfd_set_error (bfd_error_system_call);
 416               einfo (_("%P%F: cannot open map file %s: %E\n"),
 417                      config.map_filename);
 418             }
 419         }
 420     }
 421
 422   lang_process ();
 423
 424   /* Print error messages for any missing symbols, for any warning
 425      symbols, and possibly multiple definitions.  */
 426   if (link_info.relocatable)
 427     link_info.output_bfd->flags &= ~EXEC_P;
 428   else
 429     link_info.output_bfd->flags |= EXEC_P;
 430
 431   ldwrite ();
 432
 433   if (config.map_file != NULL)
 434     lang_map ();
 435   if (command_line.cref)
 436     output_cref (config.map_file != NULL ? config.map_file : stdout);
 437   if (nocrossref_list != NULL)
 438     check_nocrossrefs ();
 439 #if 0
 440   {
 441     struct bfd_link_hash_entry * h;
 442
 443     h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
 444     fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
 445   }
 446 #endif
 447   lang_finish ();
 448
 449   /* Even if we're producing relocatable output, some non-fatal errors should
 450      be reported in the exit status.  (What non-fatal errors, if any, do we
 451      want to ignore for relocatable output?)  */
 452   if (!config.make_executable && !force_make_executable)
 453     {
 454       if (trace_files)
 455         einfo (_("%P: link errors found, deleting executable `%s'\n"),
 456                output_filename);
 457
 458       /* The file will be removed by ld_cleanup.  */
 459       xexit (1);
 460     }
 461   else
 462     {
 463       if (! bfd_close (link_info.output_bfd))
 464         einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
 465
 466       /* If the --force-exe-suffix is enabled, and we're making an
 467          executable file and it doesn't end in .exe, copy it to one
 468          which does.  */
 469       if (! link_info.relocatable && 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 (_("%X%P: unable to open for source of copy `%s'\n"),
 491                        output_filename);
 492               if (!dst)
 493                 einfo (_("%X%P: 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 (plugin_active_plugins_p () && !no_more_claiming)
 796     {
 797       /* We must offer this archive member to the plugins to claim.  */
 798       const char *filename = (bfd_my_archive (abfd) != NULL
 799                               ? bfd_my_archive (abfd)->filename : abfd->filename);
 800       int fd = open (filename, O_RDONLY | O_BINARY);
 801       if (fd >= 0)
 802         {
 803           struct ld_plugin_input_file file;
 804
 805           /* Offset and filesize must refer to the individual archive
 806              member, not the whole file, and must exclude the header.
 807              Fortunately for us, that is how the data is stored in the
 808              origin field of the bfd and in the arelt_data.  */
 809           file.name = filename;
 810           file.offset = abfd->origin;
 811           file.filesize = arelt_size (abfd);
 812           file.fd = fd;
 813           plugin_maybe_claim (&file, input);
 814           if (input->flags.claimed)
 815             {
 816               input->flags.claim_archive = TRUE;
 817               *subsbfd = input->the_bfd;
 818             }
 819         }
 820     }
 821 #endif /* ENABLE_PLUGINS */
 822
 823   ldlang_add_file (input);
 824
 825   if (config.map_file != NULL)
 826     {
 827       static bfd_boolean header_printed;
 828       struct bfd_link_hash_entry *h;
 829       bfd *from;
 830       int len;
 831
 832       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 833
 834       if (h == NULL)
 835         from = NULL;
 836       else
 837         {
 838           switch (h->type)
 839             {
 840             default:
 841               from = NULL;
 842               break;
 843
 844             case bfd_link_hash_defined:
 845             case bfd_link_hash_defweak:
 846               from = h->u.def.section->owner;
 847               break;
 848
 849             case bfd_link_hash_undefined:
 850             case bfd_link_hash_undefweak:
 851               from = h->u.undef.abfd;
 852               break;
 853
 854             case bfd_link_hash_common:
 855               from = h->u.c.p->section->owner;
 856               break;
 857             }
 858         }
 859
 860       if (! header_printed)
 861         {
 862           char buf[100];
 863
 864           sprintf (buf, _("Archive member included "
 865                           "to satisfy reference by file (symbol)\n\n"));
 866           minfo ("%s", buf);
 867           header_printed = TRUE;
 868         }
 869
 870       if (bfd_my_archive (abfd) == NULL)
 871         {
 872           minfo ("%s", bfd_get_filename (abfd));
 873           len = strlen (bfd_get_filename (abfd));
 874         }
 875       else
 876         {
 877           minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
 878                  bfd_get_filename (abfd));
 879           len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
 880                  + strlen (bfd_get_filename (abfd))
 881                  + 2);
 882         }
 883
 884       if (len >= 29)
 885         {
 886           print_nl ();
 887           len = 0;
 888         }
 889       while (len < 30)
 890         {
 891           print_space ();
 892           ++len;
 893         }
 894
 895       if (from != NULL)
 896         minfo ("%B ", from);
 897       if (h != NULL)
 898         minfo ("(%T)\n", h->root.string);
 899       else
 900         minfo ("(%s)\n", name);
 901     }
 902
 903   if (trace_files || verbose)
 904     info_msg ("%I\n", &orig_input);
 905   return TRUE;
 906 }
 907
 908 /* This is called when BFD has discovered a symbol which is defined
 909    multiple times.  */
 910
 911 static bfd_boolean
 912 multiple_definition (struct bfd_link_info *info,
 913                      struct bfd_link_hash_entry *h,
 914                      bfd *nbfd,
 915                      asection *nsec,
 916                      bfd_vma nval)
 917 {
 918   const char *name;
 919   bfd *obfd;
 920   asection *osec;
 921   bfd_vma oval;
 922
 923   if (info->allow_multiple_definition)
 924     return TRUE;
 925
 926   switch (h->type)
 927     {
 928     case bfd_link_hash_defined:
 929       osec = h->u.def.section;
 930       oval = h->u.def.value;
 931       obfd = h->u.def.section->owner;
 932       break;
 933     case bfd_link_hash_indirect:
 934       osec = bfd_ind_section_ptr;
 935       oval = 0;
 936       obfd = NULL;
 937       break;
 938     default:
 939       abort ();
 940     }
 941
 942   /* Ignore a redefinition of an absolute symbol to the
 943      same value; it's harmless.  */
 944   if (h->type == bfd_link_hash_defined
 945       && bfd_is_abs_section (osec)
 946       && bfd_is_abs_section (nsec)
 947       && nval == oval)
 948     return TRUE;
 949
 950   /* If either section has the output_section field set to
 951      bfd_abs_section_ptr, it means that the section is being
 952      discarded, and this is not really a multiple definition at all.
 953      FIXME: It would be cleaner to somehow ignore symbols defined in
 954      sections which are being discarded.  */
 955   if ((osec->output_section != NULL
 956        && ! bfd_is_abs_section (osec)
 957        && bfd_is_abs_section (osec->output_section))
 958       || (nsec->output_section != NULL
 959           && ! bfd_is_abs_section (nsec)
 960           && bfd_is_abs_section (nsec->output_section)))
 961     return TRUE;
 962
 963   name = h->root.string;
 964   if (nbfd == NULL)
 965     {
 966       nbfd = obfd;
 967       nsec = osec;
 968       nval = oval;
 969       obfd = NULL;
 970     }
 971   einfo (_("%X%C: multiple definition of `%T'\n"),
 972          nbfd, nsec, nval, name);
 973   if (obfd != NULL)
 974     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 975
 976   if (RELAXATION_ENABLED_BY_USER)
 977     {
 978       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 979       DISABLE_RELAXATION;
 980     }
 981
 982   return TRUE;
 983 }
 984
 985 /* This is called when there is a definition of a common symbol, or
 986    when a common symbol is found for a symbol that is already defined,
 987    or when two common symbols are found.  We only do something if
 988    -warn-common was used.  */
 989
 990 static bfd_boolean
 991 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 992                  struct bfd_link_hash_entry *h,
 993                  bfd *nbfd,
 994                  enum bfd_link_hash_type ntype,
 995                  bfd_vma nsize)
 996 {
 997   const char *name;
 998   bfd *obfd;
 999   enum bfd_link_hash_type otype;
1000   bfd_vma osize;
1001
1002   if (!config.warn_common)
1003     return TRUE;
1004
1005   name = h->root.string;
1006   otype = h->type;
1007   if (otype == bfd_link_hash_common)
1008     {
1009       obfd = h->u.c.p->section->owner;
1010       osize = h->u.c.size;
1011     }
1012   else if (otype == bfd_link_hash_defined
1013            || otype == bfd_link_hash_defweak)
1014     {
1015       obfd = h->u.def.section->owner;
1016       osize = 0;
1017     }
1018   else
1019     {
1020       /* FIXME: It would nice if we could report the BFD which defined
1021          an indirect symbol, but we don't have anywhere to store the
1022          information.  */
1023       obfd = NULL;
1024       osize = 0;
1025     }
1026
1027   if (ntype == bfd_link_hash_defined
1028       || ntype == bfd_link_hash_defweak
1029       || ntype == bfd_link_hash_indirect)
1030     {
1031       ASSERT (otype == bfd_link_hash_common);
1032       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1033              nbfd, name);
1034       if (obfd != NULL)
1035         einfo (_("%B: warning: common is here\n"), obfd);
1036     }
1037   else if (otype == bfd_link_hash_defined
1038            || otype == bfd_link_hash_defweak
1039            || otype == bfd_link_hash_indirect)
1040     {
1041       ASSERT (ntype == bfd_link_hash_common);
1042       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1043              nbfd, name);
1044       if (obfd != NULL)
1045         einfo (_("%B: warning: defined here\n"), obfd);
1046     }
1047   else
1048     {
1049       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1050       if (osize > nsize)
1051         {
1052           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1053                  nbfd, name);
1054           if (obfd != NULL)
1055             einfo (_("%B: warning: larger common is here\n"), obfd);
1056         }
1057       else if (nsize > osize)
1058         {
1059           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1060                  nbfd, name);
1061           if (obfd != NULL)
1062             einfo (_("%B: warning: smaller common is here\n"), obfd);
1063         }
1064       else
1065         {
1066           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1067           if (obfd != NULL)
1068             einfo (_("%B: warning: previous common is here\n"), obfd);
1069         }
1070     }
1071
1072   return TRUE;
1073 }
1074
1075 /* This is called when BFD has discovered a set element.  H is the
1076    entry in the linker hash table for the set.  SECTION and VALUE
1077    represent a value which should be added to the set.  */
1078
1079 static bfd_boolean
1080 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1081             struct bfd_link_hash_entry *h,
1082             bfd_reloc_code_real_type reloc,
1083             bfd *abfd,
1084             asection *section,
1085             bfd_vma value)
1086 {
1087   if (config.warn_constructors)
1088     einfo (_("%P: warning: global constructor %s used\n"),
1089            h->root.string);
1090
1091   if (! config.build_constructors)
1092     return TRUE;
1093
1094   ldctor_add_set_entry (h, reloc, NULL, section, value);
1095
1096   if (h->type == bfd_link_hash_new)
1097     {
1098       h->type = bfd_link_hash_undefined;
1099       h->u.undef.abfd = abfd;
1100       /* We don't call bfd_link_add_undef to add this to the list of
1101          undefined symbols because we are going to define it
1102          ourselves.  */
1103     }
1104
1105   return TRUE;
1106 }
1107
1108 /* This is called when BFD has discovered a constructor.  This is only
1109    called for some object file formats--those which do not handle
1110    constructors in some more clever fashion.  This is similar to
1111    adding an element to a set, but less general.  */
1112
1113 static bfd_boolean
1114 constructor_callback (struct bfd_link_info *info,
1115                       bfd_boolean constructor,
1116                       const char *name,
1117                       bfd *abfd,
1118                       asection *section,
1119                       bfd_vma value)
1120 {
1121   char *s;
1122   struct bfd_link_hash_entry *h;
1123   char set_name[1 + sizeof "__CTOR_LIST__"];
1124
1125   if (config.warn_constructors)
1126     einfo (_("%P: warning: global constructor %s used\n"), name);
1127
1128   if (! config.build_constructors)
1129     return TRUE;
1130
1131   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1132      useful error message.  */
1133   if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1134       && (info->relocatable
1135           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1136     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1137
1138   s = set_name;
1139   if (bfd_get_symbol_leading_char (abfd) != '\0')
1140     *s++ = bfd_get_symbol_leading_char (abfd);
1141   if (constructor)
1142     strcpy (s, "__CTOR_LIST__");
1143   else
1144     strcpy (s, "__DTOR_LIST__");
1145
1146   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1147   if (h == (struct bfd_link_hash_entry *) NULL)
1148     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1149   if (h->type == bfd_link_hash_new)
1150     {
1151       h->type = bfd_link_hash_undefined;
1152       h->u.undef.abfd = abfd;
1153       /* We don't call bfd_link_add_undef to add this to the list of
1154          undefined symbols because we are going to define it
1155          ourselves.  */
1156     }
1157
1158   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1159   return TRUE;
1160 }
1161
1162 /* A structure used by warning_callback to pass information through
1163    bfd_map_over_sections.  */
1164
1165 struct warning_callback_info
1166 {
1167   bfd_boolean found;
1168   const char *warning;
1169   const char *symbol;
1170   asymbol **asymbols;
1171 };
1172
1173 /* Look through the relocs to see if we can find a plausible address
1174    for SYMBOL in ABFD.  Return TRUE if found.  Otherwise return FALSE.  */
1175
1176 static bfd_boolean
1177 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1178 {
1179   struct warning_callback_info cinfo;
1180
1181   if (!bfd_generic_link_read_symbols (abfd))
1182     einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1183
1184   cinfo.found = FALSE;
1185   cinfo.warning = warning;
1186   cinfo.symbol = symbol;
1187   cinfo.asymbols = bfd_get_outsymbols (abfd);
1188   bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1189   return cinfo.found;
1190 }
1191
1192 /* This is called when there is a reference to a warning symbol.  */
1193
1194 static bfd_boolean
1195 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1196                   const char *warning,
1197                   const char *symbol,
1198                   bfd *abfd,
1199                   asection *section,
1200                   bfd_vma address)
1201 {
1202   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1203      have a cleaner interface, but what?  */
1204   if (! config.warn_multiple_gp
1205       && strcmp (warning, "using multiple gp values") == 0)
1206     return TRUE;
1207
1208   if (section != NULL)
1209     einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1210   else if (abfd == NULL)
1211     einfo ("%P: %s%s\n", _("warning: "), warning);
1212   else if (symbol == NULL)
1213     einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1214   else if (! symbol_warning (warning, symbol, abfd))
1215     {
1216       bfd *b;
1217       /* Search all input files for a reference to SYMBOL.  */
1218       for (b = info->input_bfds; b; b = b->link.next)
1219         if (b != abfd && symbol_warning (warning, symbol, b))
1220           return TRUE;
1221       einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1222     }
1223
1224   return TRUE;
1225 }
1226
1227 /* This is called by warning_callback for each section.  It checks the
1228    relocs of the section to see if it can find a reference to the
1229    symbol which triggered the warning.  If it can, it uses the reloc
1230    to give an error message with a file and line number.  */
1231
1232 static void
1233 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1234 {
1235   struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1236   long relsize;
1237   arelent **relpp;
1238   long relcount;
1239   arelent **p, **pend;
1240
1241   if (info->found)
1242     return;
1243
1244   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1245   if (relsize < 0)
1246     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1247   if (relsize == 0)
1248     return;
1249
1250   relpp = (arelent **) xmalloc (relsize);
1251   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1252   if (relcount < 0)
1253     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1254
1255   p = relpp;
1256   pend = p + relcount;
1257   for (; p < pend && *p != NULL; p++)
1258     {
1259       arelent *q = *p;
1260
1261       if (q->sym_ptr_ptr != NULL
1262           && *q->sym_ptr_ptr != NULL
1263           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1264         {
1265           /* We found a reloc for the symbol we are looking for.  */
1266           einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1267                  info->warning);
1268           info->found = TRUE;
1269           break;
1270         }
1271     }
1272
1273   free (relpp);
1274 }
1275
1276 /* This is called when an undefined symbol is found.  */
1277
1278 static bfd_boolean
1279 undefined_symbol (struct bfd_link_info *info,
1280                   const char *name,
1281                   bfd *abfd,
1282                   asection *section,
1283                   bfd_vma address,
1284                   bfd_boolean error)
1285 {
1286   static char *error_name;
1287   static unsigned int error_count;
1288
1289 #define MAX_ERRORS_IN_A_ROW 5
1290
1291   if (info->ignore_hash != NULL
1292       && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1293     return TRUE;
1294
1295   if (config.warn_once)
1296     {
1297       /* Only warn once about a particular undefined symbol.  */
1298       add_ignoresym (info, name);
1299     }
1300
1301   /* We never print more than a reasonable number of errors in a row
1302      for a single symbol.  */
1303   if (error_name != NULL
1304       && strcmp (name, error_name) == 0)
1305     ++error_count;
1306   else
1307     {
1308       error_count = 0;
1309       if (error_name != NULL)
1310         free (error_name);
1311       error_name = xstrdup (name);
1312     }
1313
1314   if (section != NULL)
1315     {
1316       if (error_count < MAX_ERRORS_IN_A_ROW)
1317         {
1318           if (error)
1319             einfo (_("%X%C: undefined reference to `%T'\n"),
1320                    abfd, section, address, name);
1321           else
1322             einfo (_("%C: warning: undefined reference to `%T'\n"),
1323                    abfd, section, address, name);
1324         }
1325       else if (error_count == MAX_ERRORS_IN_A_ROW)
1326         {
1327           if (error)
1328             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1329                    abfd, section, address, name);
1330           else
1331             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1332                    abfd, section, address, name);
1333         }
1334       else if (error)
1335         einfo ("%X");
1336     }
1337   else
1338     {
1339       if (error_count < MAX_ERRORS_IN_A_ROW)
1340         {
1341           if (error)
1342             einfo (_("%X%B: undefined reference to `%T'\n"),
1343                    abfd, name);
1344           else
1345             einfo (_("%B: warning: undefined reference to `%T'\n"),
1346                    abfd, name);
1347         }
1348       else if (error_count == MAX_ERRORS_IN_A_ROW)
1349         {
1350           if (error)
1351             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1352                    abfd, name);
1353           else
1354             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1355                    abfd, name);
1356         }
1357       else if (error)
1358         einfo ("%X");
1359     }
1360
1361   return TRUE;
1362 }
1363
1364 /* Counter to limit the number of relocation overflow error messages
1365    to print.  Errors are printed as it is decremented.  When it's
1366    called and the counter is zero, a final message is printed
1367    indicating more relocations were omitted.  When it gets to -1, no
1368    such errors are printed.  If it's initially set to a value less
1369    than -1, all such errors will be printed (--verbose does this).  */
1370
1371 int overflow_cutoff_limit = 10;
1372
1373 /* This is called when a reloc overflows.  */
1374
1375 static bfd_boolean
1376 reloc_overflow (struct bfd_link_info *info,
1377                 struct bfd_link_hash_entry *entry,
1378                 const char *name,
1379                 const char *reloc_name,
1380                 bfd_vma addend,
1381                 bfd *abfd,
1382                 asection *section,
1383                 bfd_vma address)
1384 {
1385   if (overflow_cutoff_limit == -1)
1386     return TRUE;
1387
1388   einfo ("%X%H:", abfd, section, address);
1389
1390   if (overflow_cutoff_limit >= 0
1391       && overflow_cutoff_limit-- == 0)
1392     {
1393       einfo (_(" additional relocation overflows omitted from the output\n"));
1394       return TRUE;
1395     }
1396
1397   if (entry)
1398     {
1399       while (entry->type == bfd_link_hash_indirect
1400              || entry->type == bfd_link_hash_warning)
1401         entry = entry->u.i.link;
1402       switch (entry->type)
1403         {
1404         case bfd_link_hash_undefined:
1405         case bfd_link_hash_undefweak:
1406           einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1407                  reloc_name, entry->root.string);
1408           break;
1409         case bfd_link_hash_defined:
1410         case bfd_link_hash_defweak:
1411           einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1412                  reloc_name, entry->root.string,
1413                  entry->u.def.section,
1414                  entry->u.def.section == bfd_abs_section_ptr
1415                  ? info->output_bfd : entry->u.def.section->owner);
1416           break;
1417         default:
1418           abort ();
1419           break;
1420         }
1421     }
1422   else
1423     einfo (_(" relocation truncated to fit: %s against `%T'"),
1424            reloc_name, name);
1425   if (addend != 0)
1426     einfo ("+%v", addend);
1427   einfo ("\n");
1428   return TRUE;
1429 }
1430
1431 /* This is called when a dangerous relocation is made.  */
1432
1433 static bfd_boolean
1434 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1435                  const char *message,
1436                  bfd *abfd,
1437                  asection *section,
1438                  bfd_vma address)
1439 {
1440   einfo (_("%X%H: dangerous relocation: %s\n"),
1441          abfd, section, address, message);
1442   return TRUE;
1443 }
1444
1445 /* This is called when a reloc is being generated attached to a symbol
1446    that is not being output.  */
1447
1448 static bfd_boolean
1449 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1450                   const char *name,
1451                   bfd *abfd,
1452                   asection *section,
1453                   bfd_vma address)
1454 {
1455   einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1456          abfd, section, address, name);
1457   return TRUE;
1458 }
1459
1460 /* This is called if link_info.notice_all is set, or when a symbol in
1461    link_info.notice_hash is found.  Symbols are put in notice_hash
1462    using the -y option, while notice_all is set if the --cref option
1463    has been supplied, or if there are any NOCROSSREFS sections in the
1464    linker script; and if plugins are active, since they need to monitor
1465    all references from non-IR files.  */
1466
1467 static bfd_boolean
1468 notice (struct bfd_link_info *info,
1469         struct bfd_link_hash_entry *h,
1470         struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1471         bfd *abfd,
1472         asection *section,
1473         bfd_vma value,
1474         flagword flags ATTRIBUTE_UNUSED)
1475 {
1476   const char *name;
1477
1478   if (h == NULL)
1479     {
1480       if (command_line.cref || nocrossref_list != NULL)
1481         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1482       return TRUE;
1483     }
1484
1485   name = h->root.string;
1486   if (info->notice_hash != NULL
1487       && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1488     {
1489       if (bfd_is_und_section (section))
1490         einfo ("%B: reference to %s\n", abfd, name);
1491       else
1492         einfo ("%B: definition of %s\n", abfd, name);
1493     }
1494
1495   if (command_line.cref || nocrossref_list != NULL)
1496     add_cref (name, abfd, section, value);
1497
1498   return TRUE;
1499 }