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