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