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