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