Commit | Line | Data |
---|---|---|
a9998805 | 1 | /* Linker file opening and searching. |
5e2f1575 | 2 | Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, |
ff7a0acf | 3 | 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc. |
252b5132 | 4 | |
f96b4a7b | 5 | This file is part of the GNU Binutils. |
252b5132 | 6 | |
f96b4a7b | 7 | This program is free software; you can redistribute it and/or modify |
3fe38064 | 8 | it under the terms of the GNU General Public License as published by |
f96b4a7b NC |
9 | the Free Software Foundation; either version 3 of the License, or |
10 | (at your option) any later version. | |
252b5132 | 11 | |
f96b4a7b | 12 | This program is distributed in the hope that it will be useful, |
3fe38064 NC |
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. | |
252b5132 | 16 | |
3fe38064 | 17 | You should have received a copy of the GNU General Public License |
f96b4a7b NC |
18 | along with this program; if not, write to the Free Software |
19 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, | |
20 | MA 02110-1301, USA. */ | |
252b5132 | 21 | |
252b5132 | 22 | #include "sysdep.h" |
3db64b00 | 23 | #include "bfd.h" |
252b5132 | 24 | #include "bfdlink.h" |
3882b010 | 25 | #include "safe-ctype.h" |
252b5132 RH |
26 | #include "ld.h" |
27 | #include "ldmisc.h" | |
28 | #include "ldexp.h" | |
29 | #include "ldlang.h" | |
30 | #include "ldfile.h" | |
31 | #include "ldmain.h" | |
df2a7313 | 32 | #include <ldgram.h> |
252b5132 RH |
33 | #include "ldlex.h" |
34 | #include "ldemul.h" | |
d1b2b2dc | 35 | #include "libiberty.h" |
3fe38064 | 36 | #include "filenames.h" |
252b5132 | 37 | |
3fe38064 NC |
38 | const char * ldfile_input_filename; |
39 | bfd_boolean ldfile_assumed_script = FALSE; | |
40 | const char * ldfile_output_machine_name = ""; | |
252b5132 RH |
41 | unsigned long ldfile_output_machine; |
42 | enum bfd_architecture ldfile_output_architecture; | |
3fe38064 | 43 | search_dirs_type * search_head; |
252b5132 | 44 | |
252b5132 | 45 | #ifdef VMS |
279e75dc | 46 | static char * slash = ""; |
252b5132 RH |
47 | #else |
48 | #if defined (_WIN32) && ! defined (__CYGWIN32__) | |
279e75dc | 49 | static char * slash = "\\"; |
252b5132 | 50 | #else |
279e75dc | 51 | static char * slash = "/"; |
252b5132 RH |
52 | #endif |
53 | #endif | |
252b5132 | 54 | |
3fe38064 NC |
55 | typedef struct search_arch |
56 | { | |
4de2d33d | 57 | char *name; |
252b5132 RH |
58 | struct search_arch *next; |
59 | } search_arch_type; | |
60 | ||
3fe38064 | 61 | static search_dirs_type **search_tail_ptr = &search_head; |
252b5132 RH |
62 | static search_arch_type *search_arch_head; |
63 | static search_arch_type **search_arch_tail_ptr = &search_arch_head; | |
4de2d33d | 64 | |
3fe38064 NC |
65 | /* Test whether a pathname, after canonicalization, is the same or a |
66 | sub-directory of the sysroot directory. */ | |
67 | ||
68 | static bfd_boolean | |
1579bae1 | 69 | is_sysrooted_pathname (const char *name, bfd_boolean notsame) |
3fe38064 NC |
70 | { |
71 | char * realname = ld_canon_sysroot ? lrealpath (name) : NULL; | |
72 | int len; | |
73 | bfd_boolean result; | |
74 | ||
75 | if (! realname) | |
76 | return FALSE; | |
5e2f1575 | 77 | |
3fe38064 NC |
78 | len = strlen (realname); |
79 | ||
80 | if (((! notsame && len == ld_canon_sysroot_len) | |
81 | || (len >= ld_canon_sysroot_len | |
82 | && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]) | |
83 | && (realname[ld_canon_sysroot_len] = '\0') == '\0')) | |
84 | && FILENAME_CMP (ld_canon_sysroot, realname) == 0) | |
85 | result = TRUE; | |
86 | else | |
87 | result = FALSE; | |
88 | ||
89 | if (realname) | |
90 | free (realname); | |
91 | ||
92 | return result; | |
93 | } | |
252b5132 | 94 | |
5ed6aba4 NC |
95 | /* Adds NAME to the library search path. |
96 | Makes a copy of NAME using xmalloc(). */ | |
97 | ||
252b5132 | 98 | void |
1579bae1 | 99 | ldfile_add_library_path (const char *name, bfd_boolean cmdline) |
252b5132 RH |
100 | { |
101 | search_dirs_type *new; | |
102 | ||
361b220e CD |
103 | if (!cmdline && config.only_cmd_line_lib_dirs) |
104 | return; | |
105 | ||
1579bae1 | 106 | new = xmalloc (sizeof (search_dirs_type)); |
252b5132 | 107 | new->next = NULL; |
252b5132 RH |
108 | new->cmdline = cmdline; |
109 | *search_tail_ptr = new; | |
110 | search_tail_ptr = &new->next; | |
9c8ebd6a DJ |
111 | |
112 | /* If a directory is marked as honoring sysroot, prepend the sysroot path | |
113 | now. */ | |
5ed6aba4 | 114 | if (name[0] == '=') |
e3f2db7f | 115 | { |
ff7a0acf | 116 | new->name = concat (ld_sysroot, name + 1, (const char *) NULL); |
e3f2db7f AO |
117 | new->sysrooted = TRUE; |
118 | } | |
119 | else | |
5ed6aba4 NC |
120 | { |
121 | new->name = xstrdup (name); | |
122 | new->sysrooted = is_sysrooted_pathname (name, FALSE); | |
123 | } | |
252b5132 RH |
124 | } |
125 | ||
126 | /* Try to open a BFD for a lang_input_statement. */ | |
127 | ||
b34976b6 | 128 | bfd_boolean |
1579bae1 AM |
129 | ldfile_try_open_bfd (const char *attempt, |
130 | lang_input_statement_type *entry) | |
252b5132 RH |
131 | { |
132 | entry->the_bfd = bfd_openr (attempt, entry->target); | |
133 | ||
134 | if (trace_file_tries) | |
135 | { | |
136 | if (entry->the_bfd == NULL) | |
137 | info_msg (_("attempt to open %s failed\n"), attempt); | |
138 | else | |
139 | info_msg (_("attempt to open %s succeeded\n"), attempt); | |
140 | } | |
141 | ||
b90d1146 | 142 | if (entry->the_bfd == NULL) |
252b5132 RH |
143 | { |
144 | if (bfd_get_error () == bfd_error_invalid_target) | |
145 | einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target); | |
b34976b6 | 146 | return FALSE; |
252b5132 | 147 | } |
b90d1146 ILT |
148 | |
149 | /* If we are searching for this file, see if the architecture is | |
150 | compatible with the output file. If it isn't, keep searching. | |
151 | If we can't open the file as an object file, stop the search | |
6c0c5b1e AM |
152 | here. If we are statically linking, ensure that we don't link |
153 | a dynamic object. */ | |
b90d1146 | 154 | |
6c0c5b1e | 155 | if (entry->search_dirs_flag || !entry->dynamic) |
b90d1146 ILT |
156 | { |
157 | bfd *check; | |
158 | ||
159 | if (bfd_check_format (entry->the_bfd, bfd_archive)) | |
160 | check = bfd_openr_next_archived_file (entry->the_bfd, NULL); | |
161 | else | |
162 | check = entry->the_bfd; | |
163 | ||
a9998805 | 164 | if (check != NULL) |
b90d1146 | 165 | { |
a9998805 | 166 | if (! bfd_check_format (check, bfd_object)) |
599917b8 JJ |
167 | { |
168 | if (check == entry->the_bfd | |
6c0c5b1e | 169 | && entry->search_dirs_flag |
599917b8 JJ |
170 | && bfd_get_error () == bfd_error_file_not_recognized |
171 | && ! ldemul_unrecognized_file (entry)) | |
172 | { | |
173 | int token, skip = 0; | |
174 | char *arg, *arg1, *arg2, *arg3; | |
175 | extern FILE *yyin; | |
176 | ||
177 | /* Try to interpret the file as a linker script. */ | |
178 | ldfile_open_command_file (attempt); | |
b34976b6 AM |
179 | |
180 | ldfile_assumed_script = TRUE; | |
599917b8 JJ |
181 | parser_input = input_selected; |
182 | ldlex_both (); | |
183 | token = INPUT_SCRIPT; | |
184 | while (token != 0) | |
185 | { | |
186 | switch (token) | |
187 | { | |
188 | case OUTPUT_FORMAT: | |
189 | if ((token = yylex ()) != '(') | |
190 | continue; | |
191 | if ((token = yylex ()) != NAME) | |
192 | continue; | |
193 | arg1 = yylval.name; | |
194 | arg2 = NULL; | |
195 | arg3 = NULL; | |
196 | token = yylex (); | |
197 | if (token == ',') | |
198 | { | |
199 | if ((token = yylex ()) != NAME) | |
200 | { | |
201 | free (arg1); | |
202 | continue; | |
203 | } | |
204 | arg2 = yylval.name; | |
205 | if ((token = yylex ()) != ',' | |
206 | || (token = yylex ()) != NAME) | |
207 | { | |
208 | free (arg1); | |
209 | free (arg2); | |
210 | continue; | |
211 | } | |
212 | arg3 = yylval.name; | |
213 | token = yylex (); | |
214 | } | |
215 | if (token == ')') | |
216 | { | |
217 | switch (command_line.endian) | |
218 | { | |
219 | default: | |
220 | case ENDIAN_UNSET: | |
221 | arg = arg1; break; | |
222 | case ENDIAN_BIG: | |
223 | arg = arg2 ? arg2 : arg1; break; | |
224 | case ENDIAN_LITTLE: | |
225 | arg = arg3 ? arg3 : arg1; break; | |
226 | } | |
227 | if (strcmp (arg, lang_get_output_target ()) != 0) | |
228 | skip = 1; | |
229 | } | |
230 | free (arg1); | |
231 | if (arg2) free (arg2); | |
232 | if (arg3) free (arg3); | |
233 | break; | |
234 | case NAME: | |
235 | case LNAME: | |
236 | case VERS_IDENTIFIER: | |
237 | case VERS_TAG: | |
238 | free (yylval.name); | |
239 | break; | |
240 | case INT: | |
241 | if (yylval.bigint.str) | |
242 | free (yylval.bigint.str); | |
243 | break; | |
5e2f1575 | 244 | } |
599917b8 JJ |
245 | token = yylex (); |
246 | } | |
4f39e302 | 247 | ldlex_popstate (); |
b34976b6 | 248 | ldfile_assumed_script = FALSE; |
599917b8 JJ |
249 | fclose (yyin); |
250 | yyin = NULL; | |
251 | if (skip) | |
252 | { | |
fe7929ce AM |
253 | if (command_line.warn_search_mismatch) |
254 | einfo (_("%P: skipping incompatible %s " | |
255 | "when searching for %s\n"), | |
256 | attempt, entry->local_sym_name); | |
599917b8 JJ |
257 | bfd_close (entry->the_bfd); |
258 | entry->the_bfd = NULL; | |
b34976b6 | 259 | return FALSE; |
599917b8 JJ |
260 | } |
261 | } | |
b34976b6 | 262 | return TRUE; |
599917b8 | 263 | } |
f1f0d9ab | 264 | |
6c0c5b1e AM |
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 | |
f13a99db | 275 | && !bfd_arch_get_compatible (check, link_info.output_bfd, |
6c0c5b1e | 276 | command_line.accept_unknown_input_arch) |
312b768e | 277 | /* XCOFF archives can have 32 and 64 bit objects. */ |
f1f0d9ab | 278 | && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour |
f13a99db | 279 | && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour |
f1f0d9ab | 280 | && bfd_check_format (entry->the_bfd, bfd_archive))) |
a9998805 | 281 | { |
fe7929ce AM |
282 | if (command_line.warn_search_mismatch) |
283 | einfo (_("%P: skipping incompatible %s " | |
284 | "when searching for %s\n"), | |
285 | attempt, entry->local_sym_name); | |
a9998805 ILT |
286 | bfd_close (entry->the_bfd); |
287 | entry->the_bfd = NULL; | |
b34976b6 | 288 | return FALSE; |
a9998805 | 289 | } |
b90d1146 ILT |
290 | } |
291 | } | |
292 | ||
b34976b6 | 293 | return TRUE; |
252b5132 RH |
294 | } |
295 | ||
296 | /* Search for and open the file specified by ENTRY. If it is an | |
297 | archive, use ARCH, LIB and SUFFIX to modify the file name. */ | |
298 | ||
b34976b6 | 299 | bfd_boolean |
1579bae1 AM |
300 | ldfile_open_file_search (const char *arch, |
301 | lang_input_statement_type *entry, | |
302 | const char *lib, | |
303 | const char *suffix) | |
252b5132 RH |
304 | { |
305 | search_dirs_type *search; | |
306 | ||
307 | /* If this is not an archive, try to open it in the current | |
308 | directory first. */ | |
309 | if (! entry->is_archive) | |
310 | { | |
3fe38064 | 311 | if (entry->sysrooted && IS_ABSOLUTE_PATH (entry->filename)) |
e3f2db7f AO |
312 | { |
313 | char *name = concat (ld_sysroot, entry->filename, | |
314 | (const char *) NULL); | |
315 | if (ldfile_try_open_bfd (name, entry)) | |
316 | { | |
317 | entry->filename = name; | |
318 | return TRUE; | |
319 | } | |
320 | free (name); | |
321 | } | |
322 | else if (ldfile_try_open_bfd (entry->filename, entry)) | |
323 | { | |
3fe38064 NC |
324 | entry->sysrooted = IS_ABSOLUTE_PATH (entry->filename) |
325 | && is_sysrooted_pathname (entry->filename, TRUE); | |
e3f2db7f AO |
326 | return TRUE; |
327 | } | |
3fe38064 NC |
328 | |
329 | if (IS_ABSOLUTE_PATH (entry->filename)) | |
330 | return FALSE; | |
252b5132 RH |
331 | } |
332 | ||
1579bae1 | 333 | for (search = search_head; search != NULL; search = search->next) |
252b5132 RH |
334 | { |
335 | char *string; | |
336 | ||
1049f94e | 337 | if (entry->dynamic && ! link_info.relocatable) |
252b5132 RH |
338 | { |
339 | if (ldemul_open_dynamic_archive (arch, search, entry)) | |
e3f2db7f AO |
340 | { |
341 | entry->sysrooted = search->sysrooted; | |
342 | return TRUE; | |
343 | } | |
252b5132 RH |
344 | } |
345 | ||
1579bae1 AM |
346 | string = xmalloc (strlen (search->name) |
347 | + strlen (slash) | |
348 | + strlen (lib) | |
349 | + strlen (entry->filename) | |
350 | + strlen (arch) | |
351 | + strlen (suffix) | |
352 | + 1); | |
252b5132 RH |
353 | |
354 | if (entry->is_archive) | |
355 | sprintf (string, "%s%s%s%s%s%s", search->name, slash, | |
356 | lib, entry->filename, arch, suffix); | |
252b5132 RH |
357 | else |
358 | sprintf (string, "%s%s%s", search->name, slash, entry->filename); | |
359 | ||
360 | if (ldfile_try_open_bfd (string, entry)) | |
361 | { | |
b90d1146 | 362 | entry->filename = string; |
e3f2db7f | 363 | entry->sysrooted = search->sysrooted; |
b34976b6 | 364 | return TRUE; |
252b5132 RH |
365 | } |
366 | ||
367 | free (string); | |
368 | } | |
369 | ||
b34976b6 | 370 | return FALSE; |
252b5132 RH |
371 | } |
372 | ||
373 | /* Open the input file specified by ENTRY. */ | |
374 | ||
375 | void | |
1579bae1 | 376 | ldfile_open_file (lang_input_statement_type *entry) |
252b5132 RH |
377 | { |
378 | if (entry->the_bfd != NULL) | |
379 | return; | |
380 | ||
381 | if (! entry->search_dirs_flag) | |
382 | { | |
383 | if (ldfile_try_open_bfd (entry->filename, entry)) | |
384 | return; | |
385 | if (strcmp (entry->filename, entry->local_sym_name) != 0) | |
f24ddbdd | 386 | einfo (_("%F%P: %s (%s): No such file: %E\n"), |
252b5132 RH |
387 | entry->filename, entry->local_sym_name); |
388 | else | |
f24ddbdd | 389 | einfo (_("%F%P: %s: No such file: %E\n"), entry->local_sym_name); |
252b5132 RH |
390 | } |
391 | else | |
392 | { | |
393 | search_arch_type *arch; | |
b34976b6 | 394 | bfd_boolean found = FALSE; |
252b5132 RH |
395 | |
396 | /* Try to open <filename><suffix> or lib<filename><suffix>.a */ | |
1579bae1 | 397 | for (arch = search_arch_head; arch != NULL; arch = arch->next) |
252b5132 | 398 | { |
78f85fd7 L |
399 | found = ldfile_open_file_search (arch->name, entry, "lib", ".a"); |
400 | if (found) | |
401 | break; | |
252b5132 | 402 | #ifdef VMS |
78f85fd7 L |
403 | found = ldfile_open_file_search (arch->name, entry, ":lib", ".a"); |
404 | if (found) | |
405 | break; | |
252b5132 | 406 | #endif |
78f85fd7 L |
407 | found = ldemul_find_potential_libraries (arch->name, entry); |
408 | if (found) | |
409 | break; | |
252b5132 | 410 | } |
4de2d33d | 411 | |
78f85fd7 L |
412 | /* If we have found the file, we don't need to search directories |
413 | again. */ | |
414 | if (found) | |
b34976b6 | 415 | entry->search_dirs_flag = FALSE; |
3fe38064 NC |
416 | else if (entry->sysrooted |
417 | && ld_sysroot | |
418 | && IS_ABSOLUTE_PATH (entry->local_sym_name)) | |
419 | einfo (_("%F%P: cannot find %s inside %s\n"), | |
420 | entry->local_sym_name, ld_sysroot); | |
78f85fd7 L |
421 | else |
422 | einfo (_("%F%P: cannot find %s\n"), entry->local_sym_name); | |
252b5132 RH |
423 | } |
424 | } | |
425 | ||
426 | /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */ | |
427 | ||
428 | static FILE * | |
1579bae1 | 429 | try_open (const char *name, const char *exten) |
252b5132 RH |
430 | { |
431 | FILE *result; | |
432 | char buff[1000]; | |
433 | ||
434 | result = fopen (name, "r"); | |
4de2d33d | 435 | |
252b5132 RH |
436 | if (trace_file_tries) |
437 | { | |
438 | if (result == NULL) | |
439 | info_msg (_("cannot find script file %s\n"), name); | |
440 | else | |
441 | info_msg (_("opened script file %s\n"), name); | |
442 | } | |
443 | ||
444 | if (result != NULL) | |
445 | return result; | |
446 | ||
447 | if (*exten) | |
448 | { | |
449 | sprintf (buff, "%s%s", name, exten); | |
450 | result = fopen (buff, "r"); | |
4de2d33d | 451 | |
252b5132 RH |
452 | if (trace_file_tries) |
453 | { | |
454 | if (result == NULL) | |
455 | info_msg (_("cannot find script file %s\n"), buff); | |
456 | else | |
457 | info_msg (_("opened script file %s\n"), buff); | |
458 | } | |
459 | } | |
460 | ||
461 | return result; | |
462 | } | |
463 | ||
464 | /* Try to open NAME; if that fails, look for it in any directories | |
396a2467 | 465 | specified with -L, without and with EXTEND appended. */ |
252b5132 | 466 | |
279e75dc | 467 | static FILE * |
1579bae1 | 468 | ldfile_find_command_file (const char *name, const char *extend) |
252b5132 RH |
469 | { |
470 | search_dirs_type *search; | |
471 | FILE *result; | |
472 | char buffer[1000]; | |
473 | ||
89cdebba | 474 | /* First try raw name. */ |
1c64c4ed | 475 | result = try_open (name, ""); |
1579bae1 | 476 | if (result == NULL) |
1c64c4ed | 477 | { |
89cdebba | 478 | /* Try now prefixes. */ |
1579bae1 | 479 | for (search = search_head; search != NULL; search = search->next) |
1c64c4ed | 480 | { |
89cdebba | 481 | sprintf (buffer, "%s%s%s", search->name, slash, name); |
4de2d33d | 482 | |
1c64c4ed NC |
483 | result = try_open (buffer, extend); |
484 | if (result) | |
485 | break; | |
486 | } | |
252b5132 | 487 | } |
4de2d33d | 488 | |
252b5132 RH |
489 | return result; |
490 | } | |
491 | ||
492 | void | |
1579bae1 | 493 | ldfile_open_command_file (const char *name) |
252b5132 RH |
494 | { |
495 | FILE *ldlex_input_stack; | |
1c64c4ed | 496 | ldlex_input_stack = ldfile_find_command_file (name, ""); |
252b5132 | 497 | |
1579bae1 | 498 | if (ldlex_input_stack == NULL) |
1c64c4ed NC |
499 | { |
500 | bfd_set_error (bfd_error_system_call); | |
501 | einfo (_("%P%F: cannot open linker script file %s: %E\n"), name); | |
502 | } | |
4de2d33d | 503 | |
1c64c4ed | 504 | lex_push_file (ldlex_input_stack, name); |
4de2d33d | 505 | |
252b5132 RH |
506 | ldfile_input_filename = name; |
507 | lineno = 1; | |
b7a26f91 | 508 | |
b9a8de1e | 509 | saved_script_handle = ldlex_input_stack; |
252b5132 RH |
510 | } |
511 | ||
252b5132 | 512 | void |
1579bae1 | 513 | ldfile_add_arch (const char *in_name) |
252b5132 | 514 | { |
d1b2b2dc | 515 | char *name = xstrdup (in_name); |
1579bae1 | 516 | search_arch_type *new = xmalloc (sizeof (search_arch_type)); |
252b5132 RH |
517 | |
518 | ldfile_output_machine_name = in_name; | |
519 | ||
520 | new->name = name; | |
1579bae1 | 521 | new->next = NULL; |
252b5132 RH |
522 | while (*name) |
523 | { | |
3882b010 | 524 | *name = TOLOWER (*name); |
252b5132 RH |
525 | name++; |
526 | } | |
527 | *search_arch_tail_ptr = new; | |
528 | search_arch_tail_ptr = &new->next; | |
529 | ||
530 | } | |
252b5132 | 531 | |
89cdebba KH |
532 | /* Set the output architecture. */ |
533 | ||
252b5132 | 534 | void |
5e2f1575 | 535 | ldfile_set_output_arch (const char *string, enum bfd_architecture defarch) |
252b5132 | 536 | { |
1c64c4ed NC |
537 | const bfd_arch_info_type *arch = bfd_scan_arch (string); |
538 | ||
539 | if (arch) | |
540 | { | |
541 | ldfile_output_architecture = arch->arch; | |
542 | ldfile_output_machine = arch->mach; | |
543 | ldfile_output_machine_name = arch->printable_name; | |
544 | } | |
5e2f1575 AM |
545 | else if (defarch != bfd_arch_unknown) |
546 | ldfile_output_architecture = defarch; | |
1c64c4ed | 547 | else |
5e2f1575 | 548 | einfo (_("%P%F: cannot represent machine `%s'\n"), string); |
252b5132 | 549 | } |