1 /* Linker file opening and searching. 2 Copyright (C) 1991-2016 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 "safe-ctype.h" 25 #include "ld.h" 26 #include "ldmisc.h" 27 #include "ldexp.h" 28 #include "ldlang.h" 29 #include "ldfile.h" 30 #include "ldmain.h" 31 #include <ldgram.h> 32 #include "ldlex.h" 33 #include "ldemul.h" 34 #include "libiberty.h" 35 #include "filenames.h" 36 #ifdef ENABLE_PLUGINS 37 #include "plugin-api.h" 38 #include "plugin.h" 39 #endif /* ENABLE_PLUGINS */ 40 41 bfd_boolean ldfile_assumed_script = FALSE; 42 const char *ldfile_output_machine_name = ""; 43 unsigned long ldfile_output_machine; 44 enum bfd_architecture ldfile_output_architecture; 45 search_dirs_type *search_head; 46 47 #ifdef VMS 48 static char *slash = ""; 49 #else 50 #if defined (_WIN32) && !defined (__CYGWIN32__) 51 static char *slash = "\\"; 52 #else 53 static char *slash = "/"; 54 #endif 55 #endif 56 57 typedef struct search_arch 58 { 59 char *name; 60 struct search_arch *next; 61 } search_arch_type; 62 63 static search_dirs_type **search_tail_ptr = &search_head; 64 static search_arch_type *search_arch_head; 65 static search_arch_type **search_arch_tail_ptr = &search_arch_head; 66 67 /* Test whether a pathname, after canonicalization, is the same or a 68 sub-directory of the sysroot directory. */ 69 70 static bfd_boolean 71 is_sysrooted_pathname (const char *name) 72 { 73 char *realname; 74 int len; 75 bfd_boolean result; 76 77 if (ld_canon_sysroot == NULL) 78 return FALSE; 79 80 realname = lrealpath (name); 81 len = strlen (realname); 82 result = FALSE; 83 if (len > ld_canon_sysroot_len 84 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])) 85 { 86 realname[ld_canon_sysroot_len] = '\0'; 87 result = FILENAME_CMP (ld_canon_sysroot, realname) == 0; 88 } 89 90 free (realname); 91 return result; 92 } 93 94 /* Adds NAME to the library search path. 95 Makes a copy of NAME using xmalloc(). */ 96 97 void 98 ldfile_add_library_path (const char *name, bfd_boolean cmdline) 99 { 100 search_dirs_type *new_dirs; 101 102 if (!cmdline && config.only_cmd_line_lib_dirs) 103 return; 104 105 new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type)); 106 new_dirs->next = NULL; 107 new_dirs->cmdline = cmdline; 108 *search_tail_ptr = new_dirs; 109 search_tail_ptr = &new_dirs->next; 110 111 /* If a directory is marked as honoring sysroot, prepend the sysroot path 112 now. */ 113 if (name[0] == '=') 114 new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL); 115 else 116 new_dirs->name = xstrdup (name); 117 } 118 119 /* Try to open a BFD for a lang_input_statement. */ 120 121 bfd_boolean 122 ldfile_try_open_bfd (const char *attempt, 123 lang_input_statement_type *entry) 124 { 125 entry->the_bfd = bfd_openr (attempt, entry->target); 126 127 if (verbose) 128 { 129 if (entry->the_bfd == NULL) 130 info_msg (_("attempt to open %s failed\n"), attempt); 131 else 132 info_msg (_("attempt to open %s succeeded\n"), attempt); 133 } 134 135 if (entry->the_bfd == NULL) 136 { 137 if (bfd_get_error () == bfd_error_invalid_target) 138 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target); 139 return FALSE; 140 } 141 142 /* Linker needs to decompress sections. */ 143 entry->the_bfd->flags |= BFD_DECOMPRESS; 144 145 /* This is a linker input BFD. */ 146 entry->the_bfd->is_linker_input = 1; 147 148 #ifdef ENABLE_PLUGINS 149 if (entry->flags.lto_output) 150 entry->the_bfd->lto_output = 1; 151 #endif 152 153 /* If we are searching for this file, see if the architecture is 154 compatible with the output file. If it isn't, keep searching. 155 If we can't open the file as an object file, stop the search 156 here. If we are statically linking, ensure that we don't link 157 a dynamic object. 158 159 In the code below, it's OK to exit early if the check fails, 160 closing the checked BFD and returning FALSE, but if the BFD 161 checks out compatible, do not exit early returning TRUE, or 162 the plugins will not get a chance to claim the file. */ 163 164 if (entry->flags.search_dirs || !entry->flags.dynamic) 165 { 166 bfd *check; 167 168 if (bfd_check_format (entry->the_bfd, bfd_archive)) 169 check = bfd_openr_next_archived_file (entry->the_bfd, NULL); 170 else 171 check = entry->the_bfd; 172 173 if (check != NULL) 174 { 175 if (!bfd_check_format (check, bfd_object)) 176 { 177 if (check == entry->the_bfd 178 && entry->flags.search_dirs 179 && bfd_get_error () == bfd_error_file_not_recognized 180 && !ldemul_unrecognized_file (entry)) 181 { 182 int token, skip = 0; 183 char *arg, *arg1, *arg2, *arg3; 184 extern FILE *yyin; 185 186 /* Try to interpret the file as a linker script. */ 187 ldfile_open_command_file (attempt); 188 189 ldfile_assumed_script = TRUE; 190 parser_input = input_selected; 191 ldlex_both (); 192 token = INPUT_SCRIPT; 193 while (token != 0) 194 { 195 switch (token) 196 { 197 case OUTPUT_FORMAT: 198 if ((token = yylex ()) != '(') 199 continue; 200 if ((token = yylex ()) != NAME) 201 continue; 202 arg1 = yylval.name; 203 arg2 = NULL; 204 arg3 = NULL; 205 token = yylex (); 206 if (token == ',') 207 { 208 if ((token = yylex ()) != NAME) 209 { 210 free (arg1); 211 continue; 212 } 213 arg2 = yylval.name; 214 if ((token = yylex ()) != ',' 215 || (token = yylex ()) != NAME) 216 { 217 free (arg1); 218 free (arg2); 219 continue; 220 } 221 arg3 = yylval.name; 222 token = yylex (); 223 } 224 if (token == ')') 225 { 226 switch (command_line.endian) 227 { 228 default: 229 case ENDIAN_UNSET: 230 arg = arg1; break; 231 case ENDIAN_BIG: 232 arg = arg2 ? arg2 : arg1; break; 233 case ENDIAN_LITTLE: 234 arg = arg3 ? arg3 : arg1; break; 235 } 236 if (strcmp (arg, lang_get_output_target ()) != 0) 237 skip = 1; 238 } 239 free (arg1); 240 if (arg2) free (arg2); 241 if (arg3) free (arg3); 242 break; 243 case NAME: 244 case LNAME: 245 case VERS_IDENTIFIER: 246 case VERS_TAG: 247 free (yylval.name); 248 break; 249 case INT: 250 if (yylval.bigint.str) 251 free (yylval.bigint.str); 252 break; 253 } 254 token = yylex (); 255 } 256 ldlex_popstate (); 257 ldfile_assumed_script = FALSE; 258 fclose (yyin); 259 yyin = NULL; 260 if (skip) 261 { 262 if (command_line.warn_search_mismatch) 263 einfo (_("%P: skipping incompatible %s " 264 "when searching for %s\n"), 265 attempt, entry->local_sym_name); 266 bfd_close (entry->the_bfd); 267 entry->the_bfd = NULL; 268 return FALSE; 269 } 270 } 271 goto success; 272 } 273 274 if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0) 275 { 276 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"), 277 attempt); 278 bfd_close (entry->the_bfd); 279 entry->the_bfd = NULL; 280 return FALSE; 281 } 282 283 if (entry->flags.search_dirs 284 && !bfd_arch_get_compatible (check, link_info.output_bfd, 285 command_line.accept_unknown_input_arch) 286 /* XCOFF archives can have 32 and 64 bit objects. */ 287 && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour 288 && (bfd_get_flavour (link_info.output_bfd) 289 == bfd_target_xcoff_flavour) 290 && bfd_check_format (entry->the_bfd, bfd_archive))) 291 { 292 if (command_line.warn_search_mismatch) 293 einfo (_("%P: skipping incompatible %s " 294 "when searching for %s\n"), 295 attempt, entry->local_sym_name); 296 bfd_close (entry->the_bfd); 297 entry->the_bfd = NULL; 298 return FALSE; 299 } 300 } 301 } 302 success: 303 #ifdef ENABLE_PLUGINS 304 /* If plugins are active, they get first chance to claim 305 any successfully-opened input file. We skip archives 306 here; the plugin wants us to offer it the individual 307 members when we enumerate them, not the whole file. We 308 also ignore corefiles, because that's just weird. It is 309 a needed side-effect of calling bfd_check_format with 310 bfd_object that it sets the bfd's arch and mach, which 311 will be needed when and if we want to bfd_create a new 312 one using this one as a template. */ 313 if (link_info.lto_plugin_active 314 && !no_more_claiming 315 && bfd_check_format (entry->the_bfd, bfd_object)) 316 plugin_maybe_claim (entry); 317 #endif /* ENABLE_PLUGINS */ 318 319 /* It opened OK, the format checked out, and the plugins have had 320 their chance to claim it, so this is success. */ 321 return TRUE; 322 } 323 324 /* Search for and open the file specified by ENTRY. If it is an 325 archive, use ARCH, LIB and SUFFIX to modify the file name. */ 326 327 bfd_boolean 328 ldfile_open_file_search (const char *arch, 329 lang_input_statement_type *entry, 330 const char *lib, 331 const char *suffix) 332 { 333 search_dirs_type *search; 334 335 /* If this is not an archive, try to open it in the current 336 directory first. */ 337 if (!entry->flags.maybe_archive) 338 { 339 if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename)) 340 { 341 char *name = concat (ld_sysroot, entry->filename, 342 (const char *) NULL); 343 if (ldfile_try_open_bfd (name, entry)) 344 { 345 entry->filename = name; 346 return TRUE; 347 } 348 free (name); 349 } 350 else if (ldfile_try_open_bfd (entry->filename, entry)) 351 return TRUE; 352 353 if (IS_ABSOLUTE_PATH (entry->filename)) 354 return FALSE; 355 } 356 357 for (search = search_head; search != NULL; search = search->next) 358 { 359 char *string; 360 361 if (entry->flags.dynamic && !bfd_link_relocatable (&link_info)) 362 { 363 if (ldemul_open_dynamic_archive (arch, search, entry)) 364 return TRUE; 365 } 366 367 if (entry->flags.maybe_archive && !entry->flags.full_name_provided) 368 string = concat (search->name, slash, lib, entry->filename, 369 arch, suffix, (const char *) NULL); 370 else 371 string = concat (search->name, slash, entry->filename, 372 (const char *) 0); 373 374 if (ldfile_try_open_bfd (string, entry)) 375 { 376 entry->filename = string; 377 return TRUE; 378 } 379 380 free (string); 381 } 382 383 return FALSE; 384 } 385 386 /* Open the input file specified by ENTRY. 387 PR 4437: Do not stop on the first missing file, but 388 continue processing other input files in case there 389 are more errors to report. */ 390 391 void 392 ldfile_open_file (lang_input_statement_type *entry) 393 { 394 if (entry->the_bfd != NULL) 395 return; 396 397 if (!entry->flags.search_dirs) 398 { 399 if (ldfile_try_open_bfd (entry->filename, entry)) 400 return; 401 402 if (filename_cmp (entry->filename, entry->local_sym_name) != 0) 403 einfo (_("%P: cannot find %s (%s): %E\n"), 404 entry->filename, entry->local_sym_name); 405 else 406 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name); 407 408 entry->flags.missing_file = TRUE; 409 input_flags.missing_file = TRUE; 410 } 411 else 412 { 413 search_arch_type *arch; 414 bfd_boolean found = FALSE; 415 416 /* Try to open <filename><suffix> or lib<filename><suffix>.a */ 417 for (arch = search_arch_head; arch != NULL; arch = arch->next) 418 { 419 found = ldfile_open_file_search (arch->name, entry, "lib", ".a"); 420 if (found) 421 break; 422 #ifdef VMS 423 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a"); 424 if (found) 425 break; 426 #endif 427 found = ldemul_find_potential_libraries (arch->name, entry); 428 if (found) 429 break; 430 } 431 432 /* If we have found the file, we don't need to search directories 433 again. */ 434 if (found) 435 entry->flags.search_dirs = FALSE; 436 else 437 { 438 if (entry->flags.sysrooted 439 && ld_sysroot 440 && IS_ABSOLUTE_PATH (entry->local_sym_name)) 441 einfo (_("%P: cannot find %s inside %s\n"), 442 entry->local_sym_name, ld_sysroot); 443 else 444 einfo (_("%P: cannot find %s\n"), entry->local_sym_name); 445 entry->flags.missing_file = TRUE; 446 input_flags.missing_file = TRUE; 447 } 448 } 449 } 450 451 /* Try to open NAME. */ 452 453 static FILE * 454 try_open (const char *name, bfd_boolean *sysrooted) 455 { 456 FILE *result; 457 458 result = fopen (name, "r"); 459 460 if (result != NULL) 461 *sysrooted = is_sysrooted_pathname (name); 462 463 if (verbose) 464 { 465 if (result == NULL) 466 info_msg (_("cannot find script file %s\n"), name); 467 else 468 info_msg (_("opened script file %s\n"), name); 469 } 470 471 return result; 472 } 473 474 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */ 475 476 static bfd_boolean 477 check_for_scripts_dir (char *dir) 478 { 479 char *buf; 480 struct stat s; 481 bfd_boolean res; 482 483 buf = concat (dir, "/ldscripts", (const char *) NULL); 484 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode); 485 free (buf); 486 return res; 487 } 488 489 /* Return the default directory for finding script files. 490 We look for the "ldscripts" directory in: 491 492 SCRIPTDIR (passed from Makefile) 493 (adjusted according to the current location of the binary) 494 the dir where this program is (for using it from the build tree). */ 495 496 static char * 497 find_scripts_dir (void) 498 { 499 char *dir; 500 501 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR); 502 if (dir) 503 { 504 if (check_for_scripts_dir (dir)) 505 return dir; 506 free (dir); 507 } 508 509 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR); 510 if (dir) 511 { 512 if (check_for_scripts_dir (dir)) 513 return dir; 514 free (dir); 515 } 516 517 /* Look for "ldscripts" in the dir where our binary is. */ 518 dir = make_relative_prefix (program_name, ".", "."); 519 if (dir) 520 { 521 if (check_for_scripts_dir (dir)) 522 return dir; 523 free (dir); 524 } 525 526 return NULL; 527 } 528 529 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for 530 it in directories specified with -L, then in the default script 531 directory. If DEFAULT_ONLY is true, the search is restricted to 532 the default script location. */ 533 534 static FILE * 535 ldfile_find_command_file (const char *name, 536 bfd_boolean default_only, 537 bfd_boolean *sysrooted) 538 { 539 search_dirs_type *search; 540 FILE *result = NULL; 541 char *path; 542 static search_dirs_type *script_search; 543 544 if (!default_only) 545 { 546 /* First try raw name. */ 547 result = try_open (name, sysrooted); 548 if (result != NULL) 549 return result; 550 } 551 552 if (!script_search) 553 { 554 char *script_dir = find_scripts_dir (); 555 if (script_dir) 556 { 557 search_dirs_type **save_tail_ptr = search_tail_ptr; 558 search_tail_ptr = &script_search; 559 ldfile_add_library_path (script_dir, TRUE); 560 search_tail_ptr = save_tail_ptr; 561 } 562 } 563 564 /* Temporarily append script_search to the path list so that the 565 paths specified with -L will be searched first. */ 566 *search_tail_ptr = script_search; 567 568 /* Try now prefixes. */ 569 for (search = default_only ? script_search : search_head; 570 search != NULL; 571 search = search->next) 572 { 573 path = concat (search->name, slash, name, (const char *) NULL); 574 result = try_open (path, sysrooted); 575 free (path); 576 if (result) 577 break; 578 } 579 580 /* Restore the original path list. */ 581 *search_tail_ptr = NULL; 582 583 return result; 584 } 585 586 /* Open command file NAME. */ 587 588 static void 589 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only) 590 { 591 FILE *ldlex_input_stack; 592 bfd_boolean sysrooted; 593 594 ldlex_input_stack = ldfile_find_command_file (name, default_only, &sysrooted); 595 596 if (ldlex_input_stack == NULL) 597 { 598 bfd_set_error (bfd_error_system_call); 599 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name); 600 return; 601 } 602 603 lex_push_file (ldlex_input_stack, name, sysrooted); 604 605 lineno = 1; 606 607 saved_script_handle = ldlex_input_stack; 608 } 609 610 /* Open command file NAME in the current directory, -L directories, 611 the default script location, in that order. */ 612 613 void 614 ldfile_open_command_file (const char *name) 615 { 616 ldfile_open_command_file_1 (name, FALSE); 617 } 618 619 /* Open command file NAME at the default script location. */ 620 621 void 622 ldfile_open_default_command_file (const char *name) 623 { 624 ldfile_open_command_file_1 (name, TRUE); 625 } 626 627 void 628 ldfile_add_arch (const char *in_name) 629 { 630 char *name = xstrdup (in_name); 631 search_arch_type *new_arch 632 = (search_arch_type *) xmalloc (sizeof (search_arch_type)); 633 634 ldfile_output_machine_name = in_name; 635 636 new_arch->name = name; 637 new_arch->next = NULL; 638 while (*name) 639 { 640 *name = TOLOWER (*name); 641 name++; 642 } 643 *search_arch_tail_ptr = new_arch; 644 search_arch_tail_ptr = &new_arch->next; 645 646 } 647 648 /* Set the output architecture. */ 649 650 void 651 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch) 652 { 653 const bfd_arch_info_type *arch = bfd_scan_arch (string); 654 655 if (arch) 656 { 657 ldfile_output_architecture = arch->arch; 658 ldfile_output_machine = arch->mach; 659 ldfile_output_machine_name = arch->printable_name; 660 } 661 else if (defarch != bfd_arch_unknown) 662 ldfile_output_architecture = defarch; 663 else 664 einfo (_("%P%F: cannot represent machine `%s'\n"), string); 665 } 666