ld/ldmain.c

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