ld/ldmain.c

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