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 #include "libbfd.h"
  45 #endif /* ENABLE_PLUGINS */
  46
  47 /* Somewhere above, sys/stat.h got included.  */
  48 #if !defined(S_ISDIR) && defined(S_IFDIR)
  49 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  50 #endif
  51
  52 #include <string.h>
  53
  54 #ifdef HAVE_SBRK
  55 #if !HAVE_DECL_SBRK
  56 extern void *sbrk ();
  57 #endif
  58 #endif
  59
  60 #ifndef TARGET_SYSTEM_ROOT
  61 #define TARGET_SYSTEM_ROOT ""
  62 #endif
  63
  64 /* EXPORTS */
  65
  66 FILE *saved_script_handle = NULL;
  67 FILE *previous_script_handle = NULL;
  68 bfd_boolean force_make_executable = FALSE;
  69
  70 char *default_target;
  71 const char *output_filename = "a.out";
  72
  73 /* Name this program was invoked by.  */
  74 char *program_name;
  75
  76 /* The prefix for system library directories.  */
  77 const char *ld_sysroot;
  78
  79 /* The canonical representation of ld_sysroot.  */
  80 char * ld_canon_sysroot;
  81 int ld_canon_sysroot_len;
  82
  83 /* Set by -G argument, for targets like MIPS ELF.  */
  84 int g_switch_value = 8;
  85
  86 /* Nonzero means print names of input files as processed.  */
  87 bfd_boolean trace_files;
  88
  89 /* Nonzero means report actions taken by the linker, and describe the linker script in use.  */
  90 bfd_boolean verbose;
  91
  92 /* Nonzero means version number was printed, so exit successfully
  93    instead of complaining if no input files are given.  */
  94 bfd_boolean version_printed;
  95
  96 /* TRUE if we should demangle symbol names.  */
  97 bfd_boolean demangling;
  98
  99 args_type command_line;
 100
 101 ld_config_type config;
 102
 103 sort_type sort_section;
 104
 105 static const char *get_sysroot
 106   (int, char **);
 107 static char *get_emulation
 108   (int, char **);
 109 static bfd_boolean add_archive_element
 110   (struct bfd_link_info *, bfd *, const char *, bfd **);
 111 static bfd_boolean multiple_definition
 112   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 113    bfd *, asection *, bfd_vma);
 114 static bfd_boolean multiple_common
 115   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 116    bfd *, enum bfd_link_hash_type, bfd_vma);
 117 static bfd_boolean add_to_set
 118   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 119    bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
 120 static bfd_boolean constructor_callback
 121   (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
 122    asection *, bfd_vma);
 123 static bfd_boolean warning_callback
 124   (struct bfd_link_info *, const char *, const char *, bfd *,
 125    asection *, bfd_vma);
 126 static void warning_find_reloc
 127   (bfd *, asection *, void *);
 128 static bfd_boolean undefined_symbol
 129   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 130    bfd_boolean);
 131 static bfd_boolean reloc_overflow
 132   (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
 133    const char *, bfd_vma, bfd *, asection *, bfd_vma);
 134 static bfd_boolean reloc_dangerous
 135   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 136 static bfd_boolean unattached_reloc
 137   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 138 static bfd_boolean notice
 139   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 140    struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
 141
 142 static struct bfd_link_callbacks link_callbacks =
 143 {
 144   add_archive_element,
 145   multiple_definition,
 146   multiple_common,
 147   add_to_set,
 148   constructor_callback,
 149   warning_callback,
 150   undefined_symbol,
 151   reloc_overflow,
 152   reloc_dangerous,
 153   unattached_reloc,
 154   notice,
 155   einfo,
 156   info_msg,
 157   minfo,
 158   ldlang_override_segment_assignment
 159 };
 160
 161 static bfd_assert_handler_type default_bfd_assert_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 /* If there's a BFD assertion, we'll notice and exit with an error
 177    unless otherwise instructed.  */
 178
 179 static void
 180 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
 181                        const char *file, int line)
 182 {
 183   (*default_bfd_assert_handler) (fmt, bfdver, file, line);
 184   config.make_executable = FALSE;
 185 }
 186
 187 int
 188 main (int argc, char **argv)
 189 {
 190   char *emulation;
 191   long start_time = get_run_time ();
 192 #ifdef HAVE_SBRK
 193   char *start_sbrk = (char *) sbrk (0);
 194 #endif
 195
 196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 197   setlocale (LC_MESSAGES, "");
 198 #endif
 199 #if defined (HAVE_SETLOCALE)
 200   setlocale (LC_CTYPE, "");
 201 #endif
 202   bindtextdomain (PACKAGE, LOCALEDIR);
 203   textdomain (PACKAGE);
 204
 205   program_name = argv[0];
 206   xmalloc_set_program_name (program_name);
 207
 208   START_PROGRESS (program_name, 0);
 209
 210   expandargv (&argc, &argv);
 211
 212   bfd_init ();
 213
 214   bfd_set_error_program_name (program_name);
 215
 216   /* We want to notice and fail on those nasty BFD assertions which are
 217      likely to signal incorrect output being generated but otherwise may
 218      leave no trace.  */
 219   default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
 220
 221   xatexit (ld_cleanup);
 222
 223   /* Set up the sysroot directory.  */
 224   ld_sysroot = get_sysroot (argc, argv);
 225   if (*ld_sysroot)
 226     {
 227       if (*TARGET_SYSTEM_ROOT == 0)
 228         {
 229           einfo ("%P%F: this linker was not configured to use sysroots\n");
 230           ld_sysroot = "";
 231         }
 232       else
 233         ld_canon_sysroot = lrealpath (ld_sysroot);
 234     }
 235   if (ld_canon_sysroot)
 236     ld_canon_sysroot_len = strlen (ld_canon_sysroot);
 237   else
 238     ld_canon_sysroot_len = -1;
 239
 240   /* Set the default BFD target based on the configured target.  Doing
 241      this permits the linker to be configured for a particular target,
 242      and linked against a shared BFD library which was configured for
 243      a different target.  The macro TARGET is defined by Makefile.  */
 244   if (! bfd_set_default_target (TARGET))
 245     {
 246       einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
 247       xexit (1);
 248     }
 249
 250 #if YYDEBUG
 251   {
 252     extern int yydebug;
 253     yydebug = 1;
 254   }
 255 #endif
 256
 257   config.build_constructors = TRUE;
 258   config.rpath_separator = ':';
 259   config.split_by_reloc = (unsigned) -1;
 260   config.split_by_file = (bfd_size_type) -1;
 261   config.make_executable = TRUE;
 262   config.magic_demand_paged = TRUE;
 263   config.text_read_only = TRUE;
 264   link_info.disable_target_specific_optimizations = -1;
 265
 266   command_line.warn_mismatch = TRUE;
 267   command_line.warn_search_mismatch = TRUE;
 268   command_line.check_section_addresses = -1;
 269
 270   /* We initialize DEMANGLING based on the environment variable
 271      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
 272      output of the linker, unless COLLECT_NO_DEMANGLE is set in the
 273      environment.  Acting the same way here lets us provide the same
 274      interface by default.  */
 275   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
 276
 277   link_info.allow_undefined_version = TRUE;
 278   link_info.keep_memory = TRUE;
 279   link_info.combreloc = TRUE;
 280   link_info.strip_discarded = TRUE;
 281   link_info.emit_hash = TRUE;
 282   link_info.callbacks = &link_callbacks;
 283   link_info.input_bfds_tail = &link_info.input_bfds;
 284   /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
 285      and _fini symbols.  We are compatible.  */
 286   link_info.init_function = "_init";
 287   link_info.fini_function = "_fini";
 288   link_info.relax_pass = 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 (_("%X%P: unable to open for source of copy `%s'\n"),
 489                        output_filename);
 490               if (!dst)
 491                 einfo (_("%X%P: 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       const char *filename = (bfd_my_archive (abfd) != NULL
 797                               ? bfd_my_archive (abfd)->filename : abfd->filename);
 798       int fd = open (filename, O_RDONLY | O_BINARY);
 799       if (fd >= 0)
 800         {
 801           struct ld_plugin_input_file file;
 802
 803           /* Offset and filesize must refer to the individual archive
 804              member, not the whole file, and must exclude the header.
 805              Fortunately for us, that is how the data is stored in the
 806              origin field of the bfd and in the arelt_data.  */
 807           file.name = filename;
 808           file.offset = abfd->origin;
 809           file.filesize = arelt_size (abfd);
 810           file.fd = fd;
 811           plugin_maybe_claim (&file, input);
 812           if (input->flags.claimed)
 813             {
 814               input->flags.claim_archive = TRUE;
 815               *subsbfd = input->the_bfd;
 816             }
 817         }
 818     }
 819 #endif /* ENABLE_PLUGINS */
 820
 821   ldlang_add_file (input);
 822
 823   if (config.map_file != NULL)
 824     {
 825       static bfd_boolean header_printed;
 826       struct bfd_link_hash_entry *h;
 827       bfd *from;
 828       int len;
 829
 830       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 831
 832       if (h == NULL)
 833         from = NULL;
 834       else
 835         {
 836           switch (h->type)
 837             {
 838             default:
 839               from = NULL;
 840               break;
 841
 842             case bfd_link_hash_defined:
 843             case bfd_link_hash_defweak:
 844               from = h->u.def.section->owner;
 845               break;
 846
 847             case bfd_link_hash_undefined:
 848             case bfd_link_hash_undefweak:
 849               from = h->u.undef.abfd;
 850               break;
 851
 852             case bfd_link_hash_common:
 853               from = h->u.c.p->section->owner;
 854               break;
 855             }
 856         }
 857
 858       if (! header_printed)
 859         {
 860           char buf[100];
 861
 862           sprintf (buf, _("Archive member included "
 863                           "to satisfy reference by file (symbol)\n\n"));
 864           minfo ("%s", buf);
 865           header_printed = TRUE;
 866         }
 867
 868       if (bfd_my_archive (abfd) == NULL)
 869         {
 870           minfo ("%s", bfd_get_filename (abfd));
 871           len = strlen (bfd_get_filename (abfd));
 872         }
 873       else
 874         {
 875           minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
 876                  bfd_get_filename (abfd));
 877           len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
 878                  + strlen (bfd_get_filename (abfd))
 879                  + 2);
 880         }
 881
 882       if (len >= 29)
 883         {
 884           print_nl ();
 885           len = 0;
 886         }
 887       while (len < 30)
 888         {
 889           print_space ();
 890           ++len;
 891         }
 892
 893       if (from != NULL)
 894         minfo ("%B ", from);
 895       if (h != NULL)
 896         minfo ("(%T)\n", h->root.string);
 897       else
 898         minfo ("(%s)\n", name);
 899     }
 900
 901   if (trace_files || verbose)
 902     info_msg ("%I\n", &orig_input);
 903   return TRUE;
 904 }
 905
 906 /* This is called when BFD has discovered a symbol which is defined
 907    multiple times.  */
 908
 909 static bfd_boolean
 910 multiple_definition (struct bfd_link_info *info,
 911                      struct bfd_link_hash_entry *h,
 912                      bfd *nbfd,
 913                      asection *nsec,
 914                      bfd_vma nval)
 915 {
 916   const char *name;
 917   bfd *obfd;
 918   asection *osec;
 919   bfd_vma oval;
 920
 921   if (info->allow_multiple_definition)
 922     return TRUE;
 923
 924   switch (h->type)
 925     {
 926     case bfd_link_hash_defined:
 927       osec = h->u.def.section;
 928       oval = h->u.def.value;
 929       obfd = h->u.def.section->owner;
 930       break;
 931     case bfd_link_hash_indirect:
 932       osec = bfd_ind_section_ptr;
 933       oval = 0;
 934       obfd = NULL;
 935       break;
 936     default:
 937       abort ();
 938     }
 939
 940   /* Ignore a redefinition of an absolute symbol to the
 941      same value; it's harmless.  */
 942   if (h->type == bfd_link_hash_defined
 943       && bfd_is_abs_section (osec)
 944       && bfd_is_abs_section (nsec)
 945       && nval == oval)
 946     return TRUE;
 947
 948   /* If either section has the output_section field set to
 949      bfd_abs_section_ptr, it means that the section is being
 950      discarded, and this is not really a multiple definition at all.
 951      FIXME: It would be cleaner to somehow ignore symbols defined in
 952      sections which are being discarded.  */
 953   if ((osec->output_section != NULL
 954        && ! bfd_is_abs_section (osec)
 955        && bfd_is_abs_section (osec->output_section))
 956       || (nsec->output_section != NULL
 957           && ! bfd_is_abs_section (nsec)
 958           && bfd_is_abs_section (nsec->output_section)))
 959     return TRUE;
 960
 961   name = h->root.string;
 962   if (nbfd == NULL)
 963     {
 964       nbfd = obfd;
 965       nsec = osec;
 966       nval = oval;
 967       obfd = NULL;
 968     }
 969   einfo (_("%X%C: multiple definition of `%T'\n"),
 970          nbfd, nsec, nval, name);
 971   if (obfd != NULL)
 972     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 973
 974   if (RELAXATION_ENABLED_BY_USER)
 975     {
 976       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 977       DISABLE_RELAXATION;
 978     }
 979
 980   return TRUE;
 981 }
 982
 983 /* This is called when there is a definition of a common symbol, or
 984    when a common symbol is found for a symbol that is already defined,
 985    or when two common symbols are found.  We only do something if
 986    -warn-common was used.  */
 987
 988 static bfd_boolean
 989 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 990                  struct bfd_link_hash_entry *h,
 991                  bfd *nbfd,
 992                  enum bfd_link_hash_type ntype,
 993                  bfd_vma nsize)
 994 {
 995   const char *name;
 996   bfd *obfd;
 997   enum bfd_link_hash_type otype;
 998   bfd_vma osize;
 999
1000   if (!config.warn_common)
1001     return TRUE;
1002
1003   name = h->root.string;
1004   otype = h->type;
1005   if (otype == bfd_link_hash_common)
1006     {
1007       obfd = h->u.c.p->section->owner;
1008       osize = h->u.c.size;
1009     }
1010   else if (otype == bfd_link_hash_defined
1011            || otype == bfd_link_hash_defweak)
1012     {
1013       obfd = h->u.def.section->owner;
1014       osize = 0;
1015     }
1016   else
1017     {
1018       /* FIXME: It would nice if we could report the BFD which defined
1019          an indirect symbol, but we don't have anywhere to store the
1020          information.  */
1021       obfd = NULL;
1022       osize = 0;
1023     }
1024
1025   if (ntype == bfd_link_hash_defined
1026       || ntype == bfd_link_hash_defweak
1027       || ntype == bfd_link_hash_indirect)
1028     {
1029       ASSERT (otype == bfd_link_hash_common);
1030       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1031              nbfd, name);
1032       if (obfd != NULL)
1033         einfo (_("%B: warning: common is here\n"), obfd);
1034     }
1035   else if (otype == bfd_link_hash_defined
1036            || otype == bfd_link_hash_defweak
1037            || otype == bfd_link_hash_indirect)
1038     {
1039       ASSERT (ntype == bfd_link_hash_common);
1040       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1041              nbfd, name);
1042       if (obfd != NULL)
1043         einfo (_("%B: warning: defined here\n"), obfd);
1044     }
1045   else
1046     {
1047       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1048       if (osize > nsize)
1049         {
1050           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1051                  nbfd, name);
1052           if (obfd != NULL)
1053             einfo (_("%B: warning: larger common is here\n"), obfd);
1054         }
1055       else if (nsize > osize)
1056         {
1057           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1058                  nbfd, name);
1059           if (obfd != NULL)
1060             einfo (_("%B: warning: smaller common is here\n"), obfd);
1061         }
1062       else
1063         {
1064           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1065           if (obfd != NULL)
1066             einfo (_("%B: warning: previous common is here\n"), obfd);
1067         }
1068     }
1069
1070   return TRUE;
1071 }
1072
1073 /* This is called when BFD has discovered a set element.  H is the
1074    entry in the linker hash table for the set.  SECTION and VALUE
1075    represent a value which should be added to the set.  */
1076
1077 static bfd_boolean
1078 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1079             struct bfd_link_hash_entry *h,
1080             bfd_reloc_code_real_type reloc,
1081             bfd *abfd,
1082             asection *section,
1083             bfd_vma value)
1084 {
1085   if (config.warn_constructors)
1086     einfo (_("%P: warning: global constructor %s used\n"),
1087            h->root.string);
1088
1089   if (! config.build_constructors)
1090     return TRUE;
1091
1092   ldctor_add_set_entry (h, reloc, NULL, section, value);
1093
1094   if (h->type == bfd_link_hash_new)
1095     {
1096       h->type = bfd_link_hash_undefined;
1097       h->u.undef.abfd = abfd;
1098       /* We don't call bfd_link_add_undef to add this to the list of
1099          undefined symbols because we are going to define it
1100          ourselves.  */
1101     }
1102
1103   return TRUE;
1104 }
1105
1106 /* This is called when BFD has discovered a constructor.  This is only
1107    called for some object file formats--those which do not handle
1108    constructors in some more clever fashion.  This is similar to
1109    adding an element to a set, but less general.  */
1110
1111 static bfd_boolean
1112 constructor_callback (struct bfd_link_info *info,
1113                       bfd_boolean constructor,
1114                       const char *name,
1115                       bfd *abfd,
1116                       asection *section,
1117                       bfd_vma value)
1118 {
1119   char *s;
1120   struct bfd_link_hash_entry *h;
1121   char set_name[1 + sizeof "__CTOR_LIST__"];
1122
1123   if (config.warn_constructors)
1124     einfo (_("%P: warning: global constructor %s used\n"), name);
1125
1126   if (! config.build_constructors)
1127     return TRUE;
1128
1129   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1130      useful error message.  */
1131   if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1132       && (info->relocatable
1133           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1134     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1135
1136   s = set_name;
1137   if (bfd_get_symbol_leading_char (abfd) != '\0')
1138     *s++ = bfd_get_symbol_leading_char (abfd);
1139   if (constructor)
1140     strcpy (s, "__CTOR_LIST__");
1141   else
1142     strcpy (s, "__DTOR_LIST__");
1143
1144   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1145   if (h == (struct bfd_link_hash_entry *) NULL)
1146     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1147   if (h->type == bfd_link_hash_new)
1148     {
1149       h->type = bfd_link_hash_undefined;
1150       h->u.undef.abfd = abfd;
1151       /* We don't call bfd_link_add_undef to add this to the list of
1152          undefined symbols because we are going to define it
1153          ourselves.  */
1154     }
1155
1156   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1157   return TRUE;
1158 }
1159
1160 /* A structure used by warning_callback to pass information through
1161    bfd_map_over_sections.  */
1162
1163 struct warning_callback_info
1164 {
1165   bfd_boolean found;
1166   const char *warning;
1167   const char *symbol;
1168   asymbol **asymbols;
1169 };
1170
1171 /* Look through the relocs to see if we can find a plausible address
1172    for SYMBOL in ABFD.  Return TRUE if found.  Otherwise return FALSE.  */
1173
1174 static bfd_boolean
1175 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1176 {
1177   struct warning_callback_info cinfo;
1178
1179   if (!bfd_generic_link_read_symbols (abfd))
1180     einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1181
1182   cinfo.found = FALSE;
1183   cinfo.warning = warning;
1184   cinfo.symbol = symbol;
1185   cinfo.asymbols = bfd_get_outsymbols (abfd);
1186   bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1187   return cinfo.found;
1188 }
1189
1190 /* This is called when there is a reference to a warning symbol.  */
1191
1192 static bfd_boolean
1193 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1194                   const char *warning,
1195                   const char *symbol,
1196                   bfd *abfd,
1197                   asection *section,
1198                   bfd_vma address)
1199 {
1200   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1201      have a cleaner interface, but what?  */
1202   if (! config.warn_multiple_gp
1203       && strcmp (warning, "using multiple gp values") == 0)
1204     return TRUE;
1205
1206   if (section != NULL)
1207     einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1208   else if (abfd == NULL)
1209     einfo ("%P: %s%s\n", _("warning: "), warning);
1210   else if (symbol == NULL)
1211     einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1212   else if (! symbol_warning (warning, symbol, abfd))
1213     {
1214       bfd *b;
1215       /* Search all input files for a reference to SYMBOL.  */
1216       for (b = info->input_bfds; b; b = b->link.next)
1217         if (b != abfd && symbol_warning (warning, symbol, b))
1218           return TRUE;
1219       einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1220     }
1221
1222   return TRUE;
1223 }
1224
1225 /* This is called by warning_callback for each section.  It checks the
1226    relocs of the section to see if it can find a reference to the
1227    symbol which triggered the warning.  If it can, it uses the reloc
1228    to give an error message with a file and line number.  */
1229
1230 static void
1231 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1232 {
1233   struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1234   long relsize;
1235   arelent **relpp;
1236   long relcount;
1237   arelent **p, **pend;
1238
1239   if (info->found)
1240     return;
1241
1242   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1243   if (relsize < 0)
1244     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1245   if (relsize == 0)
1246     return;
1247
1248   relpp = (arelent **) xmalloc (relsize);
1249   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1250   if (relcount < 0)
1251     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1252
1253   p = relpp;
1254   pend = p + relcount;
1255   for (; p < pend && *p != NULL; p++)
1256     {
1257       arelent *q = *p;
1258
1259       if (q->sym_ptr_ptr != NULL
1260           && *q->sym_ptr_ptr != NULL
1261           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1262         {
1263           /* We found a reloc for the symbol we are looking for.  */
1264           einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1265                  info->warning);
1266           info->found = TRUE;
1267           break;
1268         }
1269     }
1270
1271   free (relpp);
1272 }
1273
1274 /* This is called when an undefined symbol is found.  */
1275
1276 static bfd_boolean
1277 undefined_symbol (struct bfd_link_info *info,
1278                   const char *name,
1279                   bfd *abfd,
1280                   asection *section,
1281                   bfd_vma address,
1282                   bfd_boolean error)
1283 {
1284   static char *error_name;
1285   static unsigned int error_count;
1286
1287 #define MAX_ERRORS_IN_A_ROW 5
1288
1289   if (info->ignore_hash != NULL
1290       && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1291     return TRUE;
1292
1293   if (config.warn_once)
1294     {
1295       /* Only warn once about a particular undefined symbol.  */
1296       add_ignoresym (info, name);
1297     }
1298
1299   /* We never print more than a reasonable number of errors in a row
1300      for a single symbol.  */
1301   if (error_name != NULL
1302       && strcmp (name, error_name) == 0)
1303     ++error_count;
1304   else
1305     {
1306       error_count = 0;
1307       if (error_name != NULL)
1308         free (error_name);
1309       error_name = xstrdup (name);
1310     }
1311
1312   if (section != NULL)
1313     {
1314       if (error_count < MAX_ERRORS_IN_A_ROW)
1315         {
1316           if (error)
1317             einfo (_("%X%C: undefined reference to `%T'\n"),
1318                    abfd, section, address, name);
1319           else
1320             einfo (_("%C: warning: undefined reference to `%T'\n"),
1321                    abfd, section, address, name);
1322         }
1323       else if (error_count == MAX_ERRORS_IN_A_ROW)
1324         {
1325           if (error)
1326             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1327                    abfd, section, address, name);
1328           else
1329             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1330                    abfd, section, address, name);
1331         }
1332       else if (error)
1333         einfo ("%X");
1334     }
1335   else
1336     {
1337       if (error_count < MAX_ERRORS_IN_A_ROW)
1338         {
1339           if (error)
1340             einfo (_("%X%B: undefined reference to `%T'\n"),
1341                    abfd, name);
1342           else
1343             einfo (_("%B: warning: undefined reference to `%T'\n"),
1344                    abfd, name);
1345         }
1346       else if (error_count == MAX_ERRORS_IN_A_ROW)
1347         {
1348           if (error)
1349             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1350                    abfd, name);
1351           else
1352             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1353                    abfd, name);
1354         }
1355       else if (error)
1356         einfo ("%X");
1357     }
1358
1359   return TRUE;
1360 }
1361
1362 /* Counter to limit the number of relocation overflow error messages
1363    to print.  Errors are printed as it is decremented.  When it's
1364    called and the counter is zero, a final message is printed
1365    indicating more relocations were omitted.  When it gets to -1, no
1366    such errors are printed.  If it's initially set to a value less
1367    than -1, all such errors will be printed (--verbose does this).  */
1368
1369 int overflow_cutoff_limit = 10;
1370
1371 /* This is called when a reloc overflows.  */
1372
1373 static bfd_boolean
1374 reloc_overflow (struct bfd_link_info *info,
1375                 struct bfd_link_hash_entry *entry,
1376                 const char *name,
1377                 const char *reloc_name,
1378                 bfd_vma addend,
1379                 bfd *abfd,
1380                 asection *section,
1381                 bfd_vma address)
1382 {
1383   if (overflow_cutoff_limit == -1)
1384     return TRUE;
1385
1386   einfo ("%X%H:", abfd, section, address);
1387
1388   if (overflow_cutoff_limit >= 0
1389       && overflow_cutoff_limit-- == 0)
1390     {
1391       einfo (_(" additional relocation overflows omitted from the output\n"));
1392       return TRUE;
1393     }
1394
1395   if (entry)
1396     {
1397       while (entry->type == bfd_link_hash_indirect
1398              || entry->type == bfd_link_hash_warning)
1399         entry = entry->u.i.link;
1400       switch (entry->type)
1401         {
1402         case bfd_link_hash_undefined:
1403         case bfd_link_hash_undefweak:
1404           einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1405                  reloc_name, entry->root.string);
1406           break;
1407         case bfd_link_hash_defined:
1408         case bfd_link_hash_defweak:
1409           einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1410                  reloc_name, entry->root.string,
1411                  entry->u.def.section,
1412                  entry->u.def.section == bfd_abs_section_ptr
1413                  ? info->output_bfd : entry->u.def.section->owner);
1414           break;
1415         default:
1416           abort ();
1417           break;
1418         }
1419     }
1420   else
1421     einfo (_(" relocation truncated to fit: %s against `%T'"),
1422            reloc_name, name);
1423   if (addend != 0)
1424     einfo ("+%v", addend);
1425   einfo ("\n");
1426   return TRUE;
1427 }
1428
1429 /* This is called when a dangerous relocation is made.  */
1430
1431 static bfd_boolean
1432 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1433                  const char *message,
1434                  bfd *abfd,
1435                  asection *section,
1436                  bfd_vma address)
1437 {
1438   einfo (_("%X%H: dangerous relocation: %s\n"),
1439          abfd, section, address, message);
1440   return TRUE;
1441 }
1442
1443 /* This is called when a reloc is being generated attached to a symbol
1444    that is not being output.  */
1445
1446 static bfd_boolean
1447 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1448                   const char *name,
1449                   bfd *abfd,
1450                   asection *section,
1451                   bfd_vma address)
1452 {
1453   einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1454          abfd, section, address, name);
1455   return TRUE;
1456 }
1457
1458 /* This is called if link_info.notice_all is set, or when a symbol in
1459    link_info.notice_hash is found.  Symbols are put in notice_hash
1460    using the -y option, while notice_all is set if the --cref option
1461    has been supplied, or if there are any NOCROSSREFS sections in the
1462    linker script; and if plugins are active, since they need to monitor
1463    all references from non-IR files.  */
1464
1465 static bfd_boolean
1466 notice (struct bfd_link_info *info,
1467         struct bfd_link_hash_entry *h,
1468         struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1469         bfd *abfd,
1470         asection *section,
1471         bfd_vma value,
1472         flagword flags ATTRIBUTE_UNUSED)
1473 {
1474   const char *name;
1475
1476   if (h == NULL)
1477     {
1478       if (command_line.cref || nocrossref_list != NULL)
1479         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1480       return TRUE;
1481     }
1482
1483   name = h->root.string;
1484   if (info->notice_hash != NULL
1485       && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1486     {
1487       if (bfd_is_und_section (section))
1488         einfo ("%B: reference to %s\n", abfd, name);
1489       else
1490         einfo ("%B: definition of %s\n", abfd, name);
1491     }
1492
1493   if (command_line.cref || nocrossref_list != NULL)
1494     add_cref (name, abfd, section, value);
1495
1496   return TRUE;
1497 }