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