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                    || strcmp (argv[i], "-mips64r2") == 0)
 607             {
 608               /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
 609                  passed to the linker by some MIPS compilers.  They
 610                  generally tell the linker to use a slightly different
 611                  library path.  Perhaps someday these should be
 612                  implemented as emulations; until then, we just ignore
 613                  the arguments and hope that nobody ever creates
 614                  emulations named ips1, ips2 or ips3.  */
 615             }
 616           else if (strcmp (argv[i], "-m486") == 0)
 617             {
 618               /* FIXME: The argument -m486 is passed to the linker on
 619                  some Linux systems.  Hope that nobody creates an
 620                  emulation named 486.  */
 621             }
 622           else
 623             {
 624               /* -mEMUL */
 625               emulation = &argv[i][2];
 626             }
 627         }
 628     }
 629
 630   return emulation;
 631 }
 632
 633 /* If directory DIR contains an "ldscripts" subdirectory,
 634    add DIR to the library search path and return TRUE,
 635    else return FALSE.  */
 636
 637 static bfd_boolean
 638 check_for_scripts_dir (char *dir)
 639 {
 640   size_t dirlen;
 641   char *buf;
 642   struct stat s;
 643   bfd_boolean res;
 644
 645   dirlen = strlen (dir);
 646   /* sizeof counts the terminating NUL.  */
 647   buf = xmalloc (dirlen + sizeof ("/ldscripts"));
 648   sprintf (buf, "%s/ldscripts", dir);
 649
 650   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
 651   free (buf);
 652   if (res)
 653     ldfile_add_library_path (dir, FALSE);
 654   return res;
 655 }
 656
 657 /* Set the default directory for finding script files.
 658    Libraries will be searched for here too, but that's ok.
 659    We look for the "ldscripts" directory in:
 660
 661    SCRIPTDIR (passed from Makefile)
 662              (adjusted according to the current location of the binary)
 663    SCRIPTDIR (passed from Makefile)
 664    the dir where this program is (for using it from the build tree)
 665    the dir where this program is/../lib
 666              (for installing the tool suite elsewhere).  */
 667
 668 static void
 669 set_scripts_dir (void)
 670 {
 671   char *end, *dir;
 672   size_t dirlen;
 673   bfd_boolean found;
 674
 675   dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
 676   if (dir)
 677     {
 678       found = check_for_scripts_dir (dir);
 679       free (dir);
 680       if (found)
 681         return;
 682     }
 683
 684   dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
 685   if (dir)
 686     {
 687       found = check_for_scripts_dir (dir);
 688       free (dir);
 689       if (found)
 690         return;
 691     }
 692
 693   if (check_for_scripts_dir (SCRIPTDIR))
 694     /* We've been installed normally.  */
 695     return;
 696
 697   /* Look for "ldscripts" in the dir where our binary is.  */
 698   end = strrchr (program_name, '/');
 699 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 700   {
 701     /* We could have \foo\bar, or /foo\bar.  */
 702     char *bslash = strrchr (program_name, '\\');
 703
 704     if (end == NULL || (bslash != NULL && bslash > end))
 705       end = bslash;
 706   }
 707 #endif
 708
 709   if (end == NULL)
 710     /* Don't look for ldscripts in the current directory.  There is
 711        too much potential for confusion.  */
 712     return;
 713
 714   dirlen = end - program_name;
 715   /* Make a copy of program_name in dir.
 716      Leave room for later "/../lib".  */
 717   dir = xmalloc (dirlen + 8);
 718   strncpy (dir, program_name, dirlen);
 719   dir[dirlen] = '\0';
 720
 721   if (check_for_scripts_dir (dir))
 722     {
 723       free (dir);
 724       return;
 725     }
 726
 727   /* Look for "ldscripts" in <the dir where our binary is>/../lib.  */
 728   strcpy (dir + dirlen, "/../lib");
 729   check_for_scripts_dir (dir);
 730   free (dir);
 731 }
 732
 733 void
 734 add_ysym (const char *name)
 735 {
 736   if (link_info.notice_hash == NULL)
 737     {
 738       link_info.notice_hash = xmalloc (sizeof (struct bfd_hash_table));
 739       if (! bfd_hash_table_init_n (link_info.notice_hash,
 740                                    bfd_hash_newfunc,
 741                                    61))
 742         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 743     }
 744
 745   if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
 746     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 747 }
 748
 749 /* Record a symbol to be wrapped, from the --wrap option.  */
 750
 751 void
 752 add_wrap (const char *name)
 753 {
 754   if (link_info.wrap_hash == NULL)
 755     {
 756       link_info.wrap_hash = xmalloc (sizeof (struct bfd_hash_table));
 757       if (! bfd_hash_table_init_n (link_info.wrap_hash,
 758                                    bfd_hash_newfunc,
 759                                    61))
 760         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 761     }
 762
 763   if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
 764     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 765 }
 766
 767 /* Handle the -retain-symbols-file option.  */
 768
 769 void
 770 add_keepsyms_file (const char *filename)
 771 {
 772   FILE *file;
 773   char *buf;
 774   size_t bufsize;
 775   int c;
 776
 777   if (link_info.strip == strip_some)
 778     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 779
 780   file = fopen (filename, "r");
 781   if (file == NULL)
 782     {
 783       bfd_set_error (bfd_error_system_call);
 784       einfo ("%X%P: %s: %E\n", filename);
 785       return;
 786     }
 787
 788   link_info.keep_hash = xmalloc (sizeof (struct bfd_hash_table));
 789   if (! bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc))
 790     einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 791
 792   bufsize = 100;
 793   buf = xmalloc (bufsize);
 794
 795   c = getc (file);
 796   while (c != EOF)
 797     {
 798       while (ISSPACE (c))
 799         c = getc (file);
 800
 801       if (c != EOF)
 802         {
 803           size_t len = 0;
 804
 805           while (! ISSPACE (c) && c != EOF)
 806             {
 807               buf[len] = c;
 808               ++len;
 809               if (len >= bufsize)
 810                 {
 811                   bufsize *= 2;
 812                   buf = xrealloc (buf, bufsize);
 813                 }
 814               c = getc (file);
 815             }
 816
 817           buf[len] = '\0';
 818
 819           if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
 820             einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
 821         }
 822     }
 823
 824   if (link_info.strip != strip_none)
 825     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 826
 827   free (buf);
 828   link_info.strip = strip_some;
 829 }
 830 \f
 831 /* Callbacks from the BFD linker routines.  */
 832
 833 /* This is called when BFD has decided to include an archive member in
 834    a link.  */
 835
 836 static bfd_boolean
 837 add_archive_element (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 838                      bfd *abfd,
 839                      const char *name)
 840 {
 841   lang_input_statement_type *input;
 842
 843   input = xmalloc (sizeof (lang_input_statement_type));
 844   input->filename = abfd->filename;
 845   input->local_sym_name = abfd->filename;
 846   input->the_bfd = abfd;
 847   input->asymbols = NULL;
 848   input->next = NULL;
 849   input->just_syms_flag = FALSE;
 850   input->loaded = FALSE;
 851   input->search_dirs_flag = FALSE;
 852
 853   /* FIXME: The following fields are not set: header.next,
 854      header.type, closed, passive_position, symbol_count,
 855      next_real_file, is_archive, target, real.  This bit of code is
 856      from the old decode_library_subfile function.  I don't know
 857      whether any of those fields matters.  */
 858
 859   ldlang_add_file (input);
 860
 861   if (config.map_file != NULL)
 862     {
 863       static bfd_boolean header_printed;
 864       struct bfd_link_hash_entry *h;
 865       bfd *from;
 866       int len;
 867
 868       h = bfd_link_hash_lookup (link_info.hash, name, FALSE, FALSE, TRUE);
 869
 870       if (h == NULL)
 871         from = NULL;
 872       else
 873         {
 874           switch (h->type)
 875             {
 876             default:
 877               from = NULL;
 878               break;
 879
 880             case bfd_link_hash_defined:
 881             case bfd_link_hash_defweak:
 882               from = h->u.def.section->owner;
 883               break;
 884
 885             case bfd_link_hash_undefined:
 886             case bfd_link_hash_undefweak:
 887               from = h->u.undef.abfd;
 888               break;
 889
 890             case bfd_link_hash_common:
 891               from = h->u.c.p->section->owner;
 892               break;
 893             }
 894         }
 895
 896       if (! header_printed)
 897         {
 898           char buf[100];
 899
 900           sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
 901           minfo ("%s", buf);
 902           header_printed = TRUE;
 903         }
 904
 905       if (bfd_my_archive (abfd) == NULL)
 906         {
 907           minfo ("%s", bfd_get_filename (abfd));
 908           len = strlen (bfd_get_filename (abfd));
 909         }
 910       else
 911         {
 912           minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
 913                  bfd_get_filename (abfd));
 914           len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
 915                  + strlen (bfd_get_filename (abfd))
 916                  + 2);
 917         }
 918
 919       if (len >= 29)
 920         {
 921           print_nl ();
 922           len = 0;
 923         }
 924       while (len < 30)
 925         {
 926           print_space ();
 927           ++len;
 928         }
 929
 930       if (from != NULL)
 931         minfo ("%B ", from);
 932       if (h != NULL)
 933         minfo ("(%T)\n", h->root.string);
 934       else
 935         minfo ("(%s)\n", name);
 936     }
 937
 938   if (trace_files || trace_file_tries)
 939     info_msg ("%I\n", input);
 940
 941   return TRUE;
 942 }
 943
 944 /* This is called when BFD has discovered a symbol which is defined
 945    multiple times.  */
 946
 947 static bfd_boolean
 948 multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 949                      const char *name,
 950                      bfd *obfd,
 951                      asection *osec,
 952                      bfd_vma oval,
 953                      bfd *nbfd,
 954                      asection *nsec,
 955                      bfd_vma nval)
 956 {
 957   /* If either section has the output_section field set to
 958      bfd_abs_section_ptr, it means that the section is being
 959      discarded, and this is not really a multiple definition at all.
 960      FIXME: It would be cleaner to somehow ignore symbols defined in
 961      sections which are being discarded.  */
 962   if ((osec->output_section != NULL
 963        && ! bfd_is_abs_section (osec)
 964        && bfd_is_abs_section (osec->output_section))
 965       || (nsec->output_section != NULL
 966           && ! bfd_is_abs_section (nsec)
 967           && bfd_is_abs_section (nsec->output_section)))
 968     return TRUE;
 969
 970   einfo (_("%X%C: multiple definition of `%T'\n"),
 971          nbfd, nsec, nval, name);
 972   if (obfd != NULL)
 973     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 974
 975   if (command_line.relax)
 976     {
 977       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
 978       command_line.relax = 0;
 979     }
 980
 981   return TRUE;
 982 }
 983
 984 /* This is called when there is a definition of a common symbol, or
 985    when a common symbol is found for a symbol that is already defined,
 986    or when two common symbols are found.  We only do something if
 987    -warn-common was used.  */
 988
 989 static bfd_boolean
 990 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 991                  const char *name,
 992                  bfd *obfd,
 993                  enum bfd_link_hash_type otype,
 994                  bfd_vma osize,
 995                  bfd *nbfd,
 996                  enum bfd_link_hash_type ntype,
 997                  bfd_vma nsize)
 998 {
 999   if (! config.warn_common)
1000     return TRUE;
1001
1002   if (ntype == bfd_link_hash_defined
1003       || ntype == bfd_link_hash_defweak
1004       || ntype == bfd_link_hash_indirect)
1005     {
1006       ASSERT (otype == bfd_link_hash_common);
1007       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1008              nbfd, name);
1009       if (obfd != NULL)
1010         einfo (_("%B: warning: common is here\n"), obfd);
1011     }
1012   else if (otype == bfd_link_hash_defined
1013            || otype == bfd_link_hash_defweak
1014            || otype == bfd_link_hash_indirect)
1015     {
1016       ASSERT (ntype == bfd_link_hash_common);
1017       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1018              nbfd, name);
1019       if (obfd != NULL)
1020         einfo (_("%B: warning: defined here\n"), obfd);
1021     }
1022   else
1023     {
1024       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1025       if (osize > nsize)
1026         {
1027           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1028                  nbfd, name);
1029           if (obfd != NULL)
1030             einfo (_("%B: warning: larger common is here\n"), obfd);
1031         }
1032       else if (nsize > osize)
1033         {
1034           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1035                  nbfd, name);
1036           if (obfd != NULL)
1037             einfo (_("%B: warning: smaller common is here\n"), obfd);
1038         }
1039       else
1040         {
1041           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1042           if (obfd != NULL)
1043             einfo (_("%B: warning: previous common is here\n"), obfd);
1044         }
1045     }
1046
1047   return TRUE;
1048 }
1049
1050 /* This is called when BFD has discovered a set element.  H is the
1051    entry in the linker hash table for the set.  SECTION and VALUE
1052    represent a value which should be added to the set.  */
1053
1054 static bfd_boolean
1055 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1056             struct bfd_link_hash_entry *h,
1057             bfd_reloc_code_real_type reloc,
1058             bfd *abfd,
1059             asection *section,
1060             bfd_vma value)
1061 {
1062   if (config.warn_constructors)
1063     einfo (_("%P: warning: global constructor %s used\n"),
1064            h->root.string);
1065
1066   if (! config.build_constructors)
1067     return TRUE;
1068
1069   ldctor_add_set_entry (h, reloc, NULL, section, value);
1070
1071   if (h->type == bfd_link_hash_new)
1072     {
1073       h->type = bfd_link_hash_undefined;
1074       h->u.undef.abfd = abfd;
1075       /* We don't call bfd_link_add_undef to add this to the list of
1076          undefined symbols because we are going to define it
1077          ourselves.  */
1078     }
1079
1080   return TRUE;
1081 }
1082
1083 /* This is called when BFD has discovered a constructor.  This is only
1084    called for some object file formats--those which do not handle
1085    constructors in some more clever fashion.  This is similar to
1086    adding an element to a set, but less general.  */
1087
1088 static bfd_boolean
1089 constructor_callback (struct bfd_link_info *info,
1090                       bfd_boolean constructor,
1091                       const char *name,
1092                       bfd *abfd,
1093                       asection *section,
1094                       bfd_vma value)
1095 {
1096   char *s;
1097   struct bfd_link_hash_entry *h;
1098   char set_name[1 + sizeof "__CTOR_LIST__"];
1099
1100   if (config.warn_constructors)
1101     einfo (_("%P: warning: global constructor %s used\n"), name);
1102
1103   if (! config.build_constructors)
1104     return TRUE;
1105
1106   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1107      useful error message.  */
1108   if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL
1109       && (link_info.relocatable
1110           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1111     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1112
1113   s = set_name;
1114   if (bfd_get_symbol_leading_char (abfd) != '\0')
1115     *s++ = bfd_get_symbol_leading_char (abfd);
1116   if (constructor)
1117     strcpy (s, "__CTOR_LIST__");
1118   else
1119     strcpy (s, "__DTOR_LIST__");
1120
1121   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1122   if (h == (struct bfd_link_hash_entry *) NULL)
1123     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1124   if (h->type == bfd_link_hash_new)
1125     {
1126       h->type = bfd_link_hash_undefined;
1127       h->u.undef.abfd = abfd;
1128       /* We don't call bfd_link_add_undef to add this to the list of
1129          undefined symbols because we are going to define it
1130          ourselves.  */
1131     }
1132
1133   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1134   return TRUE;
1135 }
1136
1137 /* A structure used by warning_callback to pass information through
1138    bfd_map_over_sections.  */
1139
1140 struct warning_callback_info
1141 {
1142   bfd_boolean found;
1143   const char *warning;
1144   const char *symbol;
1145   asymbol **asymbols;
1146 };
1147
1148 /* This is called when there is a reference to a warning symbol.  */
1149
1150 static bfd_boolean
1151 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1152                   const char *warning,
1153                   const char *symbol,
1154                   bfd *abfd,
1155                   asection *section,
1156                   bfd_vma address)
1157 {
1158   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1159      have a cleaner interface, but what?  */
1160   if (! config.warn_multiple_gp
1161       && strcmp (warning, "using multiple gp values") == 0)
1162     return TRUE;
1163
1164   if (section != NULL)
1165     einfo ("%C: %s\n", abfd, section, address, warning);
1166   else if (abfd == NULL)
1167     einfo ("%P: %s\n", warning);
1168   else if (symbol == NULL)
1169     einfo ("%B: %s\n", abfd, warning);
1170   else
1171     {
1172       lang_input_statement_type *entry;
1173       asymbol **asymbols;
1174       struct warning_callback_info info;
1175
1176       /* Look through the relocs to see if we can find a plausible
1177          address.  */
1178       entry = (lang_input_statement_type *) abfd->usrdata;
1179       if (entry != NULL && entry->asymbols != NULL)
1180         asymbols = entry->asymbols;
1181       else
1182         {
1183           long symsize;
1184           long symbol_count;
1185
1186           symsize = bfd_get_symtab_upper_bound (abfd);
1187           if (symsize < 0)
1188             einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1189           asymbols = xmalloc (symsize);
1190           symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
1191           if (symbol_count < 0)
1192             einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1193           if (entry != NULL)
1194             {
1195               entry->asymbols = asymbols;
1196               entry->symbol_count = symbol_count;
1197             }
1198         }
1199
1200       info.found = FALSE;
1201       info.warning = warning;
1202       info.symbol = symbol;
1203       info.asymbols = asymbols;
1204       bfd_map_over_sections (abfd, warning_find_reloc, &info);
1205
1206       if (! info.found)
1207         einfo ("%B: %s\n", abfd, warning);
1208
1209       if (entry == NULL)
1210         free (asymbols);
1211     }
1212
1213   return TRUE;
1214 }
1215
1216 /* This is called by warning_callback for each section.  It checks the
1217    relocs of the section to see if it can find a reference to the
1218    symbol which triggered the warning.  If it can, it uses the reloc
1219    to give an error message with a file and line number.  */
1220
1221 static void
1222 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1223 {
1224   struct warning_callback_info *info = iarg;
1225   long relsize;
1226   arelent **relpp;
1227   long relcount;
1228   arelent **p, **pend;
1229
1230   if (info->found)
1231     return;
1232
1233   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1234   if (relsize < 0)
1235     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1236   if (relsize == 0)
1237     return;
1238
1239   relpp = xmalloc (relsize);
1240   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1241   if (relcount < 0)
1242     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1243
1244   p = relpp;
1245   pend = p + relcount;
1246   for (; p < pend && *p != NULL; p++)
1247     {
1248       arelent *q = *p;
1249
1250       if (q->sym_ptr_ptr != NULL
1251           && *q->sym_ptr_ptr != NULL
1252           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1253         {
1254           /* We found a reloc for the symbol we are looking for.  */
1255           einfo ("%C: %s\n", abfd, sec, q->address, info->warning);
1256           info->found = TRUE;
1257           break;
1258         }
1259     }
1260
1261   free (relpp);
1262 }
1263
1264 /* This is called when an undefined symbol is found.  */
1265
1266 static bfd_boolean
1267 undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1268                   const char *name,
1269                   bfd *abfd,
1270                   asection *section,
1271                   bfd_vma address,
1272                   bfd_boolean error)
1273 {
1274   static char *error_name;
1275   static unsigned int error_count;
1276
1277 #define MAX_ERRORS_IN_A_ROW 5
1278
1279   if (config.warn_once)
1280     {
1281       static struct bfd_hash_table *hash;
1282
1283       /* Only warn once about a particular undefined symbol.  */
1284       if (hash == NULL)
1285         {
1286           hash = xmalloc (sizeof (struct bfd_hash_table));
1287           if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
1288             einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1289         }
1290
1291       if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1292         return TRUE;
1293
1294       if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1295         einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1296     }
1297
1298   /* We never print more than a reasonable number of errors in a row
1299      for a single symbol.  */
1300   if (error_name != NULL
1301       && strcmp (name, error_name) == 0)
1302     ++error_count;
1303   else
1304     {
1305       error_count = 0;
1306       if (error_name != NULL)
1307         free (error_name);
1308       error_name = xstrdup (name);
1309     }
1310
1311   if (section != NULL)
1312     {
1313       if (error_count < MAX_ERRORS_IN_A_ROW)
1314         {
1315           if (error)
1316             einfo (_("%X%C: undefined reference to `%T'\n"),
1317                    abfd, section, address, name);
1318           else
1319             einfo (_("%C: warning: undefined reference to `%T'\n"),
1320                    abfd, section, address, name);
1321         }
1322       else if (error_count == MAX_ERRORS_IN_A_ROW)
1323         {
1324           if (error)
1325             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1326                    abfd, section, address, name);
1327           else
1328             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1329                    abfd, section, address, name);
1330         }
1331       else if (error)
1332         einfo ("%X");
1333     }
1334   else
1335     {
1336       if (error_count < MAX_ERRORS_IN_A_ROW)
1337         {
1338           if (error)
1339             einfo (_("%X%B: undefined reference to `%T'\n"),
1340                    abfd, name);
1341           else
1342             einfo (_("%B: warning: undefined reference to `%T'\n"),
1343                    abfd, name);
1344         }
1345       else if (error_count == MAX_ERRORS_IN_A_ROW)
1346         {
1347           if (error)
1348             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1349                    abfd, name);
1350           else
1351             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1352                    abfd, name);
1353         }
1354       else if (error)
1355         einfo ("%X");
1356     }
1357
1358   return TRUE;
1359 }
1360
1361 /* Counter to limit the number of relocation overflow error messages
1362    to print.  Errors are printed as it is decremented.  When it's
1363    called and the counter is zero, a final message is printed
1364    indicating more relocations were omitted.  When it gets to -1, no
1365    such errors are printed.  If it's initially set to a value less
1366    than -1, all such errors will be printed (--verbose does this).  */
1367
1368 int overflow_cutoff_limit = 10;
1369
1370 /* This is called when a reloc overflows.  */
1371
1372 static bfd_boolean
1373 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1374                 const char *name,
1375                 const char *reloc_name,
1376                 bfd_vma addend,
1377                 bfd *abfd,
1378                 asection *section,
1379                 bfd_vma address)
1380 {
1381   if (overflow_cutoff_limit == -1)
1382     return TRUE;
1383
1384   if (abfd == NULL)
1385     einfo (_("%P%X: generated"));
1386   else
1387     einfo ("%X%C:", abfd, section, address);
1388
1389   if (overflow_cutoff_limit >= 0
1390       && overflow_cutoff_limit-- == 0)
1391     {
1392       einfo (_(" additional relocation overflows omitted from the output\n"));
1393       return TRUE;
1394     }
1395
1396   einfo (_(" relocation truncated to fit: %s %T"), reloc_name, name);
1397   if (addend != 0)
1398     einfo ("+%v", addend);
1399   einfo ("\n");
1400   return TRUE;
1401 }
1402
1403 /* This is called when a dangerous relocation is made.  */
1404
1405 static bfd_boolean
1406 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1407                  const char *message,
1408                  bfd *abfd,
1409                  asection *section,
1410                  bfd_vma address)
1411 {
1412   if (abfd == NULL)
1413     einfo (_("%P%X: generated"));
1414   else
1415     einfo ("%X%C:", abfd, section, address);
1416   einfo (_("dangerous relocation: %s\n"), message);
1417   return TRUE;
1418 }
1419
1420 /* This is called when a reloc is being generated attached to a symbol
1421    that is not being output.  */
1422
1423 static bfd_boolean
1424 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1425                   const char *name,
1426                   bfd *abfd,
1427                   asection *section,
1428                   bfd_vma address)
1429 {
1430   if (abfd == NULL)
1431     einfo (_("%P%X: generated"));
1432   else
1433     einfo ("%X%C:", abfd, section, address);
1434   einfo (_(" reloc refers to symbol `%T' which is not being output\n"), name);
1435   return TRUE;
1436 }
1437
1438 /* This is called if link_info.notice_all is set, or when a symbol in
1439    link_info.notice_hash is found.  Symbols are put in notice_hash
1440    using the -y option.  */
1441
1442 static bfd_boolean
1443 notice (struct bfd_link_info *info,
1444         const char *name,
1445         bfd *abfd,
1446         asection *section,
1447         bfd_vma value)
1448 {
1449   if (! info->notice_all
1450       || (info->notice_hash != NULL
1451           && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1452     {
1453       if (bfd_is_und_section (section))
1454         einfo ("%B: reference to %s\n", abfd, name);
1455       else
1456         einfo ("%B: definition of %s\n", abfd, name);
1457     }
1458
1459   if (command_line.cref || nocrossref_list != NULL)
1460     add_cref (name, abfd, section, value);
1461
1462   return TRUE;
1463 }