ld/ldmain.c

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