ld/ldmain.c

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