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