ld/ldmain.c

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