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