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