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