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