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
 854       if (h == NULL)
 855         from = NULL;
 856       else
 857         {
 858           switch (h->type)
 859             {
 860             default:
 861               from = NULL;
 862               break;
 863
 864             case bfd_link_hash_defined:
 865             case bfd_link_hash_defweak:
 866               from = h->u.def.section->owner;
 867               break;
 868
 869             case bfd_link_hash_undefined:
 870             case bfd_link_hash_undefweak:
 871               from = h->u.undef.abfd;
 872               break;
 873
 874             case bfd_link_hash_common:
 875               from = h->u.c.p->section->owner;
 876               break;
 877             }
 878         }
 879
 880       if (!header_printed)
 881         {
 882           minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
 883           header_printed = TRUE;
 884         }
 885
 886       if (abfd->my_archive == NULL
 887           || bfd_is_thin_archive (abfd->my_archive))
 888         {
 889           minfo ("%s", bfd_get_filename (abfd));
 890           len = strlen (bfd_get_filename (abfd));
 891         }
 892       else
 893         {
 894           minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
 895                  bfd_get_filename (abfd));
 896           len = (strlen (bfd_get_filename (abfd->my_archive))
 897                  + strlen (bfd_get_filename (abfd))
 898                  + 2);
 899         }
 900
 901       if (len >= 29)
 902         {
 903           print_nl ();
 904           len = 0;
 905         }
 906       while (len < 30)
 907         {
 908           print_space ();
 909           ++len;
 910         }
 911
 912       if (from != NULL)
 913         minfo ("%pB ", from);
 914       if (h != NULL)
 915         minfo ("(%pT)\n", h->root.string);
 916       else
 917         minfo ("(%s)\n", name);
 918     }
 919
 920   if (trace_files || verbose)
 921     info_msg ("%pI\n", &orig_input);
 922   return TRUE;
 923 }
 924
 925 /* This is called when BFD has discovered a symbol which is defined
 926    multiple times.  */
 927
 928 static void
 929 multiple_definition (struct bfd_link_info *info,
 930                      struct bfd_link_hash_entry *h,
 931                      bfd *nbfd,
 932                      asection *nsec,
 933                      bfd_vma nval)
 934 {
 935   const char *name;
 936   bfd *obfd;
 937   asection *osec;
 938   bfd_vma oval;
 939
 940   if (info->allow_multiple_definition)
 941     return;
 942
 943   switch (h->type)
 944     {
 945     case bfd_link_hash_defined:
 946       osec = h->u.def.section;
 947       oval = h->u.def.value;
 948       obfd = h->u.def.section->owner;
 949       break;
 950     case bfd_link_hash_indirect:
 951       osec = bfd_ind_section_ptr;
 952       oval = 0;
 953       obfd = NULL;
 954       break;
 955     default:
 956       abort ();
 957     }
 958
 959   /* Ignore a redefinition of an absolute symbol to the
 960      same value; it's harmless.  */
 961   if (h->type == bfd_link_hash_defined
 962       && bfd_is_abs_section (osec)
 963       && bfd_is_abs_section (nsec)
 964       && nval == oval)
 965     return;
 966
 967   /* If either section has the output_section field set to
 968      bfd_abs_section_ptr, it means that the section is being
 969      discarded, and this is not really a multiple definition at all.
 970      FIXME: It would be cleaner to somehow ignore symbols defined in
 971      sections which are being discarded.  */
 972   if (!info->prohibit_multiple_definition_absolute
 973       && ((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 }