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