ld/ldmain.c

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