1 /* Linker file opening and searching. 2 Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004, 2005 Free Software Foundation, Inc. 4 5 This file is part of GLD, the Gnu Linker. 6 7 GLD 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 2, or (at your option) 10 any later version. 11 12 GLD 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 GLD; see the file COPYING. If not, write to the Free 19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 20 02110-1301, USA. */ 21 22 /* ldfile.c: look after all the file stuff. */ 23 24 #include "bfd.h" 25 #include "sysdep.h" 26 #include "bfdlink.h" 27 #include "safe-ctype.h" 28 #include "ld.h" 29 #include "ldmisc.h" 30 #include "ldexp.h" 31 #include "ldlang.h" 32 #include "ldfile.h" 33 #include "ldmain.h" 34 #include <ldgram.h> 35 #include "ldlex.h" 36 #include "ldemul.h" 37 #include "libiberty.h" 38 #include "filenames.h" 39 40 const char * ldfile_input_filename; 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, bfd_boolean notsame) 72 { 73 char * realname = ld_canon_sysroot ? lrealpath (name) : NULL; 74 int len; 75 bfd_boolean result; 76 77 if (! realname) 78 return FALSE; 79 80 len = strlen (realname); 81 82 if (((! notsame && len == ld_canon_sysroot_len) 83 || (len >= ld_canon_sysroot_len 84 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]) 85 && (realname[ld_canon_sysroot_len] = '\0') == '\0')) 86 && FILENAME_CMP (ld_canon_sysroot, realname) == 0) 87 result = TRUE; 88 else 89 result = FALSE; 90 91 if (realname) 92 free (realname); 93 94 return result; 95 } 96 97 /* Adds NAME to the library search path. 98 Makes a copy of NAME using xmalloc(). */ 99 100 void 101 ldfile_add_library_path (const char *name, bfd_boolean cmdline) 102 { 103 search_dirs_type *new; 104 105 if (!cmdline && config.only_cmd_line_lib_dirs) 106 return; 107 108 new = xmalloc (sizeof (search_dirs_type)); 109 new->next = NULL; 110 new->cmdline = cmdline; 111 *search_tail_ptr = new; 112 search_tail_ptr = &new->next; 113 114 /* If a directory is marked as honoring sysroot, prepend the sysroot path 115 now. */ 116 if (name[0] == '=') 117 { 118 new->name = concat (ld_sysroot, name + 1, NULL); 119 new->sysrooted = TRUE; 120 } 121 else 122 { 123 new->name = xstrdup (name); 124 new->sysrooted = is_sysrooted_pathname (name, FALSE); 125 } 126 } 127 128 /* Try to open a BFD for a lang_input_statement. */ 129 130 bfd_boolean 131 ldfile_try_open_bfd (const char *attempt, 132 lang_input_statement_type *entry) 133 { 134 entry->the_bfd = bfd_openr (attempt, entry->target); 135 136 if (trace_file_tries) 137 { 138 if (entry->the_bfd == NULL) 139 info_msg (_("attempt to open %s failed\n"), attempt); 140 else 141 info_msg (_("attempt to open %s succeeded\n"), attempt); 142 } 143 144 if (entry->the_bfd == NULL) 145 { 146 if (bfd_get_error () == bfd_error_invalid_target) 147 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target); 148 return FALSE; 149 } 150 151 /* If we are searching for this file, see if the architecture is 152 compatible with the output file. If it isn't, keep searching. 153 If we can't open the file as an object file, stop the search 154 here. If we are statically linking, ensure that we don't link 155 a dynamic object. */ 156 157 if (entry->search_dirs_flag || !entry->dynamic) 158 { 159 bfd *check; 160 161 if (bfd_check_format (entry->the_bfd, bfd_archive)) 162 check = bfd_openr_next_archived_file (entry->the_bfd, NULL); 163 else 164 check = entry->the_bfd; 165 166 if (check != NULL) 167 { 168 if (! bfd_check_format (check, bfd_object)) 169 { 170 if (check == entry->the_bfd 171 && entry->search_dirs_flag 172 && bfd_get_error () == bfd_error_file_not_recognized 173 && ! ldemul_unrecognized_file (entry)) 174 { 175 int token, skip = 0; 176 char *arg, *arg1, *arg2, *arg3; 177 extern FILE *yyin; 178 179 /* Try to interpret the file as a linker script. */ 180 ldfile_open_command_file (attempt); 181 182 ldfile_assumed_script = TRUE; 183 parser_input = input_selected; 184 ldlex_both (); 185 token = INPUT_SCRIPT; 186 while (token != 0) 187 { 188 switch (token) 189 { 190 case OUTPUT_FORMAT: 191 if ((token = yylex ()) != '(') 192 continue; 193 if ((token = yylex ()) != NAME) 194 continue; 195 arg1 = yylval.name; 196 arg2 = NULL; 197 arg3 = NULL; 198 token = yylex (); 199 if (token == ',') 200 { 201 if ((token = yylex ()) != NAME) 202 { 203 free (arg1); 204 continue; 205 } 206 arg2 = yylval.name; 207 if ((token = yylex ()) != ',' 208 || (token = yylex ()) != NAME) 209 { 210 free (arg1); 211 free (arg2); 212 continue; 213 } 214 arg3 = yylval.name; 215 token = yylex (); 216 } 217 if (token == ')') 218 { 219 switch (command_line.endian) 220 { 221 default: 222 case ENDIAN_UNSET: 223 arg = arg1; break; 224 case ENDIAN_BIG: 225 arg = arg2 ? arg2 : arg1; break; 226 case ENDIAN_LITTLE: 227 arg = arg3 ? arg3 : arg1; break; 228 } 229 if (strcmp (arg, lang_get_output_target ()) != 0) 230 skip = 1; 231 } 232 free (arg1); 233 if (arg2) free (arg2); 234 if (arg3) free (arg3); 235 break; 236 case NAME: 237 case LNAME: 238 case VERS_IDENTIFIER: 239 case VERS_TAG: 240 free (yylval.name); 241 break; 242 case INT: 243 if (yylval.bigint.str) 244 free (yylval.bigint.str); 245 break; 246 } 247 token = yylex (); 248 } 249 ldlex_popstate (); 250 ldfile_assumed_script = FALSE; 251 fclose (yyin); 252 yyin = NULL; 253 if (skip) 254 { 255 einfo (_("%P: skipping incompatible %s when searching for %s\n"), 256 attempt, entry->local_sym_name); 257 bfd_close (entry->the_bfd); 258 entry->the_bfd = NULL; 259 return FALSE; 260 } 261 } 262 return TRUE; 263 } 264 265 if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0) 266 { 267 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"), 268 attempt); 269 bfd_close (entry->the_bfd); 270 entry->the_bfd = NULL; 271 return FALSE; 272 } 273 274 if (entry->search_dirs_flag 275 && !bfd_arch_get_compatible (check, output_bfd, 276 command_line.accept_unknown_input_arch) 277 /* XCOFF archives can have 32 and 64 bit objects. */ 278 && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour 279 && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour 280 && bfd_check_format (entry->the_bfd, bfd_archive))) 281 { 282 einfo (_("%P: skipping incompatible %s when searching for %s\n"), 283 attempt, entry->local_sym_name); 284 bfd_close (entry->the_bfd); 285 entry->the_bfd = NULL; 286 return FALSE; 287 } 288 } 289 } 290 291 return TRUE; 292 } 293 294 /* Search for and open the file specified by ENTRY. If it is an 295 archive, use ARCH, LIB and SUFFIX to modify the file name. */ 296 297 bfd_boolean 298 ldfile_open_file_search (const char *arch, 299 lang_input_statement_type *entry, 300 const char *lib, 301 const char *suffix) 302 { 303 search_dirs_type *search; 304 305 /* If this is not an archive, try to open it in the current 306 directory first. */ 307 if (! entry->is_archive) 308 { 309 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename)) 310 { 311 char *name = concat (ld_sysroot, entry->filename, 312 (const char *) NULL); 313 if (ldfile_try_open_bfd (name, entry)) 314 { 315 entry->filename = name; 316 return TRUE; 317 } 318 free (name); 319 } 320 else if (ldfile_try_open_bfd (entry->filename, entry)) 321 { 322 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename) 323 && is_sysrooted_pathname (entry->filename, TRUE); 324 return TRUE; 325 } 326 327 if (IS_ABSOLUTE_PATH (entry->filename)) 328 return FALSE; 329 } 330 331 for (search = search_head; search != NULL; search = search->next) 332 { 333 char *string; 334 335 if (entry->dynamic && ! link_info.relocatable) 336 { 337 if (ldemul_open_dynamic_archive (arch, search, entry)) 338 { 339 entry->sysrooted = search->sysrooted; 340 return TRUE; 341 } 342 } 343 344 string = xmalloc (strlen (search->name) 345 + strlen (slash) 346 + strlen (lib) 347 + strlen (entry->filename) 348 + strlen (arch) 349 + strlen (suffix) 350 + 1); 351 352 if (entry->is_archive) 353 sprintf (string, "%s%s%s%s%s%s", search->name, slash, 354 lib, entry->filename, arch, suffix); 355 else 356 sprintf (string, "%s%s%s", search->name, slash, entry->filename); 357 358 if (ldfile_try_open_bfd (string, entry)) 359 { 360 entry->filename = string; 361 entry->sysrooted = search->sysrooted; 362 return TRUE; 363 } 364 365 free (string); 366 } 367 368 return FALSE; 369 } 370 371 /* Open the input file specified by ENTRY. */ 372 373 void 374 ldfile_open_file (lang_input_statement_type *entry) 375 { 376 if (entry->the_bfd != NULL) 377 return; 378 379 if (! entry->search_dirs_flag) 380 { 381 if (ldfile_try_open_bfd (entry->filename, entry)) 382 return; 383 if (strcmp (entry->filename, entry->local_sym_name) != 0) 384 einfo (_("%F%P: %s (%s): No such file: %E\n"), 385 entry->filename, entry->local_sym_name); 386 else 387 einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name); 388 } 389 else 390 { 391 search_arch_type *arch; 392 bfd_boolean found = FALSE; 393 394 /* Try to open <filename><suffix> or lib<filename><suffix>.a */ 395 for (arch = search_arch_head; arch != NULL; arch = arch->next) 396 { 397 found = ldfile_open_file_search (arch->name, entry, "lib", ".a"); 398 if (found) 399 break; 400 #ifdef VMS 401 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a"); 402 if (found) 403 break; 404 #endif 405 found = ldemul_find_potential_libraries (arch->name, entry); 406 if (found) 407 break; 408 } 409 410 /* If we have found the file, we don't need to search directories 411 again. */ 412 if (found) 413 entry->search_dirs_flag = FALSE; 414 else if (entry->sysrooted 415 && ld_sysroot 416 && IS_ABSOLUTE_PATH (entry->local_sym_name)) 417 einfo (_("%F%P: cannot find %s inside %s\n"), 418 entry->local_sym_name, ld_sysroot); 419 else 420 einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name); 421 } 422 } 423 424 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */ 425 426 static FILE * 427 try_open (const char *name, const char *exten) 428 { 429 FILE *result; 430 char buff[1000]; 431 432 result = fopen (name, "r"); 433 434 if (trace_file_tries) 435 { 436 if (result == NULL) 437 info_msg (_("cannot find script file %s\n"), name); 438 else 439 info_msg (_("opened script file %s\n"), name); 440 } 441 442 if (result != NULL) 443 return result; 444 445 if (*exten) 446 { 447 sprintf (buff, "%s%s", name, exten); 448 result = fopen (buff, "r"); 449 450 if (trace_file_tries) 451 { 452 if (result == NULL) 453 info_msg (_("cannot find script file %s\n"), buff); 454 else 455 info_msg (_("opened script file %s\n"), buff); 456 } 457 } 458 459 return result; 460 } 461 462 /* Try to open NAME; if that fails, look for it in any directories 463 specified with -L, without and with EXTEND appended. */ 464 465 static FILE * 466 ldfile_find_command_file (const char *name, const char *extend) 467 { 468 search_dirs_type *search; 469 FILE *result; 470 char buffer[1000]; 471 472 /* First try raw name. */ 473 result = try_open (name, ""); 474 if (result == NULL) 475 { 476 /* Try now prefixes. */ 477 for (search = search_head; search != NULL; search = search->next) 478 { 479 sprintf (buffer, "%s%s%s", search->name, slash, name); 480 481 result = try_open (buffer, extend); 482 if (result) 483 break; 484 } 485 } 486 487 return result; 488 } 489 490 void 491 ldfile_open_command_file (const char *name) 492 { 493 FILE *ldlex_input_stack; 494 ldlex_input_stack = ldfile_find_command_file (name, ""); 495 496 if (ldlex_input_stack == NULL) 497 { 498 bfd_set_error (bfd_error_system_call); 499 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name); 500 } 501 502 lex_push_file (ldlex_input_stack, name); 503 504 ldfile_input_filename = name; 505 lineno = 1; 506 507 saved_script_handle = ldlex_input_stack; 508 } 509 510 void 511 ldfile_add_arch (const char *in_name) 512 { 513 char *name = xstrdup (in_name); 514 search_arch_type *new = xmalloc (sizeof (search_arch_type)); 515 516 ldfile_output_machine_name = in_name; 517 518 new->name = name; 519 new->next = NULL; 520 while (*name) 521 { 522 *name = TOLOWER (*name); 523 name++; 524 } 525 *search_arch_tail_ptr = new; 526 search_arch_tail_ptr = &new->next; 527 528 } 529 530 /* Set the output architecture. */ 531 532 void 533 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch) 534 { 535 const bfd_arch_info_type *arch = bfd_scan_arch (string); 536 537 if (arch) 538 { 539 ldfile_output_architecture = arch->arch; 540 ldfile_output_machine = arch->mach; 541 ldfile_output_machine_name = arch->printable_name; 542 } 543 else if (defarch != bfd_arch_unknown) 544 ldfile_output_architecture = defarch; 545 else 546 einfo (_("%P%F: cannot represent machine `%s'\n"), string); 547 } 548