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