ld/ldmain.c

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