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