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