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