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