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