ld/ldmain.c

   1 /* Main program of GNU linker.
   2    Copyright (C) 1991-2018 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain steve@cygnus.com
   4
   5    This file is part of the GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "safe-ctype.h"
  25 #include "libiberty.h"
  26 #include "progress.h"
  27 #include "bfdlink.h"
  28 #include "filenames.h"
  29
  30 #include "ld.h"
  31 #include "ldmain.h"
  32 #include "ldmisc.h"
  33 #include "ldwrite.h"
  34 #include "ldexp.h"
  35 #include "ldlang.h"
  36 #include <ldgram.h>
  37 #include "ldlex.h"
  38 #include "ldfile.h"
  39 #include "ldemul.h"
  40 #include "ldctor.h"
  41 #ifdef ENABLE_PLUGINS
  42 #include "plugin.h"
  43 #include "plugin-api.h"
  44 #endif /* ENABLE_PLUGINS */
  45
  46 /* Somewhere above, sys/stat.h got included.  */
  47 #if !defined(S_ISDIR) && defined(S_IFDIR)
  48 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  49 #endif
  50
  51 #include <string.h>
  52
  53 #ifndef TARGET_SYSTEM_ROOT
  54 #define TARGET_SYSTEM_ROOT ""
  55 #endif
  56
  57 /* EXPORTS */
  58
  59 FILE *saved_script_handle = NULL;
  60 FILE *previous_script_handle = NULL;
  61 bfd_boolean force_make_executable = FALSE;
  62
  63 char *default_target;
  64 const char *output_filename = "a.out";
  65
  66 /* Name this program was invoked by.  */
  67 char *program_name;
  68
  69 /* The prefix for system library directories.  */
  70 const char *ld_sysroot;
  71
  72 /* The canonical representation of ld_sysroot.  */
  73 char *ld_canon_sysroot;
  74 int ld_canon_sysroot_len;
  75
  76 /* Set by -G argument, for targets like MIPS ELF.  */
  77 int g_switch_value = 8;
  78
  79 /* Nonzero means print names of input files as processed.  */
  80 bfd_boolean trace_files;
  81
  82 /* Nonzero means report actions taken by the linker, and describe the linker script in use.  */
  83 bfd_boolean verbose;
  84
  85 /* Nonzero means version number was printed, so exit successfully
  86    instead of complaining if no input files are given.  */
  87 bfd_boolean version_printed;
  88
  89 /* TRUE if we should demangle symbol names.  */
  90 bfd_boolean demangling;
  91
  92 args_type command_line;
  93
  94 ld_config_type config;
  95
  96 sort_type sort_section;
  97
  98 static const char *get_sysroot
  99   (int, char **);
 100 static char *get_emulation
 101   (int, char **);
 102 static bfd_boolean add_archive_element
 103   (struct bfd_link_info *, bfd *, const char *, bfd **);
 104 static void multiple_definition
 105   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 106    bfd *, asection *, bfd_vma);
 107 static void multiple_common
 108   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 109    bfd *, enum bfd_link_hash_type, bfd_vma);
 110 static void add_to_set
 111   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 112    bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
 113 static void constructor_callback
 114   (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
 115    asection *, bfd_vma);
 116 static void warning_callback
 117   (struct bfd_link_info *, const char *, const char *, bfd *,
 118    asection *, bfd_vma);
 119 static void warning_find_reloc
 120   (bfd *, asection *, void *);
 121 static void undefined_symbol
 122   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 123    bfd_boolean);
 124 static void reloc_overflow
 125   (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
 126    const char *, bfd_vma, bfd *, asection *, bfd_vma);
 127 static void reloc_dangerous
 128   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 129 static void unattached_reloc
 130   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 131 static bfd_boolean notice
 132   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 133    struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
 134
 135 static struct bfd_link_callbacks link_callbacks =
 136 {
 137   add_archive_element,
 138   multiple_definition,
 139   multiple_common,
 140   add_to_set,
 141   constructor_callback,
 142   warning_callback,
 143   undefined_symbol,
 144   reloc_overflow,
 145   reloc_dangerous,
 146   unattached_reloc,
 147   notice,
 148   einfo,
 149   info_msg,
 150   minfo,
 151   ldlang_override_segment_assignment
 152 };
 153
 154 static bfd_assert_handler_type default_bfd_assert_handler;
 155 static bfd_error_handler_type default_bfd_error_handler;
 156
 157 struct bfd_link_info link_info;
 158 \f
 159 static void
 160 ld_cleanup (void)
 161 {
 162   bfd_cache_close_all ();
 163 #ifdef ENABLE_PLUGINS
 164   plugin_call_cleanup ();
 165 #endif
 166   if (output_filename && delete_output_file_on_failure)
 167     unlink_if_ordinary (output_filename);
 168 }
 169
 170 /* Hook to notice BFD assertions.  */
 171
 172 static void
 173 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
 174                        const char *file, int line)
 175 {
 176   config.make_executable = FALSE;
 177   (*default_bfd_assert_handler) (fmt, bfdver, file, line);
 178 }
 179
 180 /* Hook the bfd error/warning handler for --fatal-warnings.  */
 181
 182 static void
 183 ld_bfd_error_handler (const char *fmt, va_list ap)
 184 {
 185   if (config.fatal_warnings)
 186     config.make_executable = FALSE;
 187   (*default_bfd_error_handler) (fmt, ap);
 188 }
 189
 190 int
 191 main (int argc, char **argv)
 192 {
 193   char *emulation;
 194   long start_time = get_run_time ();
 195
 196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 197   setlocale (LC_MESSAGES, "");
 198 #endif
 199 #if defined (HAVE_SETLOCALE)
 200   setlocale (LC_CTYPE, "");
 201 #endif
 202   bindtextdomain (PACKAGE, LOCALEDIR);
 203   textdomain (PACKAGE);
 204
 205   program_name = argv[0];
 206   xmalloc_set_program_name (program_name);
 207
 208   START_PROGRESS (program_name, 0);
 209
 210   expandargv (&argc, &argv);
 211
 212   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 (trace_files || verbose)
 930     info_msg ("%pI\n", &orig_input);
 931   return TRUE;
 932 }
 933
 934 /* This is called when BFD has discovered a symbol which is defined
 935    multiple times.  */
 936
 937 static void
 938 multiple_definition (struct bfd_link_info *info,
 939                      struct bfd_link_hash_entry *h,
 940                      bfd *nbfd,
 941                      asection *nsec,
 942                      bfd_vma nval)
 943 {
 944   const char *name;
 945   bfd *obfd;
 946   asection *osec;
 947   bfd_vma oval;
 948
 949   if (info->allow_multiple_definition)
 950     return;
 951
 952   switch (h->type)
 953     {
 954     case bfd_link_hash_defined:
 955       osec = h->u.def.section;
 956       oval = h->u.def.value;
 957       obfd = h->u.def.section->owner;
 958       break;
 959     case bfd_link_hash_indirect:
 960       osec = bfd_ind_section_ptr;
 961       oval = 0;
 962       obfd = NULL;
 963       break;
 964     default:
 965       abort ();
 966     }
 967
 968   /* Ignore a redefinition of an absolute symbol to the
 969      same value; it's harmless.  */
 970   if (h->type == bfd_link_hash_defined
 971       && bfd_is_abs_section (osec)
 972       && bfd_is_abs_section (nsec)
 973       && nval == oval)
 974     return;
 975
 976   /* If either section has the output_section field set to
 977      bfd_abs_section_ptr, it means that the section is being
 978      discarded, and this is not really a multiple definition at all.
 979      FIXME: It would be cleaner to somehow ignore symbols defined in
 980      sections which are being discarded.  */
 981   if (!info->prohibit_multiple_definition_absolute
 982       && ((osec->output_section != NULL
 983            && ! bfd_is_abs_section (osec)
 984            && bfd_is_abs_section (osec->output_section))
 985           || (nsec->output_section != NULL
 986               && !bfd_is_abs_section (nsec)
 987               && bfd_is_abs_section (nsec->output_section))))
 988     return;
 989
 990   name = h->root.string;
 991   if (nbfd == NULL)
 992     {
 993       nbfd = obfd;
 994       nsec = osec;
 995       nval = oval;
 996       obfd = NULL;
 997     }
 998   einfo (_("%X%P: %C: multiple definition of `%pT'"),
 999          nbfd, nsec, nval, name);
1000   if (obfd != NULL)
1001     einfo (_("; %D: first defined here"), obfd, osec, oval);
1002   einfo ("\n");
1003
1004   if (RELAXATION_ENABLED_BY_USER)
1005     {
1006       einfo (_("%P: disabling relaxation; it will not work with multiple definitions\n"));
1007       DISABLE_RELAXATION;
1008     }
1009 }
1010
1011 /* This is called when there is a definition of a common symbol, or
1012    when a common symbol is found for a symbol that is already defined,
1013    or when two common symbols are found.  We only do something if
1014    -warn-common was used.  */
1015
1016 static void
1017 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1018                  struct bfd_link_hash_entry *h,
1019                  bfd *nbfd,
1020                  enum bfd_link_hash_type ntype,
1021                  bfd_vma nsize)
1022 {
1023   const char *name;
1024   bfd *obfd;
1025   enum bfd_link_hash_type otype;
1026   bfd_vma osize;
1027
1028   if (!config.warn_common)
1029     return;
1030
1031   name = h->root.string;
1032   otype = h->type;
1033   if (otype == bfd_link_hash_common)
1034     {
1035       obfd = h->u.c.p->section->owner;
1036       osize = h->u.c.size;
1037     }
1038   else if (otype == bfd_link_hash_defined
1039            || otype == bfd_link_hash_defweak)
1040     {
1041       obfd = h->u.def.section->owner;
1042       osize = 0;
1043     }
1044   else
1045     {
1046       /* FIXME: It would nice if we could report the BFD which defined
1047          an indirect symbol, but we don't have anywhere to store the
1048          information.  */
1049       obfd = NULL;
1050       osize = 0;
1051     }
1052
1053   if (ntype == bfd_link_hash_defined
1054       || ntype == bfd_link_hash_defweak
1055       || ntype == bfd_link_hash_indirect)
1056     {
1057       ASSERT (otype == bfd_link_hash_common);
1058       if (obfd != NULL)
1059         einfo (_("%P: %pB: warning: definition of `%pT' overriding common"
1060                  " from %pB\n"),
1061                nbfd, name, obfd);
1062       else
1063         einfo (_("%P: %pB: warning: definition of `%pT' overriding common\n"),
1064                nbfd, name);
1065     }
1066   else if (otype == bfd_link_hash_defined
1067            || otype == bfd_link_hash_defweak
1068            || otype == bfd_link_hash_indirect)
1069     {
1070       ASSERT (ntype == bfd_link_hash_common);
1071       if (obfd != NULL)
1072         einfo (_("%P: %pB: warning: common of `%pT' overridden by definition"
1073                  " from %pB\n"),
1074                nbfd, name, obfd);
1075       else
1076         einfo (_("%P: %pB: warning: common of `%pT' overridden by definition\n"),
1077                nbfd, name);
1078     }
1079   else
1080     {
1081       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1082       if (osize > nsize)
1083         {
1084           if (obfd != NULL)
1085             einfo (_("%P: %pB: warning: common of `%pT' overridden"
1086                      " by larger common from %pB\n"),
1087                    nbfd, name, obfd);
1088           else
1089             einfo (_("%P: %pB: warning: common of `%pT' overridden"
1090                      " by larger common\n"),
1091                    nbfd, name);
1092         }
1093       else if (nsize > osize)
1094         {
1095           if (obfd != NULL)
1096             einfo (_("%P: %pB: warning: common of `%pT' overriding"
1097                      " smaller common from %pB\n"),
1098                    nbfd, name, obfd);
1099           else
1100             einfo (_("%P: %pB: warning: common of `%pT' overriding"
1101                      " smaller common\n"),
1102                    nbfd, name);
1103         }
1104       else
1105         {
1106           if (obfd != NULL)
1107             einfo (_("%P: %pB and %pB: warning: multiple common of `%pT'\n"),
1108                    nbfd, obfd, name);
1109           else
1110             einfo (_("%P: %pB: warning: multiple common of `%pT'\n"),
1111                    nbfd, name);
1112         }
1113     }
1114 }
1115
1116 /* This is called when BFD has discovered a set element.  H is the
1117    entry in the linker hash table for the set.  SECTION and VALUE
1118    represent a value which should be added to the set.  */
1119
1120 static void
1121 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1122             struct bfd_link_hash_entry *h,
1123             bfd_reloc_code_real_type reloc,
1124             bfd *abfd,
1125             asection *section,
1126             bfd_vma value)
1127 {
1128   if (config.warn_constructors)
1129     einfo (_("%P: warning: global constructor %s used\n"),
1130            h->root.string);
1131
1132   if (!config.build_constructors)
1133     return;
1134
1135   ldctor_add_set_entry (h, reloc, NULL, section, value);
1136
1137   if (h->type == bfd_link_hash_new)
1138     {
1139       h->type = bfd_link_hash_undefined;
1140       h->u.undef.abfd = abfd;
1141       /* We don't call bfd_link_add_undef to add this to the list of
1142          undefined symbols because we are going to define it
1143          ourselves.  */
1144     }
1145 }
1146
1147 /* This is called when BFD has discovered a constructor.  This is only
1148    called for some object file formats--those which do not handle
1149    constructors in some more clever fashion.  This is similar to
1150    adding an element to a set, but less general.  */
1151
1152 static void
1153 constructor_callback (struct bfd_link_info *info,
1154                       bfd_boolean constructor,
1155                       const char *name,
1156                       bfd *abfd,
1157                       asection *section,
1158                       bfd_vma value)
1159 {
1160   char *s;
1161   struct bfd_link_hash_entry *h;
1162   char set_name[1 + sizeof "__CTOR_LIST__"];
1163
1164   if (config.warn_constructors)
1165     einfo (_("%P: warning: global constructor %s used\n"), name);
1166
1167   if (!config.build_constructors)
1168     return;
1169
1170   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1171      useful error message.  */
1172   if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1173       && (bfd_link_relocatable (info)
1174           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1175     einfo (_("%F%P: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1176
1177   s = set_name;
1178   if (bfd_get_symbol_leading_char (abfd) != '\0')
1179     *s++ = bfd_get_symbol_leading_char (abfd);
1180   if (constructor)
1181     strcpy (s, "__CTOR_LIST__");
1182   else
1183     strcpy (s, "__DTOR_LIST__");
1184
1185   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1186   if (h == (struct bfd_link_hash_entry *) NULL)
1187     einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1188   if (h->type == bfd_link_hash_new)
1189     {
1190       h->type = bfd_link_hash_undefined;
1191       h->u.undef.abfd = abfd;
1192       /* We don't call bfd_link_add_undef to add this to the list of
1193          undefined symbols because we are going to define it
1194          ourselves.  */
1195     }
1196
1197   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1198 }
1199
1200 /* A structure used by warning_callback to pass information through
1201    bfd_map_over_sections.  */
1202
1203 struct warning_callback_info
1204 {
1205   bfd_boolean found;
1206   const char *warning;
1207   const char *symbol;
1208   asymbol **asymbols;
1209 };
1210
1211 /* Look through the relocs to see if we can find a plausible address
1212    for SYMBOL in ABFD.  Return TRUE if found.  Otherwise return FALSE.  */
1213
1214 static bfd_boolean
1215 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1216 {
1217   struct warning_callback_info cinfo;
1218
1219   if (!bfd_generic_link_read_symbols (abfd))
1220     einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
1221
1222   cinfo.found = FALSE;
1223   cinfo.warning = warning;
1224   cinfo.symbol = symbol;
1225   cinfo.asymbols = bfd_get_outsymbols (abfd);
1226   bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1227   return cinfo.found;
1228 }
1229
1230 /* This is called when there is a reference to a warning symbol.  */
1231
1232 static void
1233 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1234                   const char *warning,
1235                   const char *symbol,
1236                   bfd *abfd,
1237                   asection *section,
1238                   bfd_vma address)
1239 {
1240   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1241      have a cleaner interface, but what?  */
1242   if (!config.warn_multiple_gp
1243       && strcmp (warning, "using multiple gp values") == 0)
1244     return;
1245
1246   if (section != NULL)
1247     einfo ("%P: %C: %s%s\n", abfd, section, address, _("warning: "), warning);
1248   else if (abfd == NULL)
1249     einfo ("%P: %s%s\n", _("warning: "), warning);
1250   else if (symbol == NULL)
1251     einfo ("%P: %pB: %s%s\n", abfd, _("warning: "), warning);
1252   else if (!symbol_warning (warning, symbol, abfd))
1253     {
1254       bfd *b;
1255       /* Search all input files for a reference to SYMBOL.  */
1256       for (b = info->input_bfds; b; b = b->link.next)
1257         if (b != abfd && symbol_warning (warning, symbol, b))
1258           return;
1259       einfo ("%P: %pB: %s%s\n", abfd, _("warning: "), warning);
1260     }
1261 }
1262
1263 /* This is called by warning_callback for each section.  It checks the
1264    relocs of the section to see if it can find a reference to the
1265    symbol which triggered the warning.  If it can, it uses the reloc
1266    to give an error message with a file and line number.  */
1267
1268 static void
1269 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1270 {
1271   struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1272   long relsize;
1273   arelent **relpp;
1274   long relcount;
1275   arelent **p, **pend;
1276
1277   if (info->found)
1278     return;
1279
1280   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1281   if (relsize < 0)
1282     einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
1283   if (relsize == 0)
1284     return;
1285
1286   relpp = (arelent **) xmalloc (relsize);
1287   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1288   if (relcount < 0)
1289     einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
1290
1291   p = relpp;
1292   pend = p + relcount;
1293   for (; p < pend && *p != NULL; p++)
1294     {
1295       arelent *q = *p;
1296
1297       if (q->sym_ptr_ptr != NULL
1298           && *q->sym_ptr_ptr != NULL
1299           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1300         {
1301           /* We found a reloc for the symbol we are looking for.  */
1302           einfo ("%P: %C: %s%s\n", abfd, sec, q->address, _("warning: "),
1303                  info->warning);
1304           info->found = TRUE;
1305           break;
1306         }
1307     }
1308
1309   free (relpp);
1310 }
1311
1312 /* This is called when an undefined symbol is found.  */
1313
1314 static void
1315 undefined_symbol (struct bfd_link_info *info,
1316                   const char *name,
1317                   bfd *abfd,
1318                   asection *section,
1319                   bfd_vma address,
1320                   bfd_boolean error)
1321 {
1322   static char *error_name;
1323   static unsigned int error_count;
1324
1325 #define MAX_ERRORS_IN_A_ROW 5
1326
1327   if (info->ignore_hash != NULL
1328       && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1329     return;
1330
1331   if (config.warn_once)
1332     {
1333       /* Only warn once about a particular undefined symbol.  */
1334       add_ignoresym (info, name);
1335     }
1336
1337   /* We never print more than a reasonable number of errors in a row
1338      for a single symbol.  */
1339   if (error_name != NULL
1340       && strcmp (name, error_name) == 0)
1341     ++error_count;
1342   else
1343     {
1344       error_count = 0;
1345       if (error_name != NULL)
1346         free (error_name);
1347       error_name = xstrdup (name);
1348     }
1349
1350   if (section != NULL)
1351     {
1352       if (error_count < MAX_ERRORS_IN_A_ROW)
1353         {
1354           if (error)
1355             einfo (_("%X%P: %C: undefined reference to `%pT'\n"),
1356                    abfd, section, address, name);
1357           else
1358             einfo (_("%P: %C: warning: undefined reference to `%pT'\n"),
1359                    abfd, section, address, name);
1360         }
1361       else if (error_count == MAX_ERRORS_IN_A_ROW)
1362         {
1363           if (error)
1364             einfo (_("%X%P: %D: more undefined references to `%pT' follow\n"),
1365                    abfd, section, address, name);
1366           else
1367             einfo (_("%P: %D: warning: more undefined references to `%pT' follow\n"),
1368                    abfd, section, address, name);
1369         }
1370       else if (error)
1371         einfo ("%X");
1372     }
1373   else
1374     {
1375       if (error_count < MAX_ERRORS_IN_A_ROW)
1376         {
1377           if (error)
1378             einfo (_("%X%P: %pB: undefined reference to `%pT'\n"),
1379                    abfd, name);
1380           else
1381             einfo (_("%P: %pB: warning: undefined reference to `%pT'\n"),
1382                    abfd, name);
1383         }
1384       else if (error_count == MAX_ERRORS_IN_A_ROW)
1385         {
1386           if (error)
1387             einfo (_("%X%P: %pB: more undefined references to `%pT' follow\n"),
1388                    abfd, name);
1389           else
1390             einfo (_("%P: %pB: warning: more undefined references to `%pT' follow\n"),
1391                    abfd, name);
1392         }
1393       else if (error)
1394         einfo ("%X");
1395     }
1396 }
1397
1398 /* Counter to limit the number of relocation overflow error messages
1399    to print.  Errors are printed as it is decremented.  When it's
1400    called and the counter is zero, a final message is printed
1401    indicating more relocations were omitted.  When it gets to -1, no
1402    such errors are printed.  If it's initially set to a value less
1403    than -1, all such errors will be printed (--verbose does this).  */
1404
1405 int overflow_cutoff_limit = 10;
1406
1407 /* This is called when a reloc overflows.  */
1408
1409 static void
1410 reloc_overflow (struct bfd_link_info *info,
1411                 struct bfd_link_hash_entry *entry,
1412                 const char *name,
1413                 const char *reloc_name,
1414                 bfd_vma addend,
1415                 bfd *abfd,
1416                 asection *section,
1417                 bfd_vma address)
1418 {
1419   if (overflow_cutoff_limit == -1)
1420     return;
1421
1422   einfo ("%X%P: %H:", abfd, section, address);
1423
1424   if (overflow_cutoff_limit >= 0
1425       && overflow_cutoff_limit-- == 0)
1426     {
1427       einfo (_(" additional relocation overflows omitted from the output\n"));
1428       return;
1429     }
1430
1431   if (entry)
1432     {
1433       while (entry->type == bfd_link_hash_indirect
1434              || entry->type == bfd_link_hash_warning)
1435         entry = entry->u.i.link;
1436       switch (entry->type)
1437         {
1438         case bfd_link_hash_undefined:
1439         case bfd_link_hash_undefweak:
1440           einfo (_(" relocation truncated to fit: "
1441                    "%s against undefined symbol `%pT'"),
1442                  reloc_name, entry->root.string);
1443           break;
1444         case bfd_link_hash_defined:
1445         case bfd_link_hash_defweak:
1446           einfo (_(" relocation truncated to fit: "
1447                    "%s against symbol `%pT' defined in %pA section in %pB"),
1448                  reloc_name, entry->root.string,
1449                  entry->u.def.section,
1450                  entry->u.def.section == bfd_abs_section_ptr
1451                  ? info->output_bfd : entry->u.def.section->owner);
1452           break;
1453         default:
1454           abort ();
1455           break;
1456         }
1457     }
1458   else
1459     einfo (_(" relocation truncated to fit: %s against `%pT'"),
1460            reloc_name, name);
1461   if (addend != 0)
1462     einfo ("+%v", addend);
1463   einfo ("\n");
1464 }
1465
1466 /* This is called when a dangerous relocation is made.  */
1467
1468 static void
1469 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1470                  const char *message,
1471                  bfd *abfd,
1472                  asection *section,
1473                  bfd_vma address)
1474 {
1475   einfo (_("%X%P: %H: dangerous relocation: %s\n"),
1476          abfd, section, address, message);
1477 }
1478
1479 /* This is called when a reloc is being generated attached to a symbol
1480    that is not being output.  */
1481
1482 static void
1483 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1484                   const char *name,
1485                   bfd *abfd,
1486                   asection *section,
1487                   bfd_vma address)
1488 {
1489   einfo (_("%X%P: %H: reloc refers to symbol `%pT' which is not being output\n"),
1490          abfd, section, address, name);
1491 }
1492
1493 /* This is called if link_info.notice_all is set, or when a symbol in
1494    link_info.notice_hash is found.  Symbols are put in notice_hash
1495    using the -y option, while notice_all is set if the --cref option
1496    has been supplied, or if there are any NOCROSSREFS sections in the
1497    linker script; and if plugins are active, since they need to monitor
1498    all references from non-IR files.  */
1499
1500 static bfd_boolean
1501 notice (struct bfd_link_info *info,
1502         struct bfd_link_hash_entry *h,
1503         struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1504         bfd *abfd,
1505         asection *section,
1506         bfd_vma value,
1507         flagword flags ATTRIBUTE_UNUSED)
1508 {
1509   const char *name;
1510
1511   if (h == NULL)
1512     {
1513       if (command_line.cref || nocrossref_list != NULL)
1514         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1515       return TRUE;
1516     }
1517
1518   name = h->root.string;
1519   if (info->notice_hash != NULL
1520       && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1521     {
1522       if (bfd_is_und_section (section))
1523         einfo (_("%P: %pB: reference to %s\n"), abfd, name);
1524       else
1525         einfo (_("%P: %pB: definition of %s\n"), abfd, name);
1526     }
1527
1528   if (command_line.cref || nocrossref_list != NULL)
1529     add_cref (name, abfd, section, value);
1530
1531   return TRUE;
1532 }