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