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