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