ld/ldmain.c

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