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