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