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