ld/ldmain.c

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