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