1 /* Linker file opening and searching.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005 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 #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
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 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;
260 }
261 }
262 return TRUE;
263 }
264
265 if (!entry->dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
266 {
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;
272 }
273
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)))
281 {
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;
287 }
288 }
289 }
290
291 return TRUE;
292 }
293
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. */
296
297 bfd_boolean
ldfile_open_file_search(const char * arch,lang_input_statement_type * entry,const char * lib,const char * suffix)298 ldfile_open_file_search (const char *arch,
299 lang_input_statement_type *entry,
300 const char *lib,
301 const char *suffix)
302 {
303 search_dirs_type *search;
304
305 /* If this is not an archive, try to open it in the current
306 directory first. */
307 if (! entry->is_archive)
308 {
309 if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename))
310 {
311 char *name = concat (ld_sysroot, entry->filename,
312 (const char *) NULL);
313 if (ldfile_try_open_bfd (name, entry))
314 {
315 entry->filename = name;
316 return TRUE;
317 }
318 free (name);
319 }
320 else if (ldfile_try_open_bfd (entry->filename, entry))
321 {
322 entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename)
323 && is_sysrooted_pathname (entry->filename, TRUE);
324 return TRUE;
325 }
326
327 if (IS_ABSOLUTE_PATH (entry->filename))
328 return FALSE;
329 }
330
331 for (search = search_head; search != NULL; search = search->next)
332 {
333 char *string;
334
335 if (entry->dynamic && ! link_info.relocatable)
336 {
337 if (ldemul_open_dynamic_archive (arch, search, entry))
338 {
339 entry->sysrooted = search->sysrooted;
340 return TRUE;
341 }
342 }
343
344 string = xmalloc (strlen (search->name)
345 + strlen (slash)
346 + strlen (lib)
347 + strlen (entry->filename)
348 + strlen (arch)
349 + strlen (suffix)
350 + 1);
351
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);
357
358 if (ldfile_try_open_bfd (string, entry))
359 {
360 entry->filename = string;
361 entry->sysrooted = search->sysrooted;
362 return TRUE;
363 }
364
365 free (string);
366 }
367
368 return FALSE;
369 }
370
371 /* Open the input file specified by ENTRY. */
372
373 void
ldfile_open_file(lang_input_statement_type * entry)374 ldfile_open_file (lang_input_statement_type *entry)
375 {
376 if (entry->the_bfd != NULL)
377 return;
378
379 if (! entry->search_dirs_flag)
380 {
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);
388 }
389 else
390 {
391 search_arch_type *arch;
392 bfd_boolean found = FALSE;
393
394 /* Try to open <filename><suffix> or lib<filename><suffix>.a */
395 for (arch = search_arch_head; arch != NULL; arch = arch->next)
396 {
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;
408 }
409
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);
421 }
422 }
423
424 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */
425
426 static FILE *
try_open(const char * name,const char * exten)427 try_open (const char *name, const char *exten)
428 {
429 FILE *result;
430 char buff[1000];
431
432 result = fopen (name, "r");
433
434 if (trace_file_tries)
435 {
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);
440 }
441
442 if (result != NULL)
443 return result;
444
445 if (*exten)
446 {
447 sprintf (buff, "%s%s", name, exten);
448 result = fopen (buff, "r");
449
450 if (trace_file_tries)
451 {
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);
456 }
457 }
458
459 return result;
460 }
461
462 /* Try to open NAME; if that fails, look for it in any directories
463 specified with -L, without and with EXTEND appended. */
464
465 FILE *
ldfile_find_command_file(const char * name,const char * extend)466 ldfile_find_command_file (const char *name, const char *extend)
467 {
468 search_dirs_type *search;
469 FILE *result;
470 char buffer[1000];
471
472 /* First try raw name. */
473 result = try_open (name, "");
474 if (result == NULL)
475 {
476 /* Try now prefixes. */
477 for (search = search_head; search != NULL; search = search->next)
478 {
479 sprintf (buffer, "%s%s%s", search->name, slash, name);
480
481 result = try_open (buffer, extend);
482 if (result)
483 break;
484 }
485 }
486
487 return result;
488 }
489
490 void
ldfile_open_command_file(const char * name)491 ldfile_open_command_file (const char *name)
492 {
493 FILE *ldlex_input_stack;
494 ldlex_input_stack = ldfile_find_command_file (name, "");
495
496 if (ldlex_input_stack == NULL)
497 {
498 bfd_set_error (bfd_error_system_call);
499 einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
500 }
501
502 lex_push_file (ldlex_input_stack, name);
503
504 ldfile_input_filename = name;
505 lineno = 1;
506
507 saved_script_handle = ldlex_input_stack;
508 }
509
510 void
ldfile_add_arch(const char * in_name)511 ldfile_add_arch (const char *in_name)
512 {
513 char *name = xstrdup (in_name);
514 search_arch_type *new = xmalloc (sizeof (search_arch_type));
515
516 ldfile_output_machine_name = in_name;
517
518 new->name = name;
519 new->next = NULL;
520 while (*name)
521 {
522 *name = TOLOWER (*name);
523 name++;
524 }
525 *search_arch_tail_ptr = new;
526 search_arch_tail_ptr = &new->next;
527
528 }
529
530 /* Set the output architecture. */
531
532 void
ldfile_set_output_arch(const char * string,enum bfd_architecture defarch)533 ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
534 {
535 const bfd_arch_info_type *arch = bfd_scan_arch (string);
536
537 if (arch)
538 {
539 ldfile_output_architecture = arch->arch;
540 ldfile_output_machine = arch->mach;
541 ldfile_output_machine_name = arch->printable_name;
542 }
543 else if (defarch != bfd_arch_unknown)
544 ldfile_output_architecture = defarch;
545 else
546 einfo (_("%P%F: cannot represent machine `%s'\n"), string);
547 }
548