ld/ldmain.c

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