1 /* Linker file opening and searching. 2 Copyright (C) 1991-2022 Free Software Foundation, Inc. 3 4 This file is part of the GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "bfdlink.h" 24 #include "ctf-api.h" 25 #include "safe-ctype.h" 26 #include "ld.h" 27 #include "ldmisc.h" 28 #include "ldexp.h" 29 #include "ldlang.h" 30 #include "ldfile.h" 31 #include "ldmain.h" 32 #include <ldgram.h> 33 #include "ldlex.h" 34 #include "ldemul.h" 35 #include "libiberty.h" 36 #include "filenames.h" 37 #if BFD_SUPPORTS_PLUGINS 38 #include "plugin-api.h" 39 #include "plugin.h" 40 #endif /* BFD_SUPPORTS_PLUGINS */ 41 42 bool ldfile_assumed_script = false; 43 const char *ldfile_output_machine_name = ""; 44 unsigned long ldfile_output_machine; 45 enum bfd_architecture ldfile_output_architecture; 46 search_dirs_type *search_head; 47 48 #ifdef VMS 49 static char *slash = ""; 50 #else 51 #if defined (_WIN32) && !defined (__CYGWIN32__) 52 static char *slash = "\\"; 53 #else 54 static char *slash = "/"; 55 #endif 56 #endif 57 58 typedef struct search_arch 59 { 60 char *name; 61 struct search_arch *next; 62 } search_arch_type; 63 64 static search_dirs_type **search_tail_ptr = &search_head; 65 static search_arch_type *search_arch_head; 66 static search_arch_type **search_arch_tail_ptr = &search_arch_head; 67 68 /* Test whether a pathname, after canonicalization, is the same or a 69 sub-directory of the sysroot directory. */ 70 71 static bool 72 is_sysrooted_pathname (const char *name) 73 { 74 char *realname; 75 int len; 76 bool result; 77 78 if (ld_canon_sysroot == NULL) 79 return false; 80 81 realname = lrealpath (name); 82 len = strlen (realname); 83 result = false; 84 if (len > ld_canon_sysroot_len 85 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])) 86 { 87 realname[ld_canon_sysroot_len] = '\0'; 88 result = FILENAME_CMP (ld_canon_sysroot, realname) == 0; 89 } 90 91 free (realname); 92 return result; 93 } 94 95 /* Adds NAME to the library search path. 96 Makes a copy of NAME using xmalloc(). */ 97 98 void 99 ldfile_add_library_path (const char *name, bool cmdline) 100 { 101 search_dirs_type *new_dirs; 102 103 if (!cmdline && config.only_cmd_line_lib_dirs) 104 return; 105 106 new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type)); 107 new_dirs->next = NULL; 108 new_dirs->cmdline = cmdline; 109 *search_tail_ptr = new_dirs; 110 search_tail_ptr = &new_dirs->next; 111 112 /* If a directory is marked as honoring sysroot, prepend the sysroot path 113 now. */ 114 if (name[0] == '=') 115 new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL); 116 else if (startswith (name, "$SYSROOT")) 117 new_dirs->name = concat (ld_sysroot, name + strlen ("$SYSROOT"), (const char *) NULL); 118 else 119 new_dirs->name = xstrdup (name); 120 } 121 122 /* Try to open a BFD for a lang_input_statement. */ 123 124 bool 125 ldfile_try_open_bfd (const char *attempt, 126 lang_input_statement_type *entry) 127 { 128 entry->the_bfd = bfd_openr (attempt, entry->target); 129 130 if (verbose) 131 { 132 if (entry->the_bfd == NULL) 133 info_msg (_("attempt to open %s failed\n"), attempt); 134 else 135 info_msg (_("attempt to open %s succeeded\n"), attempt); 136 } 137 138 if (entry->the_bfd == NULL) 139 { 140 if (bfd_get_error () == bfd_error_invalid_target) 141 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target); 142 return false; 143 } 144 145 track_dependency_files (attempt); 146 147 /* Linker needs to decompress sections. */ 148 entry->the_bfd->flags |= BFD_DECOMPRESS; 149 150 /* This is a linker input BFD. */ 151 entry->the_bfd->is_linker_input = 1; 152 153 #if BFD_SUPPORTS_PLUGINS 154 if (entry->flags.lto_output) 155 entry->the_bfd->lto_output = 1; 156 #endif 157 158 /* If we are searching for this file, see if the architecture is 159 compatible with the output file. If it isn't, keep searching. 160 If we can't open the file as an object file, stop the search 161 here. If we are statically linking, ensure that we don't link 162 a dynamic object. 163 164 In the code below, it's OK to exit early if the check fails, 165 closing the checked BFD and returning false, but if the BFD 166 checks out compatible, do not exit early returning true, or 167 the plugins will not get a chance to claim the file. */ 168 169 if (entry->flags.search_dirs || !entry->flags.dynamic) 170 { 171 bfd *check; 172 173 if (bfd_check_format (entry->the_bfd, bfd_archive)) 174 check = bfd_openr_next_archived_file (entry->the_bfd, NULL); 175 else 176 check = entry->the_bfd; 177 178 if (check != NULL) 179 { 180 if (!bfd_check_format (check, bfd_object)) 181 { 182 if (check == entry->the_bfd 183 && entry->flags.search_dirs 184 && bfd_get_error () == bfd_error_file_not_recognized 185 && !ldemul_unrecognized_file (entry)) 186 { 187 int token, skip = 0; 188 char *arg, *arg1, *arg2, *arg3; 189 extern FILE *yyin; 190 191 /* Try to interpret the file as a linker script. */ 192 ldfile_open_command_file (attempt); 193 194 ldfile_assumed_script = true; 195 parser_input = input_selected; 196 ldlex_script (); 197 token = INPUT_SCRIPT; 198 while (token != 0) 199 { 200 switch (token) 201 { 202 case OUTPUT_FORMAT: 203 if ((token = yylex ()) != '(') 204 continue; 205 if ((token = yylex ()) != NAME) 206 continue; 207 arg1 = yylval.name; 208 arg2 = NULL; 209 arg3 = NULL; 210 token = yylex (); 211 if (token == ',') 212 { 213 if ((token = yylex ()) != NAME) 214 { 215 free (arg1); 216 continue; 217 } 218 arg2 = yylval.name; 219 if ((token = yylex ()) != ',' 220 || (token = yylex ()) != NAME) 221 { 222 free (arg1); 223 free (arg2); 224 continue; 225 } 226 arg3 = yylval.name; 227 token = yylex (); 228 } 229 if (token == ')') 230 { 231 switch (command_line.endian) 232 { 233 default: 234 case ENDIAN_UNSET: 235 arg = arg1; break; 236 case ENDIAN_BIG: 237 arg = arg2 ? arg2 : arg1; break; 238 case ENDIAN_LITTLE: 239 arg = arg3 ? arg3 : arg1; break; 240 } 241 if (strcmp (arg, lang_get_output_target ()) != 0) 242 skip = 1; 243 } 244 free (arg1); 245 free (arg2); 246 free (arg3); 247 break; 248 case NAME: 249 case LNAME: 250 case VERS_IDENTIFIER: 251 case VERS_TAG: 252 free (yylval.name); 253 break; 254 case INT: 255 free (yylval.bigint.str); 256 break; 257 } 258 token = yylex (); 259 } 260 ldlex_popstate (); 261 ldfile_assumed_script = false; 262 fclose (yyin); 263 yyin = NULL; 264 if (skip) 265 { 266 if (command_line.warn_search_mismatch) 267 einfo (_("%P: skipping incompatible %s " 268 "when searching for %s\n"), 269 attempt, entry->local_sym_name); 270 bfd_close (entry->the_bfd); 271 entry->the_bfd = NULL; 272 return false; 273 } 274 } 275 goto success; 276 } 277 278 if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0) 279 { 280 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"), 281 attempt); 282 bfd_close (entry->the_bfd); 283 entry->the_bfd = NULL; 284 return false; 285 } 286 287 if (entry->flags.search_dirs 288 && !bfd_arch_get_compatible (check, link_info.output_bfd, 289 command_line.accept_unknown_input_arch) 290 /* XCOFF archives can have 32 and 64 bit objects. */ 291 && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour 292 && (bfd_get_flavour (link_info.output_bfd) 293 == bfd_target_xcoff_flavour) 294 && bfd_check_format (entry->the_bfd, bfd_archive))) 295 { 296 if (command_line.warn_search_mismatch) 297 einfo (_("%P: skipping incompatible %s " 298 "when searching for %s\n"), 299 attempt, entry->local_sym_name); 300 bfd_close (entry->the_bfd); 301 entry->the_bfd = NULL; 302 return false; 303 } 304 } 305 } 306 success: 307 #if BFD_SUPPORTS_PLUGINS 308 /* If plugins are active, they get first chance to claim 309 any successfully-opened input file. We skip archives 310 here; the plugin wants us to offer it the individual 311 members when we enumerate them, not the whole file. We 312 also ignore corefiles, because that's just weird. It is 313 a needed side-effect of calling bfd_check_format with 314 bfd_object that it sets the bfd's arch and mach, which 315 will be needed when and if we want to bfd_create a new 316 one using this one as a template. */ 317 if (link_info.lto_plugin_active 318 && !no_more_claiming 319 && bfd_check_format (entry->the_bfd, bfd_object)) 320 plugin_maybe_claim (entry); 321 #endif /* BFD_SUPPORTS_PLUGINS */ 322 323 /* It opened OK, the format checked out, and the plugins have had 324 their chance to claim it, so this is success. */ 325 return true; 326 } 327 328 /* Search for and open the file specified by ENTRY. If it is an 329 archive, use ARCH, LIB and SUFFIX to modify the file name. */ 330 331 bool 332 ldfile_open_file_search (const char *arch, 333 lang_input_statement_type *entry, 334 const char *lib, 335 const char *suffix) 336 { 337 search_dirs_type *search; 338 339 /* If this is not an archive, try to open it in the current 340 directory first. */ 341 if (!entry->flags.maybe_archive) 342 { 343 if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename)) 344 { 345 char *name = concat (ld_sysroot, entry->filename, 346 (const char *) NULL); 347 if (ldfile_try_open_bfd (name, entry)) 348 { 349 entry->filename = name; 350 return true; 351 } 352 free (name); 353 } 354 else if (ldfile_try_open_bfd (entry->filename, entry)) 355 return true; 356 357 if (IS_ABSOLUTE_PATH (entry->filename)) 358 return false; 359 } 360 361 for (search = search_head; search != NULL; search = search->next) 362 { 363 char *string; 364 365 if (entry->flags.dynamic && !bfd_link_relocatable (&link_info)) 366 { 367 if (ldemul_open_dynamic_archive (arch, search, entry)) 368 return true; 369 } 370 371 if (entry->flags.maybe_archive && !entry->flags.full_name_provided) 372 string = concat (search->name, slash, lib, entry->filename, 373 arch, suffix, (const char *) NULL); 374 else 375 string = concat (search->name, slash, entry->filename, 376 (const char *) 0); 377 378 if (ldfile_try_open_bfd (string, entry)) 379 { 380 entry->filename = string; 381 return true; 382 } 383 384 free (string); 385 } 386 387 return false; 388 } 389 390 /* Open the input file specified by ENTRY. 391 PR 4437: Do not stop on the first missing file, but 392 continue processing other input files in case there 393 are more errors to report. */ 394 395 void 396 ldfile_open_file (lang_input_statement_type *entry) 397 { 398 if (entry->the_bfd != NULL) 399 return; 400 401 if (!entry->flags.search_dirs) 402 { 403 if (ldfile_try_open_bfd (entry->filename, entry)) 404 return; 405 406 if (filename_cmp (entry->filename, entry->local_sym_name) != 0) 407 einfo (_("%P: cannot find %s (%s): %E\n"), 408 entry->filename, entry->local_sym_name); 409 else 410 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name); 411 412 entry->flags.missing_file = true; 413 input_flags.missing_file = true; 414 } 415 else 416 { 417 search_arch_type *arch; 418 bool found = false; 419 420 /* If extra_search_path is set, entry->filename is a relative path. 421 Search the directory of the current linker script before searching 422 other paths. */ 423 if (entry->extra_search_path) 424 { 425 char *path = concat (entry->extra_search_path, slash, entry->filename, 426 (const char *)0); 427 if (ldfile_try_open_bfd (path, entry)) 428 { 429 entry->filename = path; 430 entry->flags.search_dirs = false; 431 return; 432 } 433 434 free (path); 435 } 436 437 /* Try to open <filename><suffix> or lib<filename><suffix>.a. */ 438 for (arch = search_arch_head; arch != NULL; arch = arch->next) 439 { 440 found = ldfile_open_file_search (arch->name, entry, "lib", ".a"); 441 if (found) 442 break; 443 #ifdef VMS 444 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a"); 445 if (found) 446 break; 447 #endif 448 found = ldemul_find_potential_libraries (arch->name, entry); 449 if (found) 450 break; 451 } 452 453 /* If we have found the file, we don't need to search directories 454 again. */ 455 if (found) 456 entry->flags.search_dirs = false; 457 else 458 { 459 if (entry->flags.sysrooted 460 && ld_sysroot 461 && IS_ABSOLUTE_PATH (entry->local_sym_name)) 462 einfo (_("%P: cannot find %s inside %s\n"), 463 entry->local_sym_name, ld_sysroot); 464 #if SUPPORT_ERROR_HANDLING_SCRIPT 465 else if (error_handling_script != NULL) 466 { 467 char * argv[4]; 468 const char * res; 469 int status, err; 470 471 argv[0] = error_handling_script; 472 argv[1] = "missing-lib"; 473 argv[2] = (char *) entry->local_sym_name; 474 argv[3] = NULL; 475 476 if (verbose) 477 einfo (_("%P: About to run error handling script '%s' with arguments: '%s' '%s'\n"), 478 argv[0], argv[1], argv[2]); 479 480 res = pex_one (PEX_SEARCH, error_handling_script, argv, 481 N_("error handling script"), 482 NULL /* Send stdout to random, temp file. */, 483 NULL /* Write to stderr. */, 484 &status, &err); 485 if (res != NULL) 486 { 487 einfo (_("%P: Failed to run error handling script '%s', reason: "), 488 error_handling_script); 489 /* FIXME: We assume here that errrno == err. */ 490 perror (res); 491 } 492 else /* We ignore the return status of the script 493 and always print the error message. */ 494 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name); 495 } 496 #endif 497 else 498 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name); 499 500 /* PR 25747: Be kind to users who forgot to add the 501 "lib" prefix to their library when it was created. */ 502 for (arch = search_arch_head; arch != NULL; arch = arch->next) 503 { 504 if (ldfile_open_file_search (arch->name, entry, "", ".a")) 505 { 506 const char * base = lbasename (entry->filename); 507 508 einfo (_("%P: note to link with %s use -l:%s or rename it to lib%s\n"), 509 entry->filename, base, base); 510 bfd_close (entry->the_bfd); 511 entry->the_bfd = NULL; 512 break; 513 } 514 } 515 516 entry->flags.missing_file = true; 517 input_flags.missing_file = true; 518 } 519 } 520 } 521 522 /* Try to open NAME. */ 523 524 static FILE * 525 try_open (const char *name, bool *sysrooted) 526 { 527 FILE *result; 528 529 result = fopen (name, "r"); 530 531 if (result != NULL) 532 *sysrooted = is_sysrooted_pathname (name); 533 534 if (verbose) 535 { 536 if (result == NULL) 537 info_msg (_("cannot find script file %s\n"), name); 538 else 539 info_msg (_("opened script file %s\n"), name); 540 } 541 542 return result; 543 } 544 545 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */ 546 547 static bool 548 check_for_scripts_dir (char *dir) 549 { 550 char *buf; 551 struct stat s; 552 bool res; 553 554 buf = concat (dir, "/ldscripts", (const char *) NULL); 555 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode); 556 free (buf); 557 return res; 558 } 559 560 /* Return the default directory for finding script files. 561 We look for the "ldscripts" directory in: 562 563 SCRIPTDIR (passed from Makefile) 564 (adjusted according to the current location of the binary) 565 the dir where this program is (for using it from the build tree). */ 566 567 static char * 568 find_scripts_dir (void) 569 { 570 char *dir; 571 572 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR); 573 if (dir) 574 { 575 if (check_for_scripts_dir (dir)) 576 return dir; 577 free (dir); 578 } 579 580 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR); 581 if (dir) 582 { 583 if (check_for_scripts_dir (dir)) 584 return dir; 585 free (dir); 586 } 587 588 /* Look for "ldscripts" in the dir where our binary is. */ 589 dir = make_relative_prefix (program_name, ".", "."); 590 if (dir) 591 { 592 if (check_for_scripts_dir (dir)) 593 return dir; 594 free (dir); 595 } 596 597 return NULL; 598 } 599 600 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for 601 it in directories specified with -L, then in the default script 602 directory. If DEFAULT_ONLY is true, the search is restricted to 603 the default script location. */ 604 605 static FILE * 606 ldfile_find_command_file (const char *name, 607 bool default_only, 608 bool *sysrooted) 609 { 610 search_dirs_type *search; 611 FILE *result = NULL; 612 char *path; 613 static search_dirs_type *script_search; 614 615 if (!default_only) 616 { 617 /* First try raw name. */ 618 result = try_open (name, sysrooted); 619 if (result != NULL) 620 return result; 621 } 622 623 if (!script_search) 624 { 625 char *script_dir = find_scripts_dir (); 626 if (script_dir) 627 { 628 search_dirs_type **save_tail_ptr = search_tail_ptr; 629 search_tail_ptr = &script_search; 630 ldfile_add_library_path (script_dir, true); 631 search_tail_ptr = save_tail_ptr; 632 } 633 } 634 635 /* Temporarily append script_search to the path list so that the 636 paths specified with -L will be searched first. */ 637 *search_tail_ptr = script_search; 638 639 /* Try now prefixes. */ 640 for (search = default_only ? script_search : search_head; 641 search != NULL; 642 search = search->next) 643 { 644 path = concat (search->name, slash, name, (const char *) NULL); 645 result = try_open (path, sysrooted); 646 free (path); 647 if (result) 648 break; 649 } 650 651 /* Restore the original path list. */ 652 *search_tail_ptr = NULL; 653 654 return result; 655 } 656 657 enum script_open_style { 658 script_nonT, 659 script_T, 660 script_defaultT 661 }; 662 663 struct script_name_list 664 { 665 struct script_name_list *next; 666 enum script_open_style open_how; 667 char name[1]; 668 }; 669 670 /* Open command file NAME. */ 671 672 static void 673 ldfile_open_command_file_1 (const char *name, enum script_open_style open_how) 674 { 675 FILE *ldlex_input_stack; 676 bool sysrooted; 677 static struct script_name_list *processed_scripts = NULL; 678 struct script_name_list *script; 679 size_t len; 680 681 /* PR 24576: Catch the case where the user has accidentally included 682 the same linker script twice. */ 683 for (script = processed_scripts; script != NULL; script = script->next) 684 { 685 if ((open_how != script_nonT || script->open_how != script_nonT) 686 && strcmp (name, script->name) == 0) 687 { 688 einfo (_("%F%P: error: linker script file '%s'" 689 " appears multiple times\n"), name); 690 return; 691 } 692 } 693 694 /* FIXME: This memory is never freed, but that should not really matter. 695 It will be released when the linker exits, and it is unlikely to ever 696 be more than a few tens of bytes. */ 697 len = strlen (name); 698 script = xmalloc (sizeof (*script) + len); 699 script->next = processed_scripts; 700 script->open_how = open_how; 701 memcpy (script->name, name, len + 1); 702 processed_scripts = script; 703 704 ldlex_input_stack = ldfile_find_command_file (name, 705 open_how == script_defaultT, 706 &sysrooted); 707 if (ldlex_input_stack == NULL) 708 { 709 bfd_set_error (bfd_error_system_call); 710 einfo (_("%F%P: cannot open linker script file %s: %E\n"), name); 711 return; 712 } 713 714 track_dependency_files (name); 715 716 lex_push_file (ldlex_input_stack, name, sysrooted); 717 718 lineno = 1; 719 720 saved_script_handle = ldlex_input_stack; 721 } 722 723 /* Open command file NAME in the current directory, -L directories, 724 the default script location, in that order. */ 725 726 void 727 ldfile_open_command_file (const char *name) 728 { 729 ldfile_open_command_file_1 (name, script_nonT); 730 } 731 732 void 733 ldfile_open_script_file (const char *name) 734 { 735 ldfile_open_command_file_1 (name, script_T); 736 } 737 738 /* Open command file NAME at the default script location. */ 739 740 void 741 ldfile_open_default_command_file (const char *name) 742 { 743 ldfile_open_command_file_1 (name, script_defaultT); 744 } 745 746 void 747 ldfile_add_arch (const char *in_name) 748 { 749 char *name = xstrdup (in_name); 750 search_arch_type *new_arch 751 = (search_arch_type *) xmalloc (sizeof (search_arch_type)); 752 753 ldfile_output_machine_name = in_name; 754 755 new_arch->name = name; 756 new_arch->next = NULL; 757 while (*name) 758 { 759 *name = TOLOWER (*name); 760 name++; 761 } 762 *search_arch_tail_ptr = new_arch; 763 search_arch_tail_ptr = &new_arch->next; 764 765 } 766 767 /* Set the output architecture. */ 768 769 void 770 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch) 771 { 772 const bfd_arch_info_type *arch = bfd_scan_arch (string); 773 774 if (arch) 775 { 776 ldfile_output_architecture = arch->arch; 777 ldfile_output_machine = arch->mach; 778 ldfile_output_machine_name = arch->printable_name; 779 } 780 else if (defarch != bfd_arch_unknown) 781 ldfile_output_architecture = defarch; 782 else 783 einfo (_("%F%P: cannot represent machine `%s'\n"), string); 784 } 785