ld/ldmain.c

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