opcodes: handle mach-o for thumb/arm disambiguation.
[binutils-gdb.git] / ld / ldfile.c
blob96f9ecc0157d645ff2228243d373f1c1d5c393dd
1 /* Linker file opening and searching.
2 Copyright (C) 1991-2015 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfdlink.h"
24 #include "safe-ctype.h"
25 #include "ld.h"
26 #include "ldmisc.h"
27 #include "ldexp.h"
28 #include "ldlang.h"
29 #include "ldfile.h"
30 #include "ldmain.h"
31 #include <ldgram.h>
32 #include "ldlex.h"
33 #include "ldemul.h"
34 #include "libiberty.h"
35 #include "filenames.h"
36 #ifdef ENABLE_PLUGINS
37 #include "plugin-api.h"
38 #include "plugin.h"
39 #endif /* ENABLE_PLUGINS */
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;
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
57 typedef struct search_arch
59 char *name;
60 struct search_arch *next;
61 } search_arch_type;
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;
67 /* Test whether a pathname, after canonicalization, is the same or a
68 sub-directory of the sysroot directory. */
70 static bfd_boolean
71 is_sysrooted_pathname (const char *name)
73 char *realname;
74 int len;
75 bfd_boolean result;
77 if (ld_canon_sysroot == NULL)
78 return FALSE;
80 realname = lrealpath (name);
81 len = strlen (realname);
82 result = FALSE;
83 if (len > ld_canon_sysroot_len
84 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))
86 realname[ld_canon_sysroot_len] = '\0';
87 result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
90 free (realname);
91 return result;
94 /* Adds NAME to the library search path.
95 Makes a copy of NAME using xmalloc(). */
97 void
98 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
100 search_dirs_type *new_dirs;
102 if (!cmdline && config.only_cmd_line_lib_dirs)
103 return;
105 new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
106 new_dirs->next = NULL;
107 new_dirs->cmdline = cmdline;
108 *search_tail_ptr = new_dirs;
109 search_tail_ptr = &new_dirs->next;
111 /* If a directory is marked as honoring sysroot, prepend the sysroot path
112 now. */
113 if (name[0] == '=')
114 new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
115 else
116 new_dirs->name = xstrdup (name);
119 /* Try to open a BFD for a lang_input_statement. */
121 bfd_boolean
122 ldfile_try_open_bfd (const char *attempt,
123 lang_input_statement_type *entry)
125 entry->the_bfd = bfd_openr (attempt, entry->target);
127 if (verbose)
129 if (entry->the_bfd == NULL)
130 info_msg (_("attempt to open %s failed\n"), attempt);
131 else
132 info_msg (_("attempt to open %s succeeded\n"), attempt);
135 if (entry->the_bfd == NULL)
137 if (bfd_get_error () == bfd_error_invalid_target)
138 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
139 return FALSE;
142 /* Linker needs to decompress sections. */
143 entry->the_bfd->flags |= BFD_DECOMPRESS;
145 /* This is a linker input BFD. */
146 entry->the_bfd->is_linker_input = 1;
148 #ifdef ENABLE_PLUGINS
149 if (entry->flags.lto_output)
150 entry->the_bfd->lto_output = 1;
151 #endif
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
157 a dynamic object.
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->flags.search_dirs || !entry->flags.dynamic)
166 bfd *check;
168 if (bfd_check_format (entry->the_bfd, bfd_archive))
169 check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
170 else
171 check = entry->the_bfd;
173 if (check != NULL)
175 if (! bfd_check_format (check, bfd_object))
177 if (check == entry->the_bfd
178 && entry->flags.search_dirs
179 && bfd_get_error () == bfd_error_file_not_recognized
180 && ! ldemul_unrecognized_file (entry))
182 int token, skip = 0;
183 char *arg, *arg1, *arg2, *arg3;
184 extern FILE *yyin;
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;
191 ldlex_both ();
192 token = INPUT_SCRIPT;
193 while (token != 0)
195 switch (token)
197 case OUTPUT_FORMAT:
198 if ((token = yylex ()) != '(')
199 continue;
200 if ((token = yylex ()) != NAME)
201 continue;
202 arg1 = yylval.name;
203 arg2 = NULL;
204 arg3 = NULL;
205 token = yylex ();
206 if (token == ',')
208 if ((token = yylex ()) != NAME)
210 free (arg1);
211 continue;
213 arg2 = yylval.name;
214 if ((token = yylex ()) != ','
215 || (token = yylex ()) != NAME)
217 free (arg1);
218 free (arg2);
219 continue;
221 arg3 = yylval.name;
222 token = yylex ();
224 if (token == ')')
226 switch (command_line.endian)
228 default:
229 case ENDIAN_UNSET:
230 arg = arg1; break;
231 case ENDIAN_BIG:
232 arg = arg2 ? arg2 : arg1; break;
233 case ENDIAN_LITTLE:
234 arg = arg3 ? arg3 : arg1; break;
236 if (strcmp (arg, lang_get_output_target ()) != 0)
237 skip = 1;
239 free (arg1);
240 if (arg2) free (arg2);
241 if (arg3) free (arg3);
242 break;
243 case NAME:
244 case LNAME:
245 case VERS_IDENTIFIER:
246 case VERS_TAG:
247 free (yylval.name);
248 break;
249 case INT:
250 if (yylval.bigint.str)
251 free (yylval.bigint.str);
252 break;
254 token = yylex ();
256 ldlex_popstate ();
257 ldfile_assumed_script = FALSE;
258 fclose (yyin);
259 yyin = NULL;
260 if (skip)
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;
268 return FALSE;
271 goto success;
274 if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
276 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
277 attempt);
278 bfd_close (entry->the_bfd);
279 entry->the_bfd = NULL;
280 return FALSE;
283 if (entry->flags.search_dirs
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;
297 return FALSE;
301 success:
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 (link_info.lto_plugin_active
313 && !no_more_claiming
314 && bfd_check_format (entry->the_bfd, bfd_object))
315 plugin_maybe_claim (entry);
316 #endif /* ENABLE_PLUGINS */
318 /* It opened OK, the format checked out, and the plugins have had
319 their chance to claim it, so this is success. */
320 return TRUE;
323 /* Search for and open the file specified by ENTRY. If it is an
324 archive, use ARCH, LIB and SUFFIX to modify the file name. */
326 bfd_boolean
327 ldfile_open_file_search (const char *arch,
328 lang_input_statement_type *entry,
329 const char *lib,
330 const char *suffix)
332 search_dirs_type *search;
334 /* If this is not an archive, try to open it in the current
335 directory first. */
336 if (! entry->flags.maybe_archive)
338 if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
340 char *name = concat (ld_sysroot, entry->filename,
341 (const char *) NULL);
342 if (ldfile_try_open_bfd (name, entry))
344 entry->filename = name;
345 return TRUE;
347 free (name);
349 else if (ldfile_try_open_bfd (entry->filename, entry))
350 return TRUE;
352 if (IS_ABSOLUTE_PATH (entry->filename))
353 return FALSE;
356 for (search = search_head; search != NULL; search = search->next)
358 char *string;
360 if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
362 if (ldemul_open_dynamic_archive (arch, search, entry))
363 return TRUE;
366 if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
367 string = concat (search->name, slash, lib, entry->filename,
368 arch, suffix, (const char *) NULL);
369 else
370 string = concat (search->name, slash, entry->filename,
371 (const char *) 0);
373 if (ldfile_try_open_bfd (string, entry))
375 entry->filename = string;
376 return TRUE;
379 free (string);
382 return FALSE;
385 /* Open the input file specified by ENTRY.
386 PR 4437: Do not stop on the first missing file, but
387 continue processing other input files in case there
388 are more errors to report. */
390 void
391 ldfile_open_file (lang_input_statement_type *entry)
393 if (entry->the_bfd != NULL)
394 return;
396 if (! entry->flags.search_dirs)
398 if (ldfile_try_open_bfd (entry->filename, entry))
399 return;
401 if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
402 einfo (_("%P: cannot find %s (%s): %E\n"),
403 entry->filename, entry->local_sym_name);
404 else
405 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
407 entry->flags.missing_file = TRUE;
408 input_flags.missing_file = TRUE;
410 else
412 search_arch_type *arch;
413 bfd_boolean found = FALSE;
415 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
416 for (arch = search_arch_head; arch != NULL; arch = arch->next)
418 found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
419 if (found)
420 break;
421 #ifdef VMS
422 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
423 if (found)
424 break;
425 #endif
426 found = ldemul_find_potential_libraries (arch->name, entry);
427 if (found)
428 break;
431 /* If we have found the file, we don't need to search directories
432 again. */
433 if (found)
434 entry->flags.search_dirs = FALSE;
435 else
437 if (entry->flags.sysrooted
438 && ld_sysroot
439 && IS_ABSOLUTE_PATH (entry->local_sym_name))
440 einfo (_("%P: cannot find %s inside %s\n"),
441 entry->local_sym_name, ld_sysroot);
442 else
443 einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
444 entry->flags.missing_file = TRUE;
445 input_flags.missing_file = TRUE;
450 /* Try to open NAME. */
452 static FILE *
453 try_open (const char *name, bfd_boolean *sysrooted)
455 FILE *result;
457 result = fopen (name, "r");
459 if (result != NULL)
460 *sysrooted = is_sysrooted_pathname (name);
462 if (verbose)
464 if (result == NULL)
465 info_msg (_("cannot find script file %s\n"), name);
466 else
467 info_msg (_("opened script file %s\n"), name);
470 return result;
473 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */
475 static bfd_boolean
476 check_for_scripts_dir (char *dir)
478 char *buf;
479 struct stat s;
480 bfd_boolean res;
482 buf = concat (dir, "/ldscripts", (const char *) NULL);
483 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
484 free (buf);
485 return res;
488 /* Return the default directory for finding script files.
489 We look for the "ldscripts" directory in:
491 SCRIPTDIR (passed from Makefile)
492 (adjusted according to the current location of the binary)
493 the dir where this program is (for using it from the build tree). */
495 static char *
496 find_scripts_dir (void)
498 char *dir;
500 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
501 if (dir)
503 if (check_for_scripts_dir (dir))
504 return dir;
505 free (dir);
508 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
509 if (dir)
511 if (check_for_scripts_dir (dir))
512 return dir;
513 free (dir);
516 /* Look for "ldscripts" in the dir where our binary is. */
517 dir = make_relative_prefix (program_name, ".", ".");
518 if (dir)
520 if (check_for_scripts_dir (dir))
521 return dir;
522 free (dir);
525 return NULL;
528 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
529 it in directories specified with -L, then in the default script
530 directory. If DEFAULT_ONLY is true, the search is restricted to
531 the default script location. */
533 static FILE *
534 ldfile_find_command_file (const char *name,
535 bfd_boolean default_only,
536 bfd_boolean *sysrooted)
538 search_dirs_type *search;
539 FILE *result = NULL;
540 char *path;
541 static search_dirs_type *script_search;
543 if (!default_only)
545 /* First try raw name. */
546 result = try_open (name, sysrooted);
547 if (result != NULL)
548 return result;
551 if (!script_search)
553 char *script_dir = find_scripts_dir ();
554 if (script_dir)
556 search_dirs_type **save_tail_ptr = search_tail_ptr;
557 search_tail_ptr = &script_search;
558 ldfile_add_library_path (script_dir, TRUE);
559 search_tail_ptr = save_tail_ptr;
563 /* Temporarily append script_search to the path list so that the
564 paths specified with -L will be searched first. */
565 *search_tail_ptr = script_search;
567 /* Try now prefixes. */
568 for (search = default_only ? script_search : search_head;
569 search != NULL;
570 search = search->next)
572 path = concat (search->name, slash, name, (const char *) NULL);
573 result = try_open (path, sysrooted);
574 free (path);
575 if (result)
576 break;
579 /* Restore the original path list. */
580 *search_tail_ptr = NULL;
582 return result;
585 /* Open command file NAME. */
587 static void
588 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
590 FILE *ldlex_input_stack;
591 bfd_boolean sysrooted;
593 ldlex_input_stack = ldfile_find_command_file (name, default_only, &sysrooted);
595 if (ldlex_input_stack == NULL)
597 bfd_set_error (bfd_error_system_call);
598 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
599 return;
602 lex_push_file (ldlex_input_stack, name, sysrooted);
604 lineno = 1;
606 saved_script_handle = ldlex_input_stack;
609 /* Open command file NAME in the current directory, -L directories,
610 the default script location, in that order. */
612 void
613 ldfile_open_command_file (const char *name)
615 ldfile_open_command_file_1 (name, FALSE);
618 /* Open command file NAME at the default script location. */
620 void
621 ldfile_open_default_command_file (const char *name)
623 ldfile_open_command_file_1 (name, TRUE);
626 void
627 ldfile_add_arch (const char *in_name)
629 char *name = xstrdup (in_name);
630 search_arch_type *new_arch = (search_arch_type *)
631 xmalloc (sizeof (search_arch_type));
633 ldfile_output_machine_name = in_name;
635 new_arch->name = name;
636 new_arch->next = NULL;
637 while (*name)
639 *name = TOLOWER (*name);
640 name++;
642 *search_arch_tail_ptr = new_arch;
643 search_arch_tail_ptr = &new_arch->next;
647 /* Set the output architecture. */
649 void
650 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
652 const bfd_arch_info_type *arch = bfd_scan_arch (string);
654 if (arch)
656 ldfile_output_architecture = arch->arch;
657 ldfile_output_machine = arch->mach;
658 ldfile_output_machine_name = arch->printable_name;
660 else if (defarch != bfd_arch_unknown)
661 ldfile_output_architecture = defarch;
662 else
663 einfo (_("%P%F: cannot represent machine `%s'\n"), string);