ld/ldmain.c

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