1 /* Linker file opening and searching.
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
3
4 This file is part of the GNU Binutils.
5
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.
10
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.
15
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. */
20
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 */
40
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
is_sysrooted_pathname(const char * name)71 is_sysrooted_pathname (const char *name)
72 {
73 char *realname;
74 int len;
75 bfd_boolean result;
76
77 if (ld_canon_sysroot == NULL)
78 return FALSE;
79
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]))
85 {
86 realname[ld_canon_sysroot_len] = '\0';
87 result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
88 }
89
90 free (realname);
91 return result;
92 }
93
94 /* Adds NAME to the library search path.
95 Makes a copy of NAME using xmalloc(). */
96
97 void
ldfile_add_library_path(const char * name,bfd_boolean cmdline)98 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
99 {
100 search_dirs_type *new_dirs;
101
102 if (!cmdline && config.only_cmd_line_lib_dirs)
103 return;
104
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;
110
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);
117
118 if (command_line.warn_poison_system_directories
119 && (!strncmp (name, "/lib", 4)
120 /* TODO: This check is disabled for now due to a bunch of packages that
121 * use libtool and relink with -L/usr/lib paths (albeit after the right
122 * sysroot path). Once those are fixed we can enable.
123 * We also need to adjust it so it only rejects one or two levels deep.
124 * Gcc's internal paths also live below /usr/lib.
125 * http://crbug.com/488360 */
126 /* || !strncmp (name, "/usr/lib", 8) */
127 || !strncmp (name, "/usr/local/lib", 14)
128 || !strncmp (name, "/usr/X11R6/lib", 14)))
129 {
130 if (command_line.error_poison_system_directories)
131 einfo (_("%X%P: error: library search path \"%s\" is unsafe for "
132 "cross-compilation\n"), name);
133 else
134 einfo (_("%P: warning: library search path \"%s\" is unsafe for "
135 "cross-compilation\n"), name);
136 }
137 }
138
139 /* Try to open a BFD for a lang_input_statement. */
140
141 bfd_boolean
ldfile_try_open_bfd(const char * attempt,lang_input_statement_type * entry)142 ldfile_try_open_bfd (const char *attempt,
143 lang_input_statement_type *entry)
144 {
145 entry->the_bfd = bfd_openr (attempt, entry->target);
146
147 if (verbose)
148 {
149 if (entry->the_bfd == NULL)
150 info_msg (_("attempt to open %s failed\n"), attempt);
151 else
152 info_msg (_("attempt to open %s succeeded\n"), attempt);
153 }
154
155 if (entry->the_bfd == NULL)
156 {
157 if (bfd_get_error () == bfd_error_invalid_target)
158 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
159 return FALSE;
160 }
161
162 /* Linker needs to decompress sections. */
163 entry->the_bfd->flags |= BFD_DECOMPRESS;
164
165 /* If we are searching for this file, see if the architecture is
166 compatible with the output file. If it isn't, keep searching.
167 If we can't open the file as an object file, stop the search
168 here. If we are statically linking, ensure that we don't link
169 a dynamic object.
170
171 In the code below, it's OK to exit early if the check fails,
172 closing the checked BFD and returning FALSE, but if the BFD
173 checks out compatible, do not exit early returning TRUE, or
174 the plugins will not get a chance to claim the file. */
175
176 if (entry->flags.search_dirs || !entry->flags.dynamic)
177 {
178 bfd *check;
179
180 if (bfd_check_format (entry->the_bfd, bfd_archive))
181 check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
182 else
183 check = entry->the_bfd;
184
185 if (check != NULL)
186 {
187 if (! bfd_check_format (check, bfd_object))
188 {
189 if (check == entry->the_bfd
190 && entry->flags.search_dirs
191 && bfd_get_error () == bfd_error_file_not_recognized
192 && ! ldemul_unrecognized_file (entry))
193 {
194 int token, skip = 0;
195 char *arg, *arg1, *arg2, *arg3;
196 extern FILE *yyin;
197
198 /* Try to interpret the file as a linker script. */
199 ldfile_open_command_file (attempt);
200
201 ldfile_assumed_script = TRUE;
202 parser_input = input_selected;
203 ldlex_both ();
204 token = INPUT_SCRIPT;
205 while (token != 0)
206 {
207 switch (token)
208 {
209 case OUTPUT_FORMAT:
210 if ((token = yylex ()) != '(')
211 continue;
212 if ((token = yylex ()) != NAME)
213 continue;
214 arg1 = yylval.name;
215 arg2 = NULL;
216 arg3 = NULL;
217 token = yylex ();
218 if (token == ',')
219 {
220 if ((token = yylex ()) != NAME)
221 {
222 free (arg1);
223 continue;
224 }
225 arg2 = yylval.name;
226 if ((token = yylex ()) != ','
227 || (token = yylex ()) != NAME)
228 {
229 free (arg1);
230 free (arg2);
231 continue;
232 }
233 arg3 = yylval.name;
234 token = yylex ();
235 }
236 if (token == ')')
237 {
238 switch (command_line.endian)
239 {
240 default:
241 case ENDIAN_UNSET:
242 arg = arg1; break;
243 case ENDIAN_BIG:
244 arg = arg2 ? arg2 : arg1; break;
245 case ENDIAN_LITTLE:
246 arg = arg3 ? arg3 : arg1; break;
247 }
248 if (strcmp (arg, lang_get_output_target ()) != 0)
249 skip = 1;
250 }
251 free (arg1);
252 if (arg2) free (arg2);
253 if (arg3) free (arg3);
254 break;
255 case NAME:
256 case LNAME:
257 case VERS_IDENTIFIER:
258 case VERS_TAG:
259 free (yylval.name);
260 break;
261 case INT:
262 if (yylval.bigint.str)
263 free (yylval.bigint.str);
264 break;
265 }
266 token = yylex ();
267 }
268 ldlex_popstate ();
269 ldfile_assumed_script = FALSE;
270 fclose (yyin);
271 yyin = NULL;
272 if (skip)
273 {
274 if (command_line.warn_search_mismatch)
275 einfo (_("%P: skipping incompatible %s "
276 "when searching for %s\n"),
277 attempt, entry->local_sym_name);
278 bfd_close (entry->the_bfd);
279 entry->the_bfd = NULL;
280 return FALSE;
281 }
282 }
283 goto success;
284 }
285
286 if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
287 {
288 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
289 attempt);
290 bfd_close (entry->the_bfd);
291 entry->the_bfd = NULL;
292 return FALSE;
293 }
294
295 if (entry->flags.search_dirs
296 && !bfd_arch_get_compatible (check, link_info.output_bfd,
297 command_line.accept_unknown_input_arch)
298 /* XCOFF archives can have 32 and 64 bit objects. */
299 && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
300 && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
301 && bfd_check_format (entry->the_bfd, bfd_archive)))
302 {
303 if (command_line.warn_search_mismatch)
304 einfo (_("%P: skipping incompatible %s "
305 "when searching for %s\n"),
306 attempt, entry->local_sym_name);
307 bfd_close (entry->the_bfd);
308 entry->the_bfd = NULL;
309 return FALSE;
310 }
311 }
312 }
313 success:
314 #ifdef ENABLE_PLUGINS
315 /* If plugins are active, they get first chance to claim
316 any successfully-opened input file. We skip archives
317 here; the plugin wants us to offer it the individual
318 members when we enumerate them, not the whole file. We
319 also ignore corefiles, because that's just weird. It is
320 a needed side-effect of calling bfd_check_format with
321 bfd_object that it sets the bfd's arch and mach, which
322 will be needed when and if we want to bfd_create a new
323 one using this one as a template. */
324 if (bfd_check_format (entry->the_bfd, bfd_object)
325 && plugin_active_plugins_p ()
326 && !no_more_claiming)
327 {
328 int fd = open (attempt, O_RDONLY | O_BINARY);
329 if (fd >= 0)
330 {
331 struct ld_plugin_input_file file;
332
333 file.name = attempt;
334 file.offset = 0;
335 file.filesize = lseek (fd, 0, SEEK_END);
336 file.fd = fd;
337 plugin_maybe_claim (&file, entry);
338 }
339 }
340 #endif /* ENABLE_PLUGINS */
341
342 /* It opened OK, the format checked out, and the plugins have had
343 their chance to claim it, so this is success. */
344 return TRUE;
345 }
346
347 /* Search for and open the file specified by ENTRY. If it is an
348 archive, use ARCH, LIB and SUFFIX to modify the file name. */
349
350 bfd_boolean
ldfile_open_file_search(const char * arch,lang_input_statement_type * entry,const char * lib,const char * suffix)351 ldfile_open_file_search (const char *arch,
352 lang_input_statement_type *entry,
353 const char *lib,
354 const char *suffix)
355 {
356 search_dirs_type *search;
357
358 /* If this is not an archive, try to open it in the current
359 directory first. */
360 if (! entry->flags.maybe_archive)
361 {
362 if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
363 {
364 char *name = concat (ld_sysroot, entry->filename,
365 (const char *) NULL);
366 if (ldfile_try_open_bfd (name, entry))
367 {
368 entry->filename = name;
369 return TRUE;
370 }
371 free (name);
372 }
373 else if (ldfile_try_open_bfd (entry->filename, entry))
374 return TRUE;
375
376 if (IS_ABSOLUTE_PATH (entry->filename))
377 return FALSE;
378 }
379
380 for (search = search_head; search != NULL; search = search->next)
381 {
382 char *string;
383
384 if (entry->flags.dynamic && ! link_info.relocatable)
385 {
386 if (ldemul_open_dynamic_archive (arch, search, entry))
387 return TRUE;
388 }
389
390 if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
391 string = concat (search->name, slash, lib, entry->filename,
392 arch, suffix, (const char *) NULL);
393 else
394 string = concat (search->name, slash, entry->filename,
395 (const char *) 0);
396
397 if (ldfile_try_open_bfd (string, entry))
398 {
399 entry->filename = string;
400 return TRUE;
401 }
402
403 free (string);
404 }
405
406 return FALSE;
407 }
408
409 /* Open the input file specified by ENTRY.
410 PR 4437: Do not stop on the first missing file, but
411 continue processing other input files in case there
412 are more errors to report. */
413
414 void
ldfile_open_file(lang_input_statement_type * entry)415 ldfile_open_file (lang_input_statement_type *entry)
416 {
417 if (entry->the_bfd != NULL)
418 return;
419
420 if (! entry->flags.search_dirs)
421 {
422 if (ldfile_try_open_bfd (entry->filename, entry))
423 return;
424
425 if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
426 einfo (_("%P: cannot find %s (%s): %E\n"),
427 entry->filename, entry->local_sym_name);
428 else
429 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
430
431 entry->flags.missing_file = TRUE;
432 input_flags.missing_file = TRUE;
433 }
434 else
435 {
436 search_arch_type *arch;
437 bfd_boolean found = FALSE;
438
439 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
440 for (arch = search_arch_head; arch != NULL; arch = arch->next)
441 {
442 found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
443 if (found)
444 break;
445 #ifdef VMS
446 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
447 if (found)
448 break;
449 #endif
450 found = ldemul_find_potential_libraries (arch->name, entry);
451 if (found)
452 break;
453 }
454
455 /* If we have found the file, we don't need to search directories
456 again. */
457 if (found)
458 entry->flags.search_dirs = FALSE;
459 else
460 {
461 if (entry->flags.sysrooted
462 && ld_sysroot
463 && IS_ABSOLUTE_PATH (entry->local_sym_name))
464 einfo (_("%P: cannot find %s inside %s\n"),
465 entry->local_sym_name, ld_sysroot);
466 else
467 einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
468 entry->flags.missing_file = TRUE;
469 input_flags.missing_file = TRUE;
470 }
471 }
472 }
473
474 /* Try to open NAME. */
475
476 static FILE *
try_open(const char * name,bfd_boolean * sysrooted)477 try_open (const char *name, bfd_boolean *sysrooted)
478 {
479 FILE *result;
480
481 result = fopen (name, "r");
482
483 if (result != NULL)
484 *sysrooted = is_sysrooted_pathname (name);
485
486 if (verbose)
487 {
488 if (result == NULL)
489 info_msg (_("cannot find script file %s\n"), name);
490 else
491 info_msg (_("opened script file %s\n"), name);
492 }
493
494 return result;
495 }
496
497 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */
498
499 static bfd_boolean
check_for_scripts_dir(char * dir)500 check_for_scripts_dir (char *dir)
501 {
502 char *buf;
503 struct stat s;
504 bfd_boolean res;
505
506 buf = concat (dir, "/ldscripts", (const char *) NULL);
507 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
508 free (buf);
509 return res;
510 }
511
512 /* Return the default directory for finding script files.
513 We look for the "ldscripts" directory in:
514
515 SCRIPTDIR (passed from Makefile)
516 (adjusted according to the current location of the binary)
517 the dir where this program is (for using it from the build tree). */
518
519 static char *
find_scripts_dir(void)520 find_scripts_dir (void)
521 {
522 char *dir;
523
524 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
525 if (dir)
526 {
527 if (check_for_scripts_dir (dir))
528 return dir;
529 free (dir);
530 }
531
532 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
533 if (dir)
534 {
535 if (check_for_scripts_dir (dir))
536 return dir;
537 free (dir);
538 }
539
540 /* Look for "ldscripts" in the dir where our binary is. */
541 dir = make_relative_prefix (program_name, ".", ".");
542 if (dir)
543 {
544 if (check_for_scripts_dir (dir))
545 return dir;
546 free (dir);
547 }
548
549 return NULL;
550 }
551
552 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
553 it in directories specified with -L, then in the default script
554 directory. If DEFAULT_ONLY is true, the search is restricted to
555 the default script location. */
556
557 static FILE *
ldfile_find_command_file(const char * name,bfd_boolean default_only,bfd_boolean * sysrooted)558 ldfile_find_command_file (const char *name,
559 bfd_boolean default_only,
560 bfd_boolean *sysrooted)
561 {
562 search_dirs_type *search;
563 FILE *result = NULL;
564 char *path;
565 static search_dirs_type *script_search;
566
567 if (!default_only)
568 {
569 /* First try raw name. */
570 result = try_open (name, sysrooted);
571 if (result != NULL)
572 return result;
573 }
574
575 if (!script_search)
576 {
577 char *script_dir = find_scripts_dir ();
578 if (script_dir)
579 {
580 search_dirs_type **save_tail_ptr = search_tail_ptr;
581 search_tail_ptr = &script_search;
582 ldfile_add_library_path (script_dir, TRUE);
583 search_tail_ptr = save_tail_ptr;
584 }
585 }
586
587 /* Temporarily append script_search to the path list so that the
588 paths specified with -L will be searched first. */
589 *search_tail_ptr = script_search;
590
591 /* Try now prefixes. */
592 for (search = default_only ? script_search : search_head;
593 search != NULL;
594 search = search->next)
595 {
596 path = concat (search->name, slash, name, (const char *) NULL);
597 result = try_open (path, sysrooted);
598 free (path);
599 if (result)
600 break;
601 }
602
603 /* Restore the original path list. */
604 *search_tail_ptr = NULL;
605
606 return result;
607 }
608
609 /* Open command file NAME. */
610
611 static void
ldfile_open_command_file_1(const char * name,bfd_boolean default_only)612 ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
613 {
614 FILE *ldlex_input_stack;
615 bfd_boolean sysrooted;
616
617 ldlex_input_stack = ldfile_find_command_file (name, default_only, &sysrooted);
618
619 if (ldlex_input_stack == NULL)
620 {
621 bfd_set_error (bfd_error_system_call);
622 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
623 return;
624 }
625
626 lex_push_file (ldlex_input_stack, name, sysrooted);
627
628 lineno = 1;
629
630 saved_script_handle = ldlex_input_stack;
631 }
632
633 /* Open command file NAME in the current directory, -L directories,
634 the default script location, in that order. */
635
636 void
ldfile_open_command_file(const char * name)637 ldfile_open_command_file (const char *name)
638 {
639 ldfile_open_command_file_1 (name, FALSE);
640 }
641
642 /* Open command file NAME at the default script location. */
643
644 void
ldfile_open_default_command_file(const char * name)645 ldfile_open_default_command_file (const char *name)
646 {
647 ldfile_open_command_file_1 (name, TRUE);
648 }
649
650 void
ldfile_add_arch(const char * in_name)651 ldfile_add_arch (const char *in_name)
652 {
653 char *name = xstrdup (in_name);
654 search_arch_type *new_arch = (search_arch_type *)
655 xmalloc (sizeof (search_arch_type));
656
657 ldfile_output_machine_name = in_name;
658
659 new_arch->name = name;
660 new_arch->next = NULL;
661 while (*name)
662 {
663 *name = TOLOWER (*name);
664 name++;
665 }
666 *search_arch_tail_ptr = new_arch;
667 search_arch_tail_ptr = &new_arch->next;
668
669 }
670
671 /* Set the output architecture. */
672
673 void
ldfile_set_output_arch(const char * string,enum bfd_architecture defarch)674 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
675 {
676 const bfd_arch_info_type *arch = bfd_scan_arch (string);
677
678 if (arch)
679 {
680 ldfile_output_architecture = arch->arch;
681 ldfile_output_machine = arch->mach;
682 ldfile_output_machine_name = arch->printable_name;
683 }
684 else if (defarch != bfd_arch_unknown)
685 ldfile_output_architecture = defarch;
686 else
687 einfo (_("%P%F: cannot represent machine `%s'\n"), string);
688 }
689