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