daily update
[binutils.git] / ld / ldfile.c
blob25d53e0358bcb76f059ab3d123ffd4ffee41583a
1 /* Linker file opening and searching.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 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"
38 #include "filenames.h"
40 const char * ldfile_input_filename;
41 bfd_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;
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
57 typedef struct search_arch
59 char *name;
60 struct search_arch *next;
61 } search_arch_type;
63 static search_dirs_type **search_tail_ptr = &search_head;
64 static search_arch_type *search_arch_head;
65 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
67 /* Test whether a pathname, after canonicalization, is the same or a
68 sub-directory of the sysroot directory. */
70 static bfd_boolean
71 is_sysrooted_pathname (const char *name, bfd_boolean notsame)
73 char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
74 int len;
75 bfd_boolean result;
77 if (! realname)
78 return FALSE;
80 len = strlen (realname);
82 if (((! notsame && len == ld_canon_sysroot_len)
83 || (len >= ld_canon_sysroot_len
84 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
85 && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
86 && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
87 result = TRUE;
88 else
89 result = FALSE;
91 if (realname)
92 free (realname);
94 return result;
97 /* Adds NAME to the library search path.
98 Makes a copy of NAME using xmalloc(). */
100 void
101 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
103 search_dirs_type *new;
105 if (!cmdline && config.only_cmd_line_lib_dirs)
106 return;
108 new = xmalloc (sizeof (search_dirs_type));
109 new->next = NULL;
110 new->cmdline = cmdline;
111 *search_tail_ptr = new;
112 search_tail_ptr = &new->next;
114 /* If a directory is marked as honoring sysroot, prepend the sysroot path
115 now. */
116 if (name[0] == '=')
118 new->name = concat (ld_sysroot, name + 1, NULL);
119 new->sysrooted = TRUE;
121 else
123 new->name = xstrdup (name);
124 new->sysrooted = is_sysrooted_pathname (name, FALSE);
128 /* Try to open a BFD for a lang_input_statement. */
130 bfd_boolean
131 ldfile_try_open_bfd (const char *attempt,
132 lang_input_statement_type *entry)
134 entry->the_bfd = bfd_openr (attempt, entry->target);
136 if (trace_file_tries)
138 if (entry->the_bfd == NULL)
139 info_msg (_("attempt to open %s failed\n"), attempt);
140 else
141 info_msg (_("attempt to open %s succeeded\n"), attempt);
144 if (entry->the_bfd == NULL)
146 if (bfd_get_error () == bfd_error_invalid_target)
147 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
148 return FALSE;
151 /* If we are searching for this file, see if the architecture is
152 compatible with the output file. If it isn't, keep searching.
153 If we can't open the file as an object file, stop the search
154 here. If we are statically linking, ensure that we don't link
155 a dynamic object. */
157 if (entry->search_dirs_flag || !entry->dynamic)
159 bfd *check;
161 if (bfd_check_format (entry->the_bfd, bfd_archive))
162 check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
163 else
164 check = entry->the_bfd;
166 if (check != NULL)
168 if (! bfd_check_format (check, bfd_object))
170 if (check == entry->the_bfd
171 && entry->search_dirs_flag
172 && bfd_get_error () == bfd_error_file_not_recognized
173 && ! ldemul_unrecognized_file (entry))
175 int token, skip = 0;
176 char *arg, *arg1, *arg2, *arg3;
177 extern FILE *yyin;
179 /* Try to interpret the file as a linker script. */
180 ldfile_open_command_file (attempt);
182 ldfile_assumed_script = TRUE;
183 parser_input = input_selected;
184 ldlex_both ();
185 token = INPUT_SCRIPT;
186 while (token != 0)
188 switch (token)
190 case OUTPUT_FORMAT:
191 if ((token = yylex ()) != '(')
192 continue;
193 if ((token = yylex ()) != NAME)
194 continue;
195 arg1 = yylval.name;
196 arg2 = NULL;
197 arg3 = NULL;
198 token = yylex ();
199 if (token == ',')
201 if ((token = yylex ()) != NAME)
203 free (arg1);
204 continue;
206 arg2 = yylval.name;
207 if ((token = yylex ()) != ','
208 || (token = yylex ()) != NAME)
210 free (arg1);
211 free (arg2);
212 continue;
214 arg3 = yylval.name;
215 token = yylex ();
217 if (token == ')')
219 switch (command_line.endian)
221 default:
222 case ENDIAN_UNSET:
223 arg = arg1; break;
224 case ENDIAN_BIG:
225 arg = arg2 ? arg2 : arg1; break;
226 case ENDIAN_LITTLE:
227 arg = arg3 ? arg3 : arg1; break;
229 if (strcmp (arg, lang_get_output_target ()) != 0)
230 skip = 1;
232 free (arg1);
233 if (arg2) free (arg2);
234 if (arg3) free (arg3);
235 break;
236 case NAME:
237 case LNAME:
238 case VERS_IDENTIFIER:
239 case VERS_TAG:
240 free (yylval.name);
241 break;
242 case INT:
243 if (yylval.bigint.str)
244 free (yylval.bigint.str);
245 break;
247 token = yylex ();
249 ldlex_popstate ();
250 ldfile_assumed_script = FALSE;
251 fclose (yyin);
252 yyin = NULL;
253 if (skip)
255 einfo (_("%P: skipping incompatible %s when searching for %s\n"),
256 attempt, entry->local_sym_name);
257 bfd_close (entry->the_bfd);
258 entry->the_bfd = NULL;
259 return FALSE;
262 return TRUE;
265 if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
267 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
268 attempt);
269 bfd_close (entry->the_bfd);
270 entry->the_bfd = NULL;
271 return FALSE;
274 if (entry->search_dirs_flag
275 && !bfd_arch_get_compatible (check, output_bfd,
276 command_line.accept_unknown_input_arch)
277 /* XCOFF archives can have 32 and 64 bit objects. */
278 && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
279 && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
280 && bfd_check_format (entry->the_bfd, bfd_archive)))
282 einfo (_("%P: skipping incompatible %s when searching for %s\n"),
283 attempt, entry->local_sym_name);
284 bfd_close (entry->the_bfd);
285 entry->the_bfd = NULL;
286 return FALSE;
291 return TRUE;
294 /* Search for and open the file specified by ENTRY. If it is an
295 archive, use ARCH, LIB and SUFFIX to modify the file name. */
297 bfd_boolean
298 ldfile_open_file_search (const char *arch,
299 lang_input_statement_type *entry,
300 const char *lib,
301 const char *suffix)
303 search_dirs_type *search;
305 /* If this is not an archive, try to open it in the current
306 directory first. */
307 if (! entry->is_archive)
309 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
311 char *name = concat (ld_sysroot, entry->filename,
312 (const char *) NULL);
313 if (ldfile_try_open_bfd (name, entry))
315 entry->filename = name;
316 return TRUE;
318 free (name);
320 else if (ldfile_try_open_bfd (entry->filename, entry))
322 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
323 && is_sysrooted_pathname (entry->filename, TRUE);
324 return TRUE;
327 if (IS_ABSOLUTE_PATH (entry->filename))
328 return FALSE;
331 for (search = search_head; search != NULL; search = search->next)
333 char *string;
335 if (entry->dynamic && ! link_info.relocatable)
337 if (ldemul_open_dynamic_archive (arch, search, entry))
339 entry->sysrooted = search->sysrooted;
340 return TRUE;
344 string = xmalloc (strlen (search->name)
345 + strlen (slash)
346 + strlen (lib)
347 + strlen (entry->filename)
348 + strlen (arch)
349 + strlen (suffix)
350 + 1);
352 if (entry->is_archive)
353 sprintf (string, "%s%s%s%s%s%s", search->name, slash,
354 lib, entry->filename, arch, suffix);
355 else
356 sprintf (string, "%s%s%s", search->name, slash, entry->filename);
358 if (ldfile_try_open_bfd (string, entry))
360 entry->filename = string;
361 entry->sysrooted = search->sysrooted;
362 return TRUE;
365 free (string);
368 return FALSE;
371 /* Open the input file specified by ENTRY. */
373 void
374 ldfile_open_file (lang_input_statement_type *entry)
376 if (entry->the_bfd != NULL)
377 return;
379 if (! entry->search_dirs_flag)
381 if (ldfile_try_open_bfd (entry->filename, entry))
382 return;
383 if (strcmp (entry->filename, entry->local_sym_name) != 0)
384 einfo (_("%F%P: %s (%s): No such file: %E\n"),
385 entry->filename, entry->local_sym_name);
386 else
387 einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
389 else
391 search_arch_type *arch;
392 bfd_boolean found = FALSE;
394 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
395 for (arch = search_arch_head; arch != NULL; arch = arch->next)
397 found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
398 if (found)
399 break;
400 #ifdef VMS
401 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
402 if (found)
403 break;
404 #endif
405 found = ldemul_find_potential_libraries (arch->name, entry);
406 if (found)
407 break;
410 /* If we have found the file, we don't need to search directories
411 again. */
412 if (found)
413 entry->search_dirs_flag = FALSE;
414 else if (entry->sysrooted
415 && ld_sysroot
416 && IS_ABSOLUTE_PATH (entry->local_sym_name))
417 einfo (_("%F%P: cannot find %s inside %s\n"),
418 entry->local_sym_name, ld_sysroot);
419 else
420 einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
424 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */
426 static FILE *
427 try_open (const char *name, const char *exten)
429 FILE *result;
430 char buff[1000];
432 result = fopen (name, "r");
434 if (trace_file_tries)
436 if (result == NULL)
437 info_msg (_("cannot find script file %s\n"), name);
438 else
439 info_msg (_("opened script file %s\n"), name);
442 if (result != NULL)
443 return result;
445 if (*exten)
447 sprintf (buff, "%s%s", name, exten);
448 result = fopen (buff, "r");
450 if (trace_file_tries)
452 if (result == NULL)
453 info_msg (_("cannot find script file %s\n"), buff);
454 else
455 info_msg (_("opened script file %s\n"), buff);
459 return result;
462 /* Try to open NAME; if that fails, look for it in any directories
463 specified with -L, without and with EXTEND appended. */
465 FILE *
466 ldfile_find_command_file (const char *name, const char *extend)
468 search_dirs_type *search;
469 FILE *result;
470 char buffer[1000];
472 /* First try raw name. */
473 result = try_open (name, "");
474 if (result == NULL)
476 /* Try now prefixes. */
477 for (search = search_head; search != NULL; search = search->next)
479 sprintf (buffer, "%s%s%s", search->name, slash, name);
481 result = try_open (buffer, extend);
482 if (result)
483 break;
487 return result;
490 void
491 ldfile_open_command_file (const char *name)
493 FILE *ldlex_input_stack;
494 ldlex_input_stack = ldfile_find_command_file (name, "");
496 if (ldlex_input_stack == NULL)
498 bfd_set_error (bfd_error_system_call);
499 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
502 lex_push_file (ldlex_input_stack, name);
504 ldfile_input_filename = name;
505 lineno = 1;
507 saved_script_handle = ldlex_input_stack;
510 #ifdef GNU960
511 static char *
512 gnu960_map_archname (char *name)
514 struct tabentry { char *cmd_switch; char *arch; };
515 static struct tabentry arch_tab[] =
517 "", "",
518 "KA", "ka",
519 "KB", "kb",
520 "KC", "mc", /* Synonym for MC */
521 "MC", "mc",
522 "CA", "ca",
523 "SA", "ka", /* Functionally equivalent to KA */
524 "SB", "kb", /* Functionally equivalent to KB */
525 NULL, ""
527 struct tabentry *tp;
529 for (tp = arch_tab; tp->cmd_switch != NULL; tp++)
531 if (! strcmp (name,tp->cmd_switch))
532 break;
535 if (tp->cmd_switch == NULL)
536 einfo (_("%P%F: unknown architecture: %s\n"), name);
538 return tp->arch;
541 void
542 ldfile_add_arch (char *name)
544 search_arch_type *new = xmalloc (sizeof (search_arch_type));
546 if (*name != '\0')
548 if (ldfile_output_machine_name[0] != '\0')
550 einfo (_("%P%F: target architecture respecified\n"));
551 return;
554 ldfile_output_machine_name = name;
557 new->next = NULL;
558 new->name = gnu960_map_archname (name);
559 *search_arch_tail_ptr = new;
560 search_arch_tail_ptr = &new->next;
563 #else /* not GNU960 */
565 void
566 ldfile_add_arch (const char *in_name)
568 char *name = xstrdup (in_name);
569 search_arch_type *new = xmalloc (sizeof (search_arch_type));
571 ldfile_output_machine_name = in_name;
573 new->name = name;
574 new->next = NULL;
575 while (*name)
577 *name = TOLOWER (*name);
578 name++;
580 *search_arch_tail_ptr = new;
581 search_arch_tail_ptr = &new->next;
584 #endif
586 /* Set the output architecture. */
588 void
589 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
591 const bfd_arch_info_type *arch = bfd_scan_arch (string);
593 if (arch)
595 ldfile_output_architecture = arch->arch;
596 ldfile_output_machine = arch->mach;
597 ldfile_output_machine_name = arch->printable_name;
599 else if (defarch != bfd_arch_unknown)
600 ldfile_output_architecture = defarch;
601 else
602 einfo (_("%P%F: cannot represent machine `%s'\n"), string);