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