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