1 /* Linker file opening and searching. 2 Copyright (C) 1991-2020 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 #ifdef ENABLE_PLUGINS 38 #include "plugin-api.h" 39 #include "plugin.h" 40 #endif /* ENABLE_PLUGINS */ 41 42 bfd_boolean 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 bfd_boolean 72 is_sysrooted_pathname (const char *name) 73 { 74 char *realname; 75 int len; 76 bfd_boolean 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, bfd_boolean 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 (CONST_STRNEQ (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 bfd_boolean 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 /* Linker needs to decompress sections. */ 146 entry->the_bfd->flags |= BFD_DECOMPRESS; 147 148 /* This is a linker input BFD. */ 149 entry->the_bfd->is_linker_input = 1; 150 151 #ifdef ENABLE_PLUGINS 152 if (entry->flags.lto_output) 153 entry->the_bfd->lto_output = 1; 154 #endif 155 156 /* If we are searching for this file, see if the architecture is 157 compatible with the output file. If it isn't, keep searching. 158 If we can't open the file as an object file, stop the search 159 here. If we are statically linking, ensure that we don't link 160 a dynamic object. 161 162 In the code below, it's OK to exit early if the check fails, 163 closing the checked BFD and returning FALSE, but if the BFD 164 checks out compatible, do not exit early returning TRUE, or 165 the plugins will not get a chance to claim the file. */ 166 167 if (entry->flags.search_dirs || !entry->flags.dynamic) 168 { 169 bfd *check; 170 171 if (bfd_check_format (entry->the_bfd, bfd_archive)) 172 check = bfd_openr_next_archived_file (entry->the_bfd, NULL); 173 else 174 check = entry->the_bfd; 175 176 if (check != NULL) 177 { 178 if (!bfd_check_format (check, bfd_object)) 179 { 180 if (check == entry->the_bfd 181 && entry->flags.search_dirs 182 && bfd_get_error () == bfd_error_file_not_recognized 183 && !ldemul_unrecognized_file (entry)) 184 { 185 int token, skip = 0; 186 char *arg, *arg1, *arg2, *arg3; 187 extern FILE *yyin; 188 189 /* Try to interpret the file as a linker script. */ 190 ldfile_open_command_file (attempt); 191 192 ldfile_assumed_script = TRUE; 193 parser_input = input_selected; 194 ldlex_both (); 195 token = INPUT_SCRIPT; 196 while (token != 0) 197 { 198 switch (token) 199 { 200 case OUTPUT_FORMAT: 201 if ((token = yylex ()) != '(') 202 continue; 203 if ((token = yylex ()) != NAME) 204 continue; 205 arg1 = yylval.name; 206 arg2 = NULL; 207 arg3 = NULL; 208 token = yylex (); 209 if (token == ',') 210 { 211 if ((token = yylex ()) != NAME) 212 { 213 free (arg1); 214 continue; 215 } 216 arg2 = yylval.name; 217 if ((token = yylex ()) != ',' 218 || (token = yylex ()) != NAME) 219 { 220 free (arg1); 221 free (arg2); 222 continue; 223 } 224 arg3 = yylval.name; 225 token = yylex (); 226 } 227 if (token == ')') 228 { 229 switch (command_line.endian) 230 { 231 default: 232 case ENDIAN_UNSET: 233 arg = arg1; break; 234 case ENDIAN_BIG: 235 arg = arg2 ? arg2 : arg1; break; 236 case ENDIAN_LITTLE: 237 arg = arg3 ? arg3 : arg1; break; 238 } 239 if (strcmp (arg, lang_get_output_target ()) != 0) 240 skip = 1; 241 } 242 free (arg1); 243 if (arg2) free (arg2); 244 if (arg3) free (arg3); 245 break; 246 case NAME: 247 case LNAME: 248 case VERS_IDENTIFIER: 249 case VERS_TAG: 250 free (yylval.name); 251 break; 252 case INT: 253 if (yylval.bigint.str) 254 free (yylval.bigint.str); 255 break; 256 } 257 token = yylex (); 258 } 259 ldlex_popstate (); 260 ldfile_assumed_script = FALSE; 261 fclose (yyin); 262 yyin = NULL; 263 if (skip) 264 { 265 if (command_line.warn_search_mismatch) 266 einfo (_("%P: skipping incompatible %s " 267 "when searching for %s\n"), 268 attempt, entry->local_sym_name); 269 bfd_close (entry->the_bfd); 270 entry->the_bfd = NULL; 271 return FALSE; 272 } 273 } 274 goto success; 275 } 276 277 if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0) 278 { 279 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"), 280 attempt); 281 bfd_close (entry->the_bfd); 282 entry->the_bfd = NULL; 283 return FALSE; 284 } 285 286 if (entry->flags.search_dirs 287 && !bfd_arch_get_compatible (check, link_info.output_bfd, 288 command_line.accept_unknown_input_arch) 289 /* XCOFF archives can have 32 and 64 bit objects. */ 290 && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour 291 && (bfd_get_flavour (link_info.output_bfd) 292 == bfd_target_xcoff_flavour) 293 && bfd_check_format (entry->the_bfd, bfd_archive))) 294 { 295 if (command_line.warn_search_mismatch) 296 einfo (_("%P: skipping incompatible %s " 297 "when searching for %s\n"), 298 attempt, entry->local_sym_name); 299 bfd_close (entry->the_bfd); 300 entry->the_bfd = NULL; 301 return FALSE; 302 } 303 } 304 } 305 success: 306 #ifdef ENABLE_PLUGINS 307 /* If plugins are active, they get first chance to claim 308 any successfully-opened input file. We skip archives 309 here; the plugin wants us to offer it the individual 310 members when we enumerate them, not the whole file. We 311 also ignore corefiles, because that's just weird. It is 312 a needed side-effect of calling bfd_check_format with 313 bfd_object that it sets the bfd's arch and mach, which 314 will be needed when and if we want to bfd_create a new 315 one using this one as a template. */ 316 if (link_info.lto_plugin_active 317 && !no_more_claiming 318 && bfd_check_format (entry->the_bfd, bfd_object)) 319 plugin_maybe_claim (entry); 320 #endif /* ENABLE_PLUGINS */ 321 322 /* It opened OK, the format checked out, and the plugins have had 323 their chance to claim it, so this is success. */ 324 return TRUE; 325 } 326 327 /* Search for and open the file specified by ENTRY. If it is an 328 archive, use ARCH, LIB and SUFFIX to modify the file name. */ 329 330 bfd_boolean 331 ldfile_open_file_search (const char *arch, 332 lang_input_statement_type *entry, 333 const char *lib, 334 const char *suffix) 335 { 336 search_dirs_type *search; 337 338 /* If this is not an archive, try to open it in the current 339 directory first. */ 340 if (!entry->flags.maybe_archive) 341 { 342 if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename)) 343 { 344 char *name = concat (ld_sysroot, entry->filename, 345 (const char *) NULL); 346 if (ldfile_try_open_bfd (name, entry)) 347 { 348 entry->filename = name; 349 return TRUE; 350 } 351 free (name); 352 } 353 else if (ldfile_try_open_bfd (entry->filename, entry)) 354 return TRUE; 355 356 if (IS_ABSOLUTE_PATH (entry->filename)) 357 return FALSE; 358 } 359 360 for (search = search_head; search != NULL; search = search->next) 361 { 362 char *string; 363 364 if (entry->flags.dynamic && !bfd_link_relocatable (&link_info)) 365 { 366 if (ldemul_open_dynamic_archive (arch, search, entry)) 367 return TRUE; 368 } 369 370 if (entry->flags.maybe_archive && !entry->flags.full_name_provided) 371 string = concat (search->name, slash, lib, entry->filename, 372 arch, suffix, (const char *) NULL); 373 else 374 string = concat (search->name, slash, entry->filename, 375 (const char *) 0); 376 377 if (ldfile_try_open_bfd (string, entry)) 378 { 379 entry->filename = string; 380 return TRUE; 381 } 382 383 free (string); 384 } 385 386 return FALSE; 387 } 388 389 /* Open the input file specified by ENTRY. 390 PR 4437: Do not stop on the first missing file, but 391 continue processing other input files in case there 392 are more errors to report. */ 393 394 void 395 ldfile_open_file (lang_input_statement_type *entry) 396 { 397 if (entry->the_bfd != NULL) 398 return; 399 400 if (!entry->flags.search_dirs) 401 { 402 if (ldfile_try_open_bfd (entry->filename, entry)) 403 return; 404 405 if (filename_cmp (entry->filename, entry->local_sym_name) != 0) 406 einfo (_("%P: cannot find %s (%s): %E\n"), 407 entry->filename, entry->local_sym_name); 408 else 409 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name); 410 411 entry->flags.missing_file = TRUE; 412 input_flags.missing_file = TRUE; 413 } 414 else 415 { 416 search_arch_type *arch; 417 bfd_boolean found = FALSE; 418 419 /* Try to open <filename><suffix> or lib<filename><suffix>.a */ 420 for (arch = search_arch_head; arch != NULL; arch = arch->next) 421 { 422 found = ldfile_open_file_search (arch->name, entry, "lib", ".a"); 423 if (found) 424 break; 425 #ifdef VMS 426 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a"); 427 if (found) 428 break; 429 #endif 430 found = ldemul_find_potential_libraries (arch->name, entry); 431 if (found) 432 break; 433 } 434 435 /* If we have found the file, we don't need to search directories 436 again. */ 437 if (found) 438 entry->flags.search_dirs = FALSE; 439 else 440 { 441 if (entry->flags.sysrooted 442 && ld_sysroot 443 && IS_ABSOLUTE_PATH (entry->local_sym_name)) 444 einfo (_("%P: cannot find %s inside %s\n"), 445 entry->local_sym_name, ld_sysroot); 446 else 447 einfo (_("%P: cannot find %s\n"), entry->local_sym_name); 448 entry->flags.missing_file = TRUE; 449 input_flags.missing_file = TRUE; 450 } 451 } 452 } 453 454 /* Try to open NAME. */ 455 456 static FILE * 457 try_open (const char *name, bfd_boolean *sysrooted) 458 { 459 FILE *result; 460 461 result = fopen (name, "r"); 462 463 if (result != NULL) 464 *sysrooted = is_sysrooted_pathname (name); 465 466 if (verbose) 467 { 468 if (result == NULL) 469 info_msg (_("cannot find script file %s\n"), name); 470 else 471 info_msg (_("opened script file %s\n"), name); 472 } 473 474 return result; 475 } 476 477 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */ 478 479 static bfd_boolean 480 check_for_scripts_dir (char *dir) 481 { 482 char *buf; 483 struct stat s; 484 bfd_boolean res; 485 486 buf = concat (dir, "/ldscripts", (const char *) NULL); 487 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode); 488 free (buf); 489 return res; 490 } 491 492 /* Return the default directory for finding script files. 493 We look for the "ldscripts" directory in: 494 495 SCRIPTDIR (passed from Makefile) 496 (adjusted according to the current location of the binary) 497 the dir where this program is (for using it from the build tree). */ 498 499 static char * 500 find_scripts_dir (void) 501 { 502 char *dir; 503 504 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR); 505 if (dir) 506 { 507 if (check_for_scripts_dir (dir)) 508 return dir; 509 free (dir); 510 } 511 512 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR); 513 if (dir) 514 { 515 if (check_for_scripts_dir (dir)) 516 return dir; 517 free (dir); 518 } 519 520 /* Look for "ldscripts" in the dir where our binary is. */ 521 dir = make_relative_prefix (program_name, ".", "."); 522 if (dir) 523 { 524 if (check_for_scripts_dir (dir)) 525 return dir; 526 free (dir); 527 } 528 529 return NULL; 530 } 531 532 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for 533 it in directories specified with -L, then in the default script 534 directory. If DEFAULT_ONLY is true, the search is restricted to 535 the default script location. */ 536 537 static FILE * 538 ldfile_find_command_file (const char *name, 539 bfd_boolean default_only, 540 bfd_boolean *sysrooted) 541 { 542 search_dirs_type *search; 543 FILE *result = NULL; 544 char *path; 545 static search_dirs_type *script_search; 546 547 if (!default_only) 548 { 549 /* First try raw name. */ 550 result = try_open (name, sysrooted); 551 if (result != NULL) 552 return result; 553 } 554 555 if (!script_search) 556 { 557 char *script_dir = find_scripts_dir (); 558 if (script_dir) 559 { 560 search_dirs_type **save_tail_ptr = search_tail_ptr; 561 search_tail_ptr = &script_search; 562 ldfile_add_library_path (script_dir, TRUE); 563 search_tail_ptr = save_tail_ptr; 564 } 565 } 566 567 /* Temporarily append script_search to the path list so that the 568 paths specified with -L will be searched first. */ 569 *search_tail_ptr = script_search; 570 571 /* Try now prefixes. */ 572 for (search = default_only ? script_search : search_head; 573 search != NULL; 574 search = search->next) 575 { 576 path = concat (search->name, slash, name, (const char *) NULL); 577 result = try_open (path, sysrooted); 578 free (path); 579 if (result) 580 break; 581 } 582 583 /* Restore the original path list. */ 584 *search_tail_ptr = NULL; 585 586 return result; 587 } 588 589 enum script_open_style { 590 script_nonT, 591 script_T, 592 script_defaultT 593 }; 594 595 struct script_name_list 596 { 597 struct script_name_list *next; 598 enum script_open_style open_how; 599 char name[1]; 600 }; 601 602 /* Open command file NAME. */ 603 604 static void 605 ldfile_open_command_file_1 (const char *name, enum script_open_style open_how) 606 { 607 FILE *ldlex_input_stack; 608 bfd_boolean sysrooted; 609 static struct script_name_list *processed_scripts = NULL; 610 struct script_name_list *script; 611 size_t len; 612 613 /* PR 24576: Catch the case where the user has accidentally included 614 the same linker script twice. */ 615 for (script = processed_scripts; script != NULL; script = script->next) 616 { 617 if ((open_how != script_nonT || script->open_how != script_nonT) 618 && strcmp (name, script->name) == 0) 619 { 620 einfo (_("%F%P: error: linker script file '%s'" 621 " appears multiple times\n"), name); 622 return; 623 } 624 } 625 626 /* FIXME: This memory is never freed, but that should not really matter. 627 It will be released when the linker exits, and it is unlikely to ever 628 be more than a few tens of bytes. */ 629 len = strlen (name); 630 script = xmalloc (sizeof (*script) + len); 631 script->next = processed_scripts; 632 script->open_how = open_how; 633 memcpy (script->name, name, len + 1); 634 processed_scripts = script; 635 636 ldlex_input_stack = ldfile_find_command_file (name, 637 open_how == script_defaultT, 638 &sysrooted); 639 if (ldlex_input_stack == NULL) 640 { 641 bfd_set_error (bfd_error_system_call); 642 einfo (_("%F%P: cannot open linker script file %s: %E\n"), name); 643 return; 644 } 645 646 lex_push_file (ldlex_input_stack, name, sysrooted); 647 648 lineno = 1; 649 650 saved_script_handle = ldlex_input_stack; 651 } 652 653 /* Open command file NAME in the current directory, -L directories, 654 the default script location, in that order. */ 655 656 void 657 ldfile_open_command_file (const char *name) 658 { 659 ldfile_open_command_file_1 (name, script_nonT); 660 } 661 662 void 663 ldfile_open_script_file (const char *name) 664 { 665 ldfile_open_command_file_1 (name, script_T); 666 } 667 668 /* Open command file NAME at the default script location. */ 669 670 void 671 ldfile_open_default_command_file (const char *name) 672 { 673 ldfile_open_command_file_1 (name, script_defaultT); 674 } 675 676 void 677 ldfile_add_arch (const char *in_name) 678 { 679 char *name = xstrdup (in_name); 680 search_arch_type *new_arch 681 = (search_arch_type *) xmalloc (sizeof (search_arch_type)); 682 683 ldfile_output_machine_name = in_name; 684 685 new_arch->name = name; 686 new_arch->next = NULL; 687 while (*name) 688 { 689 *name = TOLOWER (*name); 690 name++; 691 } 692 *search_arch_tail_ptr = new_arch; 693 search_arch_tail_ptr = &new_arch->next; 694 695 } 696 697 /* Set the output architecture. */ 698 699 void 700 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch) 701 { 702 const bfd_arch_info_type *arch = bfd_scan_arch (string); 703 704 if (arch) 705 { 706 ldfile_output_architecture = arch->arch; 707 ldfile_output_machine = arch->mach; 708 ldfile_output_machine_name = arch->printable_name; 709 } 710 else if (defarch != bfd_arch_unknown) 711 ldfile_output_architecture = defarch; 712 else 713 einfo (_("%F%P: cannot represent machine `%s'\n"), string); 714 } 715