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