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