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