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