ld/ldmain.c

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