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
 280   ldfile_add_arch ("");
 281   emulation = get_emulation (argc, argv);
 282   ldemul_choose_mode (emulation);
 283   default_target = ldemul_choose_target (argc, argv);
 284   lang_init ();
 285   ldemul_before_parse ();
 286   lang_has_input_file = FALSE;
 287   parse_args (argc, argv);
 288
 289   if (config.hash_table_size != 0)
 290     bfd_hash_set_default_size (config.hash_table_size);
 291
 292   ldemul_set_symbols ();
 293
 294   if (link_info.relocatable)
 295     {
 296       if (command_line.relax)
 297         einfo (_("%P%F: --relax and -r may not be used together\n"));
 298       if (link_info.shared)
 299         einfo (_("%P%F: -r and -shared may not be used together\n"));
 300     }
 301
 302   /* We may have -Bsymbolic, -Bsymbolic-functions, --dynamic-list-data,
 303      --dynamic-list-cpp-new, --dynamic-list-cpp-typeinfo and
 304      --dynamic-list FILE.  -Bsymbolic and -Bsymbolic-functions are
 305      for shared libraries.  -Bsymbolic overrides all others and vice
 306      versa.  */
 307   switch (command_line.symbolic)
 308     {
 309     case symbolic_unset:
 310       break;
 311     case symbolic:
 312       /* -Bsymbolic is for shared library only.  */
 313       if (link_info.shared)
 314         {
 315           link_info.symbolic = TRUE;
 316           /* Should we free the unused memory?  */
 317           link_info.dynamic_list = NULL;
 318           command_line.dynamic_list = dynamic_list_unset;
 319         }
 320       break;
 321     case symbolic_functions:
 322       /* -Bsymbolic-functions is for shared library only.  */
 323       if (link_info.shared)
 324         command_line.dynamic_list = dynamic_list_data;
 325       break;
 326     }
 327
 328   switch (command_line.dynamic_list)
 329     {
 330     case dynamic_list_unset:
 331       break;
 332     case dynamic_list_data:
 333       link_info.dynamic_data = TRUE;
 334     case dynamic_list:
 335       link_info.dynamic = TRUE;
 336       break;
 337     }
 338
 339   if (! link_info.shared)
 340     {
 341       if (command_line.filter_shlib)
 342         einfo (_("%P%F: -F may not be used without -shared\n"));
 343       if (command_line.auxiliary_filters)
 344         einfo (_("%P%F: -f may not be used without -shared\n"));
 345     }
 346
 347   if (! link_info.shared || link_info.pie)
 348     link_info.executable = TRUE;
 349
 350   /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols).  I
 351      don't see how else this can be handled, since in this case we
 352      must preserve all externally visible symbols.  */
 353   if (link_info.relocatable && link_info.strip == strip_all)
 354     {
 355       link_info.strip = strip_debugger;
 356       if (link_info.discard == discard_sec_merge)
 357         link_info.discard = discard_all;
 358     }
 359
 360   /* This essentially adds another -L directory so this must be done after
 361      the -L's in argv have been processed.  */
 362   set_scripts_dir ();
 363
 364   /* If we have not already opened and parsed a linker script,
 365      try the default script from command line first.  */
 366   if (saved_script_handle == NULL
 367       && command_line.default_script != NULL)
 368     {
 369       ldfile_open_command_file (command_line.default_script);
 370       parser_input = input_script;
 371       yyparse ();
 372     }
 373
 374   /* If we have not already opened and parsed a linker script
 375      read the emulation's appropriate default script.  */
 376   if (saved_script_handle == NULL)
 377     {
 378       int isfile;
 379       char *s = ldemul_get_script (&isfile);
 380
 381       if (isfile)
 382         ldfile_open_command_file (s);
 383       else
 384         {
 385           lex_string = s;
 386           lex_redirect (s);
 387         }
 388       parser_input = input_script;
 389       yyparse ();
 390       lex_string = NULL;
 391     }
 392
 393   if (trace_file_tries)
 394     {
 395       if (saved_script_handle)
 396         info_msg (_("using external linker script:"));
 397       else
 398         info_msg (_("using internal linker script:"));
 399       info_msg ("\n==================================================\n");
 400
 401       if (saved_script_handle)
 402         {
 403           static const int ld_bufsz = 8193;
 404           size_t n;
 405           char *buf = xmalloc (ld_bufsz);
 406
 407           rewind (saved_script_handle);
 408           while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
 409             {
 410               buf[n] = 0;
 411               info_msg (buf);
 412             }
 413           rewind (saved_script_handle);
 414           free (buf);
 415         }
 416       else
 417         {
 418           int isfile;
 419
 420           info_msg (ldemul_get_script (&isfile));
 421         }
 422
 423       info_msg ("\n==================================================\n");
 424     }
 425
 426   lang_final ();
 427
 428   if (!lang_has_input_file)
 429     {
 430       if (version_printed)
 431         xexit (0);
 432       einfo (_("%P%F: no input files\n"));
 433     }
 434
 435   if (trace_files)
 436     info_msg (_("%P: mode %s\n"), emulation);
 437
 438   ldemul_after_parse ();
 439
 440   if (config.map_filename)
 441     {
 442       if (strcmp (config.map_filename, "-") == 0)
 443         {
 444           config.map_file = stdout;
 445         }
 446       else
 447         {
 448           config.map_file = fopen (config.map_filename, FOPEN_WT);
 449           if (config.map_file == (FILE *) NULL)
 450             {
 451               bfd_set_error (bfd_error_system_call);
 452               einfo (_("%P%F: cannot open map file %s: %E\n"),
 453                      config.map_filename);
 454             }
 455         }
 456     }
 457
 458   lang_process ();
 459
 460   /* Print error messages for any missing symbols, for any warning
 461      symbols, and possibly multiple definitions.  */
 462   if (link_info.relocatable)
 463     link_info.output_bfd->flags &= ~EXEC_P;
 464   else
 465     link_info.output_bfd->flags |= EXEC_P;
 466
 467   ldwrite ();
 468
 469   if (config.map_file != NULL)
 470     lang_map ();
 471   if (command_line.cref)
 472     output_cref (config.map_file != NULL ? config.map_file : stdout);
 473   if (nocrossref_list != NULL)
 474     check_nocrossrefs ();
 475
 476   lang_finish ();
 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 (link_info.output_bfd))
 493         einfo (_("%F%B: final close failed: %E\n"), link_info.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 (CONST_STRNEQ (argv[i], "--sysroot="))
 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 (CONST_STRNEQ (argv[i], "-m"))
 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                                   sizeof (struct bfd_hash_entry),
 782                                   61))
 783         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 784     }
 785
 786   if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)
 787     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 788 }
 789
 790 /* Record a symbol to be wrapped, from the --wrap option.  */
 791
 792 void
 793 add_wrap (const char *name)
 794 {
 795   if (link_info.wrap_hash == NULL)
 796     {
 797       link_info.wrap_hash = xmalloc (sizeof (struct bfd_hash_table));
 798       if (!bfd_hash_table_init_n (link_info.wrap_hash,
 799                                   bfd_hash_newfunc,
 800                                   sizeof (struct bfd_hash_entry),
 801                                   61))
 802         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 803     }
 804
 805   if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)
 806     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 807 }
 808
 809 /* Handle the -retain-symbols-file option.  */
 810
 811 void
 812 add_keepsyms_file (const char *filename)
 813 {
 814   FILE *file;
 815   char *buf;
 816   size_t bufsize;
 817   int c;
 818
 819   if (link_info.strip == strip_some)
 820     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 821
 822   file = fopen (filename, "r");
 823   if (file == NULL)
 824     {
 825       bfd_set_error (bfd_error_system_call);
 826       einfo ("%X%P: %s: %E\n", filename);
 827       return;
 828     }
 829
 830   link_info.keep_hash = xmalloc (sizeof (struct bfd_hash_table));
 831   if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
 832                             sizeof (struct bfd_hash_entry)))
 833     einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 834
 835   bufsize = 100;
 836   buf = xmalloc (bufsize);
 837
 838   c = getc (file);
 839   while (c != EOF)
 840     {
 841       while (ISSPACE (c))
 842         c = getc (file);
 843
 844       if (c != EOF)
 845         {
 846           size_t len = 0;
 847
 848           while (! ISSPACE (c) && c != EOF)
 849             {
 850               buf[len] = c;
 851               ++len;
 852               if (len >= bufsize)
 853                 {
 854                   bufsize *= 2;
 855                   buf = xrealloc (buf, bufsize);
 856                 }
 857               c = getc (file);
 858             }
 859
 860           buf[len] = '\0';
 861
 862           if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
 863             einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
 864         }
 865     }
 866
 867   if (link_info.strip != strip_none)
 868     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 869
 870   free (buf);
 871   link_info.strip = strip_some;
 872 }
 873 \f
 874 /* Callbacks from the BFD linker routines.  */
 875
 876 /* This is called when BFD has decided to include an archive member in
 877    a link.  */
 878
 879 static bfd_boolean
 880 add_archive_element (struct bfd_link_info *info,
 881                      bfd *abfd,
 882                      const char *name)
 883 {
 884   lang_input_statement_type *input;
 885
 886   input = xmalloc (sizeof (lang_input_statement_type));
 887   input->filename = abfd->filename;
 888   input->local_sym_name = abfd->filename;
 889   input->the_bfd = abfd;
 890   input->asymbols = NULL;
 891   input->next = NULL;
 892   input->just_syms_flag = FALSE;
 893   input->loaded = FALSE;
 894   input->search_dirs_flag = FALSE;
 895
 896   /* FIXME: The following fields are not set: header.next,
 897      header.type, closed, passive_position, symbol_count,
 898      next_real_file, is_archive, target, real.  This bit of code is
 899      from the old decode_library_subfile function.  I don't know
 900      whether any of those fields matters.  */
 901
 902   ldlang_add_file (input);
 903
 904   if (config.map_file != NULL)
 905     {
 906       static bfd_boolean header_printed;
 907       struct bfd_link_hash_entry *h;
 908       bfd *from;
 909       int len;
 910
 911       h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 912
 913       if (h == NULL)
 914         from = NULL;
 915       else
 916         {
 917           switch (h->type)
 918             {
 919             default:
 920               from = NULL;
 921               break;
 922
 923             case bfd_link_hash_defined:
 924             case bfd_link_hash_defweak:
 925               from = h->u.def.section->owner;
 926               break;
 927
 928             case bfd_link_hash_undefined:
 929             case bfd_link_hash_undefweak:
 930               from = h->u.undef.abfd;
 931               break;
 932
 933             case bfd_link_hash_common:
 934               from = h->u.c.p->section->owner;
 935               break;
 936             }
 937         }
 938
 939       if (! header_printed)
 940         {
 941           char buf[100];
 942
 943           sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
 944           minfo ("%s", buf);
 945           header_printed = TRUE;
 946         }
 947
 948       if (bfd_my_archive (abfd) == NULL)
 949         {
 950           minfo ("%s", bfd_get_filename (abfd));
 951           len = strlen (bfd_get_filename (abfd));
 952         }
 953       else
 954         {
 955           minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
 956                  bfd_get_filename (abfd));
 957           len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
 958                  + strlen (bfd_get_filename (abfd))
 959                  + 2);
 960         }
 961
 962       if (len >= 29)
 963         {
 964           print_nl ();
 965           len = 0;
 966         }
 967       while (len < 30)
 968         {
 969           print_space ();
 970           ++len;
 971         }
 972
 973       if (from != NULL)
 974         minfo ("%B ", from);
 975       if (h != NULL)
 976         minfo ("(%T)\n", h->root.string);
 977       else
 978         minfo ("(%s)\n", name);
 979     }
 980
 981   if (trace_files || trace_file_tries)
 982     info_msg ("%I\n", input);
 983
 984   return TRUE;
 985 }
 986
 987 /* This is called when BFD has discovered a symbol which is defined
 988    multiple times.  */
 989
 990 static bfd_boolean
 991 multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 992                      const char *name,
 993                      bfd *obfd,
 994                      asection *osec,
 995                      bfd_vma oval,
 996                      bfd *nbfd,
 997                      asection *nsec,
 998                      bfd_vma nval)
 999 {
1000   /* If either section has the output_section field set to
1001      bfd_abs_section_ptr, it means that the section is being
1002      discarded, and this is not really a multiple definition at all.
1003      FIXME: It would be cleaner to somehow ignore symbols defined in
1004      sections which are being discarded.  */
1005   if ((osec->output_section != NULL
1006        && ! bfd_is_abs_section (osec)
1007        && bfd_is_abs_section (osec->output_section))
1008       || (nsec->output_section != NULL
1009           && ! bfd_is_abs_section (nsec)
1010           && bfd_is_abs_section (nsec->output_section)))
1011     return TRUE;
1012
1013   einfo (_("%X%C: multiple definition of `%T'\n"),
1014          nbfd, nsec, nval, name);
1015   if (obfd != NULL)
1016     einfo (_("%D: first defined here\n"), obfd, osec, oval);
1017
1018   if (command_line.relax)
1019     {
1020       einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
1021       command_line.relax = 0;
1022     }
1023
1024   return TRUE;
1025 }
1026
1027 /* This is called when there is a definition of a common symbol, or
1028    when a common symbol is found for a symbol that is already defined,
1029    or when two common symbols are found.  We only do something if
1030    -warn-common was used.  */
1031
1032 static bfd_boolean
1033 multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1034                  const char *name,
1035                  bfd *obfd,
1036                  enum bfd_link_hash_type otype,
1037                  bfd_vma osize,
1038                  bfd *nbfd,
1039                  enum bfd_link_hash_type ntype,
1040                  bfd_vma nsize)
1041 {
1042   if (! config.warn_common)
1043     return TRUE;
1044
1045   if (ntype == bfd_link_hash_defined
1046       || ntype == bfd_link_hash_defweak
1047       || ntype == bfd_link_hash_indirect)
1048     {
1049       ASSERT (otype == bfd_link_hash_common);
1050       einfo (_("%B: warning: definition of `%T' overriding common\n"),
1051              nbfd, name);
1052       if (obfd != NULL)
1053         einfo (_("%B: warning: common is here\n"), obfd);
1054     }
1055   else if (otype == bfd_link_hash_defined
1056            || otype == bfd_link_hash_defweak
1057            || otype == bfd_link_hash_indirect)
1058     {
1059       ASSERT (ntype == bfd_link_hash_common);
1060       einfo (_("%B: warning: common of `%T' overridden by definition\n"),
1061              nbfd, name);
1062       if (obfd != NULL)
1063         einfo (_("%B: warning: defined here\n"), obfd);
1064     }
1065   else
1066     {
1067       ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
1068       if (osize > nsize)
1069         {
1070           einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
1071                  nbfd, name);
1072           if (obfd != NULL)
1073             einfo (_("%B: warning: larger common is here\n"), obfd);
1074         }
1075       else if (nsize > osize)
1076         {
1077           einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
1078                  nbfd, name);
1079           if (obfd != NULL)
1080             einfo (_("%B: warning: smaller common is here\n"), obfd);
1081         }
1082       else
1083         {
1084           einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
1085           if (obfd != NULL)
1086             einfo (_("%B: warning: previous common is here\n"), obfd);
1087         }
1088     }
1089
1090   return TRUE;
1091 }
1092
1093 /* This is called when BFD has discovered a set element.  H is the
1094    entry in the linker hash table for the set.  SECTION and VALUE
1095    represent a value which should be added to the set.  */
1096
1097 static bfd_boolean
1098 add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1099             struct bfd_link_hash_entry *h,
1100             bfd_reloc_code_real_type reloc,
1101             bfd *abfd,
1102             asection *section,
1103             bfd_vma value)
1104 {
1105   if (config.warn_constructors)
1106     einfo (_("%P: warning: global constructor %s used\n"),
1107            h->root.string);
1108
1109   if (! config.build_constructors)
1110     return TRUE;
1111
1112   ldctor_add_set_entry (h, reloc, NULL, section, value);
1113
1114   if (h->type == bfd_link_hash_new)
1115     {
1116       h->type = bfd_link_hash_undefined;
1117       h->u.undef.abfd = abfd;
1118       /* We don't call bfd_link_add_undef to add this to the list of
1119          undefined symbols because we are going to define it
1120          ourselves.  */
1121     }
1122
1123   return TRUE;
1124 }
1125
1126 /* This is called when BFD has discovered a constructor.  This is only
1127    called for some object file formats--those which do not handle
1128    constructors in some more clever fashion.  This is similar to
1129    adding an element to a set, but less general.  */
1130
1131 static bfd_boolean
1132 constructor_callback (struct bfd_link_info *info,
1133                       bfd_boolean constructor,
1134                       const char *name,
1135                       bfd *abfd,
1136                       asection *section,
1137                       bfd_vma value)
1138 {
1139   char *s;
1140   struct bfd_link_hash_entry *h;
1141   char set_name[1 + sizeof "__CTOR_LIST__"];
1142
1143   if (config.warn_constructors)
1144     einfo (_("%P: warning: global constructor %s used\n"), name);
1145
1146   if (! config.build_constructors)
1147     return TRUE;
1148
1149   /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
1150      useful error message.  */
1151   if (bfd_reloc_type_lookup (link_info.output_bfd, BFD_RELOC_CTOR) == NULL
1152       && (info->relocatable
1153           || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
1154     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
1155
1156   s = set_name;
1157   if (bfd_get_symbol_leading_char (abfd) != '\0')
1158     *s++ = bfd_get_symbol_leading_char (abfd);
1159   if (constructor)
1160     strcpy (s, "__CTOR_LIST__");
1161   else
1162     strcpy (s, "__DTOR_LIST__");
1163
1164   h = bfd_link_hash_lookup (info->hash, set_name, TRUE, TRUE, TRUE);
1165   if (h == (struct bfd_link_hash_entry *) NULL)
1166     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1167   if (h->type == bfd_link_hash_new)
1168     {
1169       h->type = bfd_link_hash_undefined;
1170       h->u.undef.abfd = abfd;
1171       /* We don't call bfd_link_add_undef to add this to the list of
1172          undefined symbols because we are going to define it
1173          ourselves.  */
1174     }
1175
1176   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
1177   return TRUE;
1178 }
1179
1180 /* A structure used by warning_callback to pass information through
1181    bfd_map_over_sections.  */
1182
1183 struct warning_callback_info
1184 {
1185   bfd_boolean found;
1186   const char *warning;
1187   const char *symbol;
1188   asymbol **asymbols;
1189 };
1190
1191 /* This is called when there is a reference to a warning symbol.  */
1192
1193 static bfd_boolean
1194 warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1195                   const char *warning,
1196                   const char *symbol,
1197                   bfd *abfd,
1198                   asection *section,
1199                   bfd_vma address)
1200 {
1201   /* This is a hack to support warn_multiple_gp.  FIXME: This should
1202      have a cleaner interface, but what?  */
1203   if (! config.warn_multiple_gp
1204       && strcmp (warning, "using multiple gp values") == 0)
1205     return TRUE;
1206
1207   if (section != NULL)
1208     einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
1209   else if (abfd == NULL)
1210     einfo ("%P: %s%s\n", _("warning: "), warning);
1211   else if (symbol == NULL)
1212     einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1213   else
1214     {
1215       lang_input_statement_type *entry;
1216       asymbol **asymbols;
1217       struct warning_callback_info info;
1218
1219       /* Look through the relocs to see if we can find a plausible
1220          address.  */
1221       entry = (lang_input_statement_type *) abfd->usrdata;
1222       if (entry != NULL && entry->asymbols != NULL)
1223         asymbols = entry->asymbols;
1224       else
1225         {
1226           long symsize;
1227           long symbol_count;
1228
1229           symsize = bfd_get_symtab_upper_bound (abfd);
1230           if (symsize < 0)
1231             einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1232           asymbols = xmalloc (symsize);
1233           symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
1234           if (symbol_count < 0)
1235             einfo (_("%B%F: could not read symbols: %E\n"), abfd);
1236           if (entry != NULL)
1237             {
1238               entry->asymbols = asymbols;
1239               entry->symbol_count = symbol_count;
1240             }
1241         }
1242
1243       info.found = FALSE;
1244       info.warning = warning;
1245       info.symbol = symbol;
1246       info.asymbols = asymbols;
1247       bfd_map_over_sections (abfd, warning_find_reloc, &info);
1248
1249       if (! info.found)
1250         einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
1251
1252       if (entry == NULL)
1253         free (asymbols);
1254     }
1255
1256   return TRUE;
1257 }
1258
1259 /* This is called by warning_callback for each section.  It checks the
1260    relocs of the section to see if it can find a reference to the
1261    symbol which triggered the warning.  If it can, it uses the reloc
1262    to give an error message with a file and line number.  */
1263
1264 static void
1265 warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1266 {
1267   struct warning_callback_info *info = iarg;
1268   long relsize;
1269   arelent **relpp;
1270   long relcount;
1271   arelent **p, **pend;
1272
1273   if (info->found)
1274     return;
1275
1276   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1277   if (relsize < 0)
1278     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1279   if (relsize == 0)
1280     return;
1281
1282   relpp = xmalloc (relsize);
1283   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
1284   if (relcount < 0)
1285     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
1286
1287   p = relpp;
1288   pend = p + relcount;
1289   for (; p < pend && *p != NULL; p++)
1290     {
1291       arelent *q = *p;
1292
1293       if (q->sym_ptr_ptr != NULL
1294           && *q->sym_ptr_ptr != NULL
1295           && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
1296         {
1297           /* We found a reloc for the symbol we are looking for.  */
1298           einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
1299                  info->warning);
1300           info->found = TRUE;
1301           break;
1302         }
1303     }
1304
1305   free (relpp);
1306 }
1307
1308 /* This is called when an undefined symbol is found.  */
1309
1310 static bfd_boolean
1311 undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1312                   const char *name,
1313                   bfd *abfd,
1314                   asection *section,
1315                   bfd_vma address,
1316                   bfd_boolean error)
1317 {
1318   static char *error_name;
1319   static unsigned int error_count;
1320
1321 #define MAX_ERRORS_IN_A_ROW 5
1322
1323   if (config.warn_once)
1324     {
1325       static struct bfd_hash_table *hash;
1326
1327       /* Only warn once about a particular undefined symbol.  */
1328       if (hash == NULL)
1329         {
1330           hash = xmalloc (sizeof (struct bfd_hash_table));
1331           if (!bfd_hash_table_init (hash, bfd_hash_newfunc,
1332                                     sizeof (struct bfd_hash_entry)))
1333             einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
1334         }
1335
1336       if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
1337         return TRUE;
1338
1339       if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
1340         einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
1341     }
1342
1343   /* We never print more than a reasonable number of errors in a row
1344      for a single symbol.  */
1345   if (error_name != NULL
1346       && strcmp (name, error_name) == 0)
1347     ++error_count;
1348   else
1349     {
1350       error_count = 0;
1351       if (error_name != NULL)
1352         free (error_name);
1353       error_name = xstrdup (name);
1354     }
1355
1356   if (section != NULL)
1357     {
1358       if (error_count < MAX_ERRORS_IN_A_ROW)
1359         {
1360           if (error)
1361             einfo (_("%X%C: undefined reference to `%T'\n"),
1362                    abfd, section, address, name);
1363           else
1364             einfo (_("%C: warning: undefined reference to `%T'\n"),
1365                    abfd, section, address, name);
1366         }
1367       else if (error_count == MAX_ERRORS_IN_A_ROW)
1368         {
1369           if (error)
1370             einfo (_("%X%D: more undefined references to `%T' follow\n"),
1371                    abfd, section, address, name);
1372           else
1373             einfo (_("%D: warning: more undefined references to `%T' follow\n"),
1374                    abfd, section, address, name);
1375         }
1376       else if (error)
1377         einfo ("%X");
1378     }
1379   else
1380     {
1381       if (error_count < MAX_ERRORS_IN_A_ROW)
1382         {
1383           if (error)
1384             einfo (_("%X%B: undefined reference to `%T'\n"),
1385                    abfd, name);
1386           else
1387             einfo (_("%B: warning: undefined reference to `%T'\n"),
1388                    abfd, name);
1389         }
1390       else if (error_count == MAX_ERRORS_IN_A_ROW)
1391         {
1392           if (error)
1393             einfo (_("%X%B: more undefined references to `%T' follow\n"),
1394                    abfd, name);
1395           else
1396             einfo (_("%B: warning: more undefined references to `%T' follow\n"),
1397                    abfd, name);
1398         }
1399       else if (error)
1400         einfo ("%X");
1401     }
1402
1403   return TRUE;
1404 }
1405
1406 /* Counter to limit the number of relocation overflow error messages
1407    to print.  Errors are printed as it is decremented.  When it's
1408    called and the counter is zero, a final message is printed
1409    indicating more relocations were omitted.  When it gets to -1, no
1410    such errors are printed.  If it's initially set to a value less
1411    than -1, all such errors will be printed (--verbose does this).  */
1412
1413 int overflow_cutoff_limit = 10;
1414
1415 /* This is called when a reloc overflows.  */
1416
1417 static bfd_boolean
1418 reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1419                 struct bfd_link_hash_entry *entry,
1420                 const char *name,
1421                 const char *reloc_name,
1422                 bfd_vma addend,
1423                 bfd *abfd,
1424                 asection *section,
1425                 bfd_vma address)
1426 {
1427   if (overflow_cutoff_limit == -1)
1428     return TRUE;
1429
1430   einfo ("%X%C:", abfd, section, address);
1431
1432   if (overflow_cutoff_limit >= 0
1433       && overflow_cutoff_limit-- == 0)
1434     {
1435       einfo (_(" additional relocation overflows omitted from the output\n"));
1436       return TRUE;
1437     }
1438
1439   if (entry)
1440     {
1441       while (entry->type == bfd_link_hash_indirect
1442              || entry->type == bfd_link_hash_warning)
1443         entry = entry->u.i.link;
1444       switch (entry->type)
1445         {
1446         case bfd_link_hash_undefined:
1447         case bfd_link_hash_undefweak:
1448           einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
1449                  reloc_name, entry->root.string);
1450           break;
1451         case bfd_link_hash_defined:
1452         case bfd_link_hash_defweak:
1453           einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
1454                  reloc_name, entry->root.string,
1455                  entry->u.def.section,
1456                  entry->u.def.section == bfd_abs_section_ptr
1457                  ? link_info.output_bfd : entry->u.def.section->owner);
1458           break;
1459         default:
1460           abort ();
1461           break;
1462         }
1463     }
1464   else
1465     einfo (_(" relocation truncated to fit: %s against `%T'"),
1466            reloc_name, name);
1467   if (addend != 0)
1468     einfo ("+%v", addend);
1469   einfo ("\n");
1470   return TRUE;
1471 }
1472
1473 /* This is called when a dangerous relocation is made.  */
1474
1475 static bfd_boolean
1476 reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1477                  const char *message,
1478                  bfd *abfd,
1479                  asection *section,
1480                  bfd_vma address)
1481 {
1482   einfo (_("%X%C: dangerous relocation: %s\n"),
1483          abfd, section, address, message);
1484   return TRUE;
1485 }
1486
1487 /* This is called when a reloc is being generated attached to a symbol
1488    that is not being output.  */
1489
1490 static bfd_boolean
1491 unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1492                   const char *name,
1493                   bfd *abfd,
1494                   asection *section,
1495                   bfd_vma address)
1496 {
1497   einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
1498          abfd, section, address, name);
1499   return TRUE;
1500 }
1501
1502 /* This is called if link_info.notice_all is set, or when a symbol in
1503    link_info.notice_hash is found.  Symbols are put in notice_hash
1504    using the -y option.  */
1505
1506 static bfd_boolean
1507 notice (struct bfd_link_info *info,
1508         const char *name,
1509         bfd *abfd,
1510         asection *section,
1511         bfd_vma value)
1512 {
1513   if (name == NULL)
1514     {
1515       if (command_line.cref || nocrossref_list != NULL)
1516         return handle_asneeded_cref (abfd, value);
1517       return TRUE;
1518     }
1519
1520   if (! info->notice_all
1521       || (info->notice_hash != NULL
1522           && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
1523     {
1524       if (bfd_is_und_section (section))
1525         einfo ("%B: reference to %s\n", abfd, name);
1526       else
1527         einfo ("%B: definition of %s\n", abfd, name);
1528     }
1529
1530   if (command_line.cref || nocrossref_list != NULL)
1531     add_cref (name, abfd, section, value);
1532
1533   return TRUE;
1534 }