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