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