1/* Linker file opening and searching.
2   Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
3   2003, 2004 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, 59 Temple Place - Suite 330, Boston, MA
20   02111-1307, 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#ifndef MPW
48#ifdef VMS
49char * slash = "";
50#else
51#if defined (_WIN32) && ! defined (__CYGWIN32__)
52char * slash = "\\";
53#else
54char * slash = "/";
55#endif
56#endif
57#else /* MPW */
58/* The MPW path char is a colon.  */
59char * slash = ":";
60#endif /* MPW */
61
62typedef struct search_arch
63{
64  char *name;
65  struct search_arch *next;
66} search_arch_type;
67
68static search_dirs_type **search_tail_ptr = &search_head;
69static search_arch_type *search_arch_head;
70static search_arch_type **search_arch_tail_ptr = &search_arch_head;
71
72/* Test whether a pathname, after canonicalization, is the same or a
73   sub-directory of the sysroot directory.  */
74
75static bfd_boolean
76is_sysrooted_pathname (const char *name, bfd_boolean notsame)
77{
78  char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
79  int len;
80  bfd_boolean result;
81
82  if (! realname)
83    return FALSE;
84
85  len = strlen (realname);
86
87  if (((! notsame && len == ld_canon_sysroot_len)
88       || (len >= ld_canon_sysroot_len
89	   && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
90	   && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
91      && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
92    result = TRUE;
93  else
94    result = FALSE;
95
96  if (realname)
97    free (realname);
98
99  return result;
100}
101
102/* Adds NAME to the library search path.
103   Makes a copy of NAME using xmalloc().  */
104
105void
106ldfile_add_library_path (const char *name, bfd_boolean cmdline)
107{
108  search_dirs_type *new;
109
110  if (!cmdline && config.only_cmd_line_lib_dirs)
111    return;
112
113  new = xmalloc (sizeof (search_dirs_type));
114  new->next = NULL;
115  new->cmdline = cmdline;
116  *search_tail_ptr = new;
117  search_tail_ptr = &new->next;
118
119  /* If a directory is marked as honoring sysroot, prepend the sysroot path
120     now.  */
121  if (name[0] == '=')
122    {
123      new->name = concat (ld_sysroot, name + 1, NULL);
124      new->sysrooted = TRUE;
125    }
126  else
127    {
128      new->name = xstrdup (name);
129      new->sysrooted = is_sysrooted_pathname (name, FALSE);
130    }
131}
132
133/* Try to open a BFD for a lang_input_statement.  */
134
135bfd_boolean
136ldfile_try_open_bfd (const char *attempt,
137		     lang_input_statement_type *entry)
138{
139  entry->the_bfd = bfd_openr (attempt, entry->target);
140
141  if (trace_file_tries)
142    {
143      if (entry->the_bfd == NULL)
144	info_msg (_("attempt to open %s failed\n"), attempt);
145      else
146	info_msg (_("attempt to open %s succeeded\n"), attempt);
147    }
148
149  if (entry->the_bfd == NULL)
150    {
151      if (bfd_get_error () == bfd_error_invalid_target)
152	einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
153      return FALSE;
154    }
155
156  /* If we are searching for this file, see if the architecture is
157     compatible with the output file.  If it isn't, keep searching.
158     If we can't open the file as an object file, stop the search
159     here.  */
160
161  if (entry->search_dirs_flag)
162    {
163      bfd *check;
164
165      if (bfd_check_format (entry->the_bfd, bfd_archive))
166	check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
167      else
168	check = entry->the_bfd;
169
170      if (check != NULL)
171	{
172	  if (! bfd_check_format (check, bfd_object))
173	    {
174	      if (check == entry->the_bfd
175		  && bfd_get_error () == bfd_error_file_not_recognized
176		  && ! ldemul_unrecognized_file (entry))
177		{
178		  int token, skip = 0;
179		  char *arg, *arg1, *arg2, *arg3;
180		  extern FILE *yyin;
181
182		  /* Try to interpret the file as a linker script.  */
183		  ldfile_open_command_file (attempt);
184
185		  ldfile_assumed_script = TRUE;
186		  parser_input = input_selected;
187		  ldlex_both ();
188		  token = INPUT_SCRIPT;
189		  while (token != 0)
190		    {
191		      switch (token)
192			{
193			case OUTPUT_FORMAT:
194			  if ((token = yylex ()) != '(')
195			    continue;
196			  if ((token = yylex ()) != NAME)
197			    continue;
198			  arg1 = yylval.name;
199			  arg2 = NULL;
200			  arg3 = NULL;
201			  token = yylex ();
202			  if (token == ',')
203			    {
204			      if ((token = yylex ()) != NAME)
205				{
206				  free (arg1);
207				  continue;
208				}
209			      arg2 = yylval.name;
210			      if ((token = yylex ()) != ','
211				  || (token = yylex ()) != NAME)
212				{
213				  free (arg1);
214				  free (arg2);
215				  continue;
216				}
217			      arg3 = yylval.name;
218			      token = yylex ();
219			    }
220			  if (token == ')')
221			    {
222			      switch (command_line.endian)
223				{
224				default:
225				case ENDIAN_UNSET:
226				  arg = arg1; break;
227				case ENDIAN_BIG:
228				  arg = arg2 ? arg2 : arg1; break;
229				case ENDIAN_LITTLE:
230				  arg = arg3 ? arg3 : arg1; break;
231				}
232			      if (strcmp (arg, lang_get_output_target ()) != 0)
233				skip = 1;
234			    }
235			  free (arg1);
236			  if (arg2) free (arg2);
237			  if (arg3) free (arg3);
238			  break;
239			case NAME:
240			case LNAME:
241			case VERS_IDENTIFIER:
242			case VERS_TAG:
243			  free (yylval.name);
244			  break;
245			case INT:
246			  if (yylval.bigint.str)
247			    free (yylval.bigint.str);
248			  break;
249			}
250		      token = yylex ();
251		    }
252		  ldlex_popstate ();
253		  ldfile_assumed_script = FALSE;
254		  fclose (yyin);
255		  yyin = NULL;
256		  if (skip)
257		    {
258		      einfo (_("%P: skipping incompatible %s when searching for %s\n"),
259			     attempt, entry->local_sym_name);
260		      bfd_close (entry->the_bfd);
261		      entry->the_bfd = NULL;
262		      return FALSE;
263		    }
264		}
265	      return TRUE;
266	    }
267
268	  if ((bfd_arch_get_compatible (check, output_bfd,
269					command_line.accept_unknown_input_arch) == NULL)
270	      /* XCOFF archives can have 32 and 64 bit objects.  */
271	      && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
272		    && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
273		    && bfd_check_format (entry->the_bfd, bfd_archive)))
274	    {
275	      einfo (_("%P: skipping incompatible %s when searching for %s\n"),
276		     attempt, entry->local_sym_name);
277	      bfd_close (entry->the_bfd);
278	      entry->the_bfd = NULL;
279	      return FALSE;
280	    }
281	}
282    }
283
284  return TRUE;
285}
286
287/* Search for and open the file specified by ENTRY.  If it is an
288   archive, use ARCH, LIB and SUFFIX to modify the file name.  */
289
290bfd_boolean
291ldfile_open_file_search (const char *arch,
292			 lang_input_statement_type *entry,
293			 const char *lib,
294			 const char *suffix)
295{
296  search_dirs_type *search;
297
298  /* If this is not an archive, try to open it in the current
299     directory first.  */
300  if (! entry->is_archive)
301    {
302      if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
303	{
304	  char *name = concat (ld_sysroot, entry->filename,
305			       (const char *) NULL);
306	  if (ldfile_try_open_bfd (name, entry))
307	    {
308	      entry->filename = name;
309	      return TRUE;
310	    }
311	  free (name);
312	}
313      else if (ldfile_try_open_bfd (entry->filename, entry))
314	{
315	  entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
316	    && is_sysrooted_pathname (entry->filename, TRUE);
317	  return TRUE;
318	}
319
320      if (IS_ABSOLUTE_PATH (entry->filename))
321	return FALSE;
322    }
323
324  for (search = search_head; search != NULL; search = search->next)
325    {
326      char *string;
327
328      if (entry->dynamic && ! link_info.relocatable)
329	{
330	  if (ldemul_open_dynamic_archive (arch, search, entry))
331	    {
332	      entry->sysrooted = search->sysrooted;
333	      return TRUE;
334	    }
335	}
336
337      string = xmalloc (strlen (search->name)
338			+ strlen (slash)
339			+ strlen (lib)
340			+ strlen (entry->filename)
341			+ strlen (arch)
342			+ strlen (suffix)
343			+ 1);
344
345      if (entry->is_archive)
346	sprintf (string, "%s%s%s%s%s%s", search->name, slash,
347		 lib, entry->filename, arch, suffix);
348      else
349	sprintf (string, "%s%s%s", search->name, slash, entry->filename);
350
351      if (ldfile_try_open_bfd (string, entry))
352	{
353	  entry->filename = string;
354	  entry->sysrooted = search->sysrooted;
355	  return TRUE;
356	}
357
358      free (string);
359    }
360
361  return FALSE;
362}
363
364/* Open the input file specified by ENTRY.  */
365
366void
367ldfile_open_file (lang_input_statement_type *entry)
368{
369  if (entry->the_bfd != NULL)
370    return;
371
372  if (! entry->search_dirs_flag)
373    {
374      if (ldfile_try_open_bfd (entry->filename, entry))
375	return;
376      if (strcmp (entry->filename, entry->local_sym_name) != 0)
377	einfo (_("%F%P: %s (%s): No such file: %E\n"),
378	       entry->filename, entry->local_sym_name);
379      else
380	einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
381    }
382  else
383    {
384      search_arch_type *arch;
385      bfd_boolean found = FALSE;
386
387      /* Try to open <filename><suffix> or lib<filename><suffix>.a */
388      for (arch = search_arch_head; arch != NULL; arch = arch->next)
389	{
390	  found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
391	  if (found)
392	    break;
393#ifdef VMS
394	  found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
395	  if (found)
396	    break;
397#endif
398	  found = ldemul_find_potential_libraries (arch->name, entry);
399	  if (found)
400	    break;
401	}
402
403      /* If we have found the file, we don't need to search directories
404	 again.  */
405      if (found)
406	entry->search_dirs_flag = FALSE;
407      else if (entry->sysrooted
408	       && ld_sysroot
409	       && IS_ABSOLUTE_PATH (entry->local_sym_name))
410	einfo (_("%F%P: cannot find %s inside %s\n"),
411	       entry->local_sym_name, ld_sysroot);
412      else
413	einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
414    }
415}
416
417/* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
418
419static FILE *
420try_open (const char *name, const char *exten)
421{
422  FILE *result;
423  char buff[1000];
424
425  result = fopen (name, "r");
426
427  if (trace_file_tries)
428    {
429      if (result == NULL)
430	info_msg (_("cannot find script file %s\n"), name);
431      else
432	info_msg (_("opened script file %s\n"), name);
433    }
434
435  if (result != NULL)
436    return result;
437
438  if (*exten)
439    {
440      sprintf (buff, "%s%s", name, exten);
441      result = fopen (buff, "r");
442
443      if (trace_file_tries)
444	{
445	  if (result == NULL)
446	    info_msg (_("cannot find script file %s\n"), buff);
447	  else
448	    info_msg (_("opened script file %s\n"), buff);
449	}
450    }
451
452  return result;
453}
454
455/* Try to open NAME; if that fails, look for it in any directories
456   specified with -L, without and with EXTEND appended.  */
457
458FILE *
459ldfile_find_command_file (const char *name, const char *extend)
460{
461  search_dirs_type *search;
462  FILE *result;
463  char buffer[1000];
464
465  /* First try raw name.  */
466  result = try_open (name, "");
467  if (result == NULL)
468    {
469      /* Try now prefixes.  */
470      for (search = search_head; search != NULL; search = search->next)
471	{
472	  sprintf (buffer, "%s%s%s", search->name, slash, name);
473
474	  result = try_open (buffer, extend);
475	  if (result)
476	    break;
477	}
478    }
479
480  return result;
481}
482
483void
484ldfile_open_command_file (const char *name)
485{
486  FILE *ldlex_input_stack;
487  ldlex_input_stack = ldfile_find_command_file (name, "");
488
489  if (ldlex_input_stack == NULL)
490    {
491      bfd_set_error (bfd_error_system_call);
492      einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
493    }
494
495  lex_push_file (ldlex_input_stack, name);
496
497  ldfile_input_filename = name;
498  lineno = 1;
499
500  saved_script_handle = ldlex_input_stack;
501}
502
503#ifdef GNU960
504static char *
505gnu960_map_archname (char *name)
506{
507  struct tabentry { char *cmd_switch; char *arch; };
508  static struct tabentry arch_tab[] =
509  {
510	"",   "",
511	"KA", "ka",
512	"KB", "kb",
513	"KC", "mc",	/* Synonym for MC */
514	"MC", "mc",
515	"CA", "ca",
516	"SA", "ka",	/* Functionally equivalent to KA */
517	"SB", "kb",	/* Functionally equivalent to KB */
518	NULL, ""
519  };
520  struct tabentry *tp;
521
522  for (tp = arch_tab; tp->cmd_switch != NULL; tp++)
523    {
524      if (! strcmp (name,tp->cmd_switch))
525	break;
526    }
527
528  if (tp->cmd_switch == NULL)
529    einfo (_("%P%F: unknown architecture: %s\n"), name);
530
531  return tp->arch;
532}
533
534void
535ldfile_add_arch (char *name)
536{
537  search_arch_type *new = xmalloc (sizeof (search_arch_type));
538
539  if (*name != '\0')
540    {
541      if (ldfile_output_machine_name[0] != '\0')
542	{
543	  einfo (_("%P%F: target architecture respecified\n"));
544	  return;
545	}
546
547      ldfile_output_machine_name = name;
548    }
549
550  new->next = NULL;
551  new->name = gnu960_map_archname (name);
552  *search_arch_tail_ptr = new;
553  search_arch_tail_ptr = &new->next;
554}
555
556#else /* not GNU960 */
557
558void
559ldfile_add_arch (const char *in_name)
560{
561  char *name = xstrdup (in_name);
562  search_arch_type *new = xmalloc (sizeof (search_arch_type));
563
564  ldfile_output_machine_name = in_name;
565
566  new->name = name;
567  new->next = NULL;
568  while (*name)
569    {
570      *name = TOLOWER (*name);
571      name++;
572    }
573  *search_arch_tail_ptr = new;
574  search_arch_tail_ptr = &new->next;
575
576}
577#endif
578
579/* Set the output architecture.  */
580
581void
582ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
583{
584  const bfd_arch_info_type *arch = bfd_scan_arch (string);
585
586  if (arch)
587    {
588      ldfile_output_architecture = arch->arch;
589      ldfile_output_machine = arch->mach;
590      ldfile_output_machine_name = arch->printable_name;
591    }
592  else if (defarch != bfd_arch_unknown)
593    ldfile_output_architecture = defarch;
594  else
595    einfo (_("%P%F: cannot represent machine `%s'\n"), string);
596}
597