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 unsigned int trace_files;
  81
  82 /* Nonzero means report actions taken by the linker, and describe the linker script in use.  */
  83 bfd_boolean verbose;
  84
  85 /* Nonzero means version number was printed, so exit successfully
  86    instead of complaining if no input files are given.  */
  87 bfd_boolean version_printed;
  88
  89 /* TRUE if we should demangle symbol names.  */
  90 bfd_boolean demangling;
  91
  92 args_type command_line;
  93
  94 ld_config_type config;
  95
  96 sort_type sort_section;
  97
  98 static const char *get_sysroot
  99   (int, char **);
 100 static char *get_emulation
 101   (int, char **);
 102 static bfd_boolean add_archive_element
 103   (struct bfd_link_info *, bfd *, const char *, bfd **);
 104 static void multiple_definition
 105   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 106    bfd *, asection *, bfd_vma);
 107 static void multiple_common
 108   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 109    bfd *, enum bfd_link_hash_type, bfd_vma);
 110 static void add_to_set
 111   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 112    bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
 113 static void constructor_callback
 114   (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
 115    asection *, bfd_vma);
 116 static void warning_callback
 117   (struct bfd_link_info *, const char *, const char *, bfd *,
 118    asection *, bfd_vma);
 119 static void warning_find_reloc
 120   (bfd *, asection *, void *);
 121 static void undefined_symbol
 122   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 123    bfd_boolean);
 124 static void reloc_overflow
 125   (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
 126    const char *, bfd_vma, bfd *, asection *, bfd_vma);
 127 static void reloc_dangerous
 128   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 129 static void unattached_reloc
 130   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 131 static bfd_boolean notice
 132   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 133    struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
 134
 135 static struct bfd_link_callbacks link_callbacks =
 136 {
 137   add_archive_element,
 138   multiple_definition,
 139   multiple_common,
 140   add_to_set,
 141   constructor_callback,
 142   warning_callback,
 143   undefined_symbol,
 144   reloc_overflow,
 145   reloc_dangerous,
 146   unattached_reloc,
 147   notice,
 148   einfo,
 149   info_msg,
 150   minfo,
 151   ldlang_override_segment_assignment
 152 };
 153
 154 static bfd_assert_handler_type default_bfd_assert_handler;
 155 static bfd_error_handler_type default_bfd_error_handler;
 156
 157 struct bfd_link_info link_info;
 158 \f
 159 static void
 160 ld_cleanup (void)
 161 {
 162   bfd_cache_close_all ();
 163 #ifdef ENABLE_PLUGINS
 164   plugin_call_cleanup ();
 165 #endif
 166   if (output_filename && delete_output_file_on_failure)
 167     unlink_if_ordinary (output_filename);
 168 }
 169
 170 /* Hook to notice BFD assertions.  */
 171
 172 static void
 173 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
 174                        const char *file, int line)
 175 {
 176   config.make_executable = FALSE;
 177   (*default_bfd_assert_handler) (fmt, bfdver, file, line);
 178 }
 179
 180 /* Hook the bfd error/warning handler for --fatal-warnings.  */
 181
 182 static void
 183 ld_bfd_error_handler (const char *fmt, va_list ap)
 184 {
 185   if (config.fatal_warnings)
 186     config.make_executable = FALSE;
 187   (*default_bfd_error_handler) (fmt, ap);
 188 }
 189
 190 int
 191 main (int argc, char **argv)
 192 {
 193   char *emulation;
 194   long start_time = get_run_time ();
 195
 196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 197   setlocale (LC_MESSAGES, "");
 198 #endif
 199 #if defined (HAVE_SETLOCALE)
 200   setlocale (LC_CTYPE, "");
 201 #endif
 202   bindtextdomain (PACKAGE, LOCALEDIR);
 203   textdomain (PACKAGE);
 204
 205   program_name = argv[0];
 206   xmalloc_set_program_name (program_name);
 207
 208   START_PROGRESS (program_name, 0);
 209
 210   expandargv (&argc, &argv);
 211
 212   if (bfd_init () != BFD_INIT_MAGIC)
 213     einfo (_("%F%P: fatal error: libbfd ABI mismatch\n"));
 214
 215   bfd_set_error_program_name (program_name);
 216
 217   /* We want to notice and fail on those nasty BFD assertions which are
 218      likely to signal incorrect output being generated but otherwise may
 219      leave no trace.  */
 220   default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
 221
 222   /* Also hook the bfd error/warning handler for --fatal-warnings.  */
 223   default_bfd_error_handler = bfd_set_error_handler (ld_bfd_error_handler);
 224
 225   xatexit (ld_cleanup);
 226
 227   /* Set up the sysroot directory.  */
 228   ld_sysroot = get_sysroot (argc, argv);
 229   if (*ld_sysroot)
 230     ld_canon_sysroot = lrealpath (ld_sysroot);
 231   if (ld_canon_sysroot)
 232     {
 233       ld_canon_sysroot_len = strlen (ld_canon_sysroot);
 234
 235       /* is_sysrooted_pathname() relies on no trailing dirsep.  */
 236       if (ld_canon_sysroot_len > 0
 237           && IS_DIR_SEPARATOR (ld_canon_sysroot [ld_canon_sysroot_len - 1]))
 238         ld_canon_sysroot [--ld_canon_sysroot_len] = '\0';
 239     }
 240   else
 241     ld_canon_sysroot_len = -1;
 242
 243   /* Set the default BFD target based on the configured target.  Doing
 244      this permits the linker to be configured for a particular target,
 245      and linked against a shared BFD library which was configured for
 246      a different target.  The macro TARGET is defined by Makefile.  */
 247   if (!bfd_set_default_target (TARGET))
 248     {
 249       einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
 250       xexit (1);
 251     }
 252
 253 #if YYDEBUG
 254   {
 255     extern int yydebug;
 256     yydebug = 1;
 257   }
 258 #endif
 259
 260   config.build_constructors = TRUE;
 261   config.rpath_separator = ':';
 262   config.split_by_reloc = (unsigned) -1;
 263   config.split_by_file = (bfd_size_type) -1;
 264   config.make_executable = TRUE;
 265   config.magic_demand_paged = TRUE;
 266   config.text_read_only = TRUE;
 267   link_info.disable_target_specific_optimizations = -1;
 268
 269   command_line.warn_mismatch = TRUE;
 270   command_line.warn_search_mismatch = TRUE;
 271   command_line.check_section_addresses = -1;
 272
 273   /* We initialize DEMANGLING based on the environment variable
 274      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
 275      output of the linker, unless COLLECT_NO_DEMANGLE is set in the
 276      environment.  Acting the same way here lets us provide the same
 277      interface by default.  */
 278   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
 279
 280   link_info.allow_undefined_version = TRUE;
 281   link_info.keep_memory = TRUE;
 282   link_info.combreloc = TRUE;
 283   link_info.strip_discarded = TRUE;
 284   link_info.prohibit_multiple_definition_absolute = FALSE;
 285   link_info.emit_hash = DEFAULT_EMIT_SYSV_HASH;
 286   link_info.emit_gnu_hash = DEFAULT_EMIT_GNU_HASH;
 287   link_info.callbacks = &link_callbacks;
 288   link_info.input_bfds_tail = &link_info.input_bfds;
 289   /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
 290      and _fini symbols.  We are compatible.  */
 291   link_info.init_function = "_init";
 292   link_info.fini_function = "_fini";
 293   link_info.relax_pass = 1;
 294   link_info.extern_protected_data = -1;
 295   link_info.dynamic_undefined_weak = -1;
 296   link_info.pei386_auto_import = -1;
 297   link_info.spare_dynamic_tags = 5;
 298   link_info.path_separator = ':';
 299 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
 300   link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
 301 #endif
 302 #ifdef DEFAULT_NEW_DTAGS
 303   link_info.new_dtags = DEFAULT_NEW_DTAGS;
 304 #endif
 305
 306   ldfile_add_arch ("");
 307   emulation = get_emulation (argc, argv);
 308   ldemul_choose_mode (emulation);
 309   default_target = ldemul_choose_target (argc, argv);
 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 (verbose)
 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 (verbose)
 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 = NULL;
 588
 589   for (i = 1; i < argc; i++)
 590     if (CONST_STRNEQ (argv[i], "--sysroot="))
 591       path = argv[i] + strlen ("--sysroot=");
 592
 593   if (!path)
 594     path = get_relative_sysroot (BINDIR);
 595
 596   if (!path)
 597     path = get_relative_sysroot (TOOLBINDIR);
 598
 599   if (!path)
 600     path = TARGET_SYSTEM_ROOT;
 601
 602   if (IS_DIR_SEPARATOR (*path) && path[1] == 0)
 603     path = "";
 604
 605   return path;
 606 }
 607
 608 /* We need to find any explicitly given emulation in order to initialize the
 609    state that's needed by the lex&yacc argument parser (parse_args).  */
 610
 611 static char *
 612 get_emulation (int argc, char **argv)
 613 {
 614   char *emulation;
 615   int i;
 616
 617   emulation = getenv (EMULATION_ENVIRON);
 618   if (emulation == NULL)
 619     emulation = DEFAULT_EMULATION;
 620
 621   for (i = 1; i < argc; i++)
 622     {
 623       if (CONST_STRNEQ (argv[i], "-m"))
 624         {
 625           if (argv[i][2] == '\0')
 626             {
 627               /* -m EMUL */
 628               if (i < argc - 1)
 629                 {
 630                   emulation = argv[i + 1];
 631                   i++;
 632                 }
 633               else
 634                 einfo (_("%F%P: missing argument to -m\n"));
 635             }
 636           else if (strcmp (argv[i], "-mips1") == 0
 637                    || strcmp (argv[i], "-mips2") == 0
 638                    || strcmp (argv[i], "-mips3") == 0
 639                    || strcmp (argv[i], "-mips4") == 0
 640                    || strcmp (argv[i], "-mips5") == 0
 641                    || strcmp (argv[i], "-mips32") == 0
 642                    || strcmp (argv[i], "-mips32r2") == 0
 643                    || strcmp (argv[i], "-mips32r6") == 0
 644                    || strcmp (argv[i], "-mips64") == 0
 645                    || strcmp (argv[i], "-mips64r2") == 0
 646                    || strcmp (argv[i], "-mips64r6") == 0)
 647             {
 648               /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
 649                  passed to the linker by some MIPS compilers.  They
 650                  generally tell the linker to use a slightly different
 651                  library path.  Perhaps someday these should be
 652                  implemented as emulations; until then, we just ignore
 653                  the arguments and hope that nobody ever creates
 654                  emulations named ips1, ips2 or ips3.  */
 655             }
 656           else if (strcmp (argv[i], "-m486") == 0)
 657             {
 658               /* FIXME: The argument -m486 is passed to the linker on
 659                  some Linux systems.  Hope that nobody creates an
 660                  emulation named 486.  */
 661             }
 662           else
 663             {
 664               /* -mEMUL */
 665               emulation = &argv[i][2];
 666             }
 667         }
 668     }
 669
 670   return emulation;
 671 }
 672
 673 void
 674 add_ysym (const char *name)
 675 {
 676   if (link_info.notice_hash == NULL)
 677     {
 678       link_info.notice_hash
 679         = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 680       if (!bfd_hash_table_init_n (link_info.notice_hash,
 681                                   bfd_hash_newfunc,
 682                                   sizeof (struct bfd_hash_entry),
 683                                   61))
 684         einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
 685     }
 686
 687   if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
 688     einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
 689 }
 690
 691 void
 692 add_ignoresym (struct bfd_link_info *info, const char *name)
 693 {
 694   if (info->ignore_hash == NULL)
 695     {
 696       info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
 697       if (!bfd_hash_table_init_n (info->ignore_hash,
 698                                   bfd_hash_newfunc,
 699                                   sizeof (struct bfd_hash_entry),
 700                                   61))
 701         einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
 702     }
 703
 704   if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)
 705     einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
 706 }
 707
 708 /* Record a symbol to be wrapped, from the --wrap option.  */
 709
 710 void
 711 add_wrap (const char *name)
 712 {
 713   if (link_info.wrap_hash == NULL)
 714     {
 715       link_info.wrap_hash
 716         = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 717       if (!bfd_hash_table_init_n (link_info.wrap_hash,
 718                                   bfd_hash_newfunc,
 719                                   sizeof (struct bfd_hash_entry),
 720                                   61))
 721         einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
 722     }
 723
 724   if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
 725     einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
 726 }
 727
 728 /* Handle the -retain-symbols-file option.  */
 729
 730 void
 731 add_keepsyms_file (const char *filename)
 732 {
 733   FILE *file;
 734   char *buf;
 735   size_t bufsize;
 736   int c;
 737
 738   if (link_info.strip == strip_some)
 739     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 740
 741   file = fopen (filename, "r");
 742   if (file == NULL)
 743     {
 744       bfd_set_error (bfd_error_system_call);
 745       einfo ("%X%P: %s: %E\n", filename);
 746       return;
 747     }
 748
 749   link_info.keep_hash = (struct bfd_hash_table *)
 750       xmalloc (sizeof (struct bfd_hash_table));
 751   if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
 752                             sizeof (struct bfd_hash_entry)))
 753     einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
 754
 755   bufsize = 100;
 756   buf = (char *) xmalloc (bufsize);
 757
 758   c = getc (file);
 759   while (c != EOF)
 760     {
 761       while (ISSPACE (c))
 762         c = getc (file);
 763
 764       if (c != EOF)
 765         {
 766           size_t len = 0;
 767
 768           while (!ISSPACE (c) && c != EOF)
 769             {
 770               buf[len] = c;
 771               ++len;
 772               if (len >= bufsize)
 773                 {
 774                   bufsize *= 2;
 775                   buf = (char *) xrealloc (buf, bufsize);
 776                 }
 777               c = getc (file);
 778             }
 779
 780           buf[len] = '\0';
 781
 782           if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
 783             einfo (_("%F%P: bfd_hash_lookup for insertion failed: %E\n"));
 784         }
 785     }
 786
 787   if (link_info.strip != strip_none)
 788     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 789
 790   free (buf);
 791   link_info.strip = strip_some;
 792   fclose (file);
 793 }
 794 \f
 795 /* Callbacks from the BFD linker routines.  */
 796
 797 /* This is called when BFD has decided to include an archive member in
 798    a link.  */
 799
 800 static bfd_boolean
 801 add_archive_element (struct bfd_link_info *info,
 802                      bfd *abfd,
 803                      const char *name,
 804                      bfd **subsbfd ATTRIBUTE_UNUSED)
 805 {
 806   lang_input_statement_type *input;
 807   lang_input_statement_type *parent;
 808   lang_input_statement_type orig_input;
 809
 810   input = (lang_input_statement_type *)
 811       xcalloc (1, sizeof (lang_input_statement_type));
 812   input->header.type = lang_input_statement_enum;
 813   input->filename = abfd->filename;
 814   input->local_sym_name = abfd->filename;
 815   input->the_bfd = abfd;
 816
 817   parent = abfd->my_archive->usrdata;
 818   if (parent != NULL && !parent->flags.reload)
 819     parent->next = (lang_statement_union_type *) input;
 820
 821   /* Save the original data for trace files/tries below, as plugins
 822      (if enabled) may possibly alter it to point to a replacement
 823      BFD, but we still want to output the original BFD filename.  */
 824   orig_input = *input;
 825 #ifdef ENABLE_PLUGINS
 826   if (link_info.lto_plugin_active)
 827     {
 828       /* We must offer this archive member to the plugins to claim.  */
 829       plugin_maybe_claim (input);
 830       if (input->flags.claimed)
 831         {
 832           if (no_more_claiming)
 833             {
 834               /* Don't claim new IR symbols after all IR symbols have
 835                  been claimed.  */
 836               if (verbose)
 837                 info_msg ("%pI: no new IR symbols to claimi\n",
 838                           &orig_input);
 839               input->flags.claimed = 0;
 840               return FALSE;
 841             }
 842           input->flags.claim_archive = TRUE;
 843           *subsbfd = input->the_bfd;
 844         }
 845     }
 846 #endif /* ENABLE_PLUGINS */
 847
 848   ldlang_add_file (input);
 849
 850   if (config.map_file != NULL)
 851     {
 852       static bfd_boolean header_printed;
 853       struct bfd_link_hash_entry *h;
 854       bfd *from;
 855       int len;
 856
 857       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 858       if (h == NULL
 859           && info->pei386_auto_import
 860           && CONST_STRNEQ (name, "__imp_"))
 861         h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
 862
 863       if (h == NULL)
 864         from = NULL;
 865       else
 866         {
 867           switch (h->type)
 868             {
 869             default:
 870               from = NULL;
 871               break;
 872
 873             case bfd_link_hash_defined:
 874             case bfd_link_hash_defweak:
 875               from = h->u.def.section->owner;
 876               break;
 877
 878             case bfd_link_hash_undefined:
 879             case bfd_link_hash_undefweak:
 880               from = h->u.undef.abfd;
 881               break;
 882
 883             case bfd_link_hash_common:
 884               from = h->u.c.p->section->owner;
 885               break;
 886             }
 887         }
 888
 889       if (!header_printed)
 890         {
 891           minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
 892           header_printed = TRUE;
 893         }
 894
 895       if (abfd->my_archive == NULL
 896           || bfd_is_thin_archive (abfd->my_archive))
 897         {
 898           minfo ("%s", bfd_get_filename (abfd));
 899           len = strlen (bfd_get_filename (abfd));
 900         }
 901       else
 902         {
 903           minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
 904                  bfd_get_filename (abfd));
 905           len = (strlen (bfd_get_filename (abfd->my_archive))
 906                  + strlen (bfd_get_filename (abfd))
 907                  + 2);
 908         }
 909
 910       if (len >= 29)
 911         {
 912           print_nl ();
 913           len = 0;
 914         }
 915       while (len < 30)
 916         {
 917           print_space ();
 918           ++len;
 919         }
 920
 921       if (from != NULL)
 922         minfo ("%pB ", from);
 923       if (h != NULL)
 924         minfo ("(%pT)\n", h->root.string);
 925       else
 926         minfo ("(%s)\n", name);
 927     }
 928
 929   if (verbose
 930       || trace_files > 1
 931       || (trace_files && bfd_is_thin_archive (orig_input.the_bfd->my_archive)))
 932     info_msg ("%pI\n", &orig_input);
 933   return TRUE;
 934 }
 935
 936 /* This is called when BFD has discovered a symbol which is defined
 937    multiple times.  */
 938
 939 static void
 940 multiple_definition (struct bfd_link_info *info,
 941                      struct bfd_link_hash_entry *h,
 942                      bfd *nbfd,
 943                      asection *nsec,
 944                      bfd_vma nval)
 945 {
 946   const char *name;
 947   bfd *obfd;
 948   asection *osec;
 949   bfd_vma oval;
 950
 951   if (info->allow_multiple_definition)
 952     return;
 953
 954   switch (h->type)
 955     {
 956     case bfd_link_hash_defined:
 957       osec = h->u.def.section;
 958       oval = h->u.def.value;
 959       obfd = h->u.def.section->owner;
 960       break;
 961     case bfd_link_hash_indirect:
 962       osec = bfd_ind_section_ptr;
 963       oval = 0;
 964       obfd = NULL;
 965       break;
 966     default:
 967       abort ();
 968     }
 969
 970   /* Ignore a redefinition of an absolute symbol to the
 971      same value; it's harmless.  */
 972   if (h->type == bfd_link_hash_defined
 973       && bfd_is_abs_section (osec)
 974       && bfd_is_abs_section (nsec)
 975       && nval == oval)
 976     return;
 977
 978   /* If either section has the output_section field set to
 979      bfd_abs_section_ptr, it means that the section is being
 980      discarded, and this is not really a multiple definition at all.
 981      FIXME: It would be cleaner to somehow ignore symbols defined in
 982      sections which are being discarded.  */
 983   if (!info->prohibit_multiple_definition_absolute
 984       && ((osec->output_section != NULL
 985            && ! bfd_is_abs_section (osec)
 986            && bfd_is_abs_section (osec->output_section))
 987           || (nsec->output_section != NULL
 988               && !bfd_is_abs_section (nsec)
 989               && bfd_is_abs_section (nsec->output_section))))
 990     return;
 991
 992   name = h->root.string;
 993   if (nbfd == NULL)
 994     {
 995       nbfd = obfd;
 996       nsec = osec;
 997       nval = oval;
 998       obfd = NULL;
 999     }
1000   einfo (_("%X%P: %C: multiple definition of `%pT'"),
1001          nbfd, nsec, nval, name);
1002   if (obfd != NULL)
1003     einfo (_("; %D: first defined here"), obfd, osec, oval);
1004   einfo ("\n");
1005
1006   if (RELAXATION_ENABLED_BY_USER)
1007     {
1008       einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1009       DISABLE_RELAXATION;
1010     }
1011 }
1012
1013 /* This is called when there is a definition of a common symbol, or
1014    when a common symbol is found for a symbol that is already defined,
1015    or when two common symbols are found.  We only do something if
1016    -warn-common was used.  */
1017
1018 static void
1019 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1020                  struct bfd_link_hash_entry *h,
1021                  bfd *nbfd,
1022                  enum bfd_link_hash_type ntype,
1023                  bfd_vma nsize)
1024 {
1025   const char *name;
1026   bfd *obfd;
1027   enum bfd_link_hash_type otype;
1028   bfd_vma osize;
1029
1030   if (!config.warn_common)
1031     return;
1032
1033   name = h->root.string;
1034   otype = h->type;
1035   if (otype == bfd_link_hash_common)
1036     {
1037       obfd = h->u.c.p->section->owner;
1038       osize = h->u.c.size;
1039     }
1040   else if (otype == bfd_link_hash_defined
1041            || otype == bfd_link_hash_defweak)
1042     {
1043       obfd = h->u.def.section->owner;
1044       osize = 0;
1045     }
1046   else
1047     {
1048       /* FIXME: It would nice if we could report the BFD which defined
1049          an indirect symbol, but we don't have anywhere to store the
1050          information.  */
1051       obfd = NULL;
1052       osize = 0;
1053     }
1054
1055   if (ntype == bfd_link_hash_defined
1056       || ntype == bfd_link_hash_defweak
1057       || ntype == bfd_link_hash_indirect)
1058     {
1059       ASSERT (otype == bfd_link_hash_common);
1060       if (obfd != NULL)
1061         einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1062                  " from %pB\n"),
1063                nbfd, name, obfd);
1064       else
1065         einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1066                nbfd, name);
1067     }
1068   else if (otype == bfd_link_hash_defined
1069            || otype == bfd_link_hash_defweak
1070            || otype == bfd_link_hash_indirect)
1071     {
1072       ASSERT (ntype == bfd_link_hash_common);
1073       if (obfd != NULL)
1074         einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1075                  " from %pB\n"),
1076                nbfd, name, obfd);
1077       else
1078         einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1079                nbfd, name);
1080     }
1081   else
1082     {
1083       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1084       if (osize > nsize)
1085         {
1086           if (obfd != NULL)
1087             einfo (_("%P: %pB: warning: common of `%pT' overridden"
1088                      " by larger common from %pB\n"),
1089                    nbfd, name, obfd);
1090           else
1091             einfo (_("%P: %pB: warning: common of `%pT' overridden"
1092                      " by larger common\n"),
1093                    nbfd, name);
1094         }
1095       else if (nsize > osize)
1096         {
1097           if (obfd != NULL)
1098             einfo (_("%P: %pB: warning: common of `%pT' overriding"
1099                      " smaller common from %pB\n"),
1100                    nbfd, name, obfd);
1101           else
1102             einfo (_("%P: %pB: warning: common of `%pT' overriding"
1103                      " smaller common\n"),
1104                    nbfd, name);
1105         }
1106       else
1107         {
1108           if (obfd != NULL)
1109             einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1110                    nbfd, obfd, name);
1111           else
1112             einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1113                    nbfd, name);
1114         }
1115     }
1116 }
1117
1118 /* This is called when BFD has discovered a set element.  H is the
1119    entry in the linker hash table for the set.  SECTION and VALUE
1120    represent a value which should be added to the set.  */
1121
1122 static void
1123 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1124             struct bfd_link_hash_entry *h,
1125             bfd_reloc_code_real_type reloc,
1126             bfd *abfd,
1127             asection *section,
1128             bfd_vma value)
1129 {
1130   if (config.warn_constructors)
1131     einfo (_("%P: warning: global constructor %s used\n"),
1132            h->root.string);
1133
1134   if (!config.build_constructors)
1135     return;
1136
1137   ldctor_add_set_entry (h, reloc, NULL, section, value);
1138
1139   if (h->type == bfd_link_hash_new)
1140     {
1141       h->type = bfd_link_hash_undefined;
1142       h->u.undef.abfd = abfd;
1143       /* We don't call bfd_link_add_undef to add this to the list of
1144          undefined symbols because we are going to define it
1145          ourselves.  */
1146     }
1147 }
1148
1149 /* This is called when BFD has discovered a constructor.  This is only
1150    called for some object file formats--those which do not handle
1151    constructors in some more clever fashion.  This is similar to
1152    adding an element to a set, but less general.  */
1153
1154 static void
1155 constructor_callback (struct bfd_link_info *info,
1156                       bfd_boolean constructor,
1157                       const char *name,
1158                       bfd *abfd,
1159                       asection *section,
1160                       bfd_vma value)
1161 {
1162   char *s;
1163   struct bfd_link_hash_entry *h;
1164   char set_name[1 + sizeof "__CTOR_LIST__"];
1165
1166   if (config.warn_constructors)
1167     einfo (_("%P: warning: global constructor %s used\n"), name);
1168
1169   if (!config.build_constructors)
1170     return;
1171
1172   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1173      useful error message.  */
1174   if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1175       && (bfd_link_relocatable (info)
1176           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1177     einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1178
1179   s = set_name;
1180   if (bfd_get_symbol_leading_char (abfd) != '\0')
1181     *s++ = bfd_get_symbol_leading_char (abfd);
1182   if (constructor)
1183     strcpy (s, "__CTOR_LIST__");
1184   else
1185     strcpy (s, "__DTOR_LIST__");
1186
1187   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1188   if (h == (struct bfd_link_hash_entry *) NULL)
1189     einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1190   if (h->type == bfd_link_hash_new)
1191     {
1192       h->type = bfd_link_hash_undefined;
1193       h->u.undef.abfd = abfd;
1194       /* We don't call bfd_link_add_undef to add this to the list of
1195          undefined symbols because we are going to define it
1196          ourselves.  */
1197     }
1198
1199   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1200 }
1201
1202 /* A structure used by warning_callback to pass information through
1203    bfd_map_over_sections.  */
1204
1205 struct warning_callback_info
1206 {
1207   bfd_boolean found;
1208   const char *warning;
1209   const char *symbol;
1210   asymbol **asymbols;
1211 };
1212
1213 /* Look through the relocs to see if we can find a plausible address
1214    for SYMBOL in ABFD.  Return TRUE if found.  Otherwise return FALSE.  */
1215
1216 static bfd_boolean
1217 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1218 {
1219   struct warning_callback_info cinfo;
1220
1221   if (!bfd_generic_link_read_symbols (abfd))
1222     einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
1223
1224   cinfo.found = FALSE;
1225   cinfo.warning = warning;
1226   cinfo.symbol = symbol;
1227   cinfo.asymbols = bfd_get_outsymbols (abfd);
1228   bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1229   return cinfo.found;
1230 }
1231
1232 /* This is called when there is a reference to a warning symbol.  */
1233
1234 static void
1235 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1236                   const char *warning,
1237                   const char *symbol,
1238                   bfd *abfd,
1239                   asection *section,
1240                   bfd_vma address)
1241 {
1242   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1243      have a cleaner interface, but what?  */
1244   if (!config.warn_multiple_gp
1245       && strcmp (warning, "using multiple gp values") == 0)
1246     return;
1247
1248   if (section != NULL)
1249     einfo ("%P: %C: %s%s\n", abfd, section, address, _("warning: "), warning);
1250   else if (abfd == NULL)
1251     einfo ("%P: %s%s\n", _("warning: "), warning);
1252   else if (symbol == NULL)
1253     einfo ("%P: %pB: %s%s\n", abfd, _("warning: "), warning);
1254   else if (!symbol_warning (warning, symbol, abfd))
1255     {
1256       bfd *b;
1257       /* Search all input files for a reference to SYMBOL.  */
1258       for (b = info->input_bfds; b; b = b->link.next)
1259         if (b != abfd && symbol_warning (warning, symbol, b))
1260           return;
1261       einfo ("%P: %pB: %s%s\n", abfd, _("warning: "), warning);
1262     }
1263 }
1264
1265 /* This is called by warning_callback for each section.  It checks the
1266    relocs of the section to see if it can find a reference to the
1267    symbol which triggered the warning.  If it can, it uses the reloc
1268    to give an error message with a file and line number.  */
1269
1270 static void
1271 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1272 {
1273   struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1274   long relsize;
1275   arelent **relpp;
1276   long relcount;
1277   arelent **p, **pend;
1278
1279   if (info->found)
1280     return;
1281
1282   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1283   if (relsize < 0)
1284     einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
1285   if (relsize == 0)
1286     return;
1287
1288   relpp = (arelent **) xmalloc (relsize);
1289   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1290   if (relcount < 0)
1291     einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
1292
1293   p = relpp;
1294   pend = p + relcount;
1295   for (; p < pend && *p != NULL; p++)
1296     {
1297       arelent *q = *p;
1298
1299       if (q->sym_ptr_ptr != NULL
1300           && *q->sym_ptr_ptr != NULL
1301           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1302         {
1303           /* We found a reloc for the symbol we are looking for.  */
1304           einfo ("%P: %C: %s%s\n", abfd, sec, q->address, _("warning: "),
1305                  info->warning);
1306           info->found = TRUE;
1307           break;
1308         }
1309     }
1310
1311   free (relpp);
1312 }
1313
1314 /* This is called when an undefined symbol is found.  */
1315
1316 static void
1317 undefined_symbol (struct bfd_link_info *info,
1318                   const char *name,
1319                   bfd *abfd,
1320                   asection *section,
1321                   bfd_vma address,
1322                   bfd_boolean error)
1323 {
1324   static char *error_name;
1325   static unsigned int error_count;
1326
1327 #define MAX_ERRORS_IN_A_ROW 5
1328
1329   if (info->ignore_hash != NULL
1330       && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1331     return;
1332
1333   if (config.warn_once)
1334     {
1335       /* Only warn once about a particular undefined symbol.  */
1336       add_ignoresym (info, name);
1337     }
1338
1339   /* We never print more than a reasonable number of errors in a row
1340      for a single symbol.  */
1341   if (error_name != NULL
1342       && strcmp (name, error_name) == 0)
1343     ++error_count;
1344   else
1345     {
1346       error_count = 0;
1347       if (error_name != NULL)
1348         free (error_name);
1349       error_name = xstrdup (name);
1350     }
1351
1352   if (section != NULL)
1353     {
1354       if (error_count < MAX_ERRORS_IN_A_ROW)
1355         {
1356           if (error)
1357             einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1358                    abfd, section, address, name);
1359           else
1360             einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1361                    abfd, section, address, name);
1362         }
1363       else if (error_count == MAX_ERRORS_IN_A_ROW)
1364         {
1365           if (error)
1366             einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1367                    abfd, section, address, name);
1368           else
1369             einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1370                    abfd, section, address, name);
1371         }
1372       else if (error)
1373         einfo ("%X");
1374     }
1375   else
1376     {
1377       if (error_count < MAX_ERRORS_IN_A_ROW)
1378         {
1379           if (error)
1380             einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1381                    abfd, name);
1382           else
1383             einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1384                    abfd, name);
1385         }
1386       else if (error_count == MAX_ERRORS_IN_A_ROW)
1387         {
1388           if (error)
1389             einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1390                    abfd, name);
1391           else
1392             einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1393                    abfd, name);
1394         }
1395       else if (error)
1396         einfo ("%X");
1397     }
1398 }
1399
1400 /* Counter to limit the number of relocation overflow error messages
1401    to print.  Errors are printed as it is decremented.  When it's
1402    called and the counter is zero, a final message is printed
1403    indicating more relocations were omitted.  When it gets to -1, no
1404    such errors are printed.  If it's initially set to a value less
1405    than -1, all such errors will be printed (--verbose does this).  */
1406
1407 int overflow_cutoff_limit = 10;
1408
1409 /* This is called when a reloc overflows.  */
1410
1411 static void
1412 reloc_overflow (struct bfd_link_info *info,
1413                 struct bfd_link_hash_entry *entry,
1414                 const char *name,
1415                 const char *reloc_name,
1416                 bfd_vma addend,
1417                 bfd *abfd,
1418                 asection *section,
1419                 bfd_vma address)
1420 {
1421   if (overflow_cutoff_limit == -1)
1422     return;
1423
1424   einfo ("%X%H:", abfd, section, address);
1425
1426   if (overflow_cutoff_limit >= 0
1427       && overflow_cutoff_limit-- == 0)
1428     {
1429       einfo (_(" additional relocation overflows omitted from the output\n"));
1430       return;
1431     }
1432
1433   if (entry)
1434     {
1435       while (entry->type == bfd_link_hash_indirect
1436              || entry->type == bfd_link_hash_warning)
1437         entry = entry->u.i.link;
1438       switch (entry->type)
1439         {
1440         case bfd_link_hash_undefined:
1441         case bfd_link_hash_undefweak:
1442           einfo (_(" relocation truncated to fit: "
1443                    "%s against undefined symbol `%pT'"),
1444                  reloc_name, entry->root.string);
1445           break;
1446         case bfd_link_hash_defined:
1447         case bfd_link_hash_defweak:
1448           einfo (_(" relocation truncated to fit: "
1449                    "%s against symbol `%pT' defined in %pA section in %pB"),
1450                  reloc_name, entry->root.string,
1451                  entry->u.def.section,
1452                  entry->u.def.section == bfd_abs_section_ptr
1453                  ? info->output_bfd : entry->u.def.section->owner);
1454           break;
1455         default:
1456           abort ();
1457           break;
1458         }
1459     }
1460   else
1461     einfo (_(" relocation truncated to fit: %s against `%pT'"),
1462            reloc_name, name);
1463   if (addend != 0)
1464     einfo ("+%v", addend);
1465   einfo ("\n");
1466 }
1467
1468 /* This is called when a dangerous relocation is made.  */
1469
1470 static void
1471 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1472                  const char *message,
1473                  bfd *abfd,
1474                  asection *section,
1475                  bfd_vma address)
1476 {
1477   einfo (_("%X%H: dangerous relocation: %s\n"),
1478          abfd, section, address, message);
1479 }
1480
1481 /* This is called when a reloc is being generated attached to a symbol
1482    that is not being output.  */
1483
1484 static void
1485 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1486                   const char *name,
1487                   bfd *abfd,
1488                   asection *section,
1489                   bfd_vma address)
1490 {
1491   einfo (_("%X%H: reloc refers to symbol `%pT' which is not being output\n"),
1492          abfd, section, address, name);
1493 }
1494
1495 /* This is called if link_info.notice_all is set, or when a symbol in
1496    link_info.notice_hash is found.  Symbols are put in notice_hash
1497    using the -y option, while notice_all is set if the --cref option
1498    has been supplied, or if there are any NOCROSSREFS sections in the
1499    linker script; and if plugins are active, since they need to monitor
1500    all references from non-IR files.  */
1501
1502 static bfd_boolean
1503 notice (struct bfd_link_info *info,
1504         struct bfd_link_hash_entry *h,
1505         struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1506         bfd *abfd,
1507         asection *section,
1508         bfd_vma value,
1509         flagword flags ATTRIBUTE_UNUSED)
1510 {
1511   const char *name;
1512
1513   if (h == NULL)
1514     {
1515       if (command_line.cref || nocrossref_list != NULL)
1516         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1517       return TRUE;
1518     }
1519
1520   name = h->root.string;
1521   if (info->notice_hash != NULL
1522       && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1523     {
1524       if (bfd_is_und_section (section))
1525         einfo (_("%P: %pB: reference to %s\n"), abfd, name);
1526       else
1527         einfo (_("%P: %pB: definition of %s\n"), abfd, name);
1528     }
1529
1530   if (command_line.cref || nocrossref_list != NULL)
1531     add_cref (name, abfd, section, value);
1532
1533   return TRUE;
1534 }