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