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