ld/ldmain.c

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