1/* Linker file opening and searching.
2   Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
3   2003, 2004, 2005 Free Software Foundation, Inc.
4
5   This file is part of GLD, the Gnu Linker.
6
7   GLD is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 2, or (at your option)
10   any later version.
11
12   GLD is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with GLD; see the file COPYING.  If not, write to the Free
19   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
20   02110-1301, USA.  */
21
22/* ldfile.c:  look after all the file stuff.  */
23
24#include "bfd.h"
25#include "sysdep.h"
26#include "bfdlink.h"
27#include "safe-ctype.h"
28#include "ld.h"
29#include "ldmisc.h"
30#include "ldexp.h"
31#include "ldlang.h"
32#include "ldfile.h"
33#include "ldmain.h"
34#include <ldgram.h>
35#include "ldlex.h"
36#include "ldemul.h"
37#include "libiberty.h"
38#include "filenames.h"
39
40const char * ldfile_input_filename;
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, bfd_boolean notsame)
72{
73  char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
74  int len;
75  bfd_boolean result;
76
77  if (! realname)
78    return FALSE;
79
80  len = strlen (realname);
81
82  if (((! notsame && len == ld_canon_sysroot_len)
83       || (len >= ld_canon_sysroot_len
84	   && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
85	   && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
86      && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
87    result = TRUE;
88  else
89    result = FALSE;
90
91  if (realname)
92    free (realname);
93
94  return result;
95}
96
97/* Adds NAME to the library search path.
98   Makes a copy of NAME using xmalloc().  */
99
100void
101ldfile_add_library_path (const char *name, bfd_boolean cmdline)
102{
103  search_dirs_type *new;
104
105  if (!cmdline && config.only_cmd_line_lib_dirs)
106    return;
107
108  new = xmalloc (sizeof (search_dirs_type));
109  new->next = NULL;
110  new->cmdline = cmdline;
111  *search_tail_ptr = new;
112  search_tail_ptr = &new->next;
113
114  /* If a directory is marked as honoring sysroot, prepend the sysroot path
115     now.  */
116  if (name[0] == '=')
117    {
118      new->name = concat (ld_sysroot, name + 1, NULL);
119      new->sysrooted = TRUE;
120    }
121  else
122    {
123      new->name = xstrdup (name);
124      new->sysrooted = is_sysrooted_pathname (name, FALSE);
125    }
126}
127
128/* Try to open a BFD for a lang_input_statement.  */
129
130bfd_boolean
131ldfile_try_open_bfd (const char *attempt,
132		     lang_input_statement_type *entry)
133{
134  entry->the_bfd = bfd_openr (attempt, entry->target);
135
136  if (trace_file_tries)
137    {
138      if (entry->the_bfd == NULL)
139	info_msg (_("attempt to open %s failed\n"), attempt);
140      else
141	info_msg (_("attempt to open %s succeeded\n"), attempt);
142    }
143
144  if (entry->the_bfd == NULL)
145    {
146      if (bfd_get_error () == bfd_error_invalid_target)
147	einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
148      return FALSE;
149    }
150
151  /* If we are searching for this file, see if the architecture is
152     compatible with the output file.  If it isn't, keep searching.
153     If we can't open the file as an object file, stop the search
154     here.  If we are statically linking, ensure that we don't link
155     a dynamic object.  */
156
157  if (entry->search_dirs_flag || !entry->dynamic)
158    {
159      bfd *check;
160
161      if (bfd_check_format (entry->the_bfd, bfd_archive))
162	check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
163      else
164	check = entry->the_bfd;
165
166      if (check != NULL)
167	{
168	  if (! bfd_check_format (check, bfd_object))
169	    {
170	      if (check == entry->the_bfd
171		  && entry->search_dirs_flag
172		  && bfd_get_error () == bfd_error_file_not_recognized
173		  && ! ldemul_unrecognized_file (entry))
174		{
175		  int token, skip = 0;
176		  char *arg, *arg1, *arg2, *arg3;
177		  extern FILE *yyin;
178
179		  /* Try to interpret the file as a linker script.  */
180		  ldfile_open_command_file (attempt);
181
182		  ldfile_assumed_script = TRUE;
183		  parser_input = input_selected;
184		  ldlex_both ();
185		  token = INPUT_SCRIPT;
186		  while (token != 0)
187		    {
188		      switch (token)
189			{
190			case OUTPUT_FORMAT:
191			  if ((token = yylex ()) != '(')
192			    continue;
193			  if ((token = yylex ()) != NAME)
194			    continue;
195			  arg1 = yylval.name;
196			  arg2 = NULL;
197			  arg3 = NULL;
198			  token = yylex ();
199			  if (token == ',')
200			    {
201			      if ((token = yylex ()) != NAME)
202				{
203				  free (arg1);
204				  continue;
205				}
206			      arg2 = yylval.name;
207			      if ((token = yylex ()) != ','
208				  || (token = yylex ()) != NAME)
209				{
210				  free (arg1);
211				  free (arg2);
212				  continue;
213				}
214			      arg3 = yylval.name;
215			      token = yylex ();
216			    }
217			  if (token == ')')
218			    {
219			      switch (command_line.endian)
220				{
221				default:
222				case ENDIAN_UNSET:
223				  arg = arg1; break;
224				case ENDIAN_BIG:
225				  arg = arg2 ? arg2 : arg1; break;
226				case ENDIAN_LITTLE:
227				  arg = arg3 ? arg3 : arg1; break;
228				}
229			      if (strcmp (arg, lang_get_output_target ()) != 0)
230				skip = 1;
231			    }
232			  free (arg1);
233			  if (arg2) free (arg2);
234			  if (arg3) free (arg3);
235			  break;
236			case NAME:
237			case LNAME:
238			case VERS_IDENTIFIER:
239			case VERS_TAG:
240			  free (yylval.name);
241			  break;
242			case INT:
243			  if (yylval.bigint.str)
244			    free (yylval.bigint.str);
245			  break;
246			}
247		      token = yylex ();
248		    }
249		  ldlex_popstate ();
250		  ldfile_assumed_script = FALSE;
251		  fclose (yyin);
252		  yyin = NULL;
253		  if (skip)
254		    {
255		      einfo (_("%P: skipping incompatible %s when searching for %s\n"),
256			     attempt, entry->local_sym_name);
257		      bfd_close (entry->the_bfd);
258		      entry->the_bfd = NULL;
259		      return FALSE;
260		    }
261		}
262	      return TRUE;
263	    }
264
265	  if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
266	    {
267	      einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
268		     attempt);
269	      bfd_close (entry->the_bfd);
270	      entry->the_bfd = NULL;
271	      return FALSE;
272	    }
273
274	  if (entry->search_dirs_flag
275	      && !bfd_arch_get_compatible (check, output_bfd,
276					   command_line.accept_unknown_input_arch)
277	      /* XCOFF archives can have 32 and 64 bit objects.  */
278	      && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
279		    && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
280		    && bfd_check_format (entry->the_bfd, bfd_archive)))
281	    {
282	      einfo (_("%P: skipping incompatible %s when searching for %s\n"),
283		     attempt, entry->local_sym_name);
284	      bfd_close (entry->the_bfd);
285	      entry->the_bfd = NULL;
286	      return FALSE;
287	    }
288	}
289    }
290
291  return TRUE;
292}
293
294/* Search for and open the file specified by ENTRY.  If it is an
295   archive, use ARCH, LIB and SUFFIX to modify the file name.  */
296
297bfd_boolean
298ldfile_open_file_search (const char *arch,
299			 lang_input_statement_type *entry,
300			 const char *lib,
301			 const char *suffix)
302{
303  search_dirs_type *search;
304
305  /* If this is not an archive, try to open it in the current
306     directory first.  */
307  if (! entry->is_archive)
308    {
309      if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
310	{
311	  char *name = concat (ld_sysroot, entry->filename,
312			       (const char *) NULL);
313	  if (ldfile_try_open_bfd (name, entry))
314	    {
315	      entry->filename = name;
316	      return TRUE;
317	    }
318	  free (name);
319	}
320      else if (ldfile_try_open_bfd (entry->filename, entry))
321	{
322	  entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
323	    && is_sysrooted_pathname (entry->filename, TRUE);
324	  return TRUE;
325	}
326
327      if (IS_ABSOLUTE_PATH (entry->filename))
328	return FALSE;
329    }
330
331  for (search = search_head; search != NULL; search = search->next)
332    {
333      char *string;
334
335      if (entry->dynamic && ! link_info.relocatable)
336	{
337	  if (ldemul_open_dynamic_archive (arch, search, entry))
338	    {
339	      entry->sysrooted = search->sysrooted;
340	      return TRUE;
341	    }
342	}
343
344      string = xmalloc (strlen (search->name)
345			+ strlen (slash)
346			+ strlen (lib)
347			+ strlen (entry->filename)
348			+ strlen (arch)
349			+ strlen (suffix)
350			+ 1);
351
352      if (entry->is_archive)
353	sprintf (string, "%s%s%s%s%s%s", search->name, slash,
354		 lib, entry->filename, arch, suffix);
355      else
356	sprintf (string, "%s%s%s", search->name, slash, entry->filename);
357
358      if (ldfile_try_open_bfd (string, entry))
359	{
360	  entry->filename = string;
361	  entry->sysrooted = search->sysrooted;
362	  return TRUE;
363	}
364
365      free (string);
366    }
367
368  return FALSE;
369}
370
371/* Open the input file specified by ENTRY.  */
372
373void
374ldfile_open_file (lang_input_statement_type *entry)
375{
376  if (entry->the_bfd != NULL)
377    return;
378
379  if (! entry->search_dirs_flag)
380    {
381      if (ldfile_try_open_bfd (entry->filename, entry))
382	return;
383      if (strcmp (entry->filename, entry->local_sym_name) != 0)
384	einfo (_("%F%P: %s (%s): No such file: %E\n"),
385	       entry->filename, entry->local_sym_name);
386      else
387	einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
388    }
389  else
390    {
391      search_arch_type *arch;
392      bfd_boolean found = FALSE;
393
394      /* Try to open <filename><suffix> or lib<filename><suffix>.a */
395      for (arch = search_arch_head; arch != NULL; arch = arch->next)
396	{
397	  found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
398	  if (found)
399	    break;
400#ifdef VMS
401	  found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
402	  if (found)
403	    break;
404#endif
405	  found = ldemul_find_potential_libraries (arch->name, entry);
406	  if (found)
407	    break;
408	}
409
410      /* If we have found the file, we don't need to search directories
411	 again.  */
412      if (found)
413	entry->search_dirs_flag = FALSE;
414      else if (entry->sysrooted
415	       && ld_sysroot
416	       && IS_ABSOLUTE_PATH (entry->local_sym_name))
417	einfo (_("%F%P: cannot find %s inside %s\n"),
418	       entry->local_sym_name, ld_sysroot);
419      else
420	einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
421    }
422}
423
424/* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
425
426static FILE *
427try_open (const char *name, const char *exten)
428{
429  FILE *result;
430  char buff[1000];
431
432  result = fopen (name, "r");
433
434  if (trace_file_tries)
435    {
436      if (result == NULL)
437	info_msg (_("cannot find script file %s\n"), name);
438      else
439	info_msg (_("opened script file %s\n"), name);
440    }
441
442  if (result != NULL)
443    return result;
444
445  if (*exten)
446    {
447      sprintf (buff, "%s%s", name, exten);
448      result = fopen (buff, "r");
449
450      if (trace_file_tries)
451	{
452	  if (result == NULL)
453	    info_msg (_("cannot find script file %s\n"), buff);
454	  else
455	    info_msg (_("opened script file %s\n"), buff);
456	}
457    }
458
459  return result;
460}
461
462/* Try to open NAME; if that fails, look for it in any directories
463   specified with -L, without and with EXTEND appended.  */
464
465static FILE *
466ldfile_find_command_file (const char *name, const char *extend)
467{
468  search_dirs_type *search;
469  FILE *result;
470  char buffer[1000];
471
472  /* First try raw name.  */
473  result = try_open (name, "");
474  if (result == NULL)
475    {
476      /* Try now prefixes.  */
477      for (search = search_head; search != NULL; search = search->next)
478	{
479	  sprintf (buffer, "%s%s%s", search->name, slash, name);
480
481	  result = try_open (buffer, extend);
482	  if (result)
483	    break;
484	}
485    }
486
487  return result;
488}
489
490void
491ldfile_open_command_file (const char *name)
492{
493  FILE *ldlex_input_stack;
494  ldlex_input_stack = ldfile_find_command_file (name, "");
495
496  if (ldlex_input_stack == NULL)
497    {
498      bfd_set_error (bfd_error_system_call);
499      einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
500    }
501
502  lex_push_file (ldlex_input_stack, name);
503
504  ldfile_input_filename = name;
505  lineno = 1;
506
507  saved_script_handle = ldlex_input_stack;
508}
509
510void
511ldfile_add_arch (const char *in_name)
512{
513  char *name = xstrdup (in_name);
514  search_arch_type *new = xmalloc (sizeof (search_arch_type));
515
516  ldfile_output_machine_name = in_name;
517
518  new->name = name;
519  new->next = NULL;
520  while (*name)
521    {
522      *name = TOLOWER (*name);
523      name++;
524    }
525  *search_arch_tail_ptr = new;
526  search_arch_tail_ptr = &new->next;
527
528}
529
530/* Set the output architecture.  */
531
532void
533ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
534{
535  const bfd_arch_info_type *arch = bfd_scan_arch (string);
536
537  if (arch)
538    {
539      ldfile_output_architecture = arch->arch;
540      ldfile_output_machine = arch->mach;
541      ldfile_output_machine_name = arch->printable_name;
542    }
543  else if (defarch != bfd_arch_unknown)
544    ldfile_output_architecture = defarch;
545  else
546    einfo (_("%P%F: cannot represent machine `%s'\n"), string);
547}
548