ld/ldmain.c

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