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