1 /* Linker file opening and searching.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2007 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, 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 /* ldfile.c: look after all the file stuff. */
23
24 #include "sysdep.h"
25 #include "bfd.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 #ifdef VMS
48 static char * slash = "";
49 #else
50 #if defined (_WIN32) && ! defined (__CYGWIN32__)
51 static char * slash = "\\";
52 #else
53 static char * slash = "/";
54 #endif
55 #endif
56
57 typedef struct search_arch
58 {
59 char *name;
60 struct search_arch *next;
61 } search_arch_type;
62
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;
66
67 /* Test whether a pathname, after canonicalization, is the same or a
68 sub-directory of the sysroot directory. */
69
70 static bfd_boolean
is_sysrooted_pathname(const char * name,bfd_boolean notsame)71 is_sysrooted_pathname (const char *name, bfd_boolean notsame)
72 {
73 char * realname = ld_canon_sysroot ? lrealpath (name) : NULL;
74 int len;
75 bfd_boolean result;
76
77 if (! realname)
78 return FALSE;
79
80 len = strlen (realname);
81
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;
90
91 if (realname)
92 free (realname);
93
94 return result;
95 }
96
97 /* Adds NAME to the library search path.
98 Makes a copy of NAME using xmalloc(). */
99
100 void
ldfile_add_library_path(const char * name,bfd_boolean cmdline)101 ldfile_add_library_path (const char *name, bfd_boolean cmdline)
102 {
103 search_dirs_type *new;
104
105 if (!cmdline && config.only_cmd_line_lib_dirs)
106 return;
107
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;
113
114 /* If a directory is marked as honoring sysroot, prepend the sysroot path
115 now. */
116 if (name[0] == '=')
117 {
118 new->name = concat (ld_sysroot, name + 1, NULL);
119 new->sysrooted = TRUE;
120 }
121 else
122 {
123 new->name = xstrdup (name);
124 new->sysrooted = is_sysrooted_pathname (name, FALSE);
125 }
126 }
127
128 /* Try to open a BFD for a lang_input_statement. */
129
130 bfd_boolean
ldfile_try_open_bfd(const char * attempt,lang_input_statement_type * entry)131 ldfile_try_open_bfd (const char *attempt,
132 lang_input_statement_type *entry)
133 {
134 entry->the_bfd = bfd_openr (attempt, entry->target);
135
136 if (trace_file_tries)
137 {
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);
142 }
143
144 if (entry->the_bfd == NULL)
145 {
146 if (bfd_get_error () == bfd_error_invalid_target)
147 einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
148 return FALSE;
149 }
150
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. */
156
157 if (entry->search_dirs_flag || !entry->dynamic)
158 {
159 bfd *check;
160
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;
165
166 if (check != NULL)
167 {
168 if (! bfd_check_format (check, bfd_object))
169 {
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))
174 {
175 int token, skip = 0;
176 char *arg, *arg1, *arg2, *arg3;
177 extern FILE *yyin;
178
179 /* Try to interpret the file as a linker script. */
180 ldfile_open_command_file (attempt);
181
182 ldfile_assumed_script = TRUE;
183 parser_input = input_selected;
184 ldlex_both ();
185 token = INPUT_SCRIPT;
186 while (token != 0)
187 {
188 switch (token)
189 {
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 == ',')
200 {
201 if ((token = yylex ()) != NAME)
202 {
203 free (arg1);
204 continue;
205 }
206 arg2 = yylval.name;
207 if ((token = yylex ()) != ','
208 || (token = yylex ()) != NAME)
209 {
210 free (arg1);
211 free (arg2);
212 continue;
213 }
214 arg3 = yylval.name;
215 token = yylex ();
216 }
217 if (token == ')')
218 {
219 switch (command_line.endian)
220 {
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;
228 }
229 if (strcmp (arg, lang_get_output_target ()) != 0)
230 skip = 1;
231 }
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;
246 }
247 token = yylex ();
248 }
249 ldlex_popstate ();
250 ldfile_assumed_script = FALSE;
251 fclose (yyin);
252 yyin = NULL;
253 if (skip)
254 {
255 if (command_line.warn_search_mismatch)
256 einfo (_("%P: skipping incompatible %s "
257 "when searching for %s\n"),
258 attempt, entry->local_sym_name);
259 bfd_close (entry->the_bfd);
260 entry->the_bfd = NULL;
261 return FALSE;
262 }
263 }
264 return TRUE;
265 }
266
267 if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
268 {
269 einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
270 attempt);
271 bfd_close (entry->the_bfd);
272 entry->the_bfd = NULL;
273 return FALSE;
274 }
275
276 if (entry->search_dirs_flag
277 && !bfd_arch_get_compatible (check, output_bfd,
278 command_line.accept_unknown_input_arch)
279 /* XCOFF archives can have 32 and 64 bit objects. */
280 && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
281 && bfd_get_flavour (output_bfd) == bfd_target_xcoff_flavour
282 && bfd_check_format (entry->the_bfd, bfd_archive)))
283 {
284 if (command_line.warn_search_mismatch)
285 einfo (_("%P: skipping incompatible %s "
286 "when searching for %s\n"),
287 attempt, entry->local_sym_name);
288 bfd_close (entry->the_bfd);
289 entry->the_bfd = NULL;
290 return FALSE;
291 }
292 }
293 }
294
295 return TRUE;
296 }
297
298 /* Search for and open the file specified by ENTRY. If it is an
299 archive, use ARCH, LIB and SUFFIX to modify the file name. */
300
301 bfd_boolean
ldfile_open_file_search(const char * arch,lang_input_statement_type * entry,const char * lib,const char * suffix)302 ldfile_open_file_search (const char *arch,
303 lang_input_statement_type *entry,
304 const char *lib,
305 const char *suffix)
306 {
307 search_dirs_type *search;
308
309 /* If this is not an archive, try to open it in the current
310 directory first. */
311 if (! entry->is_archive)
312 {
313 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
314 {
315 char *name = concat (ld_sysroot, entry->filename,
316 (const char *) NULL);
317 if (ldfile_try_open_bfd (name, entry))
318 {
319 entry->filename = name;
320 return TRUE;
321 }
322 free (name);
323 }
324 else if (ldfile_try_open_bfd (entry->filename, entry))
325 {
326 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
327 && is_sysrooted_pathname (entry->filename, TRUE);
328 return TRUE;
329 }
330
331 if (IS_ABSOLUTE_PATH (entry->filename))
332 return FALSE;
333 }
334
335 for (search = search_head; search != NULL; search = search->next)
336 {
337 char *string;
338
339 if (entry->dynamic && ! link_info.relocatable)
340 {
341 if (ldemul_open_dynamic_archive (arch, search, entry))
342 {
343 entry->sysrooted = search->sysrooted;
344 return TRUE;
345 }
346 }
347
348 string = xmalloc (strlen (search->name)
349 + strlen (slash)
350 + strlen (lib)
351 + strlen (entry->filename)
352 + strlen (arch)
353 + strlen (suffix)
354 + 1);
355
356 if (entry->is_archive)
357 sprintf (string, "%s%s%s%s%s%s", search->name, slash,
358 lib, entry->filename, arch, suffix);
359 else
360 sprintf (string, "%s%s%s", search->name, slash, entry->filename);
361
362 if (ldfile_try_open_bfd (string, entry))
363 {
364 entry->filename = string;
365 entry->sysrooted = search->sysrooted;
366 return TRUE;
367 }
368
369 free (string);
370 }
371
372 return FALSE;
373 }
374
375 /* Open the input file specified by ENTRY. */
376
377 void
ldfile_open_file(lang_input_statement_type * entry)378 ldfile_open_file (lang_input_statement_type *entry)
379 {
380 if (entry->the_bfd != NULL)
381 return;
382
383 if (! entry->search_dirs_flag)
384 {
385 if (ldfile_try_open_bfd (entry->filename, entry))
386 return;
387 if (strcmp (entry->filename, entry->local_sym_name) != 0)
388 einfo (_("%F%P: %s (%s): No such file: %E\n"),
389 entry->filename, entry->local_sym_name);
390 else
391 einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name);
392 }
393 else
394 {
395 search_arch_type *arch;
396 bfd_boolean found = FALSE;
397
398 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
399 for (arch = search_arch_head; arch != NULL; arch = arch->next)
400 {
401 found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
402 if (found)
403 break;
404 #ifdef VMS
405 found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
406 if (found)
407 break;
408 #endif
409 found = ldemul_find_potential_libraries (arch->name, entry);
410 if (found)
411 break;
412 }
413
414 /* If we have found the file, we don't need to search directories
415 again. */
416 if (found)
417 entry->search_dirs_flag = FALSE;
418 else if (entry->sysrooted
419 && ld_sysroot
420 && IS_ABSOLUTE_PATH (entry->local_sym_name))
421 einfo (_("%F%P: cannot find %s inside %s\n"),
422 entry->local_sym_name, ld_sysroot);
423 else
424 einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name);
425 }
426 }
427
428 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */
429
430 static FILE *
try_open(const char * name,const char * exten)431 try_open (const char *name, const char *exten)
432 {
433 FILE *result;
434 char buff[1000];
435
436 result = fopen (name, "r");
437
438 if (trace_file_tries)
439 {
440 if (result == NULL)
441 info_msg (_("cannot find script file %s\n"), name);
442 else
443 info_msg (_("opened script file %s\n"), name);
444 }
445
446 if (result != NULL)
447 return result;
448
449 if (*exten)
450 {
451 sprintf (buff, "%s%s", name, exten);
452 result = fopen (buff, "r");
453
454 if (trace_file_tries)
455 {
456 if (result == NULL)
457 info_msg (_("cannot find script file %s\n"), buff);
458 else
459 info_msg (_("opened script file %s\n"), buff);
460 }
461 }
462
463 return result;
464 }
465
466 /* Try to open NAME; if that fails, look for it in any directories
467 specified with -L, without and with EXTEND appended. */
468
469 static FILE *
ldfile_find_command_file(const char * name,const char * extend)470 ldfile_find_command_file (const char *name, const char *extend)
471 {
472 search_dirs_type *search;
473 FILE *result;
474 char buffer[1000];
475
476 /* First try raw name. */
477 result = try_open (name, "");
478 if (result == NULL)
479 {
480 /* Try now prefixes. */
481 for (search = search_head; search != NULL; search = search->next)
482 {
483 sprintf (buffer, "%s%s%s", search->name, slash, name);
484
485 result = try_open (buffer, extend);
486 if (result)
487 break;
488 }
489 }
490
491 return result;
492 }
493
494 void
ldfile_open_command_file(const char * name)495 ldfile_open_command_file (const char *name)
496 {
497 FILE *ldlex_input_stack;
498 ldlex_input_stack = ldfile_find_command_file (name, "");
499
500 if (ldlex_input_stack == NULL)
501 {
502 bfd_set_error (bfd_error_system_call);
503 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
504 }
505
506 lex_push_file (ldlex_input_stack, name);
507
508 ldfile_input_filename = name;
509 lineno = 1;
510
511 saved_script_handle = ldlex_input_stack;
512 }
513
514 void
ldfile_add_arch(const char * in_name)515 ldfile_add_arch (const char *in_name)
516 {
517 char *name = xstrdup (in_name);
518 search_arch_type *new = xmalloc (sizeof (search_arch_type));
519
520 ldfile_output_machine_name = in_name;
521
522 new->name = name;
523 new->next = NULL;
524 while (*name)
525 {
526 *name = TOLOWER (*name);
527 name++;
528 }
529 *search_arch_tail_ptr = new;
530 search_arch_tail_ptr = &new->next;
531
532 }
533
534 /* Set the output architecture. */
535
536 void
ldfile_set_output_arch(const char * string,enum bfd_architecture defarch)537 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
538 {
539 const bfd_arch_info_type *arch = bfd_scan_arch (string);
540
541 if (arch)
542 {
543 ldfile_output_architecture = arch->arch;
544 ldfile_output_machine = arch->mach;
545 ldfile_output_machine_name = arch->printable_name;
546 }
547 else if (defarch != bfd_arch_unknown)
548 ldfile_output_architecture = defarch;
549 else
550 einfo (_("%P%F: cannot represent machine `%s'\n"), string);
551 }
552