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