ld/ldmain.c

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