ld/ldmain.c

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