ld/ldmain.c

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