ld/ldmain.c

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