Remove long-obsolete MPW support.
[binutils.git] / ld / ldfile.c
bloba6f0d603dde45093ef30c84562c71e2a7a54c133
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 #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 */
62 typedef struct search_arch
64 char *name;
65 struct search_arch *next;
66 } search_arch_type;
68 static search_dirs_type **search_tail_ptr = &search_head;
69 static search_arch_type *search_arch_head;
70 static search_arch_type **search_arch_tail_ptr = &search_arch_head;
72 /* Test whether a pathname, after canonicalization, is the same or a
73 sub-directory of the sysroot directory. */
75 static bfd_boolean
76 is_sysrooted_pathname (const char *name, bfd_boolean notsame)
78 char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
79 int len;
80 bfd_boolean result;
82 if (! realname)
83 return FALSE;
85 len = strlen (realname);
87 if (((! notsame && len == ld_canon_sysroot_len)
88 || (len >= ld_canon_sysroot_len
89 && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])
90 && (realname[ld_canon_sysroot_len] = '\0') == '\0'))
91 && FILENAME_CMP (ld_canon_sysroot, realname) == 0)
92 result = TRUE;
93 else
94 result = FALSE;
96 if (realname)
97 free (realname);
99 return result;
102 /* Adds NAME to the library search path.
103 Makes a copy of NAME using xmalloc(). */
105 void
106 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
108 search_dirs_type *new;
110 if (!cmdline && config.only_cmd_line_lib_dirs)
111 return;
113 new = xmalloc (sizeof (search_dirs_type));
114 new->next = NULL;
115 new->cmdline = cmdline;
116 *search_tail_ptr = new;
117 search_tail_ptr = &new->next;
119 /* If a directory is marked as honoring sysroot, prepend the sysroot path
120 now. */
121 if (name[0] == '=')
123 new->name = concat (ld_sysroot, name + 1, NULL);
124 new->sysrooted = TRUE;
126 else
128 new->name = xstrdup (name);
129 new->sysrooted = is_sysrooted_pathname (name, FALSE);
133 /* Try to open a BFD for a lang_input_statement. */
135 bfd_boolean
136 ldfile_try_open_bfd (const char *attempt,
137 lang_input_statement_type *entry)
139 entry->the_bfd = bfd_openr (attempt, entry->target);
141 if (trace_file_tries)
143 if (entry->the_bfd == NULL)
144 info_msg (_("attempt to open %s failed\n"), attempt);
145 else
146 info_msg (_("attempt to open %s succeeded\n"), attempt);
149 if (entry->the_bfd == NULL)
151 if (bfd_get_error () == bfd_error_invalid_target)
152 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
153 return FALSE;
156 /* If we are searching for this file, see if the architecture is
157 compatible with the output file. If it isn't, keep searching.
158 If we can't open the file as an object file, stop the search
159 here. */
161 if (entry->search_dirs_flag)
163 bfd *check;
165 if (bfd_check_format (entry->the_bfd, bfd_archive))
166 check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
167 else
168 check = entry->the_bfd;
170 if (check != NULL)
172 if (! bfd_check_format (check, bfd_object))
174 if (check == entry->the_bfd
175 && bfd_get_error () == bfd_error_file_not_recognized
176 && ! ldemul_unrecognized_file (entry))
178 int token, skip = 0;
179 char *arg, *arg1, *arg2, *arg3;
180 extern FILE *yyin;
182 /* Try to interpret the file as a linker script. */
183 ldfile_open_command_file (attempt);
185 ldfile_assumed_script = TRUE;
186 parser_input = input_selected;
187 ldlex_both ();
188 token = INPUT_SCRIPT;
189 while (token != 0)
191 switch (token)
193 case OUTPUT_FORMAT:
194 if ((token = yylex ()) != '(')
195 continue;
196 if ((token = yylex ()) != NAME)
197 continue;
198 arg1 = yylval.name;
199 arg2 = NULL;
200 arg3 = NULL;
201 token = yylex ();
202 if (token == ',')
204 if ((token = yylex ()) != NAME)
206 free (arg1);
207 continue;
209 arg2 = yylval.name;
210 if ((token = yylex ()) != ','
211 || (token = yylex ()) != NAME)
213 free (arg1);
214 free (arg2);
215 continue;
217 arg3 = yylval.name;
218 token = yylex ();
220 if (token == ')')
222 switch (command_line.endian)
224 default:
225 case ENDIAN_UNSET:
226 arg = arg1; break;
227 case ENDIAN_BIG:
228 arg = arg2 ? arg2 : arg1; break;
229 case ENDIAN_LITTLE:
230 arg = arg3 ? arg3 : arg1; break;
232 if (strcmp (arg, lang_get_output_target ()) != 0)
233 skip = 1;
235 free (arg1);
236 if (arg2) free (arg2);
237 if (arg3) free (arg3);
238 break;
239 case NAME:
240 case LNAME:
241 case VERS_IDENTIFIER:
242 case VERS_TAG:
243 free (yylval.name);
244 break;
245 case INT:
246 if (yylval.bigint.str)
247 free (yylval.bigint.str);
248 break;
250 token = yylex ();
252 ldlex_popstate ();
253 ldfile_assumed_script = FALSE;
254 fclose (yyin);
255 yyin = NULL;
256 if (skip)
258 einfo (_("%P: skipping incompatible %s when searching for %s\n"),
259 attempt, entry->local_sym_name);
260 bfd_close (entry->the_bfd);
261 entry->the_bfd = NULL;
262 return FALSE;
265 return TRUE;
268 if ((bfd_arch_get_compatible (check, output_bfd,
269 command_line.accept_unknown_input_arch) == NULL)
270 /* XCOFF archives can have 32 and 64 bit objects. */
271 && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
272 && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
273 && bfd_check_format (entry->the_bfd, bfd_archive)))
275 einfo (_("%P: skipping incompatible %s when searching for %s\n"),
276 attempt, entry->local_sym_name);
277 bfd_close (entry->the_bfd);
278 entry->the_bfd = NULL;
279 return FALSE;
284 return TRUE;
287 /* Search for and open the file specified by ENTRY. If it is an
288 archive, use ARCH, LIB and SUFFIX to modify the file name. */
290 bfd_boolean
291 ldfile_open_file_search (const char *arch,
292 lang_input_statement_type *entry,
293 const char *lib,
294 const char *suffix)
296 search_dirs_type *search;
298 /* If this is not an archive, try to open it in the current
299 directory first. */
300 if (! entry->is_archive)
302 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
304 char *name = concat (ld_sysroot, entry->filename,
305 (const char *) NULL);
306 if (ldfile_try_open_bfd (name, entry))
308 entry->filename = name;
309 return TRUE;
311 free (name);
313 else if (ldfile_try_open_bfd (entry->filename, entry))
315 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
316 && is_sysrooted_pathname (entry->filename, TRUE);
317 return TRUE;
320 if (IS_ABSOLUTE_PATH (entry->filename))
321 return FALSE;
324 for (search = search_head; search != NULL; search = search->next)
326 char *string;
328 if (entry->dynamic && ! link_info.relocatable)
330 if (ldemul_open_dynamic_archive (arch, search, entry))
332 entry->sysrooted = search->sysrooted;
333 return TRUE;
337 string = xmalloc (strlen (search->name)
338 + strlen (slash)
339 + strlen (lib)
340 + strlen (entry->filename)
341 + strlen (arch)
342 + strlen (suffix)
343 + 1);
345 if (entry->is_archive)
346 sprintf (string, "%s%s%s%s%s%s", search->name, slash,
347 lib, entry->filename, arch, suffix);
348 else
349 sprintf (string, "%s%s%s", search->name, slash, entry->filename);
351 if (ldfile_try_open_bfd (string, entry))
353 entry->filename = string;
354 entry->sysrooted = search->sysrooted;
355 return TRUE;
358 free (string);
361 return FALSE;
364 /* Open the input file specified by ENTRY. */
366 void
367 ldfile_open_file (lang_input_statement_type *entry)
369 if (entry->the_bfd != NULL)
370 return;
372 if (! entry->search_dirs_flag)
374 if (ldfile_try_open_bfd (entry->filename, entry))
375 return;
376 if (strcmp (entry->filename, entry->local_sym_name) != 0)
377 einfo (_("%F%P: %s (%s): No such file: %E\n"),
378 entry->filename, entry->local_sym_name);
379 else
380 einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
382 else
384 search_arch_type *arch;
385 bfd_boolean found = FALSE;
387 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
388 for (arch = search_arch_head; arch != NULL; arch = arch->next)
390 found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
391 if (found)
392 break;
393 #ifdef VMS
394 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
395 if (found)
396 break;
397 #endif
398 found = ldemul_find_potential_libraries (arch->name, entry);
399 if (found)
400 break;
403 /* If we have found the file, we don't need to search directories
404 again. */
405 if (found)
406 entry->search_dirs_flag = FALSE;
407 else if (entry->sysrooted
408 && ld_sysroot
409 && IS_ABSOLUTE_PATH (entry->local_sym_name))
410 einfo (_("%F%P: cannot find %s inside %s\n"),
411 entry->local_sym_name, ld_sysroot);
412 else
413 einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
417 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */
419 static FILE *
420 try_open (const char *name, const char *exten)
422 FILE *result;
423 char buff[1000];
425 result = fopen (name, "r");
427 if (trace_file_tries)
429 if (result == NULL)
430 info_msg (_("cannot find script file %s\n"), name);
431 else
432 info_msg (_("opened script file %s\n"), name);
435 if (result != NULL)
436 return result;
438 if (*exten)
440 sprintf (buff, "%s%s", name, exten);
441 result = fopen (buff, "r");
443 if (trace_file_tries)
445 if (result == NULL)
446 info_msg (_("cannot find script file %s\n"), buff);
447 else
448 info_msg (_("opened script file %s\n"), buff);
452 return result;
455 /* Try to open NAME; if that fails, look for it in any directories
456 specified with -L, without and with EXTEND appended. */
458 FILE *
459 ldfile_find_command_file (const char *name, const char *extend)
461 search_dirs_type *search;
462 FILE *result;
463 char buffer[1000];
465 /* First try raw name. */
466 result = try_open (name, "");
467 if (result == NULL)
469 /* Try now prefixes. */
470 for (search = search_head; search != NULL; search = search->next)
472 sprintf (buffer, "%s%s%s", search->name, slash, name);
474 result = try_open (buffer, extend);
475 if (result)
476 break;
480 return result;
483 void
484 ldfile_open_command_file (const char *name)
486 FILE *ldlex_input_stack;
487 ldlex_input_stack = ldfile_find_command_file (name, "");
489 if (ldlex_input_stack == NULL)
491 bfd_set_error (bfd_error_system_call);
492 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
495 lex_push_file (ldlex_input_stack, name);
497 ldfile_input_filename = name;
498 lineno = 1;
500 saved_script_handle = ldlex_input_stack;
503 #ifdef GNU960
504 static char *
505 gnu960_map_archname (char *name)
507 struct tabentry { char *cmd_switch; char *arch; };
508 static struct tabentry arch_tab[] =
510 "", "",
511 "KA", "ka",
512 "KB", "kb",
513 "KC", "mc", /* Synonym for MC */
514 "MC", "mc",
515 "CA", "ca",
516 "SA", "ka", /* Functionally equivalent to KA */
517 "SB", "kb", /* Functionally equivalent to KB */
518 NULL, ""
520 struct tabentry *tp;
522 for (tp = arch_tab; tp->cmd_switch != NULL; tp++)
524 if (! strcmp (name,tp->cmd_switch))
525 break;
528 if (tp->cmd_switch == NULL)
529 einfo (_("%P%F: unknown architecture: %s\n"), name);
531 return tp->arch;
534 void
535 ldfile_add_arch (char *name)
537 search_arch_type *new = xmalloc (sizeof (search_arch_type));
539 if (*name != '\0')
541 if (ldfile_output_machine_name[0] != '\0')
543 einfo (_("%P%F: target architecture respecified\n"));
544 return;
547 ldfile_output_machine_name = name;
550 new->next = NULL;
551 new->name = gnu960_map_archname (name);
552 *search_arch_tail_ptr = new;
553 search_arch_tail_ptr = &new->next;
556 #else /* not GNU960 */
558 void
559 ldfile_add_arch (const char *in_name)
561 char *name = xstrdup (in_name);
562 search_arch_type *new = xmalloc (sizeof (search_arch_type));
564 ldfile_output_machine_name = in_name;
566 new->name = name;
567 new->next = NULL;
568 while (*name)
570 *name = TOLOWER (*name);
571 name++;
573 *search_arch_tail_ptr = new;
574 search_arch_tail_ptr = &new->next;
577 #endif
579 /* Set the output architecture. */
581 void
582 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
584 const bfd_arch_info_type *arch = bfd_scan_arch (string);
586 if (arch)
588 ldfile_output_architecture = arch->arch;
589 ldfile_output_machine = arch->mach;
590 ldfile_output_machine_name = arch->printable_name;
592 else if (defarch != bfd_arch_unknown)
593 ldfile_output_architecture = defarch;
594 else
595 einfo (_("%P%F: cannot represent machine `%s'\n"), string);