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