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 SCRIPTDIR (passed from Makefile)
551 the dir where this program is (for using it from the build tree). */
554 find_scripts_dir (void)
558 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
561 if (check_for_scripts_dir (dir))
566 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
569 if (check_for_scripts_dir (dir))
574 if (check_for_scripts_dir (SCRIPTDIR))
575 /* We've been installed normally. */
578 /* Look for "ldscripts" in the dir where our binary is. */
579 dir = make_relative_prefix (program_name, ".", ".");
582 if (check_for_scripts_dir (dir))
590 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
591 it in directories specified with -L, then in the default script
592 directory, without and with EXTEND appended. If DEFAULT_ONLY is
593 true, the search is restricted to the default script location. */
596 ldfile_find_command_file (const char *name, const char *extend,
597 bfd_boolean default_only)
599 search_dirs_type *search;
602 static search_dirs_type *script_search;
606 /* First try raw name. */
607 result = try_open (name, "");
614 char *script_dir = find_scripts_dir ();
617 search_dirs_type **save_tail_ptr = search_tail_ptr;
618 search_tail_ptr = &script_search;
619 ldfile_add_library_path (script_dir, TRUE);
620 search_tail_ptr = save_tail_ptr;
624 /* Temporarily append script_search to the path list so that the
625 paths specified with -L will be searched first. */
626 *search_tail_ptr = script_search;
628 /* Try now prefixes. */
629 for (search = default_only ? script_search : search_head;
631 search = search->next)
633 buffer = concat (search->name, slash, name, (const char *) NULL);
634 result = try_open (buffer, extend);
640 /* Restore the original path list. */
641 *search_tail_ptr = NULL;
646 /* Open command file NAME. */
649 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
651 FILE *ldlex_input_stack;
652 ldlex_input_stack = ldfile_find_command_file (name, "", default_only);
654 if (ldlex_input_stack == NULL)
656 bfd_set_error (bfd_error_system_call);
657 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
660 lex_push_file (ldlex_input_stack, name);
662 ldfile_input_filename = name;
665 saved_script_handle = ldlex_input_stack;
668 /* Open command file NAME in the current directory, -L directories,
669 the default script location, in that order. */
672 ldfile_open_command_file (const char *name)
674 ldfile_open_command_file_1 (name, FALSE);
677 /* Open command file NAME at the default script location. */
680 ldfile_open_default_command_file (const char *name)
682 ldfile_open_command_file_1 (name, TRUE);
686 ldfile_add_arch (const char *in_name)
688 char *name = xstrdup (in_name);
689 search_arch_type *new_arch = (search_arch_type *)
690 xmalloc (sizeof (search_arch_type));
692 ldfile_output_machine_name = in_name;
694 new_arch->name = name;
695 new_arch->next = NULL;
698 *name = TOLOWER (*name);
701 *search_arch_tail_ptr = new_arch;
702 search_arch_tail_ptr = &new_arch->next;
706 /* Set the output architecture. */
709 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
711 const bfd_arch_info_type *arch = bfd_scan_arch (string);
715 ldfile_output_architecture = arch->arch;
716 ldfile_output_machine = arch->mach;
717 ldfile_output_machine_name = arch->printable_name;
719 else if (defarch != bfd_arch_unknown)
720 ldfile_output_architecture = defarch;
722 einfo (_("%P%F: cannot represent machine `%s'\n"), string);