ld/ldmain.c

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