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