ld/ldmain.c

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