ldfile.c revision 60484 
1/* Linker file opening and searching.
2   Copyright (C) 1991, 92, 93, 94, 95, 98, 99, 2000
3   Free Software Foundation, Inc.
4
5This file is part of GLD, the Gnu Linker.
6
7GLD is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GLD is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GLD; see the file COPYING.  If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA.  */
21
22/*
23 ldfile.c
24
25 look after all the file stuff
26
27 */
28
29#include "bfd.h"
30#include "sysdep.h"
31#include "bfdlink.h"
32#include "ld.h"
33#include "ldmisc.h"
34#include "ldexp.h"
35#include "ldlang.h"
36#include "ldfile.h"
37#include "ldmain.h"
38#include "ldgram.h"
39#include "ldlex.h"
40#include "ldemul.h"
41
42#include <ctype.h>
43
44const char *ldfile_input_filename;
45boolean ldfile_assumed_script = false;
46const char *ldfile_output_machine_name = "";
47unsigned long ldfile_output_machine;
48enum bfd_architecture ldfile_output_architecture;
49search_dirs_type *search_head;
50
51#ifndef MPW
52#ifdef VMS
53char *slash = "";
54#else
55#if defined (_WIN32) && ! defined (__CYGWIN32__)
56char *slash = "\\";
57#else
58char *slash = "/";
59#endif
60#endif
61#else /* MPW */
62/* The MPW path char is a colon. */
63char *slash = ":";
64#endif /* MPW */
65
66/* LOCAL */
67
68static search_dirs_type **search_tail_ptr = &search_head;
69
70typedef struct search_arch
71{
72  char *name;
73  struct search_arch *next;
74} search_arch_type;
75
76static search_arch_type *search_arch_head;
77static search_arch_type **search_arch_tail_ptr = &search_arch_head;
78
79static FILE *try_open PARAMS ((const char *name, const char *exten));
80
81void
82ldfile_add_library_path (name, cmdline)
83     const char *name;
84     boolean cmdline;
85{
86  search_dirs_type *new;
87
88  new = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
89  new->next = NULL;
90  new->name = name;
91  new->cmdline = cmdline;
92  *search_tail_ptr = new;
93  search_tail_ptr = &new->next;
94}
95
96/* Try to open a BFD for a lang_input_statement.  */
97
98boolean
99ldfile_try_open_bfd (attempt, entry)
100     const char *attempt;
101     lang_input_statement_type *entry;
102{
103  entry->the_bfd = bfd_openr (attempt, entry->target);
104
105  if (trace_file_tries)
106    {
107      if (entry->the_bfd == NULL)
108	info_msg (_("attempt to open %s failed\n"), attempt);
109      else
110	info_msg (_("attempt to open %s succeeded\n"), attempt);
111    }
112
113  if (entry->the_bfd == NULL)
114    {
115      if (bfd_get_error () == bfd_error_invalid_target)
116	einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
117      return false;
118    }
119
120  /* If we are searching for this file, see if the architecture is
121     compatible with the output file.  If it isn't, keep searching.
122     If we can't open the file as an object file, stop the search
123     here.  */
124
125  if (entry->search_dirs_flag)
126    {
127      bfd *check;
128
129      if (bfd_check_format (entry->the_bfd, bfd_archive))
130	check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
131      else
132	check = entry->the_bfd;
133
134      if (check != NULL)
135	{
136	  if (! bfd_check_format (check, bfd_object))
137	    return true;
138	  if (bfd_arch_get_compatible (check, output_bfd) == NULL)
139	    {
140	      einfo (_("%P: skipping incompatible %s when searching for %s"),
141		     attempt, entry->local_sym_name);
142	      bfd_close (entry->the_bfd);
143	      entry->the_bfd = NULL;
144	      return false;
145	    }
146	}
147    }
148
149  return true;
150}
151
152/* Search for and open the file specified by ENTRY.  If it is an
153   archive, use ARCH, LIB and SUFFIX to modify the file name.  */
154
155boolean
156ldfile_open_file_search (arch, entry, lib, suffix)
157     const char *arch;
158     lang_input_statement_type *entry;
159     const char *lib;
160     const char *suffix;
161{
162  search_dirs_type *search;
163
164  /* If this is not an archive, try to open it in the current
165     directory first.  */
166  if (! entry->is_archive)
167    {
168      if (ldfile_try_open_bfd (entry->filename, entry))
169	return true;
170    }
171
172  for (search = search_head;
173       search != (search_dirs_type *)NULL;
174       search = search->next)
175    {
176      char *string;
177
178      if (entry->dynamic && ! link_info.relocateable)
179	{
180	  if (ldemul_open_dynamic_archive (arch, search, entry))
181	    return true;
182	}
183
184      string = (char *) xmalloc (strlen (search->name)
185				 + strlen (slash)
186				 + strlen (lib)
187				 + strlen (entry->filename)
188				 + strlen (arch)
189				 + strlen (suffix)
190				 + 1);
191
192      if (entry->is_archive)
193	sprintf (string, "%s%s%s%s%s%s", search->name, slash,
194		 lib, entry->filename, arch, suffix);
195      else if (entry->filename[0] == '/' || entry->filename[0] == '.'
196#if defined (__MSDOS__) || defined (_WIN32)
197	       || entry->filename[0] == '\\'
198	       || (isalpha (entry->filename[0])
199	           && entry->filename[1] == ':')
200#endif
201	  )
202	strcpy (string, entry->filename);
203      else
204	sprintf (string, "%s%s%s", search->name, slash, entry->filename);
205
206      if (ldfile_try_open_bfd (string, entry))
207	{
208	  entry->filename = string;
209	  return true;
210	}
211
212      free (string);
213    }
214
215  return false;
216}
217
218/* Open the input file specified by ENTRY.  */
219
220void
221ldfile_open_file (entry)
222     lang_input_statement_type *entry;
223{
224  if (entry->the_bfd != NULL)
225    return;
226
227  if (! entry->search_dirs_flag)
228    {
229      if (ldfile_try_open_bfd (entry->filename, entry))
230	return;
231      if (strcmp (entry->filename, entry->local_sym_name) != 0)
232	einfo (_("%F%P: cannot open %s for %s: %E\n"),
233	       entry->filename, entry->local_sym_name);
234      else
235	einfo(_("%F%P: cannot open %s: %E\n"), entry->local_sym_name);
236    }
237  else
238    {
239      search_arch_type *arch;
240
241      /* Try to open <filename><suffix> or lib<filename><suffix>.a */
242      for (arch = search_arch_head;
243	   arch != (search_arch_type *) NULL;
244	   arch = arch->next)
245	{
246	  if (ldfile_open_file_search (arch->name, entry, "lib", ".a"))
247	    return;
248#ifdef VMS
249	  if (ldfile_open_file_search (arch->name, entry, ":lib", ".a"))
250	    return;
251#endif
252	  if (ldemul_find_potential_libraries (arch->name, entry))
253	    return;
254	}
255      einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
256    }
257}
258
259/* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
260
261static FILE *
262try_open (name, exten)
263     const char *name;
264     const char *exten;
265{
266  FILE *result;
267  char buff[1000];
268
269  result = fopen (name, "r");
270  if (trace_file_tries)
271    {
272      if (result == NULL)
273	info_msg (_("cannot find script file %s\n"), name);
274      else
275	info_msg (_("opened script file %s\n"), name);
276    }
277
278  if (result != NULL)
279    return result;
280
281  if (*exten)
282    {
283      sprintf (buff, "%s%s", name, exten);
284      result = fopen (buff, "r");
285      if (trace_file_tries)
286	{
287	  if (result == NULL)
288	    info_msg (_("cannot find script file %s\n"), buff);
289	  else
290	    info_msg (_("opened script file %s\n"), buff);
291	}
292    }
293
294  return result;
295}
296
297/* Try to open NAME; if that fails, look for it in any directories
298   specified with -L, without and with EXTEND apppended.  */
299
300FILE *
301ldfile_find_command_file (name, extend)
302     const char *name;
303     const char *extend;
304{
305  search_dirs_type *search;
306  FILE *result;
307  char buffer[1000];
308
309  /* First try raw name */
310  result = try_open(name,"");
311  if (result == (FILE *)NULL) {
312    /* Try now prefixes */
313    for (search = search_head;
314	 search != (search_dirs_type *)NULL;
315	 search = search->next) {
316      sprintf(buffer,"%s%s%s", search->name, slash, name);
317      result = try_open(buffer, extend);
318      if (result)break;
319    }
320  }
321  return result;
322}
323
324void
325ldfile_open_command_file (name)
326     const char *name;
327{
328  FILE *ldlex_input_stack;
329  ldlex_input_stack = ldfile_find_command_file(name, "");
330
331  if (ldlex_input_stack == (FILE *)NULL) {
332    bfd_set_error (bfd_error_system_call);
333    einfo(_("%P%F: cannot open linker script file %s: %E\n"),name);
334  }
335  lex_push_file(ldlex_input_stack, name);
336
337  ldfile_input_filename = name;
338  lineno = 1;
339  had_script = true;
340}
341
342
343
344
345
346#ifdef GNU960
347static
348char *
349gnu960_map_archname( name )
350char *name;
351{
352  struct tabentry { char *cmd_switch; char *arch; };
353  static struct tabentry arch_tab[] = {
354	"",   "",
355	"KA", "ka",
356	"KB", "kb",
357	"KC", "mc",	/* Synonym for MC */
358	"MC", "mc",
359	"CA", "ca",
360	"SA", "ka",	/* Functionally equivalent to KA */
361	"SB", "kb",	/* Functionally equivalent to KB */
362	NULL, ""
363  };
364  struct tabentry *tp;
365
366
367  for ( tp = arch_tab; tp->cmd_switch != NULL; tp++ ){
368    if ( !strcmp(name,tp->cmd_switch) ){
369      break;
370    }
371  }
372
373  if ( tp->cmd_switch == NULL ){
374    einfo(_("%P%F: unknown architecture: %s\n"),name);
375  }
376  return tp->arch;
377}
378
379
380
381void
382ldfile_add_arch(name)
383char *name;
384{
385  search_arch_type *new =
386    (search_arch_type *)xmalloc((bfd_size_type)(sizeof(search_arch_type)));
387
388
389  if (*name != '\0') {
390    if (ldfile_output_machine_name[0] != '\0') {
391      einfo(_("%P%F: target architecture respecified\n"));
392      return;
393    }
394    ldfile_output_machine_name = name;
395  }
396
397  new->next = (search_arch_type*)NULL;
398  new->name = gnu960_map_archname( name );
399  *search_arch_tail_ptr = new;
400  search_arch_tail_ptr = &new->next;
401
402}
403
404#else	/* not GNU960 */
405
406
407void
408ldfile_add_arch (in_name)
409     CONST char * in_name;
410{
411  char *name = buystring(in_name);
412  search_arch_type *new =
413    (search_arch_type *) xmalloc (sizeof (search_arch_type));
414
415  ldfile_output_machine_name = in_name;
416
417  new->name = name;
418  new->next = (search_arch_type*)NULL;
419  while (*name)
420    {
421      if (isupper ((unsigned char) *name))
422	*name = tolower ((unsigned char) *name);
423      name++;
424    }
425  *search_arch_tail_ptr = new;
426  search_arch_tail_ptr = &new->next;
427
428}
429#endif
430
431/* Set the output architecture */
432void
433ldfile_set_output_arch (string)
434     CONST char *string;
435{
436  const bfd_arch_info_type *arch = bfd_scan_arch(string);
437
438  if (arch) {
439    ldfile_output_architecture = arch->arch;
440    ldfile_output_machine = arch->mach;
441    ldfile_output_machine_name = arch->printable_name;
442  }
443  else {
444    einfo(_("%P%F: cannot represent machine `%s'\n"), string);
445  }
446}
447