ld/ldmain.c

   1 /* Main program of GNU linker.
   2    Copyright (C) 1991-2017 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain steve@cygnus.com
   4
   5    This file is part of the GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "safe-ctype.h"
  25 #include "libiberty.h"
  26 #include "progress.h"
  27 #include "bfdlink.h"
  28 #include "filenames.h"
  29
  30 #include "ld.h"
  31 #include "ldmain.h"
  32 #include "ldmisc.h"
  33 #include "ldwrite.h"
  34 #include "ldexp.h"
  35 #include "ldlang.h"
  36 #include <ldgram.h>
  37 #include "ldlex.h"
  38 #include "ldfile.h"
  39 #include "ldemul.h"
  40 #include "ldctor.h"
  41 #ifdef ENABLE_PLUGINS
  42 #include "plugin.h"
  43 #include "plugin-api.h"
  44 #endif /* ENABLE_PLUGINS */
  45
  46 /* Somewhere above, sys/stat.h got included.  */
  47 #if !defined(S_ISDIR) && defined(S_IFDIR)
  48 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  49 #endif
  50
  51 #include <string.h>
  52
  53 #ifndef TARGET_SYSTEM_ROOT
  54 #define TARGET_SYSTEM_ROOT ""
  55 #endif
  56
  57 /* EXPORTS */
  58
  59 FILE *saved_script_handle = NULL;
  60 FILE *previous_script_handle = NULL;
  61 bfd_boolean force_make_executable = FALSE;
  62
  63 char *default_target;
  64 const char *output_filename = "a.out";
  65
  66 /* Name this program was invoked by.  */
  67 char *program_name;
  68
  69 /* The prefix for system library directories.  */
  70 const char *ld_sysroot;
  71
  72 /* The canonical representation of ld_sysroot.  */
  73 char *ld_canon_sysroot;
  74 int ld_canon_sysroot_len;
  75
  76 /* Set by -G argument, for targets like MIPS ELF.  */
  77 int g_switch_value = 8;
  78
  79 /* Nonzero means print names of input files as processed.  */
  80 bfd_boolean trace_files;
  81
  82 /* Nonzero means report actions taken by the linker, and describe the linker script in use.  */
  83 bfd_boolean verbose;
  84
  85 /* Nonzero means version number was printed, so exit successfully
  86    instead of complaining if no input files are given.  */
  87 bfd_boolean version_printed;
  88
  89 /* TRUE if we should demangle symbol names.  */
  90 bfd_boolean demangling;
  91
  92 args_type command_line;
  93
  94 ld_config_type config;
  95
  96 sort_type sort_section;
  97
  98 static const char *get_sysroot
  99   (int, char **);
 100 static char *get_emulation
 101   (int, char **);
 102 static bfd_boolean add_archive_element
 103   (struct bfd_link_info *, bfd *, const char *, bfd **);
 104 static void multiple_definition
 105   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 106    bfd *, asection *, bfd_vma);
 107 static void multiple_common
 108   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 109    bfd *, enum bfd_link_hash_type, bfd_vma);
 110 static void add_to_set
 111   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 112    bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
 113 static void constructor_callback
 114   (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
 115    asection *, bfd_vma);
 116 static void warning_callback
 117   (struct bfd_link_info *, const char *, const char *, bfd *,
 118    asection *, bfd_vma);
 119 static void warning_find_reloc
 120   (bfd *, asection *, void *);
 121 static void undefined_symbol
 122   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 123    bfd_boolean);
 124 static void reloc_overflow
 125   (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
 126    const char *, bfd_vma, bfd *, asection *, bfd_vma);
 127 static void reloc_dangerous
 128   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 129 static void unattached_reloc
 130   (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
 131 static bfd_boolean notice
 132   (struct bfd_link_info *, struct bfd_link_hash_entry *,
 133    struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);
 134
 135 static struct bfd_link_callbacks link_callbacks =
 136 {
 137   add_archive_element,
 138   multiple_definition,
 139   multiple_common,
 140   add_to_set,
 141   constructor_callback,
 142   warning_callback,
 143   undefined_symbol,
 144   reloc_overflow,
 145   reloc_dangerous,
 146   unattached_reloc,
 147   notice,
 148   einfo,
 149   info_msg,
 150   minfo,
 151   ldlang_override_segment_assignment
 152 };
 153
 154 static bfd_assert_handler_type default_bfd_assert_handler;
 155 static bfd_error_handler_type default_bfd_error_handler;
 156
 157 struct bfd_link_info link_info;
 158 \f
 159 static void
 160 ld_cleanup (void)
 161 {
 162   bfd_cache_close_all ();
 163 #ifdef ENABLE_PLUGINS
 164   plugin_call_cleanup ();
 165 #endif
 166   if (output_filename && delete_output_file_on_failure)
 167     unlink_if_ordinary (output_filename);
 168 }
 169
 170 /* Hook to notice BFD assertions.  */
 171
 172 static void
 173 ld_bfd_assert_handler (const char *fmt, const char *bfdver,
 174                        const char *file, int line)
 175 {
 176   config.make_executable = FALSE;
 177   (*default_bfd_assert_handler) (fmt, bfdver, file, line);
 178 }
 179
 180 /* Hook the bfd error/warning handler for --fatal-warnings.  */
 181
 182 static void
 183 ld_bfd_error_handler (const char *fmt, va_list ap)
 184 {
 185   if (config.fatal_warnings)
 186     config.make_executable = FALSE;
 187   (*default_bfd_error_handler) (fmt, ap);
 188 }
 189
 190 int
 191 main (int argc, char **argv)
 192 {
 193   char *emulation;
 194   long start_time = get_run_time ();
 195
 196 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 197   setlocale (LC_MESSAGES, "");
 198 #endif
 199 #if defined (HAVE_SETLOCALE)
 200   setlocale (LC_CTYPE, "");
 201 #endif
 202   bindtextdomain (PACKAGE, LOCALEDIR);
 203   textdomain (PACKAGE);
 204
 205   program_name = argv[0];
 206   xmalloc_set_program_name (program_name);
 207
 208   START_PROGRESS (program_name, 0);
 209
 210   expandargv (&argc, &argv);
 211
 212   bfd_init ();
 213
 214   bfd_set_error_program_name (program_name);
 215
 216   /* We want to notice and fail on those nasty BFD assertions which are
 217      likely to signal incorrect output being generated but otherwise may
 218      leave no trace.  */
 219   default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
 220
 221   /* Also hook the bfd error/warning handler for --fatal-warnings.  */
 222   default_bfd_error_handler = bfd_set_error_handler (ld_bfd_error_handler);
 223
 224   xatexit (ld_cleanup);
 225
 226   /* Set up the sysroot directory.  */
 227   ld_sysroot = get_sysroot (argc, argv);
 228   if (*ld_sysroot)
 229     ld_canon_sysroot = lrealpath (ld_sysroot);
 230   if (ld_canon_sysroot)
 231     ld_canon_sysroot_len = strlen (ld_canon_sysroot);
 232   else
 233     ld_canon_sysroot_len = -1;
 234
 235   /* Set the default BFD target based on the configured target.  Doing
 236      this permits the linker to be configured for a particular target,
 237      and linked against a shared BFD library which was configured for
 238      a different target.  The macro TARGET is defined by Makefile.  */
 239   if (!bfd_set_default_target (TARGET))
 240     {
 241       einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
 242       xexit (1);
 243     }
 244
 245 #if YYDEBUG
 246   {
 247     extern int yydebug;
 248     yydebug = 1;
 249   }
 250 #endif
 251
 252   config.build_constructors = TRUE;
 253   config.rpath_separator = ':';
 254   config.split_by_reloc = (unsigned) -1;
 255   config.split_by_file = (bfd_size_type) -1;
 256   config.make_executable = TRUE;
 257   config.magic_demand_paged = TRUE;
 258   config.text_read_only = TRUE;
 259   link_info.disable_target_specific_optimizations = -1;
 260
 261   command_line.warn_mismatch = TRUE;
 262   command_line.warn_search_mismatch = TRUE;
 263   command_line.check_section_addresses = -1;
 264
 265   /* We initialize DEMANGLING based on the environment variable
 266      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
 267      output of the linker, unless COLLECT_NO_DEMANGLE is set in the
 268      environment.  Acting the same way here lets us provide the same
 269      interface by default.  */
 270   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
 271
 272   link_info.allow_undefined_version = TRUE;
 273   link_info.keep_memory = TRUE;
 274   link_info.combreloc = TRUE;
 275   link_info.strip_discarded = TRUE;
 276   link_info.emit_hash = DEFAULT_EMIT_SYSV_HASH;
 277   link_info.emit_gnu_hash = DEFAULT_EMIT_GNU_HASH;
 278   link_info.callbacks = &link_callbacks;
 279   link_info.input_bfds_tail = &link_info.input_bfds;
 280   /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
 281      and _fini symbols.  We are compatible.  */
 282   link_info.init_function = "_init";
 283   link_info.fini_function = "_fini";
 284   link_info.relax_pass = 1;
 285   link_info.extern_protected_data = -1;
 286   link_info.dynamic_undefined_weak = -1;
 287   link_info.pei386_auto_import = -1;
 288   link_info.spare_dynamic_tags = 5;
 289   link_info.path_separator = ':';
 290 #ifdef DEFAULT_FLAG_COMPRESS_DEBUG
 291   link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
 292 #endif
 293 #ifdef DEFAULT_NEW_DTAGS
 294   link_info.new_dtags = DEFAULT_NEW_DTAGS;
 295 #endif
 296
 297   ldfile_add_arch ("");
 298   emulation = get_emulation (argc, argv);
 299   ldemul_choose_mode (emulation);
 300   default_target = ldemul_choose_target (argc, argv);
 301   config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
 302   config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
 303   lang_init ();
 304   ldexp_init ();
 305   ldemul_before_parse ();
 306   lang_has_input_file = FALSE;
 307   parse_args (argc, argv);
 308
 309   if (config.hash_table_size != 0)
 310     bfd_hash_set_default_size (config.hash_table_size);
 311
 312 #ifdef ENABLE_PLUGINS
 313   /* Now all the plugin arguments have been gathered, we can load them.  */
 314   plugin_load_plugins ();
 315 #endif /* ENABLE_PLUGINS */
 316
 317   ldemul_set_symbols ();
 318
 319   /* If we have not already opened and parsed a linker script,
 320      try the default script from command line first.  */
 321   if (saved_script_handle == NULL
 322       && command_line.default_script != NULL)
 323     {
 324       ldfile_open_command_file (command_line.default_script);
 325       parser_input = input_script;
 326       yyparse ();
 327     }
 328
 329   /* If we have not already opened and parsed a linker script
 330      read the emulation's appropriate default script.  */
 331   if (saved_script_handle == NULL)
 332     {
 333       int isfile;
 334       char *s = ldemul_get_script (&isfile);
 335
 336       if (isfile)
 337         ldfile_open_default_command_file (s);
 338       else
 339         {
 340           lex_string = s;
 341           lex_redirect (s, _("built in linker script"), 1);
 342         }
 343       parser_input = input_script;
 344       yyparse ();
 345       lex_string = NULL;
 346     }
 347
 348   if (verbose)
 349     {
 350       if (saved_script_handle)
 351         info_msg (_("using external linker script:"));
 352       else
 353         info_msg (_("using internal linker script:"));
 354       info_msg ("\n==================================================\n");
 355
 356       if (saved_script_handle)
 357         {
 358           static const int ld_bufsz = 8193;
 359           size_t n;
 360           char *buf = (char *) xmalloc (ld_bufsz);
 361
 362           rewind (saved_script_handle);
 363           while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
 364             {
 365               buf[n] = 0;
 366               info_msg ("%s", buf);
 367             }
 368           rewind (saved_script_handle);
 369           free (buf);
 370         }
 371       else
 372         {
 373           int isfile;
 374
 375           info_msg (ldemul_get_script (&isfile));
 376         }
 377
 378       info_msg ("\n==================================================\n");
 379     }
 380
 381   if (command_line.force_group_allocation
 382       || !bfd_link_relocatable (&link_info))
 383     link_info.resolve_section_groups = TRUE;
 384   else
 385     link_info.resolve_section_groups = FALSE;
 386
 387   if (command_line.print_output_format)
 388     info_msg ("%s\n", lang_get_output_target ());
 389
 390   lang_final ();
 391
 392   /* If the only command line argument has been -v or --version or --verbose
 393      then ignore any input files provided by linker scripts and exit now.
 394      We do not want to create an output file when the linker is just invoked
 395      to provide version information.  */
 396   if (argc == 2 && version_printed)
 397     xexit (0);
 398
 399   if (link_info.inhibit_common_definition && !bfd_link_dll (&link_info))
 400     einfo (_("%P%F: --no-define-common may not be used without -shared\n"));
 401
 402   if (!lang_has_input_file)
 403     {
 404       if (version_printed || command_line.print_output_format)
 405         xexit (0);
 406       einfo (_("%P%F: no input files\n"));
 407     }
 408
 409   if (trace_files)
 410     info_msg (_("%P: mode %s\n"), emulation);
 411
 412   ldemul_after_parse ();
 413
 414   if (config.map_filename)
 415     {
 416       if (strcmp (config.map_filename, "-") == 0)
 417         {
 418           config.map_file = stdout;
 419         }
 420       else
 421         {
 422           config.map_file = fopen (config.map_filename, FOPEN_WT);
 423           if (config.map_file == (FILE *) NULL)
 424             {
 425               bfd_set_error (bfd_error_system_call);
 426               einfo (_("%P%F: cannot open map file %s: %E\n"),
 427                      config.map_filename);
 428             }
 429         }
 430     }
 431
 432   lang_process ();
 433
 434   /* Print error messages for any missing symbols, for any warning
 435      symbols, and possibly multiple definitions.  */
 436   if (bfd_link_relocatable (&link_info))
 437     link_info.output_bfd->flags &= ~EXEC_P;
 438   else
 439     link_info.output_bfd->flags |= EXEC_P;
 440
 441   if ((link_info.compress_debug & COMPRESS_DEBUG))
 442     {
 443       link_info.output_bfd->flags |= BFD_COMPRESS;
 444       if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
 445         link_info.output_bfd->flags |= BFD_COMPRESS_GABI;
 446     }
 447
 448   ldwrite ();
 449
 450   if (config.map_file != NULL)
 451     lang_map ();
 452   if (command_line.cref)
 453     output_cref (config.map_file != NULL ? config.map_file : stdout);
 454   if (nocrossref_list != NULL)
 455     check_nocrossrefs ();
 456   if (command_line.print_memory_usage)
 457     lang_print_memory_usage ();
 458 #if 0
 459   {
 460     struct bfd_link_hash_entry *h;
 461
 462     h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
 463     fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
 464   }
 465 #endif
 466   ldexp_finish ();
 467   lang_finish ();
 468
 469   /* Even if we're producing relocatable output, some non-fatal errors should
 470      be reported in the exit status.  (What non-fatal errors, if any, do we
 471      want to ignore for relocatable output?)  */
 472   if (!config.make_executable && !force_make_executable)
 473     {
 474       if (trace_files)
 475         einfo (_("%P: link errors found, deleting executable `%s'\n"),
 476                output_filename);
 477
 478       /* The file will be removed by ld_cleanup.  */
 479       xexit (1);
 480     }
 481   else
 482     {
 483       if (!bfd_close (link_info.output_bfd))
 484         einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
 485
 486       /* If the --force-exe-suffix is enabled, and we're making an
 487          executable file and it doesn't end in .exe, copy it to one
 488          which does.  */
 489       if (!bfd_link_relocatable (&link_info)
 490           && command_line.force_exe_suffix)
 491         {
 492           int len = strlen (output_filename);
 493
 494           if (len < 4
 495               || (strcasecmp (output_filename + len - 4, ".exe") != 0
 496                   && strcasecmp (output_filename + len - 4, ".dll") != 0))
 497             {
 498               FILE *src;
 499               FILE *dst;
 500               const int bsize = 4096;
 501               char *buf = (char *) xmalloc (bsize);
 502               int l;
 503               char *dst_name = (char *) xmalloc (len + 5);
 504
 505               strcpy (dst_name, output_filename);
 506               strcat (dst_name, ".exe");
 507               src = fopen (output_filename, FOPEN_RB);
 508               dst = fopen (dst_name, FOPEN_WB);
 509
 510               if (!src)
 511                 einfo (_("%P%F: unable to open for source of copy `%s'\n"),
 512                        output_filename);
 513               if (!dst)
 514                 einfo (_("%P%F: unable to open for destination of copy `%s'\n"),
 515                        dst_name);
 516               while ((l = fread (buf, 1, bsize, src)) > 0)
 517                 {
 518                   int done = fwrite (buf, 1, l, dst);
 519
 520                   if (done != l)
 521                     einfo (_("%P: Error writing file `%s'\n"), dst_name);
 522                 }
 523
 524               fclose (src);
 525               if (fclose (dst) == EOF)
 526                 einfo (_("%P: Error closing file `%s'\n"), dst_name);
 527               free (dst_name);
 528               free (buf);
 529             }
 530         }
 531     }
 532
 533   END_PROGRESS (program_name);
 534
 535   if (config.stats)
 536     {
 537       long run_time = get_run_time () - start_time;
 538
 539       fflush (stdout);
 540       fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
 541                program_name, run_time / 1000000, run_time % 1000000);
 542       fflush (stderr);
 543     }
 544
 545   /* Prevent ld_cleanup from doing anything, after a successful link.  */
 546   output_filename = NULL;
 547
 548   xexit (0);
 549   return 0;
 550 }
 551
 552 /* If the configured sysroot is relocatable, try relocating it based on
 553    default prefix FROM.  Return the relocated directory if it exists,
 554    otherwise return null.  */
 555
 556 static char *
 557 get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)
 558 {
 559 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 560   char *path;
 561   struct stat s;
 562
 563   path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);
 564   if (path)
 565     {
 566       if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))
 567         return path;
 568       free (path);
 569     }
 570 #endif
 571   return 0;
 572 }
 573
 574 /* Return the sysroot directory.  Return "" if no sysroot is being used.  */
 575
 576 static const char *
 577 get_sysroot (int argc, char **argv)
 578 {
 579   int i;
 580   const char *path;
 581
 582   for (i = 1; i < argc; i++)
 583     if (CONST_STRNEQ (argv[i], "--sysroot="))
 584       return argv[i] + strlen ("--sysroot=");
 585
 586   path = get_relative_sysroot (BINDIR);
 587   if (path)
 588     return path;
 589
 590   path = get_relative_sysroot (TOOLBINDIR);
 591   if (path)
 592     return path;
 593
 594   return TARGET_SYSTEM_ROOT;
 595 }
 596
 597 /* We need to find any explicitly given emulation in order to initialize the
 598    state that's needed by the lex&yacc argument parser (parse_args).  */
 599
 600 static char *
 601 get_emulation (int argc, char **argv)
 602 {
 603   char *emulation;
 604   int i;
 605
 606   emulation = getenv (EMULATION_ENVIRON);
 607   if (emulation == NULL)
 608     emulation = DEFAULT_EMULATION;
 609
 610   for (i = 1; i < argc; i++)
 611     {
 612       if (CONST_STRNEQ (argv[i], "-m"))
 613         {
 614           if (argv[i][2] == '\0')
 615             {
 616               /* -m EMUL */
 617               if (i < argc - 1)
 618                 {
 619                   emulation = argv[i + 1];
 620                   i++;
 621                 }
 622               else
 623                 einfo (_("%P%F: missing argument to -m\n"));
 624             }
 625           else if (strcmp (argv[i], "-mips1") == 0
 626                    || strcmp (argv[i], "-mips2") == 0
 627                    || strcmp (argv[i], "-mips3") == 0
 628                    || strcmp (argv[i], "-mips4") == 0
 629                    || strcmp (argv[i], "-mips5") == 0
 630                    || strcmp (argv[i], "-mips32") == 0
 631                    || strcmp (argv[i], "-mips32r2") == 0
 632                    || strcmp (argv[i], "-mips32r6") == 0
 633                    || strcmp (argv[i], "-mips64") == 0
 634                    || strcmp (argv[i], "-mips64r2") == 0
 635                    || strcmp (argv[i], "-mips64r6") == 0)
 636             {
 637               /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
 638                  passed to the linker by some MIPS compilers.  They
 639                  generally tell the linker to use a slightly different
 640                  library path.  Perhaps someday these should be
 641                  implemented as emulations; until then, we just ignore
 642                  the arguments and hope that nobody ever creates
 643                  emulations named ips1, ips2 or ips3.  */
 644             }
 645           else if (strcmp (argv[i], "-m486") == 0)
 646             {
 647               /* FIXME: The argument -m486 is passed to the linker on
 648                  some Linux systems.  Hope that nobody creates an
 649                  emulation named 486.  */
 650             }
 651           else
 652             {
 653               /* -mEMUL */
 654               emulation = &argv[i][2];
 655             }
 656         }
 657     }
 658
 659   return emulation;
 660 }
 661
 662 void
 663 add_ysym (const char *name)
 664 {
 665   if (link_info.notice_hash == NULL)
 666     {
 667       link_info.notice_hash
 668         = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 669       if (!bfd_hash_table_init_n (link_info.notice_hash,
 670                                   bfd_hash_newfunc,
 671                                   sizeof (struct bfd_hash_entry),
 672                                   61))
 673         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 674     }
 675
 676   if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
 677     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 678 }
 679
 680 void
 681 add_ignoresym (struct bfd_link_info *info, const char *name)
 682 {
 683   if (info->ignore_hash == NULL)
 684     {
 685       info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
 686       if (!bfd_hash_table_init_n (info->ignore_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 (info->ignore_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   fclose (file);
 782 }
 783 \f
 784 /* Callbacks from the BFD linker routines.  */
 785
 786 /* This is called when BFD has decided to include an archive member in
 787    a link.  */
 788
 789 static bfd_boolean
 790 add_archive_element (struct bfd_link_info *info,
 791                      bfd *abfd,
 792                      const char *name,
 793                      bfd **subsbfd ATTRIBUTE_UNUSED)
 794 {
 795   lang_input_statement_type *input;
 796   lang_input_statement_type *parent;
 797   lang_input_statement_type orig_input;
 798
 799   input = (lang_input_statement_type *)
 800       xcalloc (1, sizeof (lang_input_statement_type));
 801   input->header.type = lang_input_statement_enum;
 802   input->filename = abfd->filename;
 803   input->local_sym_name = abfd->filename;
 804   input->the_bfd = abfd;
 805
 806   parent = abfd->my_archive->usrdata;
 807   if (parent != NULL && !parent->flags.reload)
 808     parent->next = (lang_statement_union_type *) input;
 809
 810   /* Save the original data for trace files/tries below, as plugins
 811      (if enabled) may possibly alter it to point to a replacement
 812      BFD, but we still want to output the original BFD filename.  */
 813   orig_input = *input;
 814 #ifdef ENABLE_PLUGINS
 815   if (link_info.lto_plugin_active)
 816     {
 817       /* We must offer this archive member to the plugins to claim.  */
 818       plugin_maybe_claim (input);
 819       if (input->flags.claimed)
 820         {
 821           if (no_more_claiming)
 822             {
 823               /* Don't claim new IR symbols after all IR symbols have
 824                  been claimed.  */
 825               if (trace_files || verbose)
 826                 info_msg ("%I: no new IR symbols to claimi\n",
 827                           &orig_input);
 828               input->flags.claimed = 0;
 829               return FALSE;
 830             }
 831           input->flags.claim_archive = TRUE;
 832           *subsbfd = input->the_bfd;
 833         }
 834     }
 835 #endif /* ENABLE_PLUGINS */
 836
 837   ldlang_add_file (input);
 838
 839   if (config.map_file != NULL)
 840     {
 841       static bfd_boolean header_printed;
 842       struct bfd_link_hash_entry *h;
 843       bfd *from;
 844       int len;
 845
 846       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 847
 848       if (h == NULL)
 849         from = NULL;
 850       else
 851         {
 852           switch (h->type)
 853             {
 854             default:
 855               from = NULL;
 856               break;
 857
 858             case bfd_link_hash_defined:
 859             case bfd_link_hash_defweak:
 860               from = h->u.def.section->owner;
 861               break;
 862
 863             case bfd_link_hash_undefined:
 864             case bfd_link_hash_undefweak:
 865               from = h->u.undef.abfd;
 866               break;
 867
 868             case bfd_link_hash_common:
 869               from = h->u.c.p->section->owner;
 870               break;
 871             }
 872         }
 873
 874       if (!header_printed)
 875         {
 876           minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
 877           header_printed = TRUE;
 878         }
 879
 880       if (abfd->my_archive == NULL
 881           || bfd_is_thin_archive (abfd->my_archive))
 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 (abfd->my_archive),
 889                  bfd_get_filename (abfd));
 890           len = (strlen (bfd_get_filename (abfd->my_archive))
 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 || verbose)
 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 void
 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;
 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;
 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;
 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_BY_USER)
 988     {
 989       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 990       DISABLE_RELAXATION;
 991     }
 992 }
 993
 994 /* This is called when there is a definition of a common symbol, or
 995    when a common symbol is found for a symbol that is already defined,
 996    or when two common symbols are found.  We only do something if
 997    -warn-common was used.  */
 998
 999 static void
1000 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1001                  struct bfd_link_hash_entry *h,
1002                  bfd *nbfd,
1003                  enum bfd_link_hash_type ntype,
1004                  bfd_vma nsize)
1005 {
1006   const char *name;
1007   bfd *obfd;
1008   enum bfd_link_hash_type otype;
1009   bfd_vma osize;
1010
1011   if (!config.warn_common)
1012     return;
1013
1014   name = h->root.string;
1015   otype = h->type;
1016   if (otype == bfd_link_hash_common)
1017     {
1018       obfd = h->u.c.p->section->owner;
1019       osize = h->u.c.size;
1020     }
1021   else if (otype == bfd_link_hash_defined
1022            || otype == bfd_link_hash_defweak)
1023     {
1024       obfd = h->u.def.section->owner;
1025       osize = 0;
1026     }
1027   else
1028     {
1029       /* FIXME: It would nice if we could report the BFD which defined
1030          an indirect symbol, but we don't have anywhere to store the
1031          information.  */
1032       obfd = NULL;
1033       osize = 0;
1034     }
1035
1036   if (ntype == bfd_link_hash_defined
1037       || ntype == bfd_link_hash_defweak
1038       || ntype == bfd_link_hash_indirect)
1039     {
1040       ASSERT (otype == bfd_link_hash_common);
1041       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1042              nbfd, name);
1043       if (obfd != NULL)
1044         einfo (_("%B: warning: common is here\n"), obfd);
1045     }
1046   else if (otype == bfd_link_hash_defined
1047            || otype == bfd_link_hash_defweak
1048            || otype == bfd_link_hash_indirect)
1049     {
1050       ASSERT (ntype == bfd_link_hash_common);
1051       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1052              nbfd, name);
1053       if (obfd != NULL)
1054         einfo (_("%B: warning: defined here\n"), obfd);
1055     }
1056   else
1057     {
1058       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1059       if (osize > nsize)
1060         {
1061           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1062                  nbfd, name);
1063           if (obfd != NULL)
1064             einfo (_("%B: warning: larger common is here\n"), obfd);
1065         }
1066       else if (nsize > osize)
1067         {
1068           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1069                  nbfd, name);
1070           if (obfd != NULL)
1071             einfo (_("%B: warning: smaller common is here\n"), obfd);
1072         }
1073       else
1074         {
1075           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1076           if (obfd != NULL)
1077             einfo (_("%B: warning: previous common is here\n"), obfd);
1078         }
1079     }
1080 }
1081
1082 /* This is called when BFD has discovered a set element.  H is the
1083    entry in the linker hash table for the set.  SECTION and VALUE
1084    represent a value which should be added to the set.  */
1085
1086 static void
1087 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1088             struct bfd_link_hash_entry *h,
1089             bfd_reloc_code_real_type reloc,
1090             bfd *abfd,
1091             asection *section,
1092             bfd_vma value)
1093 {
1094   if (config.warn_constructors)
1095     einfo (_("%P: warning: global constructor %s used\n"),
1096            h->root.string);
1097
1098   if (!config.build_constructors)
1099     return;
1100
1101   ldctor_add_set_entry (h, reloc, NULL, section, value);
1102
1103   if (h->type == bfd_link_hash_new)
1104     {
1105       h->type = bfd_link_hash_undefined;
1106       h->u.undef.abfd = abfd;
1107       /* We don't call bfd_link_add_undef to add this to the list of
1108          undefined symbols because we are going to define it
1109          ourselves.  */
1110     }
1111 }
1112
1113 /* This is called when BFD has discovered a constructor.  This is only
1114    called for some object file formats--those which do not handle
1115    constructors in some more clever fashion.  This is similar to
1116    adding an element to a set, but less general.  */
1117
1118 static void
1119 constructor_callback (struct bfd_link_info *info,
1120                       bfd_boolean constructor,
1121                       const char *name,
1122                       bfd *abfd,
1123                       asection *section,
1124                       bfd_vma value)
1125 {
1126   char *s;
1127   struct bfd_link_hash_entry *h;
1128   char set_name[1 + sizeof "__CTOR_LIST__"];
1129
1130   if (config.warn_constructors)
1131     einfo (_("%P: warning: global constructor %s used\n"), name);
1132
1133   if (!config.build_constructors)
1134     return;
1135
1136   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1137      useful error message.  */
1138   if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1139       && (bfd_link_relocatable (info)
1140           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1141     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1142
1143   s = set_name;
1144   if (bfd_get_symbol_leading_char (abfd) != '\0')
1145     *s++ = bfd_get_symbol_leading_char (abfd);
1146   if (constructor)
1147     strcpy (s, "__CTOR_LIST__");
1148   else
1149     strcpy (s, "__DTOR_LIST__");
1150
1151   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1152   if (h == (struct bfd_link_hash_entry *) NULL)
1153     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1154   if (h->type == bfd_link_hash_new)
1155     {
1156       h->type = bfd_link_hash_undefined;
1157       h->u.undef.abfd = abfd;
1158       /* We don't call bfd_link_add_undef to add this to the list of
1159          undefined symbols because we are going to define it
1160          ourselves.  */
1161     }
1162
1163   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1164 }
1165
1166 /* A structure used by warning_callback to pass information through
1167    bfd_map_over_sections.  */
1168
1169 struct warning_callback_info
1170 {
1171   bfd_boolean found;
1172   const char *warning;
1173   const char *symbol;
1174   asymbol **asymbols;
1175 };
1176
1177 /* Look through the relocs to see if we can find a plausible address
1178    for SYMBOL in ABFD.  Return TRUE if found.  Otherwise return FALSE.  */
1179
1180 static bfd_boolean
1181 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1182 {
1183   struct warning_callback_info cinfo;
1184
1185   if (!bfd_generic_link_read_symbols (abfd))
1186     einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1187
1188   cinfo.found = FALSE;
1189   cinfo.warning = warning;
1190   cinfo.symbol = symbol;
1191   cinfo.asymbols = bfd_get_outsymbols (abfd);
1192   bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1193   return cinfo.found;
1194 }
1195
1196 /* This is called when there is a reference to a warning symbol.  */
1197
1198 static void
1199 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1200                   const char *warning,
1201                   const char *symbol,
1202                   bfd *abfd,
1203                   asection *section,
1204                   bfd_vma address)
1205 {
1206   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1207      have a cleaner interface, but what?  */
1208   if (!config.warn_multiple_gp
1209       && strcmp (warning, "using multiple gp values") == 0)
1210     return;
1211
1212   if (section != NULL)
1213     einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1214   else if (abfd == NULL)
1215     einfo ("%P: %s%s\n", _("warning: "), warning);
1216   else if (symbol == NULL)
1217     einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1218   else if (!symbol_warning (warning, symbol, abfd))
1219     {
1220       bfd *b;
1221       /* Search all input files for a reference to SYMBOL.  */
1222       for (b = info->input_bfds; b; b = b->link.next)
1223         if (b != abfd && symbol_warning (warning, symbol, b))
1224           return;
1225       einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1226     }
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 void
1281 undefined_symbol (struct bfd_link_info *info,
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 (info->ignore_hash != NULL
1294       && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1295     return;
1296
1297   if (config.warn_once)
1298     {
1299       /* Only warn once about a particular undefined symbol.  */
1300       add_ignoresym (info, name);
1301     }
1302
1303   /* We never print more than a reasonable number of errors in a row
1304      for a single symbol.  */
1305   if (error_name != NULL
1306       && strcmp (name, error_name) == 0)
1307     ++error_count;
1308   else
1309     {
1310       error_count = 0;
1311       if (error_name != NULL)
1312         free (error_name);
1313       error_name = xstrdup (name);
1314     }
1315
1316   if (section != NULL)
1317     {
1318       if (error_count < MAX_ERRORS_IN_A_ROW)
1319         {
1320           if (error)
1321             einfo (_("%X%C: undefined reference to `%T'\n"),
1322                    abfd, section, address, name);
1323           else
1324             einfo (_("%C: warning: undefined reference to `%T'\n"),
1325                    abfd, section, address, name);
1326         }
1327       else if (error_count == MAX_ERRORS_IN_A_ROW)
1328         {
1329           if (error)
1330             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1331                    abfd, section, address, name);
1332           else
1333             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1334                    abfd, section, address, name);
1335         }
1336       else if (error)
1337         einfo ("%X");
1338     }
1339   else
1340     {
1341       if (error_count < MAX_ERRORS_IN_A_ROW)
1342         {
1343           if (error)
1344             einfo (_("%X%B: undefined reference to `%T'\n"),
1345                    abfd, name);
1346           else
1347             einfo (_("%B: warning: undefined reference to `%T'\n"),
1348                    abfd, name);
1349         }
1350       else if (error_count == MAX_ERRORS_IN_A_ROW)
1351         {
1352           if (error)
1353             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1354                    abfd, name);
1355           else
1356             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1357                    abfd, name);
1358         }
1359       else if (error)
1360         einfo ("%X");
1361     }
1362 }
1363
1364 /* Counter to limit the number of relocation overflow error messages
1365    to print.  Errors are printed as it is decremented.  When it's
1366    called and the counter is zero, a final message is printed
1367    indicating more relocations were omitted.  When it gets to -1, no
1368    such errors are printed.  If it's initially set to a value less
1369    than -1, all such errors will be printed (--verbose does this).  */
1370
1371 int overflow_cutoff_limit = 10;
1372
1373 /* This is called when a reloc overflows.  */
1374
1375 static void
1376 reloc_overflow (struct bfd_link_info *info,
1377                 struct bfd_link_hash_entry *entry,
1378                 const char *name,
1379                 const char *reloc_name,
1380                 bfd_vma addend,
1381                 bfd *abfd,
1382                 asection *section,
1383                 bfd_vma address)
1384 {
1385   if (overflow_cutoff_limit == -1)
1386     return;
1387
1388   einfo ("%X%H:", abfd, section, address);
1389
1390   if (overflow_cutoff_limit >= 0
1391       && overflow_cutoff_limit-- == 0)
1392     {
1393       einfo (_(" additional relocation overflows omitted from the output\n"));
1394       return;
1395     }
1396
1397   if (entry)
1398     {
1399       while (entry->type == bfd_link_hash_indirect
1400              || entry->type == bfd_link_hash_warning)
1401         entry = entry->u.i.link;
1402       switch (entry->type)
1403         {
1404         case bfd_link_hash_undefined:
1405         case bfd_link_hash_undefweak:
1406           einfo (_(" relocation truncated to fit: "
1407                    "%s against undefined symbol `%T'"),
1408                  reloc_name, entry->root.string);
1409           break;
1410         case bfd_link_hash_defined:
1411         case bfd_link_hash_defweak:
1412           einfo (_(" relocation truncated to fit: "
1413                    "%s against symbol `%T' defined in %A section in %B"),
1414                  reloc_name, entry->root.string,
1415                  entry->u.def.section,
1416                  entry->u.def.section == bfd_abs_section_ptr
1417                  ? info->output_bfd : entry->u.def.section->owner);
1418           break;
1419         default:
1420           abort ();
1421           break;
1422         }
1423     }
1424   else
1425     einfo (_(" relocation truncated to fit: %s against `%T'"),
1426            reloc_name, name);
1427   if (addend != 0)
1428     einfo ("+%v", addend);
1429   einfo ("\n");
1430 }
1431
1432 /* This is called when a dangerous relocation is made.  */
1433
1434 static void
1435 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1436                  const char *message,
1437                  bfd *abfd,
1438                  asection *section,
1439                  bfd_vma address)
1440 {
1441   einfo (_("%X%H: dangerous relocation: %s\n"),
1442          abfd, section, address, message);
1443 }
1444
1445 /* This is called when a reloc is being generated attached to a symbol
1446    that is not being output.  */
1447
1448 static void
1449 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1450                   const char *name,
1451                   bfd *abfd,
1452                   asection *section,
1453                   bfd_vma address)
1454 {
1455   einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1456          abfd, section, address, name);
1457 }
1458
1459 /* This is called if link_info.notice_all is set, or when a symbol in
1460    link_info.notice_hash is found.  Symbols are put in notice_hash
1461    using the -y option, while notice_all is set if the --cref option
1462    has been supplied, or if there are any NOCROSSREFS sections in the
1463    linker script; and if plugins are active, since they need to monitor
1464    all references from non-IR files.  */
1465
1466 static bfd_boolean
1467 notice (struct bfd_link_info *info,
1468         struct bfd_link_hash_entry *h,
1469         struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1470         bfd *abfd,
1471         asection *section,
1472         bfd_vma value,
1473         flagword flags ATTRIBUTE_UNUSED)
1474 {
1475   const char *name;
1476
1477   if (h == NULL)
1478     {
1479       if (command_line.cref || nocrossref_list != NULL)
1480         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1481       return TRUE;
1482     }
1483
1484   name = h->root.string;
1485   if (info->notice_hash != NULL
1486       && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1487     {
1488       if (bfd_is_und_section (section))
1489         einfo (_("%B: reference to %s\n"), abfd, name);
1490       else
1491         einfo (_("%B: definition of %s\n"), abfd, name);
1492     }
1493
1494   if (command_line.cref || nocrossref_list != NULL)
1495     add_cref (name, abfd, section, value);
1496
1497   return TRUE;
1498 }