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