1 /* Linker file opening and searching. 2 Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004, 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. 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 "bfdlink.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 const char * ldfile_input_filename; 43 bfd_boolean ldfile_assumed_script = FALSE; 44 const char * ldfile_output_machine_name = ""; 45 unsigned long ldfile_output_machine; 46 enum bfd_architecture ldfile_output_architecture; 47 search_dirs_type * search_head; 48 49 #ifdef VMS 50 static char * slash = ""; 51 #else 52 #if defined (_WIN32) && ! defined (__CYGWIN32__) 53 static char * slash = "\\"; 54 #else 55 static char * slash = "/"; 56 #endif 57 #endif 58 59 typedef struct search_arch 60 { 61 char *name; 62 struct search_arch *next; 63 } search_arch_type; 64 65 static search_dirs_type **search_tail_ptr = &search_head; 66 static search_arch_type *search_arch_head; 67 static search_arch_type **search_arch_tail_ptr = &search_arch_head; 68 69 /* Test whether a pathname, after canonicalization, is the same or a 70 sub-directory of the sysroot directory. */ 71 72 static bfd_boolean 73 is_sysrooted_pathname (const char *name, bfd_boolean notsame) 74 { 75 char * realname = ld_canon_sysroot ? lrealpath (name) : NULL; 76 int len; 77 bfd_boolean result; 78 79 if (! realname) 80 return FALSE; 81 82 len = strlen (realname); 83 84 if (((! notsame && len == ld_canon_sysroot_len) 85 || (len >= ld_canon_sysroot_len 86 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]) 87 && (realname[ld_canon_sysroot_len] = '\0') == '\0')) 88 && FILENAME_CMP (ld_canon_sysroot, realname) == 0) 89 result = TRUE; 90 else 91 result = FALSE; 92 93 if (realname) 94 free (realname); 95 96 return result; 97 } 98 99 /* Adds NAME to the library search path. 100 Makes a copy of NAME using xmalloc(). */ 101 102 void 103 ldfile_add_library_path (const char *name, bfd_boolean cmdline) 104 { 105 search_dirs_type *new_dirs; 106 107 if (!cmdline && config.only_cmd_line_lib_dirs) 108 return; 109 110 new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type)); 111 new_dirs->next = NULL; 112 new_dirs->cmdline = cmdline; 113 *search_tail_ptr = new_dirs; 114 search_tail_ptr = &new_dirs->next; 115 116 /* If a directory is marked as honoring sysroot, prepend the sysroot path 117 now. */ 118 if (name[0] == '=') 119 { 120 new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL); 121 new_dirs->sysrooted = TRUE; 122 } 123 else 124 { 125 new_dirs->name = xstrdup (name); 126 new_dirs->sysrooted = is_sysrooted_pathname (name, FALSE); 127 } 128 } 129 130 /* Try to open a BFD for a lang_input_statement. */ 131 132 bfd_boolean 133 ldfile_try_open_bfd (const char *attempt, 134 lang_input_statement_type *entry) 135 { 136 entry->the_bfd = bfd_openr (attempt, entry->target); 137 138 if (trace_file_tries) 139 { 140 if (entry->the_bfd == NULL) 141 info_msg (_("attempt to open %s failed\n"), attempt); 142 else 143 info_msg (_("attempt to open %s succeeded\n"), attempt); 144 } 145 146 if (entry->the_bfd == NULL) 147 { 148 if (bfd_get_error () == bfd_error_invalid_target) 149 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target); 150 return FALSE; 151 } 152 153 /* Linker needs to decompress sections. */ 154 entry->the_bfd->flags |= BFD_DECOMPRESS; 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->search_dirs_flag || !entry->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->search_dirs_flag 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->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->search_dirs_flag 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) == bfd_target_xcoff_flavour 292 && bfd_check_format (entry->the_bfd, bfd_archive))) 293 { 294 if (command_line.warn_search_mismatch) 295 einfo (_("%P: skipping incompatible %s " 296 "when searching for %s\n"), 297 attempt, entry->local_sym_name); 298 bfd_close (entry->the_bfd); 299 entry->the_bfd = NULL; 300 return FALSE; 301 } 302 } 303 } 304 success: 305 #ifdef ENABLE_PLUGINS 306 /* If plugins are active, they get first chance to claim 307 any successfully-opened input file. We skip archives 308 here; the plugin wants us to offer it the individual 309 members when we enumerate them, not the whole file. We 310 also ignore corefiles, because that's just weird. It is 311 a needed side-effect of calling bfd_check_format with 312 bfd_object that it sets the bfd's arch and mach, which 313 will be needed when and if we want to bfd_create a new 314 one using this one as a template. */ 315 if (bfd_check_format (entry->the_bfd, bfd_object) 316 && plugin_active_plugins_p () 317 && !no_more_claiming) 318 { 319 int fd = open (attempt, O_RDONLY | O_BINARY); 320 if (fd >= 0) 321 { 322 struct ld_plugin_input_file file; 323 324 file.name = attempt; 325 file.offset = 0; 326 file.filesize = lseek (fd, 0, SEEK_END); 327 file.fd = fd; 328 plugin_maybe_claim (&file, entry); 329 } 330 } 331 #endif /* ENABLE_PLUGINS */ 332 333 /* It opened OK, the format checked out, and the plugins have had 334 their chance to claim it, so this is success. */ 335 return TRUE; 336 } 337 338 /* Search for and open the file specified by ENTRY. If it is an 339 archive, use ARCH, LIB and SUFFIX to modify the file name. */ 340 341 bfd_boolean 342 ldfile_open_file_search (const char *arch, 343 lang_input_statement_type *entry, 344 const char *lib, 345 const char *suffix) 346 { 347 search_dirs_type *search; 348 349 /* If this is not an archive, try to open it in the current 350 directory first. */ 351 if (! entry->maybe_archive) 352 { 353 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename)) 354 { 355 char *name = concat (ld_sysroot, entry->filename, 356 (const char *) NULL); 357 if (ldfile_try_open_bfd (name, entry)) 358 { 359 entry->filename = name; 360 return TRUE; 361 } 362 free (name); 363 } 364 else if (ldfile_try_open_bfd (entry->filename, entry)) 365 { 366 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename) 367 && is_sysrooted_pathname (entry->filename, TRUE); 368 return TRUE; 369 } 370 371 if (IS_ABSOLUTE_PATH (entry->filename)) 372 return FALSE; 373 } 374 375 for (search = search_head; search != NULL; search = search->next) 376 { 377 char *string; 378 379 if (entry->dynamic && ! link_info.relocatable) 380 { 381 if (ldemul_open_dynamic_archive (arch, search, entry)) 382 { 383 entry->sysrooted = search->sysrooted; 384 return TRUE; 385 } 386 } 387 388 if (entry->maybe_archive) 389 string = concat (search->name, slash, lib, entry->filename, 390 arch, suffix, (const char *) NULL); 391 else 392 string = concat (search->name, slash, entry->filename, 393 (const char *) 0); 394 395 if (ldfile_try_open_bfd (string, entry)) 396 { 397 entry->filename = string; 398 entry->sysrooted = search->sysrooted; 399 return TRUE; 400 } 401 402 free (string); 403 } 404 405 return FALSE; 406 } 407 408 /* Open the input file specified by ENTRY. 409 PR 4437: Do not stop on the first missing file, but 410 continue processing other input files in case there 411 are more errors to report. */ 412 413 void 414 ldfile_open_file (lang_input_statement_type *entry) 415 { 416 if (entry->the_bfd != NULL) 417 return; 418 419 if (! entry->search_dirs_flag) 420 { 421 if (ldfile_try_open_bfd (entry->filename, entry)) 422 return; 423 424 if (strcmp (entry->filename, entry->local_sym_name) != 0) 425 einfo (_("%P: cannot find %s (%s): %E\n"), 426 entry->filename, entry->local_sym_name); 427 else 428 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name); 429 430 entry->missing_file = TRUE; 431 missing_file = TRUE; 432 } 433 else 434 { 435 search_arch_type *arch; 436 bfd_boolean found = FALSE; 437 438 /* Try to open <filename><suffix> or lib<filename><suffix>.a */ 439 for (arch = search_arch_head; arch != NULL; arch = arch->next) 440 { 441 found = ldfile_open_file_search (arch->name, entry, "lib", ".a"); 442 if (found) 443 break; 444 #ifdef VMS 445 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a"); 446 if (found) 447 break; 448 #endif 449 found = ldemul_find_potential_libraries (arch->name, entry); 450 if (found) 451 break; 452 } 453 454 /* If we have found the file, we don't need to search directories 455 again. */ 456 if (found) 457 entry->search_dirs_flag = FALSE; 458 else 459 { 460 if (entry->sysrooted 461 && ld_sysroot 462 && IS_ABSOLUTE_PATH (entry->local_sym_name)) 463 einfo (_("%P: cannot find %s inside %s\n"), 464 entry->local_sym_name, ld_sysroot); 465 else 466 einfo (_("%P: cannot find %s\n"), entry->local_sym_name); 467 entry->missing_file = TRUE; 468 missing_file = TRUE; 469 } 470 } 471 } 472 473 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */ 474 475 static FILE * 476 try_open (const char *name, const char *exten) 477 { 478 FILE *result; 479 480 result = fopen (name, "r"); 481 482 if (trace_file_tries) 483 { 484 if (result == NULL) 485 info_msg (_("cannot find script file %s\n"), name); 486 else 487 info_msg (_("opened script file %s\n"), name); 488 } 489 490 if (result != NULL) 491 return result; 492 493 if (*exten) 494 { 495 char *buff; 496 497 buff = concat (name, exten, (const char *) NULL); 498 result = fopen (buff, "r"); 499 500 if (trace_file_tries) 501 { 502 if (result == NULL) 503 info_msg (_("cannot find script file %s\n"), buff); 504 else 505 info_msg (_("opened script file %s\n"), buff); 506 } 507 free (buff); 508 } 509 510 return result; 511 } 512 513 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */ 514 515 static bfd_boolean 516 check_for_scripts_dir (char *dir) 517 { 518 char *buf; 519 struct stat s; 520 bfd_boolean res; 521 522 buf = concat (dir, "/ldscripts", (const char *) NULL); 523 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode); 524 free (buf); 525 return res; 526 } 527 528 /* Return the default directory for finding script files. 529 We look for the "ldscripts" directory in: 530 531 SCRIPTDIR (passed from Makefile) 532 (adjusted according to the current location of the binary) 533 the dir where this program is (for using it from the build tree). */ 534 535 static char * 536 find_scripts_dir (void) 537 { 538 char *dir; 539 540 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR); 541 if (dir) 542 { 543 if (check_for_scripts_dir (dir)) 544 return dir; 545 free (dir); 546 } 547 548 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR); 549 if (dir) 550 { 551 if (check_for_scripts_dir (dir)) 552 return dir; 553 free (dir); 554 } 555 556 /* Look for "ldscripts" in the dir where our binary is. */ 557 dir = make_relative_prefix (program_name, ".", "."); 558 if (dir) 559 { 560 if (check_for_scripts_dir (dir)) 561 return dir; 562 free (dir); 563 } 564 565 return NULL; 566 } 567 568 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for 569 it in directories specified with -L, then in the default script 570 directory, without and with EXTEND appended. If DEFAULT_ONLY is 571 true, the search is restricted to the default script location. */ 572 573 static FILE * 574 ldfile_find_command_file (const char *name, const char *extend, 575 bfd_boolean default_only) 576 { 577 search_dirs_type *search; 578 FILE *result = NULL; 579 char *buffer; 580 static search_dirs_type *script_search; 581 582 if (!default_only) 583 { 584 /* First try raw name. */ 585 result = try_open (name, ""); 586 if (result != NULL) 587 return result; 588 } 589 590 if (!script_search) 591 { 592 char *script_dir = find_scripts_dir (); 593 if (script_dir) 594 { 595 search_dirs_type **save_tail_ptr = search_tail_ptr; 596 search_tail_ptr = &script_search; 597 ldfile_add_library_path (script_dir, TRUE); 598 search_tail_ptr = save_tail_ptr; 599 } 600 } 601 602 /* Temporarily append script_search to the path list so that the 603 paths specified with -L will be searched first. */ 604 *search_tail_ptr = script_search; 605 606 /* Try now prefixes. */ 607 for (search = default_only ? script_search : search_head; 608 search != NULL; 609 search = search->next) 610 { 611 buffer = concat (search->name, slash, name, (const char *) NULL); 612 result = try_open (buffer, extend); 613 free (buffer); 614 if (result) 615 break; 616 } 617 618 /* Restore the original path list. */ 619 *search_tail_ptr = NULL; 620 621 return result; 622 } 623 624 /* Open command file NAME. */ 625 626 static void 627 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only) 628 { 629 FILE *ldlex_input_stack; 630 ldlex_input_stack = ldfile_find_command_file (name, "", default_only); 631 632 if (ldlex_input_stack == NULL) 633 { 634 bfd_set_error (bfd_error_system_call); 635 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name); 636 } 637 638 lex_push_file (ldlex_input_stack, name); 639 640 ldfile_input_filename = name; 641 lineno = 1; 642 643 saved_script_handle = ldlex_input_stack; 644 } 645 646 /* Open command file NAME in the current directory, -L directories, 647 the default script location, in that order. */ 648 649 void 650 ldfile_open_command_file (const char *name) 651 { 652 ldfile_open_command_file_1 (name, FALSE); 653 } 654 655 /* Open command file NAME at the default script location. */ 656 657 void 658 ldfile_open_default_command_file (const char *name) 659 { 660 ldfile_open_command_file_1 (name, TRUE); 661 } 662 663 void 664 ldfile_add_arch (const char *in_name) 665 { 666 char *name = xstrdup (in_name); 667 search_arch_type *new_arch = (search_arch_type *) 668 xmalloc (sizeof (search_arch_type)); 669 670 ldfile_output_machine_name = in_name; 671 672 new_arch->name = name; 673 new_arch->next = NULL; 674 while (*name) 675 { 676 *name = TOLOWER (*name); 677 name++; 678 } 679 *search_arch_tail_ptr = new_arch; 680 search_arch_tail_ptr = &new_arch->next; 681 682 } 683 684 /* Set the output architecture. */ 685 686 void 687 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch) 688 { 689 const bfd_arch_info_type *arch = bfd_scan_arch (string); 690 691 if (arch) 692 { 693 ldfile_output_architecture = arch->arch; 694 ldfile_output_machine = arch->mach; 695 ldfile_output_machine_name = arch->printable_name; 696 } 697 else if (defarch != bfd_arch_unknown) 698 ldfile_output_architecture = defarch; 699 else 700 einfo (_("%P%F: cannot represent machine `%s'\n"), string); 701 } 702