ld/ldmain.c

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