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