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