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