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