1/* Linker file opening and searching. 2 Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004 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, 59 Temple Place - Suite 330, Boston, MA 20 02111-1307, 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 40const char * ldfile_input_filename; 41bfd_boolean ldfile_assumed_script = FALSE; 42const char * ldfile_output_machine_name = ""; 43unsigned long ldfile_output_machine; 44enum bfd_architecture ldfile_output_architecture; 45search_dirs_type * search_head; 46 47#ifndef MPW 48#ifdef VMS 49char * slash = ""; 50#else 51#if defined (_WIN32) && ! defined (__CYGWIN32__) 52char * slash = "\\"; 53#else 54char * slash = "/"; 55#endif 56#endif 57#else /* MPW */ 58/* The MPW path char is a colon. */ 59char * slash = ":"; 60#endif /* MPW */ 61 62typedef struct search_arch 63{ 64 char *name; 65 struct search_arch *next; 66} search_arch_type; 67 68static search_dirs_type **search_tail_ptr = &search_head; 69static search_arch_type *search_arch_head; 70static search_arch_type **search_arch_tail_ptr = &search_arch_head; 71 72/* Test whether a pathname, after canonicalization, is the same or a 73 sub-directory of the sysroot directory. */ 74 75static bfd_boolean 76is_sysrooted_pathname (const char *name, bfd_boolean notsame) 77{ 78 char * realname = ld_canon_sysroot ? lrealpath (name) : NULL; 79 int len; 80 bfd_boolean result; 81 82 if (! realname) 83 return FALSE; 84 85 len = strlen (realname); 86 87 if (((! notsame && len == ld_canon_sysroot_len) 88 || (len >= ld_canon_sysroot_len 89 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]) 90 && (realname[ld_canon_sysroot_len] = '\0') == '\0')) 91 && FILENAME_CMP (ld_canon_sysroot, realname) == 0) 92 result = TRUE; 93 else 94 result = FALSE; 95 96 if (realname) 97 free (realname); 98 99 return result; 100} 101 102/* Adds NAME to the library search path. 103 Makes a copy of NAME using xmalloc(). */ 104 105void 106ldfile_add_library_path (const char *name, bfd_boolean cmdline) 107{ 108 search_dirs_type *new; 109 110 if (!cmdline && config.only_cmd_line_lib_dirs) 111 return; 112 113 new = xmalloc (sizeof (search_dirs_type)); 114 new->next = NULL; 115 new->cmdline = cmdline; 116 *search_tail_ptr = new; 117 search_tail_ptr = &new->next; 118 119 /* If a directory is marked as honoring sysroot, prepend the sysroot path 120 now. */ 121 if (name[0] == '=') 122 { 123 new->name = concat (ld_sysroot, name + 1, NULL); 124 new->sysrooted = TRUE; 125 } 126 else 127 { 128 new->name = xstrdup (name); 129 new->sysrooted = is_sysrooted_pathname (name, FALSE); 130 } 131} 132 133/* Try to open a BFD for a lang_input_statement. */ 134 135bfd_boolean 136ldfile_try_open_bfd (const char *attempt, 137 lang_input_statement_type *entry) 138{ 139 entry->the_bfd = bfd_openr (attempt, entry->target); 140 141 if (trace_file_tries) 142 { 143 if (entry->the_bfd == NULL) 144 info_msg (_("attempt to open %s failed\n"), attempt); 145 else 146 info_msg (_("attempt to open %s succeeded\n"), attempt); 147 } 148 149 if (entry->the_bfd == NULL) 150 { 151 if (bfd_get_error () == bfd_error_invalid_target) 152 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target); 153 return FALSE; 154 } 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. */ 160 161 if (entry->search_dirs_flag) 162 { 163 bfd *check; 164 165 if (bfd_check_format (entry->the_bfd, bfd_archive)) 166 check = bfd_openr_next_archived_file (entry->the_bfd, NULL); 167 else 168 check = entry->the_bfd; 169 170 if (check != NULL) 171 { 172 if (! bfd_check_format (check, bfd_object)) 173 { 174 if (check == entry->the_bfd 175 && bfd_get_error () == bfd_error_file_not_recognized 176 && ! ldemul_unrecognized_file (entry)) 177 { 178 int token, skip = 0; 179 char *arg, *arg1, *arg2, *arg3; 180 extern FILE *yyin; 181 182 /* Try to interpret the file as a linker script. */ 183 ldfile_open_command_file (attempt); 184 185 ldfile_assumed_script = TRUE; 186 parser_input = input_selected; 187 ldlex_both (); 188 token = INPUT_SCRIPT; 189 while (token != 0) 190 { 191 switch (token) 192 { 193 case OUTPUT_FORMAT: 194 if ((token = yylex ()) != '(') 195 continue; 196 if ((token = yylex ()) != NAME) 197 continue; 198 arg1 = yylval.name; 199 arg2 = NULL; 200 arg3 = NULL; 201 token = yylex (); 202 if (token == ',') 203 { 204 if ((token = yylex ()) != NAME) 205 { 206 free (arg1); 207 continue; 208 } 209 arg2 = yylval.name; 210 if ((token = yylex ()) != ',' 211 || (token = yylex ()) != NAME) 212 { 213 free (arg1); 214 free (arg2); 215 continue; 216 } 217 arg3 = yylval.name; 218 token = yylex (); 219 } 220 if (token == ')') 221 { 222 switch (command_line.endian) 223 { 224 default: 225 case ENDIAN_UNSET: 226 arg = arg1; break; 227 case ENDIAN_BIG: 228 arg = arg2 ? arg2 : arg1; break; 229 case ENDIAN_LITTLE: 230 arg = arg3 ? arg3 : arg1; break; 231 } 232 if (strcmp (arg, lang_get_output_target ()) != 0) 233 skip = 1; 234 } 235 free (arg1); 236 if (arg2) free (arg2); 237 if (arg3) free (arg3); 238 break; 239 case NAME: 240 case LNAME: 241 case VERS_IDENTIFIER: 242 case VERS_TAG: 243 free (yylval.name); 244 break; 245 case INT: 246 if (yylval.bigint.str) 247 free (yylval.bigint.str); 248 break; 249 } 250 token = yylex (); 251 } 252 ldlex_popstate (); 253 ldfile_assumed_script = FALSE; 254 fclose (yyin); 255 yyin = NULL; 256 if (skip) 257 { 258 einfo (_("%P: skipping incompatible %s when searching for %s\n"), 259 attempt, entry->local_sym_name); 260 bfd_close (entry->the_bfd); 261 entry->the_bfd = NULL; 262 return FALSE; 263 } 264 } 265 return TRUE; 266 } 267 268 if ((bfd_arch_get_compatible (check, output_bfd, 269 command_line.accept_unknown_input_arch) == NULL) 270 /* XCOFF archives can have 32 and 64 bit objects. */ 271 && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour 272 && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour 273 && bfd_check_format (entry->the_bfd, bfd_archive))) 274 { 275 einfo (_("%P: skipping incompatible %s when searching for %s\n"), 276 attempt, entry->local_sym_name); 277 bfd_close (entry->the_bfd); 278 entry->the_bfd = NULL; 279 return FALSE; 280 } 281 } 282 } 283 284 return TRUE; 285} 286 287/* Search for and open the file specified by ENTRY. If it is an 288 archive, use ARCH, LIB and SUFFIX to modify the file name. */ 289 290bfd_boolean 291ldfile_open_file_search (const char *arch, 292 lang_input_statement_type *entry, 293 const char *lib, 294 const char *suffix) 295{ 296 search_dirs_type *search; 297 298 /* If this is not an archive, try to open it in the current 299 directory first. */ 300 if (! entry->is_archive) 301 { 302 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename)) 303 { 304 char *name = concat (ld_sysroot, entry->filename, 305 (const char *) NULL); 306 if (ldfile_try_open_bfd (name, entry)) 307 { 308 entry->filename = name; 309 return TRUE; 310 } 311 free (name); 312 } 313 else if (ldfile_try_open_bfd (entry->filename, entry)) 314 { 315 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename) 316 && is_sysrooted_pathname (entry->filename, TRUE); 317 return TRUE; 318 } 319 320 if (IS_ABSOLUTE_PATH (entry->filename)) 321 return FALSE; 322 } 323 324 for (search = search_head; search != NULL; search = search->next) 325 { 326 char *string; 327 328 if (entry->dynamic && ! link_info.relocatable) 329 { 330 if (ldemul_open_dynamic_archive (arch, search, entry)) 331 { 332 entry->sysrooted = search->sysrooted; 333 return TRUE; 334 } 335 } 336 337 string = xmalloc (strlen (search->name) 338 + strlen (slash) 339 + strlen (lib) 340 + strlen (entry->filename) 341 + strlen (arch) 342 + strlen (suffix) 343 + 1); 344 345 if (entry->is_archive) 346 sprintf (string, "%s%s%s%s%s%s", search->name, slash, 347 lib, entry->filename, arch, suffix); 348 else 349 sprintf (string, "%s%s%s", search->name, slash, entry->filename); 350 351 if (ldfile_try_open_bfd (string, entry)) 352 { 353 entry->filename = string; 354 entry->sysrooted = search->sysrooted; 355 return TRUE; 356 } 357 358 free (string); 359 } 360 361 return FALSE; 362} 363 364/* Open the input file specified by ENTRY. */ 365 366void 367ldfile_open_file (lang_input_statement_type *entry) 368{ 369 if (entry->the_bfd != NULL) 370 return; 371 372 if (! entry->search_dirs_flag) 373 { 374 if (ldfile_try_open_bfd (entry->filename, entry)) 375 return; 376 if (strcmp (entry->filename, entry->local_sym_name) != 0) 377 einfo (_("%F%P: %s (%s): No such file: %E\n"), 378 entry->filename, entry->local_sym_name); 379 else 380 einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name); 381 } 382 else 383 { 384 search_arch_type *arch; 385 bfd_boolean found = FALSE; 386 387 /* Try to open <filename><suffix> or lib<filename><suffix>.a */ 388 for (arch = search_arch_head; arch != NULL; arch = arch->next) 389 { 390 found = ldfile_open_file_search (arch->name, entry, "lib", ".a"); 391 if (found) 392 break; 393#ifdef VMS 394 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a"); 395 if (found) 396 break; 397#endif 398 found = ldemul_find_potential_libraries (arch->name, entry); 399 if (found) 400 break; 401 } 402 403 /* If we have found the file, we don't need to search directories 404 again. */ 405 if (found) 406 entry->search_dirs_flag = FALSE; 407 else if (entry->sysrooted 408 && ld_sysroot 409 && IS_ABSOLUTE_PATH (entry->local_sym_name)) 410 einfo (_("%F%P: cannot find %s inside %s\n"), 411 entry->local_sym_name, ld_sysroot); 412 else 413 einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name); 414 } 415} 416 417/* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */ 418 419static FILE * 420try_open (const char *name, const char *exten) 421{ 422 FILE *result; 423 char buff[1000]; 424 425 result = fopen (name, "r"); 426 427 if (trace_file_tries) 428 { 429 if (result == NULL) 430 info_msg (_("cannot find script file %s\n"), name); 431 else 432 info_msg (_("opened script file %s\n"), name); 433 } 434 435 if (result != NULL) 436 return result; 437 438 if (*exten) 439 { 440 sprintf (buff, "%s%s", name, exten); 441 result = fopen (buff, "r"); 442 443 if (trace_file_tries) 444 { 445 if (result == NULL) 446 info_msg (_("cannot find script file %s\n"), buff); 447 else 448 info_msg (_("opened script file %s\n"), buff); 449 } 450 } 451 452 return result; 453} 454 455/* Try to open NAME; if that fails, look for it in any directories 456 specified with -L, without and with EXTEND appended. */ 457 458FILE * 459ldfile_find_command_file (const char *name, const char *extend) 460{ 461 search_dirs_type *search; 462 FILE *result; 463 char buffer[1000]; 464 465 /* First try raw name. */ 466 result = try_open (name, ""); 467 if (result == NULL) 468 { 469 /* Try now prefixes. */ 470 for (search = search_head; search != NULL; search = search->next) 471 { 472 sprintf (buffer, "%s%s%s", search->name, slash, name); 473 474 result = try_open (buffer, extend); 475 if (result) 476 break; 477 } 478 } 479 480 return result; 481} 482 483void 484ldfile_open_command_file (const char *name) 485{ 486 FILE *ldlex_input_stack; 487 ldlex_input_stack = ldfile_find_command_file (name, ""); 488 489 if (ldlex_input_stack == NULL) 490 { 491 bfd_set_error (bfd_error_system_call); 492 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name); 493 } 494 495 lex_push_file (ldlex_input_stack, name); 496 497 ldfile_input_filename = name; 498 lineno = 1; 499 500 saved_script_handle = ldlex_input_stack; 501} 502 503#ifdef GNU960 504static char * 505gnu960_map_archname (char *name) 506{ 507 struct tabentry { char *cmd_switch; char *arch; }; 508 static struct tabentry arch_tab[] = 509 { 510 "", "", 511 "KA", "ka", 512 "KB", "kb", 513 "KC", "mc", /* Synonym for MC */ 514 "MC", "mc", 515 "CA", "ca", 516 "SA", "ka", /* Functionally equivalent to KA */ 517 "SB", "kb", /* Functionally equivalent to KB */ 518 NULL, "" 519 }; 520 struct tabentry *tp; 521 522 for (tp = arch_tab; tp->cmd_switch != NULL; tp++) 523 { 524 if (! strcmp (name,tp->cmd_switch)) 525 break; 526 } 527 528 if (tp->cmd_switch == NULL) 529 einfo (_("%P%F: unknown architecture: %s\n"), name); 530 531 return tp->arch; 532} 533 534void 535ldfile_add_arch (char *name) 536{ 537 search_arch_type *new = xmalloc (sizeof (search_arch_type)); 538 539 if (*name != '\0') 540 { 541 if (ldfile_output_machine_name[0] != '\0') 542 { 543 einfo (_("%P%F: target architecture respecified\n")); 544 return; 545 } 546 547 ldfile_output_machine_name = name; 548 } 549 550 new->next = NULL; 551 new->name = gnu960_map_archname (name); 552 *search_arch_tail_ptr = new; 553 search_arch_tail_ptr = &new->next; 554} 555 556#else /* not GNU960 */ 557 558void 559ldfile_add_arch (const char *in_name) 560{ 561 char *name = xstrdup (in_name); 562 search_arch_type *new = xmalloc (sizeof (search_arch_type)); 563 564 ldfile_output_machine_name = in_name; 565 566 new->name = name; 567 new->next = NULL; 568 while (*name) 569 { 570 *name = TOLOWER (*name); 571 name++; 572 } 573 *search_arch_tail_ptr = new; 574 search_arch_tail_ptr = &new->next; 575 576} 577#endif 578 579/* Set the output architecture. */ 580 581void 582ldfile_set_output_arch (const char *string, enum bfd_architecture defarch) 583{ 584 const bfd_arch_info_type *arch = bfd_scan_arch (string); 585 586 if (arch) 587 { 588 ldfile_output_architecture = arch->arch; 589 ldfile_output_machine = arch->mach; 590 ldfile_output_machine_name = arch->printable_name; 591 } 592 else if (defarch != bfd_arch_unknown) 593 ldfile_output_architecture = defarch; 594 else 595 einfo (_("%P%F: cannot represent machine `%s'\n"), string); 596} 597