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