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