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