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