1 /* Linker file opening and searching.
2 Copyright (C) 1991-2022 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 "ctf-api.h"
25 #include "safe-ctype.h"
26 #include "ld.h"
27 #include "ldmisc.h"
28 #include "ldexp.h"
29 #include "ldlang.h"
30 #include "ldfile.h"
31 #include "ldmain.h"
32 #include <ldgram.h>
33 #include "ldlex.h"
34 #include "ldemul.h"
35 #include "libiberty.h"
36 #include "filenames.h"
37 #if BFD_SUPPORTS_PLUGINS
38 #include "plugin-api.h"
39 #include "plugin.h"
40 #endif /* BFD_SUPPORTS_PLUGINS */
41
42 bool ldfile_assumed_script = false;
43 const char *ldfile_output_machine_name = "";
44 unsigned long ldfile_output_machine;
45 enum bfd_architecture ldfile_output_architecture;
46 search_dirs_type *search_head;
47
48 #ifdef VMS
49 static char *slash = "";
50 #else
51 #if defined (_WIN32) && !defined (__CYGWIN32__)
52 static char *slash = "\\";
53 #else
54 static char *slash = "/";
55 #endif
56 #endif
57
58 typedef struct search_arch
59 {
60 char *name;
61 struct search_arch *next;
62 } search_arch_type;
63
64 static search_dirs_type **search_tail_ptr = &search_head;
65 static search_arch_type *search_arch_head;
66 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
67
68 /* Test whether a pathname, after canonicalization, is the same or a
69 sub-directory of the sysroot directory. */
70
71 static bool
is_sysrooted_pathname(const char * name)72 is_sysrooted_pathname (const char *name)
73 {
74 char *realname;
75 int len;
76 bool result;
77
78 if (ld_canon_sysroot == NULL)
79 return false;
80
81 realname = lrealpath (name);
82 len = strlen (realname);
83 result = false;
84 if (len > ld_canon_sysroot_len
85 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))
86 {
87 realname[ld_canon_sysroot_len] = '\0';
88 result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
89 }
90
91 free (realname);
92 return result;
93 }
94
95 /* Adds NAME to the library search path.
96 Makes a copy of NAME using xmalloc(). */
97
98 void
ldfile_add_library_path(const char * name,bool cmdline)99 ldfile_add_library_path (const char *name, bool cmdline)
100 {
101 search_dirs_type *new_dirs;
102
103 if (!cmdline && config.only_cmd_line_lib_dirs)
104 return;
105
106 new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
107 new_dirs->next = NULL;
108 new_dirs->cmdline = cmdline;
109 *search_tail_ptr = new_dirs;
110 search_tail_ptr = &new_dirs->next;
111
112 /* If a directory is marked as honoring sysroot, prepend the sysroot path
113 now. */
114 if (name[0] == '=')
115 new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
116 else if (startswith (name, "$SYSROOT"))
117 new_dirs->name = concat (ld_sysroot, name + strlen ("$SYSROOT"), (const char *) NULL);
118 else
119 new_dirs->name = xstrdup (name);
120 }
121
122 /* Try to open a BFD for a lang_input_statement. */
123
124 bool
ldfile_try_open_bfd(const char * attempt,lang_input_statement_type * entry)125 ldfile_try_open_bfd (const char *attempt,
126 lang_input_statement_type *entry)
127 {
128 entry->the_bfd = bfd_openr (attempt, entry->target);
129
130 if (verbose)
131 {
132 if (entry->the_bfd == NULL)
133 info_msg (_("attempt to open %s failed\n"), attempt);
134 else
135 info_msg (_("attempt to open %s succeeded\n"), attempt);
136 }
137
138 if (entry->the_bfd == NULL)
139 {
140 if (bfd_get_error () == bfd_error_invalid_target)
141 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
142 return false;
143 }
144
145 track_dependency_files (attempt);
146
147 /* Linker needs to decompress sections. */
148 entry->the_bfd->flags |= BFD_DECOMPRESS;
149
150 /* This is a linker input BFD. */
151 entry->the_bfd->is_linker_input = 1;
152
153 #if BFD_SUPPORTS_PLUGINS
154 if (entry->flags.lto_output)
155 entry->the_bfd->lto_output = 1;
156 #endif
157
158 /* If we are searching for this file, see if the architecture is
159 compatible with the output file. If it isn't, keep searching.
160 If we can't open the file as an object file, stop the search
161 here. If we are statically linking, ensure that we don't link
162 a dynamic object.
163
164 In the code below, it's OK to exit early if the check fails,
165 closing the checked BFD and returning false, but if the BFD
166 checks out compatible, do not exit early returning true, or
167 the plugins will not get a chance to claim the file. */
168
169 if (entry->flags.search_dirs || !entry->flags.dynamic)
170 {
171 bfd *check;
172
173 if (bfd_check_format (entry->the_bfd, bfd_archive))
174 check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
175 else
176 check = entry->the_bfd;
177
178 if (check != NULL)
179 {
180 if (!bfd_check_format (check, bfd_object))
181 {
182 if (check == entry->the_bfd
183 && entry->flags.search_dirs
184 && bfd_get_error () == bfd_error_file_not_recognized
185 && !ldemul_unrecognized_file (entry))
186 {
187 int token, skip = 0;
188 char *arg, *arg1, *arg2, *arg3;
189 extern FILE *yyin;
190
191 /* Try to interpret the file as a linker script. */
192 ldfile_open_command_file (attempt);
193
194 ldfile_assumed_script = true;
195 parser_input = input_selected;
196 ldlex_script ();
197 token = INPUT_SCRIPT;
198 while (token != 0)
199 {
200 switch (token)
201 {
202 case OUTPUT_FORMAT:
203 if ((token = yylex ()) != '(')
204 continue;
205 if ((token = yylex ()) != NAME)
206 continue;
207 arg1 = yylval.name;
208 arg2 = NULL;
209 arg3 = NULL;
210 token = yylex ();
211 if (token == ',')
212 {
213 if ((token = yylex ()) != NAME)
214 {
215 free (arg1);
216 continue;
217 }
218 arg2 = yylval.name;
219 if ((token = yylex ()) != ','
220 || (token = yylex ()) != NAME)
221 {
222 free (arg1);
223 free (arg2);
224 continue;
225 }
226 arg3 = yylval.name;
227 token = yylex ();
228 }
229 if (token == ')')
230 {
231 switch (command_line.endian)
232 {
233 default:
234 case ENDIAN_UNSET:
235 arg = arg1; break;
236 case ENDIAN_BIG:
237 arg = arg2 ? arg2 : arg1; break;
238 case ENDIAN_LITTLE:
239 arg = arg3 ? arg3 : arg1; break;
240 }
241 if (strcmp (arg, lang_get_output_target ()) != 0)
242 skip = 1;
243 }
244 free (arg1);
245 free (arg2);
246 free (arg3);
247 break;
248 case NAME:
249 case LNAME:
250 case VERS_IDENTIFIER:
251 case VERS_TAG:
252 free (yylval.name);
253 break;
254 case INT:
255 free (yylval.bigint.str);
256 break;
257 }
258 token = yylex ();
259 }
260 ldlex_popstate ();
261 ldfile_assumed_script = false;
262 fclose (yyin);
263 yyin = NULL;
264 if (skip)
265 {
266 if (command_line.warn_search_mismatch)
267 einfo (_("%P: skipping incompatible %s "
268 "when searching for %s\n"),
269 attempt, entry->local_sym_name);
270 bfd_close (entry->the_bfd);
271 entry->the_bfd = NULL;
272 return false;
273 }
274 }
275 goto success;
276 }
277
278 if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
279 {
280 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
281 attempt);
282 bfd_close (entry->the_bfd);
283 entry->the_bfd = NULL;
284 return false;
285 }
286
287 if (entry->flags.search_dirs
288 && !bfd_arch_get_compatible (check, link_info.output_bfd,
289 command_line.accept_unknown_input_arch)
290 /* XCOFF archives can have 32 and 64 bit objects. */
291 && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour
292 && (bfd_get_flavour (link_info.output_bfd)
293 == bfd_target_xcoff_flavour)
294 && bfd_check_format (entry->the_bfd, bfd_archive)))
295 {
296 if (command_line.warn_search_mismatch)
297 einfo (_("%P: skipping incompatible %s "
298 "when searching for %s\n"),
299 attempt, entry->local_sym_name);
300 bfd_close (entry->the_bfd);
301 entry->the_bfd = NULL;
302 return false;
303 }
304 }
305 }
306 success:
307 #if BFD_SUPPORTS_PLUGINS
308 /* If plugins are active, they get first chance to claim
309 any successfully-opened input file. We skip archives
310 here; the plugin wants us to offer it the individual
311 members when we enumerate them, not the whole file. We
312 also ignore corefiles, because that's just weird. It is
313 a needed side-effect of calling bfd_check_format with
314 bfd_object that it sets the bfd's arch and mach, which
315 will be needed when and if we want to bfd_create a new
316 one using this one as a template. */
317 if (link_info.lto_plugin_active
318 && !no_more_claiming
319 && bfd_check_format (entry->the_bfd, bfd_object))
320 plugin_maybe_claim (entry);
321 #endif /* BFD_SUPPORTS_PLUGINS */
322
323 /* It opened OK, the format checked out, and the plugins have had
324 their chance to claim it, so this is success. */
325 return true;
326 }
327
328 /* Search for and open the file specified by ENTRY. If it is an
329 archive, use ARCH, LIB and SUFFIX to modify the file name. */
330
331 bool
ldfile_open_file_search(const char * arch,lang_input_statement_type * entry,const char * lib,const char * suffix)332 ldfile_open_file_search (const char *arch,
333 lang_input_statement_type *entry,
334 const char *lib,
335 const char *suffix)
336 {
337 search_dirs_type *search;
338
339 /* If this is not an archive, try to open it in the current
340 directory first. */
341 if (!entry->flags.maybe_archive)
342 {
343 if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
344 {
345 char *name = concat (ld_sysroot, entry->filename,
346 (const char *) NULL);
347 if (ldfile_try_open_bfd (name, entry))
348 {
349 entry->filename = name;
350 return true;
351 }
352 free (name);
353 }
354 else if (ldfile_try_open_bfd (entry->filename, entry))
355 return true;
356
357 if (IS_ABSOLUTE_PATH (entry->filename))
358 return false;
359 }
360
361 for (search = search_head; search != NULL; search = search->next)
362 {
363 char *string;
364
365 if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
366 {
367 if (ldemul_open_dynamic_archive (arch, search, entry))
368 return true;
369 }
370
371 if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
372 string = concat (search->name, slash, lib, entry->filename,
373 arch, suffix, (const char *) NULL);
374 else
375 string = concat (search->name, slash, entry->filename,
376 (const char *) 0);
377
378 if (ldfile_try_open_bfd (string, entry))
379 {
380 entry->filename = string;
381 return true;
382 }
383
384 free (string);
385 }
386
387 return false;
388 }
389
390 /* Open the input file specified by ENTRY.
391 PR 4437: Do not stop on the first missing file, but
392 continue processing other input files in case there
393 are more errors to report. */
394
395 void
ldfile_open_file(lang_input_statement_type * entry)396 ldfile_open_file (lang_input_statement_type *entry)
397 {
398 if (entry->the_bfd != NULL)
399 return;
400
401 if (!entry->flags.search_dirs)
402 {
403 if (ldfile_try_open_bfd (entry->filename, entry))
404 return;
405
406 if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
407 einfo (_("%P: cannot find %s (%s): %E\n"),
408 entry->filename, entry->local_sym_name);
409 else
410 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
411
412 entry->flags.missing_file = true;
413 input_flags.missing_file = true;
414 }
415 else
416 {
417 search_arch_type *arch;
418 bool found = false;
419
420 /* If extra_search_path is set, entry->filename is a relative path.
421 Search the directory of the current linker script before searching
422 other paths. */
423 if (entry->extra_search_path)
424 {
425 char *path = concat (entry->extra_search_path, slash, entry->filename,
426 (const char *)0);
427 if (ldfile_try_open_bfd (path, entry))
428 {
429 entry->filename = path;
430 entry->flags.search_dirs = false;
431 return;
432 }
433
434 free (path);
435 }
436
437 /* Try to open <filename><suffix> or lib<filename><suffix>.a. */
438 for (arch = search_arch_head; arch != NULL; arch = arch->next)
439 {
440 found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
441 if (found)
442 break;
443 #ifdef VMS
444 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
445 if (found)
446 break;
447 #endif
448 found = ldemul_find_potential_libraries (arch->name, entry);
449 if (found)
450 break;
451 }
452
453 /* If we have found the file, we don't need to search directories
454 again. */
455 if (found)
456 entry->flags.search_dirs = false;
457 else
458 {
459 if (entry->flags.sysrooted
460 && ld_sysroot
461 && IS_ABSOLUTE_PATH (entry->local_sym_name))
462 einfo (_("%P: cannot find %s inside %s\n"),
463 entry->local_sym_name, ld_sysroot);
464 #if SUPPORT_ERROR_HANDLING_SCRIPT
465 else if (error_handling_script != NULL)
466 {
467 char * argv[4];
468 const char * res;
469 int status, err;
470
471 argv[0] = error_handling_script;
472 argv[1] = "missing-lib";
473 argv[2] = (char *) entry->local_sym_name;
474 argv[3] = NULL;
475
476 if (verbose)
477 einfo (_("%P: About to run error handling script '%s' with arguments: '%s' '%s'\n"),
478 argv[0], argv[1], argv[2]);
479
480 res = pex_one (PEX_SEARCH, error_handling_script, argv,
481 N_("error handling script"),
482 NULL /* Send stdout to random, temp file. */,
483 NULL /* Write to stderr. */,
484 &status, &err);
485 if (res != NULL)
486 {
487 einfo (_("%P: Failed to run error handling script '%s', reason: "),
488 error_handling_script);
489 /* FIXME: We assume here that errrno == err. */
490 perror (res);
491 }
492 else /* We ignore the return status of the script
493 and always print the error message. */
494 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
495 }
496 #endif
497 else
498 einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
499
500 /* PR 25747: Be kind to users who forgot to add the
501 "lib" prefix to their library when it was created. */
502 for (arch = search_arch_head; arch != NULL; arch = arch->next)
503 {
504 if (ldfile_open_file_search (arch->name, entry, "", ".a"))
505 {
506 const char * base = lbasename (entry->filename);
507
508 einfo (_("%P: note to link with %s use -l:%s or rename it to lib%s\n"),
509 entry->filename, base, base);
510 bfd_close (entry->the_bfd);
511 entry->the_bfd = NULL;
512 break;
513 }
514 }
515
516 entry->flags.missing_file = true;
517 input_flags.missing_file = true;
518 }
519 }
520 }
521
522 /* Try to open NAME. */
523
524 static FILE *
try_open(const char * name,bool * sysrooted)525 try_open (const char *name, bool *sysrooted)
526 {
527 FILE *result;
528
529 result = fopen (name, "r");
530
531 if (result != NULL)
532 *sysrooted = is_sysrooted_pathname (name);
533
534 if (verbose)
535 {
536 if (result == NULL)
537 info_msg (_("cannot find script file %s\n"), name);
538 else
539 info_msg (_("opened script file %s\n"), name);
540 }
541
542 return result;
543 }
544
545 /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */
546
547 static bool
check_for_scripts_dir(char * dir)548 check_for_scripts_dir (char *dir)
549 {
550 char *buf;
551 struct stat s;
552 bool res;
553
554 buf = concat (dir, "/ldscripts", (const char *) NULL);
555 res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
556 free (buf);
557 return res;
558 }
559
560 /* Return the default directory for finding script files.
561 We look for the "ldscripts" directory in:
562
563 SCRIPTDIR (passed from Makefile)
564 (adjusted according to the current location of the binary)
565 the dir where this program is (for using it from the build tree). */
566
567 static char *
find_scripts_dir(void)568 find_scripts_dir (void)
569 {
570 char *dir;
571
572 dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
573 if (dir)
574 {
575 if (check_for_scripts_dir (dir))
576 return dir;
577 free (dir);
578 }
579
580 dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
581 if (dir)
582 {
583 if (check_for_scripts_dir (dir))
584 return dir;
585 free (dir);
586 }
587
588 /* Look for "ldscripts" in the dir where our binary is. */
589 dir = make_relative_prefix (program_name, ".", ".");
590 if (dir)
591 {
592 if (check_for_scripts_dir (dir))
593 return dir;
594 free (dir);
595 }
596
597 return NULL;
598 }
599
600 /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
601 it in directories specified with -L, then in the default script
602 directory. If DEFAULT_ONLY is true, the search is restricted to
603 the default script location. */
604
605 static FILE *
ldfile_find_command_file(const char * name,bool default_only,bool * sysrooted)606 ldfile_find_command_file (const char *name,
607 bool default_only,
608 bool *sysrooted)
609 {
610 search_dirs_type *search;
611 FILE *result = NULL;
612 char *path;
613 static search_dirs_type *script_search;
614
615 if (!default_only)
616 {
617 /* First try raw name. */
618 result = try_open (name, sysrooted);
619 if (result != NULL)
620 return result;
621 }
622
623 if (!script_search)
624 {
625 char *script_dir = find_scripts_dir ();
626 if (script_dir)
627 {
628 search_dirs_type **save_tail_ptr = search_tail_ptr;
629 search_tail_ptr = &script_search;
630 ldfile_add_library_path (script_dir, true);
631 search_tail_ptr = save_tail_ptr;
632 }
633 }
634
635 /* Temporarily append script_search to the path list so that the
636 paths specified with -L will be searched first. */
637 *search_tail_ptr = script_search;
638
639 /* Try now prefixes. */
640 for (search = default_only ? script_search : search_head;
641 search != NULL;
642 search = search->next)
643 {
644 path = concat (search->name, slash, name, (const char *) NULL);
645 result = try_open (path, sysrooted);
646 free (path);
647 if (result)
648 break;
649 }
650
651 /* Restore the original path list. */
652 *search_tail_ptr = NULL;
653
654 return result;
655 }
656
657 enum script_open_style {
658 script_nonT,
659 script_T,
660 script_defaultT
661 };
662
663 struct script_name_list
664 {
665 struct script_name_list *next;
666 enum script_open_style open_how;
667 char name[1];
668 };
669
670 /* Open command file NAME. */
671
672 static void
ldfile_open_command_file_1(const char * name,enum script_open_style open_how)673 ldfile_open_command_file_1 (const char *name, enum script_open_style open_how)
674 {
675 FILE *ldlex_input_stack;
676 bool sysrooted;
677 static struct script_name_list *processed_scripts = NULL;
678 struct script_name_list *script;
679 size_t len;
680
681 /* PR 24576: Catch the case where the user has accidentally included
682 the same linker script twice. */
683 for (script = processed_scripts; script != NULL; script = script->next)
684 {
685 if ((open_how != script_nonT || script->open_how != script_nonT)
686 && strcmp (name, script->name) == 0)
687 {
688 einfo (_("%F%P: error: linker script file '%s'"
689 " appears multiple times\n"), name);
690 return;
691 }
692 }
693
694 /* FIXME: This memory is never freed, but that should not really matter.
695 It will be released when the linker exits, and it is unlikely to ever
696 be more than a few tens of bytes. */
697 len = strlen (name);
698 script = xmalloc (sizeof (*script) + len);
699 script->next = processed_scripts;
700 script->open_how = open_how;
701 memcpy (script->name, name, len + 1);
702 processed_scripts = script;
703
704 ldlex_input_stack = ldfile_find_command_file (name,
705 open_how == script_defaultT,
706 &sysrooted);
707 if (ldlex_input_stack == NULL)
708 {
709 bfd_set_error (bfd_error_system_call);
710 einfo (_("%F%P: cannot open linker script file %s: %E\n"), name);
711 return;
712 }
713
714 track_dependency_files (name);
715
716 lex_push_file (ldlex_input_stack, name, sysrooted);
717
718 lineno = 1;
719
720 saved_script_handle = ldlex_input_stack;
721 }
722
723 /* Open command file NAME in the current directory, -L directories,
724 the default script location, in that order. */
725
726 void
ldfile_open_command_file(const char * name)727 ldfile_open_command_file (const char *name)
728 {
729 ldfile_open_command_file_1 (name, script_nonT);
730 }
731
732 void
ldfile_open_script_file(const char * name)733 ldfile_open_script_file (const char *name)
734 {
735 ldfile_open_command_file_1 (name, script_T);
736 }
737
738 /* Open command file NAME at the default script location. */
739
740 void
ldfile_open_default_command_file(const char * name)741 ldfile_open_default_command_file (const char *name)
742 {
743 ldfile_open_command_file_1 (name, script_defaultT);
744 }
745
746 void
ldfile_add_arch(const char * in_name)747 ldfile_add_arch (const char *in_name)
748 {
749 char *name = xstrdup (in_name);
750 search_arch_type *new_arch
751 = (search_arch_type *) xmalloc (sizeof (search_arch_type));
752
753 ldfile_output_machine_name = in_name;
754
755 new_arch->name = name;
756 new_arch->next = NULL;
757 while (*name)
758 {
759 *name = TOLOWER (*name);
760 name++;
761 }
762 *search_arch_tail_ptr = new_arch;
763 search_arch_tail_ptr = &new_arch->next;
764
765 }
766
767 /* Set the output architecture. */
768
769 void
ldfile_set_output_arch(const char * string,enum bfd_architecture defarch)770 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
771 {
772 const bfd_arch_info_type *arch = bfd_scan_arch (string);
773
774 if (arch)
775 {
776 ldfile_output_architecture = arch->arch;
777 ldfile_output_machine = arch->mach;
778 ldfile_output_machine_name = arch->printable_name;
779 }
780 else if (defarch != bfd_arch_unknown)
781 ldfile_output_architecture = defarch;
782 else
783 einfo (_("%F%P: cannot represent machine `%s'\n"), string);
784 }
785