daily update
[binutils.git] / ld / ldfile.c
blob813d55edafd1dd703cd83fef0907b71a45af0919
1 /* Linker file opening and searching.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GLD, the Gnu Linker.
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.
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.
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. */
22 /* ldfile.c: look after all the file stuff. */
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"
39 const char *ldfile_input_filename;
40 boolean ldfile_assumed_script = false;
41 const char *ldfile_output_machine_name = "";
42 unsigned long ldfile_output_machine;
43 enum bfd_architecture ldfile_output_architecture;
44 search_dirs_type *search_head;
46 #ifndef MPW
47 #ifdef VMS
48 char *slash = "";
49 #else
50 #if defined (_WIN32) && ! defined (__CYGWIN32__)
51 char *slash = "\\";
52 #else
53 char *slash = "/";
54 #endif
55 #endif
56 #else /* MPW */
57 /* The MPW path char is a colon. */
58 char *slash = ":";
59 #endif /* MPW */
61 /* LOCAL */
63 static search_dirs_type **search_tail_ptr = &search_head;
65 typedef struct search_arch {
66 char *name;
67 struct search_arch *next;
68 } search_arch_type;
70 static search_arch_type *search_arch_head;
71 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
73 static FILE *try_open PARAMS ((const char *name, const char *exten));
75 void
76 ldfile_add_library_path (name, cmdline)
77 const char *name;
78 boolean cmdline;
80 search_dirs_type *new;
82 if (!cmdline && config.only_cmd_line_lib_dirs)
83 return;
85 new = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
86 new->next = NULL;
87 new->name = name;
88 new->cmdline = cmdline;
89 *search_tail_ptr = new;
90 search_tail_ptr = &new->next;
93 /* Try to open a BFD for a lang_input_statement. */
95 boolean
96 ldfile_try_open_bfd (attempt, entry)
97 const char *attempt;
98 lang_input_statement_type *entry;
100 entry->the_bfd = bfd_openr (attempt, entry->target);
102 if (trace_file_tries)
104 if (entry->the_bfd == NULL)
105 info_msg (_("attempt to open %s failed\n"), attempt);
106 else
107 info_msg (_("attempt to open %s succeeded\n"), attempt);
110 if (entry->the_bfd == NULL)
112 if (bfd_get_error () == bfd_error_invalid_target)
113 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
114 return false;
117 /* If we are searching for this file, see if the architecture is
118 compatible with the output file. If it isn't, keep searching.
119 If we can't open the file as an object file, stop the search
120 here. */
122 if (entry->search_dirs_flag)
124 bfd *check;
126 if (bfd_check_format (entry->the_bfd, bfd_archive))
127 check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
128 else
129 check = entry->the_bfd;
131 if (check != NULL)
133 if (! bfd_check_format (check, bfd_object))
135 if (check == entry->the_bfd
136 && bfd_get_error () == bfd_error_file_not_recognized
137 && ! ldemul_unrecognized_file (entry))
139 int token, skip = 0;
140 char *arg, *arg1, *arg2, *arg3;
141 extern FILE *yyin;
143 /* Try to interpret the file as a linker script. */
144 ldfile_open_command_file (attempt);
146 ldfile_assumed_script = true;
147 parser_input = input_selected;
148 ldlex_both ();
149 token = INPUT_SCRIPT;
150 while (token != 0)
152 switch (token)
154 case OUTPUT_FORMAT:
155 if ((token = yylex ()) != '(')
156 continue;
157 if ((token = yylex ()) != NAME)
158 continue;
159 arg1 = yylval.name;
160 arg2 = NULL;
161 arg3 = NULL;
162 token = yylex ();
163 if (token == ',')
165 if ((token = yylex ()) != NAME)
167 free (arg1);
168 continue;
170 arg2 = yylval.name;
171 if ((token = yylex ()) != ','
172 || (token = yylex ()) != NAME)
174 free (arg1);
175 free (arg2);
176 continue;
178 arg3 = yylval.name;
179 token = yylex ();
181 if (token == ')')
183 switch (command_line.endian)
185 default:
186 case ENDIAN_UNSET:
187 arg = arg1; break;
188 case ENDIAN_BIG:
189 arg = arg2 ? arg2 : arg1; break;
190 case ENDIAN_LITTLE:
191 arg = arg3 ? arg3 : arg1; break;
193 if (strcmp (arg, lang_get_output_target ()) != 0)
194 skip = 1;
196 free (arg1);
197 if (arg2) free (arg2);
198 if (arg3) free (arg3);
199 break;
200 case NAME:
201 case LNAME:
202 case VERS_IDENTIFIER:
203 case VERS_TAG:
204 free (yylval.name);
205 break;
206 case INT:
207 if (yylval.bigint.str)
208 free (yylval.bigint.str);
209 break;
211 token = yylex ();
213 ldfile_assumed_script = false;
214 fclose (yyin);
215 yyin = NULL;
216 if (skip)
218 einfo (_("%P: skipping incompatible %s when searching for %s\n"),
219 attempt, entry->local_sym_name);
220 bfd_close (entry->the_bfd);
221 entry->the_bfd = NULL;
222 return false;
225 return true;
228 if ((bfd_arch_get_compatible (check, output_bfd) == NULL)
229 /* XCOFF archives can have 32 and 64 bit objects */
230 && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
231 && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
232 && bfd_check_format (entry->the_bfd, bfd_archive)))
234 einfo (_("%P: skipping incompatible %s when searching for %s\n"),
235 attempt, entry->local_sym_name);
236 bfd_close (entry->the_bfd);
237 entry->the_bfd = NULL;
238 return false;
243 return true;
246 /* Search for and open the file specified by ENTRY. If it is an
247 archive, use ARCH, LIB and SUFFIX to modify the file name. */
249 boolean
250 ldfile_open_file_search (arch, entry, lib, suffix)
251 const char *arch;
252 lang_input_statement_type *entry;
253 const char *lib;
254 const char *suffix;
256 search_dirs_type *search;
258 /* If this is not an archive, try to open it in the current
259 directory first. */
260 if (! entry->is_archive)
262 if (ldfile_try_open_bfd (entry->filename, entry))
263 return true;
266 for (search = search_head;
267 search != (search_dirs_type *) NULL;
268 search = search->next)
270 char *string;
272 if (entry->dynamic && ! link_info.relocateable)
274 if (ldemul_open_dynamic_archive (arch, search, entry))
275 return true;
278 string = (char *) xmalloc (strlen (search->name)
279 + strlen (slash)
280 + strlen (lib)
281 + strlen (entry->filename)
282 + strlen (arch)
283 + strlen (suffix)
284 + 1);
286 if (entry->is_archive)
287 sprintf (string, "%s%s%s%s%s%s", search->name, slash,
288 lib, entry->filename, arch, suffix);
289 else if (entry->filename[0] == '/' || entry->filename[0] == '.'
290 #if defined (__MSDOS__) || defined (_WIN32)
291 || entry->filename[0] == '\\'
292 || (ISALPHA (entry->filename[0])
293 && entry->filename[1] == ':')
294 #endif
296 strcpy (string, entry->filename);
297 else
298 sprintf (string, "%s%s%s", search->name, slash, entry->filename);
300 if (ldfile_try_open_bfd (string, entry))
302 entry->filename = string;
303 return true;
306 free (string);
309 return false;
312 /* Open the input file specified by ENTRY. */
314 void
315 ldfile_open_file (entry)
316 lang_input_statement_type *entry;
318 if (entry->the_bfd != NULL)
319 return;
321 if (! entry->search_dirs_flag)
323 if (ldfile_try_open_bfd (entry->filename, entry))
324 return;
325 if (strcmp (entry->filename, entry->local_sym_name) != 0)
326 einfo (_("%F%P: cannot open %s for %s: %E\n"),
327 entry->filename, entry->local_sym_name);
328 else
329 einfo (_("%F%P: cannot open %s: %E\n"), entry->local_sym_name);
331 else
333 search_arch_type *arch;
334 boolean found = false;
336 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
337 for (arch = search_arch_head;
338 arch != (search_arch_type *) NULL;
339 arch = arch->next)
341 found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
342 if (found)
343 break;
344 #ifdef VMS
345 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
346 if (found)
347 break;
348 #endif
349 found = ldemul_find_potential_libraries (arch->name, entry);
350 if (found)
351 break;
354 /* If we have found the file, we don't need to search directories
355 again. */
356 if (found)
357 entry->search_dirs_flag = false;
358 else
359 einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
363 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */
365 static FILE *
366 try_open (name, exten)
367 const char *name;
368 const char *exten;
370 FILE *result;
371 char buff[1000];
373 result = fopen (name, "r");
375 if (trace_file_tries)
377 if (result == NULL)
378 info_msg (_("cannot find script file %s\n"), name);
379 else
380 info_msg (_("opened script file %s\n"), name);
383 if (result != NULL)
384 return result;
386 if (*exten)
388 sprintf (buff, "%s%s", name, exten);
389 result = fopen (buff, "r");
391 if (trace_file_tries)
393 if (result == NULL)
394 info_msg (_("cannot find script file %s\n"), buff);
395 else
396 info_msg (_("opened script file %s\n"), buff);
400 return result;
403 /* Try to open NAME; if that fails, look for it in any directories
404 specified with -L, without and with EXTEND apppended. */
406 FILE *
407 ldfile_find_command_file (name, extend)
408 const char *name;
409 const char *extend;
411 search_dirs_type *search;
412 FILE *result;
413 char buffer[1000];
415 /* First try raw name. */
416 result = try_open (name, "");
417 if (result == (FILE *) NULL)
419 /* Try now prefixes. */
420 for (search = search_head;
421 search != (search_dirs_type *) NULL;
422 search = search->next)
424 sprintf (buffer, "%s%s%s", search->name, slash, name);
426 result = try_open (buffer, extend);
427 if (result)
428 break;
432 return result;
435 void
436 ldfile_open_command_file (name)
437 const char *name;
439 FILE *ldlex_input_stack;
440 ldlex_input_stack = ldfile_find_command_file (name, "");
442 if (ldlex_input_stack == (FILE *) NULL)
444 bfd_set_error (bfd_error_system_call);
445 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
448 lex_push_file (ldlex_input_stack, name);
450 ldfile_input_filename = name;
451 lineno = 1;
453 saved_script_handle = ldlex_input_stack;
456 #ifdef GNU960
457 static char *
458 gnu960_map_archname (name)
459 char *name;
461 struct tabentry { char *cmd_switch; char *arch; };
462 static struct tabentry arch_tab[] =
464 "", "",
465 "KA", "ka",
466 "KB", "kb",
467 "KC", "mc", /* Synonym for MC */
468 "MC", "mc",
469 "CA", "ca",
470 "SA", "ka", /* Functionally equivalent to KA */
471 "SB", "kb", /* Functionally equivalent to KB */
472 NULL, ""
474 struct tabentry *tp;
476 for (tp = arch_tab; tp->cmd_switch != NULL; tp++)
478 if (! strcmp (name,tp->cmd_switch))
479 break;
482 if (tp->cmd_switch == NULL)
483 einfo (_("%P%F: unknown architecture: %s\n"), name);
485 return tp->arch;
488 void
489 ldfile_add_arch (name)
490 char *name;
492 search_arch_type *new =
493 (search_arch_type *) xmalloc ((bfd_size_type) (sizeof (search_arch_type)));
495 if (*name != '\0')
497 if (ldfile_output_machine_name[0] != '\0')
499 einfo (_("%P%F: target architecture respecified\n"));
500 return;
503 ldfile_output_machine_name = name;
506 new->next = (search_arch_type *) NULL;
507 new->name = gnu960_map_archname (name);
508 *search_arch_tail_ptr = new;
509 search_arch_tail_ptr = &new->next;
512 #else /* not GNU960 */
514 void
515 ldfile_add_arch (in_name)
516 const char *in_name;
518 char *name = xstrdup (in_name);
519 search_arch_type *new =
520 (search_arch_type *) xmalloc (sizeof (search_arch_type));
522 ldfile_output_machine_name = in_name;
524 new->name = name;
525 new->next = (search_arch_type *) NULL;
526 while (*name)
528 *name = TOLOWER (*name);
529 name++;
531 *search_arch_tail_ptr = new;
532 search_arch_tail_ptr = &new->next;
535 #endif
537 /* Set the output architecture. */
539 void
540 ldfile_set_output_arch (string)
541 const char *string;
543 const bfd_arch_info_type *arch = bfd_scan_arch (string);
545 if (arch)
547 ldfile_output_architecture = arch->arch;
548 ldfile_output_machine = arch->mach;
549 ldfile_output_machine_name = arch->printable_name;
551 else
553 einfo (_("%P%F: cannot represent machine `%s'\n"), string);