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