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.
4
5 This file is part of GLD, the Gnu Linker.
6
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.
11
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.
16
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. */
21
22 /* ldfile.c: look after all the file stuff. */
23
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"
39
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;
46
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 */
61
62 typedef struct search_arch
63 {
64 char *name;
65 struct search_arch *next;
66 } search_arch_type;
67
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;
71
72 /* Test whether a pathname, after canonicalization, is the same or a
73 sub-directory of the sysroot directory. */
74
75 static bfd_boolean
is_sysrooted_pathname(const char * name,bfd_boolean notsame)76 is_sysrooted_pathname (const char *name, bfd_boolean notsame)
77 {
78 char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
79 int len;
80 bfd_boolean result;
81
82 if (! realname)
83 return FALSE;
84
85 len = strlen (realname);
86
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;
95
96 if (realname)
97 free (realname);
98
99 return result;
100 }
101
102 /* Adds NAME to the library search path.
103 Makes a copy of NAME using xmalloc(). */
104
105 void
ldfile_add_library_path(const char * name,bfd_boolean cmdline)106 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
107 {
108 search_dirs_type *new;
109
110 if (!cmdline && config.only_cmd_line_lib_dirs)
111 return;
112
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;
118
119 /* If a directory is marked as honoring sysroot, prepend the sysroot path
120 now. */
121 if (name[0] == '=')
122 {
123 new->name = concat (ld_sysroot, name + 1, NULL);
124 new->sysrooted = TRUE;
125 }
126 else
127 {
128 new->name = xstrdup (name);
129 new->sysrooted = is_sysrooted_pathname (name, FALSE);
130 }
131 }
132
133 /* Try to open a BFD for a lang_input_statement. */
134
135 bfd_boolean
ldfile_try_open_bfd(const char * attempt,lang_input_statement_type * entry)136 ldfile_try_open_bfd (const char *attempt,
137 lang_input_statement_type *entry)
138 {
139 entry->the_bfd = bfd_openr (attempt, entry->target);
140
141 if (trace_file_tries)
142 {
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);
147 }
148
149 if (entry->the_bfd == NULL)
150 {
151 if (bfd_get_error () == bfd_error_invalid_target)
152 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
153 return FALSE;
154 }
155
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. */
160
161 if (entry->search_dirs_flag)
162 {
163 bfd *check;
164
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;
169
170 if (check != NULL)
171 {
172 if (! bfd_check_format (check, bfd_object))
173 {
174 if (check == entry->the_bfd
175 && bfd_get_error () == bfd_error_file_not_recognized
176 && ! ldemul_unrecognized_file (entry))
177 {
178 int token, skip = 0;
179 char *arg, *arg1, *arg2, *arg3;
180 extern FILE *yyin;
181
182 /* Try to interpret the file as a linker script. */
183 ldfile_open_command_file (attempt);
184
185 ldfile_assumed_script = TRUE;
186 parser_input = input_selected;
187 ldlex_both ();
188 token = INPUT_SCRIPT;
189 while (token != 0)
190 {
191 switch (token)
192 {
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 == ',')
203 {
204 if ((token = yylex ()) != NAME)
205 {
206 free (arg1);
207 continue;
208 }
209 arg2 = yylval.name;
210 if ((token = yylex ()) != ','
211 || (token = yylex ()) != NAME)
212 {
213 free (arg1);
214 free (arg2);
215 continue;
216 }
217 arg3 = yylval.name;
218 token = yylex ();
219 }
220 if (token == ')')
221 {
222 switch (command_line.endian)
223 {
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;
231 }
232 if (strcmp (arg, lang_get_output_target ()) != 0)
233 skip = 1;
234 }
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;
249 }
250 token = yylex ();
251 }
252 ldlex_popstate ();
253 ldfile_assumed_script = FALSE;
254 fclose (yyin);
255 yyin = NULL;
256 if (skip)
257 {
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;
263 }
264 }
265 return TRUE;
266 }
267
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)))
274 {
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;
280 }
281 }
282 }
283
284 return TRUE;
285 }
286
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. */
289
290 bfd_boolean
ldfile_open_file_search(const char * arch,lang_input_statement_type * entry,const char * lib,const char * suffix)291 ldfile_open_file_search (const char *arch,
292 lang_input_statement_type *entry,
293 const char *lib,
294 const char *suffix)
295 {
296 search_dirs_type *search;
297
298 /* If this is not an archive, try to open it in the current
299 directory first. */
300 if (! entry->is_archive)
301 {
302 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
303 {
304 char *name = concat (ld_sysroot, entry->filename,
305 (const char *) NULL);
306 if (ldfile_try_open_bfd (name, entry))
307 {
308 entry->filename = name;
309 return TRUE;
310 }
311 free (name);
312 }
313 else if (ldfile_try_open_bfd (entry->filename, entry))
314 {
315 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
316 && is_sysrooted_pathname (entry->filename, TRUE);
317 return TRUE;
318 }
319
320 if (IS_ABSOLUTE_PATH (entry->filename))
321 return FALSE;
322 }
323
324 for (search = search_head; search != NULL; search = search->next)
325 {
326 char *string;
327
328 if (entry->dynamic && ! link_info.relocatable)
329 {
330 if (ldemul_open_dynamic_archive (arch, search, entry))
331 {
332 entry->sysrooted = search->sysrooted;
333 return TRUE;
334 }
335 }
336
337 string = xmalloc (strlen (search->name)
338 + strlen (slash)
339 + strlen (lib)
340 + strlen (entry->filename)
341 + strlen (arch)
342 + strlen (suffix)
343 + 1);
344
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);
350
351 if (ldfile_try_open_bfd (string, entry))
352 {
353 entry->filename = string;
354 entry->sysrooted = search->sysrooted;
355 return TRUE;
356 }
357
358 free (string);
359 }
360
361 return FALSE;
362 }
363
364 /* Open the input file specified by ENTRY. */
365
366 void
ldfile_open_file(lang_input_statement_type * entry)367 ldfile_open_file (lang_input_statement_type *entry)
368 {
369 if (entry->the_bfd != NULL)
370 return;
371
372 if (! entry->search_dirs_flag)
373 {
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);
381 }
382 else
383 {
384 search_arch_type *arch;
385 bfd_boolean found = FALSE;
386
387 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
388 for (arch = search_arch_head; arch != NULL; arch = arch->next)
389 {
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;
401 }
402
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);
414 }
415 }
416
417 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */
418
419 static FILE *
try_open(const char * name,const char * exten)420 try_open (const char *name, const char *exten)
421 {
422 FILE *result;
423 char buff[1000];
424
425 result = fopen (name, "r");
426
427 if (trace_file_tries)
428 {
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);
433 }
434
435 if (result != NULL)
436 return result;
437
438 if (*exten)
439 {
440 sprintf (buff, "%s%s", name, exten);
441 result = fopen (buff, "r");
442
443 if (trace_file_tries)
444 {
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);
449 }
450 }
451
452 return result;
453 }
454
455 /* Try to open NAME; if that fails, look for it in any directories
456 specified with -L, without and with EXTEND appended. */
457
458 FILE *
ldfile_find_command_file(const char * name,const char * extend)459 ldfile_find_command_file (const char *name, const char *extend)
460 {
461 search_dirs_type *search;
462 FILE *result;
463 char buffer[1000];
464
465 /* First try raw name. */
466 result = try_open (name, "");
467 if (result == NULL)
468 {
469 /* Try now prefixes. */
470 for (search = search_head; search != NULL; search = search->next)
471 {
472 sprintf (buffer, "%s%s%s", search->name, slash, name);
473
474 result = try_open (buffer, extend);
475 if (result)
476 break;
477 }
478 }
479
480 return result;
481 }
482
483 void
ldfile_open_command_file(const char * name)484 ldfile_open_command_file (const char *name)
485 {
486 FILE *ldlex_input_stack;
487 ldlex_input_stack = ldfile_find_command_file (name, "");
488
489 if (ldlex_input_stack == NULL)
490 {
491 bfd_set_error (bfd_error_system_call);
492 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
493 }
494
495 lex_push_file (ldlex_input_stack, name);
496
497 ldfile_input_filename = name;
498 lineno = 1;
499
500 saved_script_handle = ldlex_input_stack;
501 }
502
503 #ifdef GNU960
504 static char *
gnu960_map_archname(char * name)505 gnu960_map_archname (char *name)
506 {
507 struct tabentry { char *cmd_switch; char *arch; };
508 static struct tabentry arch_tab[] =
509 {
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, ""
519 };
520 struct tabentry *tp;
521
522 for (tp = arch_tab; tp->cmd_switch != NULL; tp++)
523 {
524 if (! strcmp (name,tp->cmd_switch))
525 break;
526 }
527
528 if (tp->cmd_switch == NULL)
529 einfo (_("%P%F: unknown architecture: %s\n"), name);
530
531 return tp->arch;
532 }
533
534 void
ldfile_add_arch(char * name)535 ldfile_add_arch (char *name)
536 {
537 search_arch_type *new = xmalloc (sizeof (search_arch_type));
538
539 if (*name != '\0')
540 {
541 if (ldfile_output_machine_name[0] != '\0')
542 {
543 einfo (_("%P%F: target architecture respecified\n"));
544 return;
545 }
546
547 ldfile_output_machine_name = name;
548 }
549
550 new->next = NULL;
551 new->name = gnu960_map_archname (name);
552 *search_arch_tail_ptr = new;
553 search_arch_tail_ptr = &new->next;
554 }
555
556 #else /* not GNU960 */
557
558 void
ldfile_add_arch(const char * in_name)559 ldfile_add_arch (const char *in_name)
560 {
561 char *name = xstrdup (in_name);
562 search_arch_type *new = xmalloc (sizeof (search_arch_type));
563
564 ldfile_output_machine_name = in_name;
565
566 new->name = name;
567 new->next = NULL;
568 while (*name)
569 {
570 *name = TOLOWER (*name);
571 name++;
572 }
573 *search_arch_tail_ptr = new;
574 search_arch_tail_ptr = &new->next;
575
576 }
577 #endif
578
579 /* Set the output architecture. */
580
581 void
ldfile_set_output_arch(const char * string,enum bfd_architecture defarch)582 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
583 {
584 const bfd_arch_info_type *arch = bfd_scan_arch (string);
585
586 if (arch)
587 {
588 ldfile_output_architecture = arch->arch;
589 ldfile_output_machine = arch->mach;
590 ldfile_output_machine_name = arch->printable_name;
591 }
592 else if (defarch != bfd_arch_unknown)
593 ldfile_output_architecture = defarch;
594 else
595 einfo (_("%P%F: cannot represent machine `%s'\n"), string);
596 }
597