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