ld/ldmain.c

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