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