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 orig_input;
 797
 798   input = (lang_input_statement_type *)
 799       xcalloc (1, sizeof (lang_input_statement_type));
 800   input->header.type = lang_input_statement_enum;
 801   input->filename = abfd->filename;
 802   input->local_sym_name = abfd->filename;
 803   input->the_bfd = abfd;
 804
 805   /* Save the original data for trace files/tries below, as plugins
 806      (if enabled) may possibly alter it to point to a replacement
 807      BFD, but we still want to output the original BFD filename.  */
 808   orig_input = *input;
 809 #ifdef ENABLE_PLUGINS
 810   if (link_info.lto_plugin_active)
 811     {
 812       /* We must offer this archive member to the plugins to claim.  */
 813       plugin_maybe_claim (input);
 814       if (input->flags.claimed)
 815         {
 816           if (no_more_claiming)
 817             {
 818               /* Don't claim new IR symbols after all IR symbols have
 819                  been claimed.  */
 820               if (trace_files || verbose)
 821                 info_msg ("%I: no new IR symbols to claimi\n",
 822                           &orig_input);
 823               input->flags.claimed = 0;
 824               return FALSE;
 825             }
 826           input->flags.claim_archive = TRUE;
 827           *subsbfd = input->the_bfd;
 828         }
 829     }
 830 #endif /* ENABLE_PLUGINS */
 831
 832   ldlang_add_file (input);
 833
 834   if (config.map_file != NULL)
 835     {
 836       static bfd_boolean header_printed;
 837       struct bfd_link_hash_entry *h;
 838       bfd *from;
 839       int len;
 840
 841       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 842
 843       if (h == NULL)
 844         from = NULL;
 845       else
 846         {
 847           switch (h->type)
 848             {
 849             default:
 850               from = NULL;
 851               break;
 852
 853             case bfd_link_hash_defined:
 854             case bfd_link_hash_defweak:
 855               from = h->u.def.section->owner;
 856               break;
 857
 858             case bfd_link_hash_undefined:
 859             case bfd_link_hash_undefweak:
 860               from = h->u.undef.abfd;
 861               break;
 862
 863             case bfd_link_hash_common:
 864               from = h->u.c.p->section->owner;
 865               break;
 866             }
 867         }
 868
 869       if (!header_printed)
 870         {
 871           minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
 872           header_printed = TRUE;
 873         }
 874
 875       if (abfd->my_archive == NULL
 876           || bfd_is_thin_archive (abfd->my_archive))
 877         {
 878           minfo ("%s", bfd_get_filename (abfd));
 879           len = strlen (bfd_get_filename (abfd));
 880         }
 881       else
 882         {
 883           minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
 884                  bfd_get_filename (abfd));
 885           len = (strlen (bfd_get_filename (abfd->my_archive))
 886                  + strlen (bfd_get_filename (abfd))
 887                  + 2);
 888         }
 889
 890       if (len >= 29)
 891         {
 892           print_nl ();
 893           len = 0;
 894         }
 895       while (len < 30)
 896         {
 897           print_space ();
 898           ++len;
 899         }
 900
 901       if (from != NULL)
 902         minfo ("%B ", from);
 903       if (h != NULL)
 904         minfo ("(%T)\n", h->root.string);
 905       else
 906         minfo ("(%s)\n", name);
 907     }
 908
 909   if (trace_files || verbose)
 910     info_msg ("%I\n", &orig_input);
 911   return TRUE;
 912 }
 913
 914 /* This is called when BFD has discovered a symbol which is defined
 915    multiple times.  */
 916
 917 static void
 918 multiple_definition (struct bfd_link_info *info,
 919                      struct bfd_link_hash_entry *h,
 920                      bfd *nbfd,
 921                      asection *nsec,
 922                      bfd_vma nval)
 923 {
 924   const char *name;
 925   bfd *obfd;
 926   asection *osec;
 927   bfd_vma oval;
 928
 929   if (info->allow_multiple_definition)
 930     return;
 931
 932   switch (h->type)
 933     {
 934     case bfd_link_hash_defined:
 935       osec = h->u.def.section;
 936       oval = h->u.def.value;
 937       obfd = h->u.def.section->owner;
 938       break;
 939     case bfd_link_hash_indirect:
 940       osec = bfd_ind_section_ptr;
 941       oval = 0;
 942       obfd = NULL;
 943       break;
 944     default:
 945       abort ();
 946     }
 947
 948   /* Ignore a redefinition of an absolute symbol to the
 949      same value; it's harmless.  */
 950   if (h->type == bfd_link_hash_defined
 951       && bfd_is_abs_section (osec)
 952       && bfd_is_abs_section (nsec)
 953       && nval == oval)
 954     return;
 955
 956   /* If either section has the output_section field set to
 957      bfd_abs_section_ptr, it means that the section is being
 958      discarded, and this is not really a multiple definition at all.
 959      FIXME: It would be cleaner to somehow ignore symbols defined in
 960      sections which are being discarded.  */
 961   if ((osec->output_section != NULL
 962        && !bfd_is_abs_section (osec)
 963        && bfd_is_abs_section (osec->output_section))
 964       || (nsec->output_section != NULL
 965           && !bfd_is_abs_section (nsec)
 966           && bfd_is_abs_section (nsec->output_section)))
 967     return;
 968
 969   name = h->root.string;
 970   if (nbfd == NULL)
 971     {
 972       nbfd = obfd;
 973       nsec = osec;
 974       nval = oval;
 975       obfd = NULL;
 976     }
 977   einfo (_("%X%C: multiple definition of `%T'\n"),
 978          nbfd, nsec, nval, name);
 979   if (obfd != NULL)
 980     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 981
 982   if (RELAXATION_ENABLED_BY_USER)
 983     {
 984       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 985       DISABLE_RELAXATION;
 986     }
 987 }
 988
 989 /* This is called when there is a definition of a common symbol, or
 990    when a common symbol is found for a symbol that is already defined,
 991    or when two common symbols are found.  We only do something if
 992    -warn-common was used.  */
 993
 994 static void
 995 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 996                  struct bfd_link_hash_entry *h,
 997                  bfd *nbfd,
 998                  enum bfd_link_hash_type ntype,
 999                  bfd_vma nsize)
1000 {
1001   const char *name;
1002   bfd *obfd;
1003   enum bfd_link_hash_type otype;
1004   bfd_vma osize;
1005
1006   if (!config.warn_common)
1007     return;
1008
1009   name = h->root.string;
1010   otype = h->type;
1011   if (otype == bfd_link_hash_common)
1012     {
1013       obfd = h->u.c.p->section->owner;
1014       osize = h->u.c.size;
1015     }
1016   else if (otype == bfd_link_hash_defined
1017            || otype == bfd_link_hash_defweak)
1018     {
1019       obfd = h->u.def.section->owner;
1020       osize = 0;
1021     }
1022   else
1023     {
1024       /* FIXME: It would nice if we could report the BFD which defined
1025          an indirect symbol, but we don't have anywhere to store the
1026          information.  */
1027       obfd = NULL;
1028       osize = 0;
1029     }
1030
1031   if (ntype == bfd_link_hash_defined
1032       || ntype == bfd_link_hash_defweak
1033       || ntype == bfd_link_hash_indirect)
1034     {
1035       ASSERT (otype == bfd_link_hash_common);
1036       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1037              nbfd, name);
1038       if (obfd != NULL)
1039         einfo (_("%B: warning: common is here\n"), obfd);
1040     }
1041   else if (otype == bfd_link_hash_defined
1042            || otype == bfd_link_hash_defweak
1043            || otype == bfd_link_hash_indirect)
1044     {
1045       ASSERT (ntype == bfd_link_hash_common);
1046       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1047              nbfd, name);
1048       if (obfd != NULL)
1049         einfo (_("%B: warning: defined here\n"), obfd);
1050     }
1051   else
1052     {
1053       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1054       if (osize > nsize)
1055         {
1056           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1057                  nbfd, name);
1058           if (obfd != NULL)
1059             einfo (_("%B: warning: larger common is here\n"), obfd);
1060         }
1061       else if (nsize > osize)
1062         {
1063           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1064                  nbfd, name);
1065           if (obfd != NULL)
1066             einfo (_("%B: warning: smaller common is here\n"), obfd);
1067         }
1068       else
1069         {
1070           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1071           if (obfd != NULL)
1072             einfo (_("%B: warning: previous common is here\n"), obfd);
1073         }
1074     }
1075 }
1076
1077 /* This is called when BFD has discovered a set element.  H is the
1078    entry in the linker hash table for the set.  SECTION and VALUE
1079    represent a value which should be added to the set.  */
1080
1081 static void
1082 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1083             struct bfd_link_hash_entry *h,
1084             bfd_reloc_code_real_type reloc,
1085             bfd *abfd,
1086             asection *section,
1087             bfd_vma value)
1088 {
1089   if (config.warn_constructors)
1090     einfo (_("%P: warning: global constructor %s used\n"),
1091            h->root.string);
1092
1093   if (!config.build_constructors)
1094     return;
1095
1096   ldctor_add_set_entry (h, reloc, NULL, section, value);
1097
1098   if (h->type == bfd_link_hash_new)
1099     {
1100       h->type = bfd_link_hash_undefined;
1101       h->u.undef.abfd = abfd;
1102       /* We don't call bfd_link_add_undef to add this to the list of
1103          undefined symbols because we are going to define it
1104          ourselves.  */
1105     }
1106 }
1107
1108 /* This is called when BFD has discovered a constructor.  This is only
1109    called for some object file formats--those which do not handle
1110    constructors in some more clever fashion.  This is similar to
1111    adding an element to a set, but less general.  */
1112
1113 static void
1114 constructor_callback (struct bfd_link_info *info,
1115                       bfd_boolean constructor,
1116                       const char *name,
1117                       bfd *abfd,
1118                       asection *section,
1119                       bfd_vma value)
1120 {
1121   char *s;
1122   struct bfd_link_hash_entry *h;
1123   char set_name[1 + sizeof "__CTOR_LIST__"];
1124
1125   if (config.warn_constructors)
1126     einfo (_("%P: warning: global constructor %s used\n"), name);
1127
1128   if (!config.build_constructors)
1129     return;
1130
1131   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1132      useful error message.  */
1133   if (bfd_reloc_type_lookup (info->output_bfd, BFD_RELOC_CTOR) == NULL
1134       && (bfd_link_relocatable (info)
1135           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1136     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1137
1138   s = set_name;
1139   if (bfd_get_symbol_leading_char (abfd) != '\0')
1140     *s++ = bfd_get_symbol_leading_char (abfd);
1141   if (constructor)
1142     strcpy (s, "__CTOR_LIST__");
1143   else
1144     strcpy (s, "__DTOR_LIST__");
1145
1146   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1147   if (h == (struct bfd_link_hash_entry *) NULL)
1148     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1149   if (h->type == bfd_link_hash_new)
1150     {
1151       h->type = bfd_link_hash_undefined;
1152       h->u.undef.abfd = abfd;
1153       /* We don't call bfd_link_add_undef to add this to the list of
1154          undefined symbols because we are going to define it
1155          ourselves.  */
1156     }
1157
1158   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1159 }
1160
1161 /* A structure used by warning_callback to pass information through
1162    bfd_map_over_sections.  */
1163
1164 struct warning_callback_info
1165 {
1166   bfd_boolean found;
1167   const char *warning;
1168   const char *symbol;
1169   asymbol **asymbols;
1170 };
1171
1172 /* Look through the relocs to see if we can find a plausible address
1173    for SYMBOL in ABFD.  Return TRUE if found.  Otherwise return FALSE.  */
1174
1175 static bfd_boolean
1176 symbol_warning (const char *warning, const char *symbol, bfd *abfd)
1177 {
1178   struct warning_callback_info cinfo;
1179
1180   if (!bfd_generic_link_read_symbols (abfd))
1181     einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1182
1183   cinfo.found = FALSE;
1184   cinfo.warning = warning;
1185   cinfo.symbol = symbol;
1186   cinfo.asymbols = bfd_get_outsymbols (abfd);
1187   bfd_map_over_sections (abfd, warning_find_reloc, &cinfo);
1188   return cinfo.found;
1189 }
1190
1191 /* This is called when there is a reference to a warning symbol.  */
1192
1193 static void
1194 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1195                   const char *warning,
1196                   const char *symbol,
1197                   bfd *abfd,
1198                   asection *section,
1199                   bfd_vma address)
1200 {
1201   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1202      have a cleaner interface, but what?  */
1203   if (!config.warn_multiple_gp
1204       && strcmp (warning, "using multiple gp values") == 0)
1205     return;
1206
1207   if (section != NULL)
1208     einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1209   else if (abfd == NULL)
1210     einfo ("%P: %s%s\n", _("warning: "), warning);
1211   else if (symbol == NULL)
1212     einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1213   else if (!symbol_warning (warning, symbol, abfd))
1214     {
1215       bfd *b;
1216       /* Search all input files for a reference to SYMBOL.  */
1217       for (b = info->input_bfds; b; b = b->link.next)
1218         if (b != abfd && symbol_warning (warning, symbol, b))
1219           return;
1220       einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1221     }
1222 }
1223
1224 /* This is called by warning_callback for each section.  It checks the
1225    relocs of the section to see if it can find a reference to the
1226    symbol which triggered the warning.  If it can, it uses the reloc
1227    to give an error message with a file and line number.  */
1228
1229 static void
1230 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1231 {
1232   struct warning_callback_info *info = (struct warning_callback_info *) iarg;
1233   long relsize;
1234   arelent **relpp;
1235   long relcount;
1236   arelent **p, **pend;
1237
1238   if (info->found)
1239     return;
1240
1241   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1242   if (relsize < 0)
1243     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1244   if (relsize == 0)
1245     return;
1246
1247   relpp = (arelent **) xmalloc (relsize);
1248   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1249   if (relcount < 0)
1250     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1251
1252   p = relpp;
1253   pend = p + relcount;
1254   for (; p < pend && *p != NULL; p++)
1255     {
1256       arelent *q = *p;
1257
1258       if (q->sym_ptr_ptr != NULL
1259           && *q->sym_ptr_ptr != NULL
1260           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1261         {
1262           /* We found a reloc for the symbol we are looking for.  */
1263           einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1264                  info->warning);
1265           info->found = TRUE;
1266           break;
1267         }
1268     }
1269
1270   free (relpp);
1271 }
1272
1273 /* This is called when an undefined symbol is found.  */
1274
1275 static void
1276 undefined_symbol (struct bfd_link_info *info,
1277                   const char *name,
1278                   bfd *abfd,
1279                   asection *section,
1280                   bfd_vma address,
1281                   bfd_boolean error)
1282 {
1283   static char *error_name;
1284   static unsigned int error_count;
1285
1286 #define MAX_ERRORS_IN_A_ROW 5
1287
1288   if (info->ignore_hash != NULL
1289       && bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
1290     return;
1291
1292   if (config.warn_once)
1293     {
1294       /* Only warn once about a particular undefined symbol.  */
1295       add_ignoresym (info, name);
1296     }
1297
1298   /* We never print more than a reasonable number of errors in a row
1299      for a single symbol.  */
1300   if (error_name != NULL
1301       && strcmp (name, error_name) == 0)
1302     ++error_count;
1303   else
1304     {
1305       error_count = 0;
1306       if (error_name != NULL)
1307         free (error_name);
1308       error_name = xstrdup (name);
1309     }
1310
1311   if (section != NULL)
1312     {
1313       if (error_count < MAX_ERRORS_IN_A_ROW)
1314         {
1315           if (error)
1316             einfo (_("%X%C: undefined reference to `%T'\n"),
1317                    abfd, section, address, name);
1318           else
1319             einfo (_("%C: warning: undefined reference to `%T'\n"),
1320                    abfd, section, address, name);
1321         }
1322       else if (error_count == MAX_ERRORS_IN_A_ROW)
1323         {
1324           if (error)
1325             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1326                    abfd, section, address, name);
1327           else
1328             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1329                    abfd, section, address, name);
1330         }
1331       else if (error)
1332         einfo ("%X");
1333     }
1334   else
1335     {
1336       if (error_count < MAX_ERRORS_IN_A_ROW)
1337         {
1338           if (error)
1339             einfo (_("%X%B: undefined reference to `%T'\n"),
1340                    abfd, name);
1341           else
1342             einfo (_("%B: warning: undefined reference to `%T'\n"),
1343                    abfd, name);
1344         }
1345       else if (error_count == MAX_ERRORS_IN_A_ROW)
1346         {
1347           if (error)
1348             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1349                    abfd, name);
1350           else
1351             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1352                    abfd, name);
1353         }
1354       else if (error)
1355         einfo ("%X");
1356     }
1357 }
1358
1359 /* Counter to limit the number of relocation overflow error messages
1360    to print.  Errors are printed as it is decremented.  When it's
1361    called and the counter is zero, a final message is printed
1362    indicating more relocations were omitted.  When it gets to -1, no
1363    such errors are printed.  If it's initially set to a value less
1364    than -1, all such errors will be printed (--verbose does this).  */
1365
1366 int overflow_cutoff_limit = 10;
1367
1368 /* This is called when a reloc overflows.  */
1369
1370 static void
1371 reloc_overflow (struct bfd_link_info *info,
1372                 struct bfd_link_hash_entry *entry,
1373                 const char *name,
1374                 const char *reloc_name,
1375                 bfd_vma addend,
1376                 bfd *abfd,
1377                 asection *section,
1378                 bfd_vma address)
1379 {
1380   if (overflow_cutoff_limit == -1)
1381     return;
1382
1383   einfo ("%X%H:", abfd, section, address);
1384
1385   if (overflow_cutoff_limit >= 0
1386       && overflow_cutoff_limit-- == 0)
1387     {
1388       einfo (_(" additional relocation overflows omitted from the output\n"));
1389       return;
1390     }
1391
1392   if (entry)
1393     {
1394       while (entry->type == bfd_link_hash_indirect
1395              || entry->type == bfd_link_hash_warning)
1396         entry = entry->u.i.link;
1397       switch (entry->type)
1398         {
1399         case bfd_link_hash_undefined:
1400         case bfd_link_hash_undefweak:
1401           einfo (_(" relocation truncated to fit: "
1402                    "%s against undefined symbol `%T'"),
1403                  reloc_name, entry->root.string);
1404           break;
1405         case bfd_link_hash_defined:
1406         case bfd_link_hash_defweak:
1407           einfo (_(" relocation truncated to fit: "
1408                    "%s against symbol `%T' defined in %A section in %B"),
1409                  reloc_name, entry->root.string,
1410                  entry->u.def.section,
1411                  entry->u.def.section == bfd_abs_section_ptr
1412                  ? info->output_bfd : entry->u.def.section->owner);
1413           break;
1414         default:
1415           abort ();
1416           break;
1417         }
1418     }
1419   else
1420     einfo (_(" relocation truncated to fit: %s against `%T'"),
1421            reloc_name, name);
1422   if (addend != 0)
1423     einfo ("+%v", addend);
1424   einfo ("\n");
1425 }
1426
1427 /* This is called when a dangerous relocation is made.  */
1428
1429 static void
1430 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1431                  const char *message,
1432                  bfd *abfd,
1433                  asection *section,
1434                  bfd_vma address)
1435 {
1436   einfo (_("%X%H: dangerous relocation: %s\n"),
1437          abfd, section, address, message);
1438 }
1439
1440 /* This is called when a reloc is being generated attached to a symbol
1441    that is not being output.  */
1442
1443 static void
1444 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1445                   const char *name,
1446                   bfd *abfd,
1447                   asection *section,
1448                   bfd_vma address)
1449 {
1450   einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
1451          abfd, section, address, name);
1452 }
1453
1454 /* This is called if link_info.notice_all is set, or when a symbol in
1455    link_info.notice_hash is found.  Symbols are put in notice_hash
1456    using the -y option, while notice_all is set if the --cref option
1457    has been supplied, or if there are any NOCROSSREFS sections in the
1458    linker script; and if plugins are active, since they need to monitor
1459    all references from non-IR files.  */
1460
1461 static bfd_boolean
1462 notice (struct bfd_link_info *info,
1463         struct bfd_link_hash_entry *h,
1464         struct bfd_link_hash_entry *inh ATTRIBUTE_UNUSED,
1465         bfd *abfd,
1466         asection *section,
1467         bfd_vma value,
1468         flagword flags ATTRIBUTE_UNUSED)
1469 {
1470   const char *name;
1471
1472   if (h == NULL)
1473     {
1474       if (command_line.cref || nocrossref_list != NULL)
1475         return handle_asneeded_cref (abfd, (enum notice_asneeded_action) value);
1476       return TRUE;
1477     }
1478
1479   name = h->root.string;
1480   if (info->notice_hash != NULL
1481       && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
1482     {
1483       if (bfd_is_und_section (section))
1484         einfo ("%B: reference to %s\n", abfd, name);
1485       else
1486         einfo ("%B: definition of %s\n", abfd, name);
1487     }
1488
1489   if (command_line.cref || nocrossref_list != NULL)
1490     add_cref (name, abfd, section, value);
1491
1492   return TRUE;
1493 }