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