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.
5 This file is part of the GNU Binutils.
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.
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.
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. */
25 #include "safe-ctype.h"
35 #include "libiberty.h"
36 #include "filenames.h"
38 #include "plugin-api.h"
40 #endif /* ENABLE_PLUGINS */
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;
50 static char * slash = "";
52 #if defined (_WIN32) && ! defined (__CYGWIN32__)
53 static char * slash = "\\";
55 static char * slash = "/";
59 typedef struct search_arch
62 struct search_arch *next;
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;
69 /* Test whether a pathname, after canonicalization, is the same or a
70 sub-directory of the sysroot directory. */
73 is_sysrooted_pathname (const char *name, bfd_boolean notsame)
75 char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
82 len = strlen (realname);
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)
99 /* Adds NAME to the library search path.
100 Makes a copy of NAME using xmalloc(). */
103 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
105 search_dirs_type *new_dirs;
107 if (!cmdline && config.only_cmd_line_lib_dirs)
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;
116 /* If a directory is marked as honoring sysroot, prepend the sysroot path
120 new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
121 new_dirs->sysrooted = TRUE;
125 new_dirs->name = xstrdup (name);
126 new_dirs->sysrooted = is_sysrooted_pathname (name, FALSE);
130 /* Try to open a BFD for a lang_input_statement. */
133 ldfile_try_open_bfd (const char *attempt,
134 lang_input_statement_type *entry)
136 entry->the_bfd = bfd_openr (attempt, entry->target);
138 if (trace_file_tries)
140 if (entry->the_bfd == NULL)
141 info_msg (_("attempt to open %s failed\n"), attempt);
143 info_msg (_("attempt to open %s succeeded\n"), attempt);
146 if (entry->the_bfd == NULL)
148 if (bfd_get_error () == bfd_error_invalid_target)
149 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
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
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. */
164 if (entry->search_dirs_flag || !entry->dynamic)
168 if (bfd_check_format (entry->the_bfd, bfd_archive))
169 check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
171 check = entry->the_bfd;
175 if (! bfd_check_format (check, bfd_object))
177 if (check == entry->the_bfd
178 && entry->search_dirs_flag
179 && bfd_get_error () == bfd_error_file_not_recognized
180 && ! ldemul_unrecognized_file (entry))
183 char *arg, *arg1, *arg2, *arg3;
186 /* Try to interpret the file as a linker script. */
187 ldfile_open_command_file (attempt);
189 ldfile_assumed_script = TRUE;
190 parser_input = input_selected;
192 token = INPUT_SCRIPT;
198 if ((token = yylex ()) != '(')
200 if ((token = yylex ()) != NAME)
208 if ((token = yylex ()) != NAME)
214 if ((token = yylex ()) != ','
215 || (token = yylex ()) != NAME)
226 switch (command_line.endian)
232 arg = arg2 ? arg2 : arg1; break;
234 arg = arg3 ? arg3 : arg1; break;
236 if (strcmp (arg, lang_get_output_target ()) != 0)
240 if (arg2) free (arg2);
241 if (arg3) free (arg3);
245 case VERS_IDENTIFIER:
250 if (yylval.bigint.str)
251 free (yylval.bigint.str);
257 ldfile_assumed_script = FALSE;
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;
274 if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
276 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
278 bfd_close (entry->the_bfd);
279 entry->the_bfd = NULL;
283 if (entry->search_dirs_flag
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) == bfd_target_xcoff_flavour
289 && bfd_check_format (entry->the_bfd, bfd_archive)))
291 if (command_line.warn_search_mismatch)
292 einfo (_("%P: skipping incompatible %s "
293 "when searching for %s\n"),
294 attempt, entry->local_sym_name);
295 bfd_close (entry->the_bfd);
296 entry->the_bfd = NULL;
302 #ifdef ENABLE_PLUGINS
303 /* If plugins are active, they get first chance to claim
304 any successfully-opened input file. We skip archives
305 here; the plugin wants us to offer it the individual
306 members when we enumerate them, not the whole file. We
307 also ignore corefiles, because that's just weird. It is
308 a needed side-effect of calling bfd_check_format with
309 bfd_object that it sets the bfd's arch and mach, which
310 will be needed when and if we want to bfd_create a new
311 one using this one as a template. */
312 if (bfd_check_format (entry->the_bfd, bfd_object))
314 int fd = open (attempt, O_RDONLY | O_BINARY);
317 struct ld_plugin_input_file file;
322 file.filesize = lseek (fd, 0, SEEK_END);
324 /* We create a dummy BFD, initially empty, to house
325 whatever symbols the plugin may want to add. */
326 file.handle = plugin_get_ir_dummy_bfd (attempt, entry->the_bfd);
327 if (plugin_call_claim_file (&file, &claimed))
328 einfo (_("%P%F: %s: plugin reported error claiming file\n"),
329 plugin_error_plugin ());
332 /* Discard the real file's BFD and substitute the dummy one. */
333 bfd_close (entry->the_bfd);
334 entry->the_bfd = file.handle;
335 entry->claimed = TRUE;
336 bfd_make_readable (entry->the_bfd);
340 /* If plugin didn't claim the file, we don't need the fd or the
341 dummy bfd. Can't avoid speculatively creating it, alas. */
342 bfd_close_all_done (file.handle);
344 entry->claimed = FALSE;
348 #endif /* ENABLE_PLUGINS */
350 /* It opened OK, the format checked out, and the plugins have had
351 their chance to claim it, so this is success. */
355 /* Search for and open the file specified by ENTRY. If it is an
356 archive, use ARCH, LIB and SUFFIX to modify the file name. */
359 ldfile_open_file_search (const char *arch,
360 lang_input_statement_type *entry,
364 search_dirs_type *search;
366 /* If this is not an archive, try to open it in the current
368 if (! entry->is_archive)
370 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
372 char *name = concat (ld_sysroot, entry->filename,
373 (const char *) NULL);
374 if (ldfile_try_open_bfd (name, entry))
376 entry->filename = name;
381 else if (ldfile_try_open_bfd (entry->filename, entry))
383 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
384 && is_sysrooted_pathname (entry->filename, TRUE);
388 if (IS_ABSOLUTE_PATH (entry->filename))
392 for (search = search_head; search != NULL; search = search->next)
396 if (entry->dynamic && ! link_info.relocatable)
398 if (ldemul_open_dynamic_archive (arch, search, entry))
400 entry->sysrooted = search->sysrooted;
405 if (entry->is_archive)
406 string = concat (search->name, slash, lib, entry->filename,
407 arch, suffix, (const char *) NULL);
409 string = concat (search->name, slash, entry->filename,
412 if (ldfile_try_open_bfd (string, entry))
414 entry->filename = string;
415 entry->sysrooted = search->sysrooted;
425 /* Open the input file specified by ENTRY.
426 PR 4437: Do not stop on the first missing file, but
427 continue processing other input files in case there
428 are more errors to report. */
431 ldfile_open_file (lang_input_statement_type *entry)
433 if (entry->the_bfd != NULL)
436 if (! entry->search_dirs_flag)
438 if (ldfile_try_open_bfd (entry->filename, entry))
441 if (strcmp (entry->filename, entry->local_sym_name) != 0)
442 einfo (_("%P: cannot find %s (%s): %E\n"),
443 entry->filename, entry->local_sym_name);
445 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
447 entry->missing_file = TRUE;
452 search_arch_type *arch;
453 bfd_boolean found = FALSE;
455 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
456 for (arch = search_arch_head; arch != NULL; arch = arch->next)
458 found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
462 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
466 found = ldemul_find_potential_libraries (arch->name, entry);
471 /* If we have found the file, we don't need to search directories
474 entry->search_dirs_flag = FALSE;
479 && IS_ABSOLUTE_PATH (entry->local_sym_name))
480 einfo (_("%P: cannot find %s inside %s\n"),
481 entry->local_sym_name, ld_sysroot);
483 einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
484 entry->missing_file = TRUE;
490 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */
493 try_open (const char *name, const char *exten)
497 result = fopen (name, "r");
499 if (trace_file_tries)
502 info_msg (_("cannot find script file %s\n"), name);
504 info_msg (_("opened script file %s\n"), name);
514 buff = concat (name, exten, (const char *) NULL);
515 result = fopen (buff, "r");
517 if (trace_file_tries)
520 info_msg (_("cannot find script file %s\n"), buff);
522 info_msg (_("opened script file %s\n"), buff);
530 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */
533 check_for_scripts_dir (char *dir)
539 buf = concat (dir, "/ldscripts", (const char *) NULL);
540 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
545 /* Return the default directory for finding script files.
546 We look for the "ldscripts" directory in:
548 SCRIPTDIR (passed from Makefile)
549 (adjusted according to the current location of the binary)
550 the dir where this program is (for using it from the build tree). */
553 find_scripts_dir (void)
557 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
560 if (check_for_scripts_dir (dir))
565 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
568 if (check_for_scripts_dir (dir))
573 /* Look for "ldscripts" in the dir where our binary is. */
574 dir = make_relative_prefix (program_name, ".", ".");
577 if (check_for_scripts_dir (dir))
585 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
586 it in directories specified with -L, then in the default script
587 directory, without and with EXTEND appended. If DEFAULT_ONLY is
588 true, the search is restricted to the default script location. */
591 ldfile_find_command_file (const char *name, const char *extend,
592 bfd_boolean default_only)
594 search_dirs_type *search;
597 static search_dirs_type *script_search;
601 /* First try raw name. */
602 result = try_open (name, "");
609 char *script_dir = find_scripts_dir ();
612 search_dirs_type **save_tail_ptr = search_tail_ptr;
613 search_tail_ptr = &script_search;
614 ldfile_add_library_path (script_dir, TRUE);
615 search_tail_ptr = save_tail_ptr;
619 /* Temporarily append script_search to the path list so that the
620 paths specified with -L will be searched first. */
621 *search_tail_ptr = script_search;
623 /* Try now prefixes. */
624 for (search = default_only ? script_search : search_head;
626 search = search->next)
628 buffer = concat (search->name, slash, name, (const char *) NULL);
629 result = try_open (buffer, extend);
635 /* Restore the original path list. */
636 *search_tail_ptr = NULL;
641 /* Open command file NAME. */
644 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
646 FILE *ldlex_input_stack;
647 ldlex_input_stack = ldfile_find_command_file (name, "", default_only);
649 if (ldlex_input_stack == NULL)
651 bfd_set_error (bfd_error_system_call);
652 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
655 lex_push_file (ldlex_input_stack, name);
657 ldfile_input_filename = name;
660 saved_script_handle = ldlex_input_stack;
663 /* Open command file NAME in the current directory, -L directories,
664 the default script location, in that order. */
667 ldfile_open_command_file (const char *name)
669 ldfile_open_command_file_1 (name, FALSE);
672 /* Open command file NAME at the default script location. */
675 ldfile_open_default_command_file (const char *name)
677 ldfile_open_command_file_1 (name, TRUE);
681 ldfile_add_arch (const char *in_name)
683 char *name = xstrdup (in_name);
684 search_arch_type *new_arch = (search_arch_type *)
685 xmalloc (sizeof (search_arch_type));
687 ldfile_output_machine_name = in_name;
689 new_arch->name = name;
690 new_arch->next = NULL;
693 *name = TOLOWER (*name);
696 *search_arch_tail_ptr = new_arch;
697 search_arch_tail_ptr = &new_arch->next;
701 /* Set the output architecture. */
704 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
706 const bfd_arch_info_type *arch = bfd_scan_arch (string);
710 ldfile_output_architecture = arch->arch;
711 ldfile_output_machine = arch->mach;
712 ldfile_output_machine_name = arch->printable_name;
714 else if (defarch != bfd_arch_unknown)
715 ldfile_output_architecture = defarch;
717 einfo (_("%P%F: cannot represent machine `%s'\n"), string);