* ldemul.h (ldemul_open_dynamic_archive): Add search parameter to
[external/binutils.git] / ld / ldfile.c
1 /* Copyright (C) 1991, 92, 93, 94 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 1, 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
17 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
18
19 /*
20  ldfile.c
21
22  look after all the file stuff
23
24  */
25
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "bfdlink.h"
29 #include "ld.h"
30 #include "ldmisc.h"
31 #include "ldexp.h"
32 #include "ldlang.h"
33 #include "ldfile.h"
34 #include "ldmain.h"
35 #include "ldgram.h"
36 #include "ldlex.h"
37 #include "ldemul.h"
38
39 #include <ctype.h>
40
41 const char *ldfile_input_filename;
42 boolean ldfile_assumed_script = false;
43 const char *ldfile_output_machine_name = "";
44 unsigned long ldfile_output_machine;
45 enum bfd_architecture ldfile_output_architecture;
46 search_dirs_type *search_head;
47
48 #ifndef MPW
49 #ifdef VMS
50 char *slash = "";
51 #else
52 char *slash = "/";
53 #endif
54 #else /* MPW */
55 /* The MPW path char is a colon. */
56 char *slash = ":";
57 #endif /* MPW */
58
59 /* LOCAL */
60
61 static search_dirs_type **search_tail_ptr = &search_head;
62
63 typedef struct search_arch 
64 {
65   char *name; 
66   struct search_arch *next;
67 } search_arch_type;
68
69 static search_arch_type *search_arch_head;
70 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
71  
72 static boolean ldfile_open_file_search
73   PARAMS ((const char *arch, lang_input_statement_type *,
74            const char *lib, const char *suffix));
75 static FILE *try_open PARAMS ((const char *name, const char *exten));
76
77 void
78 ldfile_add_library_path (name, cmdline)
79      const char *name;
80      boolean cmdline;
81 {
82   search_dirs_type *new;
83
84   new = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
85   new->next = NULL;
86   new->name = name;
87   new->cmdline = cmdline;
88   *search_tail_ptr = new;
89   search_tail_ptr = &new->next;
90 }
91
92 /* Try to open a BFD for a lang_input_statement.  */
93
94 boolean
95 ldfile_try_open_bfd (attempt, entry)
96      const char *attempt;
97      lang_input_statement_type *entry;
98 {
99   entry->the_bfd = bfd_openr (attempt, entry->target);
100
101   if (trace_file_tries)
102     info_msg ("attempt to open %s %s\n", attempt,
103               entry->the_bfd == NULL ? "failed" : "succeeded");
104
105   if (entry->the_bfd != NULL)
106     return true;
107   else
108     return false;
109 }
110
111 /* Search for and open the file specified by ENTRY.  If it is an
112    archive, use ARCH, LIB and SUFFIX to modify the file name.  */
113
114 static boolean
115 ldfile_open_file_search (arch, entry, lib, suffix)
116      const char *arch;
117      lang_input_statement_type *entry;
118      const char *lib;
119      const char *suffix;
120 {
121   search_dirs_type *search;
122
123   /* If this is not an archive, try to open it in the current
124      directory first.  */
125   if (! entry->is_archive)
126     {
127       if (ldfile_try_open_bfd (entry->filename, entry))
128         return true;
129     }
130
131   for (search = search_head;
132        search != (search_dirs_type *)NULL;
133        search = search->next) 
134     {
135       char *string;
136
137       if (entry->dynamic && ! link_info.relocateable)
138         {
139           if (ldemul_open_dynamic_archive (arch, search, entry))
140             return true;
141         }
142
143       string = (char *) xmalloc (strlen (search->name)
144                                  + strlen (slash)
145                                  + strlen (lib)
146                                  + strlen (entry->filename)
147                                  + strlen (arch)
148                                  + strlen (suffix)
149                                  + 1);
150
151       if (entry->is_archive)
152         sprintf (string, "%s%s%s%s%s%s", search->name, slash,
153                  lib, entry->filename, arch, suffix);
154       else if (entry->filename[0] == '/' || entry->filename[0] == '.')
155         strcpy (string, entry->filename);
156       else
157         sprintf (string, "%s%s%s", search->name, slash, entry->filename);
158
159       if (ldfile_try_open_bfd (string, entry))
160         {
161           entry->filename = string;
162           return true;
163         }
164
165       free (string);
166     }
167
168   return false;
169 }
170
171 /* Open the input file specified by ENTRY.  */
172
173 void
174 ldfile_open_file (entry)
175      lang_input_statement_type *entry;
176 {
177   if (entry->the_bfd != NULL)
178     return;
179
180   if (! entry->search_dirs_flag)
181     {
182       if (ldfile_try_open_bfd (entry->filename, entry))
183         return;
184     }
185   else
186     {
187       search_arch_type *arch;
188
189       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
190       for (arch = search_arch_head;
191            arch != (search_arch_type *) NULL;
192            arch = arch->next)
193         {
194           if (ldfile_open_file_search (arch->name, entry, "lib", ".a"))
195             return;
196 #ifdef VMS
197           if (ldfile_open_file_search (arch->name, entry, ":lib", ".a"))
198             return;
199 #endif
200         }
201     }
202
203   einfo("%F%P: cannot open %s: %E\n", entry->local_sym_name);
204 }
205
206 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
207
208 static FILE *
209 try_open (name, exten)
210      const char *name;
211      const char *exten;
212 {
213   FILE *result;
214   char buff[1000];
215
216   result = fopen (name, "r");
217   if (trace_file_tries)
218     {
219       if (result == NULL)
220         info_msg ("cannot find script file ");
221       else
222         info_msg ("opened script file ");
223       info_msg ("%s\n",name);
224     }
225
226   if (result != NULL)
227     return result;
228
229   if (*exten)
230     {
231       sprintf (buff, "%s%s", name, exten);
232       result = fopen (buff, "r");
233       if (trace_file_tries)
234         {
235           if (result == NULL)
236             info_msg ("cannot find script file ");
237           else
238             info_msg ("opened script file ");
239           info_msg ("%s\n", buff);
240         }
241     }
242
243   return result;
244 }
245
246 /* Try to open NAME; if that fails, look for it in any directories
247    specified with -L, without and with EXTEND apppended.  */
248
249 FILE *
250 ldfile_find_command_file (name, extend)
251      const char *name;
252      const char *extend;
253 {
254   search_dirs_type *search;
255   FILE *result;
256   char buffer[1000];
257
258   /* First try raw name */
259   result = try_open(name,"");
260   if (result == (FILE *)NULL) {
261     /* Try now prefixes */
262     for (search = search_head;
263          search != (search_dirs_type *)NULL;
264          search = search->next) {
265       sprintf(buffer,"%s/%s", search->name, name);
266       result = try_open(buffer, extend);
267       if (result)break;
268     }
269   }
270   return result;
271 }
272
273 void
274 ldfile_open_command_file (name)
275      const char *name;
276 {
277   FILE *ldlex_input_stack;
278   ldlex_input_stack = ldfile_find_command_file(name, "");
279
280   if (ldlex_input_stack == (FILE *)NULL) {
281     bfd_set_error (bfd_error_system_call);
282     einfo("%P%F: cannot open linker script file %s: %E\n",name);
283   }
284   lex_push_file(ldlex_input_stack, name);
285   
286   ldfile_input_filename = name;
287   lineno = 1;
288   had_script = true;
289 }
290
291
292
293
294
295 #ifdef GNU960
296 static
297 char *
298 gnu960_map_archname( name )
299 char *name;
300 {
301   struct tabentry { char *cmd_switch; char *arch; };
302   static struct tabentry arch_tab[] = {
303         "",   "",
304         "KA", "ka",
305         "KB", "kb",
306         "KC", "mc",     /* Synonym for MC */
307         "MC", "mc",
308         "CA", "ca",
309         "SA", "ka",     /* Functionally equivalent to KA */
310         "SB", "kb",     /* Functionally equivalent to KB */
311         NULL, ""
312   };
313   struct tabentry *tp;
314   
315
316   for ( tp = arch_tab; tp->cmd_switch != NULL; tp++ ){
317     if ( !strcmp(name,tp->cmd_switch) ){
318       break;
319     }
320   }
321
322   if ( tp->cmd_switch == NULL ){
323     einfo("%P%F: unknown architecture: %s\n",name);
324   }
325   return tp->arch;
326 }
327
328
329
330 void
331 ldfile_add_arch(name)
332 char *name;
333 {
334   search_arch_type *new =
335     (search_arch_type *)xmalloc((bfd_size_type)(sizeof(search_arch_type)));
336
337
338   if (*name != '\0') {
339     if (ldfile_output_machine_name[0] != '\0') {
340       einfo("%P%F: target architecture respecified\n");
341       return;
342     }
343     ldfile_output_machine_name = name;
344   }
345
346   new->next = (search_arch_type*)NULL;
347   new->name = gnu960_map_archname( name );
348   *search_arch_tail_ptr = new;
349   search_arch_tail_ptr = &new->next;
350
351 }
352
353 #else   /* not GNU960 */
354
355
356 void
357 ldfile_add_arch (in_name)
358      CONST char * in_name;
359 {
360   char *name = buystring(in_name);
361   search_arch_type *new =
362     (search_arch_type *)xmalloc((bfd_size_type)(sizeof(search_arch_type)));
363
364   ldfile_output_machine_name = in_name;
365
366   new->name = name;
367   new->next = (search_arch_type*)NULL;
368   while (*name) {
369     if (isupper(*name)) *name = tolower(*name);
370     name++;
371   }
372   *search_arch_tail_ptr = new;
373   search_arch_tail_ptr = &new->next;
374
375 }
376 #endif
377
378 /* Set the output architecture */
379 void
380 ldfile_set_output_arch (string)
381      CONST char *string;
382 {
383   bfd_arch_info_type *arch = bfd_scan_arch(string);
384
385   if (arch) {
386     ldfile_output_architecture = arch->arch;
387     ldfile_output_machine = arch->mach;
388     ldfile_output_machine_name = arch->printable_name;
389   }
390   else {
391     einfo("%P%F: cannot represent machine `%s'\n", string);
392   }
393 }