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