Commit | Line | Data |
---|---|---|
a9998805 | 1 | /* Linker file opening and searching. |
b3adc24a | 2 | Copyright (C) 1991-2020 Free Software Foundation, Inc. |
252b5132 | 3 | |
f96b4a7b | 4 | This file is part of the GNU Binutils. |
252b5132 | 5 | |
f96b4a7b | 6 | This program is free software; you can redistribute it and/or modify |
3fe38064 | 7 | it under the terms of the GNU General Public License as published by |
f96b4a7b NC |
8 | the Free Software Foundation; either version 3 of the License, or |
9 | (at your option) any later version. | |
252b5132 | 10 | |
f96b4a7b | 11 | This program is distributed in the hope that it will be useful, |
3fe38064 NC |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
252b5132 | 15 | |
3fe38064 | 16 | You should have received a copy of the GNU General Public License |
f96b4a7b NC |
17 | along with this program; if not, write to the Free Software |
18 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, | |
19 | MA 02110-1301, USA. */ | |
252b5132 | 20 | |
252b5132 | 21 | #include "sysdep.h" |
3db64b00 | 22 | #include "bfd.h" |
252b5132 | 23 | #include "bfdlink.h" |
1ff6de03 | 24 | #include "ctf-api.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" |
0381901e | 37 | #if BFD_SUPPORTS_PLUGINS |
5d3236ee DK |
38 | #include "plugin-api.h" |
39 | #include "plugin.h" | |
0381901e | 40 | #endif /* BFD_SUPPORTS_PLUGINS */ |
252b5132 | 41 | |
0aa7f586 AM |
42 | bfd_boolean ldfile_assumed_script = FALSE; |
43 | const char *ldfile_output_machine_name = ""; | |
252b5132 RH |
44 | unsigned long ldfile_output_machine; |
45 | enum bfd_architecture ldfile_output_architecture; | |
0aa7f586 | 46 | search_dirs_type *search_head; |
252b5132 | 47 | |
252b5132 | 48 | #ifdef VMS |
0aa7f586 | 49 | static char *slash = ""; |
252b5132 | 50 | #else |
0aa7f586 AM |
51 | #if defined (_WIN32) && !defined (__CYGWIN32__) |
52 | static char *slash = "\\"; | |
252b5132 | 53 | #else |
0aa7f586 | 54 | static char *slash = "/"; |
252b5132 RH |
55 | #endif |
56 | #endif | |
252b5132 | 57 | |
3fe38064 NC |
58 | typedef struct search_arch |
59 | { | |
4de2d33d | 60 | char *name; |
252b5132 RH |
61 | struct search_arch *next; |
62 | } search_arch_type; | |
63 | ||
3fe38064 | 64 | static search_dirs_type **search_tail_ptr = &search_head; |
252b5132 RH |
65 | static search_arch_type *search_arch_head; |
66 | static search_arch_type **search_arch_tail_ptr = &search_arch_head; | |
4de2d33d | 67 | |
3fe38064 NC |
68 | /* Test whether a pathname, after canonicalization, is the same or a |
69 | sub-directory of the sysroot directory. */ | |
70 | ||
71 | static bfd_boolean | |
f4a23d42 | 72 | is_sysrooted_pathname (const char *name) |
3fe38064 | 73 | { |
66be1055 | 74 | char *realname; |
3fe38064 NC |
75 | int len; |
76 | bfd_boolean result; | |
77 | ||
66be1055 | 78 | if (ld_canon_sysroot == NULL) |
3fe38064 | 79 | return FALSE; |
5e2f1575 | 80 | |
66be1055 | 81 | realname = lrealpath (name); |
3fe38064 | 82 | len = strlen (realname); |
66be1055 | 83 | result = FALSE; |
f4a23d42 AM |
84 | if (len > ld_canon_sysroot_len |
85 | && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])) | |
66be1055 | 86 | { |
66be1055 | 87 | realname[ld_canon_sysroot_len] = '\0'; |
f4a23d42 | 88 | result = FILENAME_CMP (ld_canon_sysroot, realname) == 0; |
66be1055 | 89 | } |
3fe38064 | 90 | |
66be1055 | 91 | free (realname); |
3fe38064 NC |
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 | 100 | { |
d3ce72d0 | 101 | search_dirs_type *new_dirs; |
252b5132 | 102 | |
361b220e CD |
103 | if (!cmdline && config.only_cmd_line_lib_dirs) |
104 | return; | |
105 | ||
d3ce72d0 NC |
106 | new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type)); |
107 | new_dirs->next = NULL; | |
108 | new_dirs->cmdline = cmdline; | |
109 | *search_tail_ptr = new_dirs; | |
110 | search_tail_ptr = &new_dirs->next; | |
9c8ebd6a DJ |
111 | |
112 | /* If a directory is marked as honoring sysroot, prepend the sysroot path | |
113 | now. */ | |
5ed6aba4 | 114 | if (name[0] == '=') |
f4a23d42 | 115 | new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL); |
3aa2d05a NC |
116 | else if (CONST_STRNEQ (name, "$SYSROOT")) |
117 | new_dirs->name = concat (ld_sysroot, name + strlen ("$SYSROOT"), (const char *) NULL); | |
e3f2db7f | 118 | else |
f4a23d42 | 119 | new_dirs->name = xstrdup (name); |
252b5132 RH |
120 | } |
121 | ||
122 | /* Try to open a BFD for a lang_input_statement. */ | |
123 | ||
b34976b6 | 124 | bfd_boolean |
1579bae1 AM |
125 | ldfile_try_open_bfd (const char *attempt, |
126 | lang_input_statement_type *entry) | |
252b5132 RH |
127 | { |
128 | entry->the_bfd = bfd_openr (attempt, entry->target); | |
129 | ||
cd6f1cf3 | 130 | if (verbose) |
252b5132 RH |
131 | { |
132 | if (entry->the_bfd == NULL) | |
133 | info_msg (_("attempt to open %s failed\n"), attempt); | |
134 | else | |
135 | info_msg (_("attempt to open %s succeeded\n"), attempt); | |
136 | } | |
137 | ||
b90d1146 | 138 | if (entry->the_bfd == NULL) |
252b5132 RH |
139 | { |
140 | if (bfd_get_error () == bfd_error_invalid_target) | |
141 | einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target); | |
b34976b6 | 142 | return FALSE; |
252b5132 | 143 | } |
b90d1146 | 144 | |
f37b21b4 RM |
145 | track_dependency_files (attempt); |
146 | ||
4a114e3e L |
147 | /* Linker needs to decompress sections. */ |
148 | entry->the_bfd->flags |= BFD_DECOMPRESS; | |
149 | ||
f6fe1ccd L |
150 | /* This is a linker input BFD. */ |
151 | entry->the_bfd->is_linker_input = 1; | |
152 | ||
0381901e | 153 | #if BFD_SUPPORTS_PLUGINS |
ce875075 AM |
154 | if (entry->flags.lto_output) |
155 | entry->the_bfd->lto_output = 1; | |
156 | #endif | |
157 | ||
b90d1146 ILT |
158 | /* If we are searching for this file, see if the architecture is |
159 | compatible with the output file. If it isn't, keep searching. | |
160 | If we can't open the file as an object file, stop the search | |
6c0c5b1e | 161 | here. If we are statically linking, ensure that we don't link |
5d3236ee DK |
162 | a dynamic object. |
163 | ||
164 | In the code below, it's OK to exit early if the check fails, | |
165 | closing the checked BFD and returning FALSE, but if the BFD | |
166 | checks out compatible, do not exit early returning TRUE, or | |
167 | the plugins will not get a chance to claim the file. */ | |
b90d1146 | 168 | |
66be1055 | 169 | if (entry->flags.search_dirs || !entry->flags.dynamic) |
b90d1146 ILT |
170 | { |
171 | bfd *check; | |
172 | ||
173 | if (bfd_check_format (entry->the_bfd, bfd_archive)) | |
174 | check = bfd_openr_next_archived_file (entry->the_bfd, NULL); | |
175 | else | |
176 | check = entry->the_bfd; | |
177 | ||
a9998805 | 178 | if (check != NULL) |
b90d1146 | 179 | { |
0aa7f586 | 180 | if (!bfd_check_format (check, bfd_object)) |
599917b8 JJ |
181 | { |
182 | if (check == entry->the_bfd | |
66be1055 | 183 | && entry->flags.search_dirs |
599917b8 | 184 | && bfd_get_error () == bfd_error_file_not_recognized |
0aa7f586 | 185 | && !ldemul_unrecognized_file (entry)) |
599917b8 JJ |
186 | { |
187 | int token, skip = 0; | |
188 | char *arg, *arg1, *arg2, *arg3; | |
189 | extern FILE *yyin; | |
190 | ||
191 | /* Try to interpret the file as a linker script. */ | |
82d7a6f4 | 192 | ldfile_open_command_file (attempt); |
b34976b6 AM |
193 | |
194 | ldfile_assumed_script = TRUE; | |
599917b8 JJ |
195 | parser_input = input_selected; |
196 | ldlex_both (); | |
197 | token = INPUT_SCRIPT; | |
198 | while (token != 0) | |
199 | { | |
200 | switch (token) | |
201 | { | |
202 | case OUTPUT_FORMAT: | |
203 | if ((token = yylex ()) != '(') | |
204 | continue; | |
205 | if ((token = yylex ()) != NAME) | |
206 | continue; | |
207 | arg1 = yylval.name; | |
208 | arg2 = NULL; | |
209 | arg3 = NULL; | |
210 | token = yylex (); | |
211 | if (token == ',') | |
212 | { | |
213 | if ((token = yylex ()) != NAME) | |
214 | { | |
215 | free (arg1); | |
216 | continue; | |
217 | } | |
218 | arg2 = yylval.name; | |
219 | if ((token = yylex ()) != ',' | |
220 | || (token = yylex ()) != NAME) | |
221 | { | |
222 | free (arg1); | |
223 | free (arg2); | |
224 | continue; | |
225 | } | |
226 | arg3 = yylval.name; | |
227 | token = yylex (); | |
228 | } | |
229 | if (token == ')') | |
230 | { | |
231 | switch (command_line.endian) | |
232 | { | |
233 | default: | |
234 | case ENDIAN_UNSET: | |
235 | arg = arg1; break; | |
236 | case ENDIAN_BIG: | |
237 | arg = arg2 ? arg2 : arg1; break; | |
238 | case ENDIAN_LITTLE: | |
239 | arg = arg3 ? arg3 : arg1; break; | |
240 | } | |
241 | if (strcmp (arg, lang_get_output_target ()) != 0) | |
242 | skip = 1; | |
243 | } | |
244 | free (arg1); | |
5e2ab612 AM |
245 | free (arg2); |
246 | free (arg3); | |
599917b8 JJ |
247 | break; |
248 | case NAME: | |
249 | case LNAME: | |
250 | case VERS_IDENTIFIER: | |
251 | case VERS_TAG: | |
252 | free (yylval.name); | |
253 | break; | |
254 | case INT: | |
5e2ab612 | 255 | free (yylval.bigint.str); |
599917b8 | 256 | break; |
5e2f1575 | 257 | } |
599917b8 JJ |
258 | token = yylex (); |
259 | } | |
4f39e302 | 260 | ldlex_popstate (); |
b34976b6 | 261 | ldfile_assumed_script = FALSE; |
599917b8 JJ |
262 | fclose (yyin); |
263 | yyin = NULL; | |
264 | if (skip) | |
265 | { | |
fe7929ce AM |
266 | if (command_line.warn_search_mismatch) |
267 | einfo (_("%P: skipping incompatible %s " | |
268 | "when searching for %s\n"), | |
269 | attempt, entry->local_sym_name); | |
599917b8 JJ |
270 | bfd_close (entry->the_bfd); |
271 | entry->the_bfd = NULL; | |
b34976b6 | 272 | return FALSE; |
599917b8 JJ |
273 | } |
274 | } | |
5d3236ee | 275 | goto success; |
599917b8 | 276 | } |
f1f0d9ab | 277 | |
66be1055 | 278 | if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0) |
6c0c5b1e AM |
279 | { |
280 | einfo (_("%F%P: attempted static link of dynamic object `%s'\n"), | |
281 | attempt); | |
282 | bfd_close (entry->the_bfd); | |
283 | entry->the_bfd = NULL; | |
284 | return FALSE; | |
285 | } | |
286 | ||
66be1055 | 287 | if (entry->flags.search_dirs |
f13a99db | 288 | && !bfd_arch_get_compatible (check, link_info.output_bfd, |
6c0c5b1e | 289 | command_line.accept_unknown_input_arch) |
312b768e | 290 | /* XCOFF archives can have 32 and 64 bit objects. */ |
0aa7f586 AM |
291 | && !(bfd_get_flavour (check) == bfd_target_xcoff_flavour |
292 | && (bfd_get_flavour (link_info.output_bfd) | |
293 | == bfd_target_xcoff_flavour) | |
294 | && bfd_check_format (entry->the_bfd, bfd_archive))) | |
a9998805 | 295 | { |
fe7929ce AM |
296 | if (command_line.warn_search_mismatch) |
297 | einfo (_("%P: skipping incompatible %s " | |
298 | "when searching for %s\n"), | |
299 | attempt, entry->local_sym_name); | |
a9998805 ILT |
300 | bfd_close (entry->the_bfd); |
301 | entry->the_bfd = NULL; | |
b34976b6 | 302 | return FALSE; |
a9998805 | 303 | } |
b90d1146 ILT |
304 | } |
305 | } | |
dc1e8a47 | 306 | success: |
0381901e | 307 | #if BFD_SUPPORTS_PLUGINS |
5d3236ee DK |
308 | /* If plugins are active, they get first chance to claim |
309 | any successfully-opened input file. We skip archives | |
310 | here; the plugin wants us to offer it the individual | |
311 | members when we enumerate them, not the whole file. We | |
312 | also ignore corefiles, because that's just weird. It is | |
313 | a needed side-effect of calling bfd_check_format with | |
314 | bfd_object that it sets the bfd's arch and mach, which | |
315 | will be needed when and if we want to bfd_create a new | |
316 | one using this one as a template. */ | |
1d5b29cf L |
317 | if (link_info.lto_plugin_active |
318 | && !no_more_claiming | |
319 | && bfd_check_format (entry->the_bfd, bfd_object)) | |
35a1e5f3 | 320 | plugin_maybe_claim (entry); |
0381901e | 321 | #endif /* BFD_SUPPORTS_PLUGINS */ |
b90d1146 | 322 | |
5d3236ee DK |
323 | /* It opened OK, the format checked out, and the plugins have had |
324 | their chance to claim it, so this is success. */ | |
b34976b6 | 325 | return TRUE; |
252b5132 RH |
326 | } |
327 | ||
328 | /* Search for and open the file specified by ENTRY. If it is an | |
329 | archive, use ARCH, LIB and SUFFIX to modify the file name. */ | |
330 | ||
b34976b6 | 331 | bfd_boolean |
1579bae1 AM |
332 | ldfile_open_file_search (const char *arch, |
333 | lang_input_statement_type *entry, | |
334 | const char *lib, | |
335 | const char *suffix) | |
252b5132 RH |
336 | { |
337 | search_dirs_type *search; | |
338 | ||
339 | /* If this is not an archive, try to open it in the current | |
340 | directory first. */ | |
0aa7f586 | 341 | if (!entry->flags.maybe_archive) |
252b5132 | 342 | { |
66be1055 | 343 | if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename)) |
e3f2db7f AO |
344 | { |
345 | char *name = concat (ld_sysroot, entry->filename, | |
346 | (const char *) NULL); | |
347 | if (ldfile_try_open_bfd (name, entry)) | |
348 | { | |
349 | entry->filename = name; | |
350 | return TRUE; | |
351 | } | |
352 | free (name); | |
353 | } | |
354 | else if (ldfile_try_open_bfd (entry->filename, entry)) | |
f4a23d42 | 355 | return TRUE; |
3fe38064 NC |
356 | |
357 | if (IS_ABSOLUTE_PATH (entry->filename)) | |
358 | return FALSE; | |
252b5132 RH |
359 | } |
360 | ||
1579bae1 | 361 | for (search = search_head; search != NULL; search = search->next) |
252b5132 RH |
362 | { |
363 | char *string; | |
364 | ||
0e1862bb | 365 | if (entry->flags.dynamic && !bfd_link_relocatable (&link_info)) |
252b5132 RH |
366 | { |
367 | if (ldemul_open_dynamic_archive (arch, search, entry)) | |
f4a23d42 | 368 | return TRUE; |
252b5132 RH |
369 | } |
370 | ||
d4ae5fb0 | 371 | if (entry->flags.maybe_archive && !entry->flags.full_name_provided) |
a26cc967 AM |
372 | string = concat (search->name, slash, lib, entry->filename, |
373 | arch, suffix, (const char *) NULL); | |
252b5132 | 374 | else |
a26cc967 AM |
375 | string = concat (search->name, slash, entry->filename, |
376 | (const char *) 0); | |
252b5132 RH |
377 | |
378 | if (ldfile_try_open_bfd (string, entry)) | |
379 | { | |
b90d1146 | 380 | entry->filename = string; |
b34976b6 | 381 | return TRUE; |
252b5132 RH |
382 | } |
383 | ||
384 | free (string); | |
385 | } | |
386 | ||
b34976b6 | 387 | return FALSE; |
252b5132 RH |
388 | } |
389 | ||
c4b78195 NC |
390 | /* Open the input file specified by ENTRY. |
391 | PR 4437: Do not stop on the first missing file, but | |
392 | continue processing other input files in case there | |
393 | are more errors to report. */ | |
252b5132 RH |
394 | |
395 | void | |
1579bae1 | 396 | ldfile_open_file (lang_input_statement_type *entry) |
252b5132 RH |
397 | { |
398 | if (entry->the_bfd != NULL) | |
399 | return; | |
400 | ||
0aa7f586 | 401 | if (!entry->flags.search_dirs) |
252b5132 RH |
402 | { |
403 | if (ldfile_try_open_bfd (entry->filename, entry)) | |
404 | return; | |
c4b78195 | 405 | |
42627821 | 406 | if (filename_cmp (entry->filename, entry->local_sym_name) != 0) |
c4b78195 | 407 | einfo (_("%P: cannot find %s (%s): %E\n"), |
252b5132 RH |
408 | entry->filename, entry->local_sym_name); |
409 | else | |
c4b78195 NC |
410 | einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name); |
411 | ||
66be1055 AM |
412 | entry->flags.missing_file = TRUE; |
413 | input_flags.missing_file = TRUE; | |
252b5132 RH |
414 | } |
415 | else | |
416 | { | |
417 | search_arch_type *arch; | |
b34976b6 | 418 | bfd_boolean found = FALSE; |
252b5132 | 419 | |
16171946 | 420 | /* If extra_search_path is set, entry->filename is a relative path. |
f37b21b4 RM |
421 | Search the directory of the current linker script before searching |
422 | other paths. */ | |
16171946 | 423 | if (entry->extra_search_path) |
f37b21b4 RM |
424 | { |
425 | char *path = concat (entry->extra_search_path, slash, entry->filename, | |
426 | (const char *)0); | |
427 | if (ldfile_try_open_bfd (path, entry)) | |
428 | { | |
429 | entry->filename = path; | |
430 | entry->flags.search_dirs = FALSE; | |
431 | return; | |
432 | } | |
16171946 FS |
433 | |
434 | free (path); | |
f37b21b4 | 435 | } |
16171946 FS |
436 | |
437 | /* Try to open <filename><suffix> or lib<filename><suffix>.a. */ | |
1579bae1 | 438 | for (arch = search_arch_head; arch != NULL; arch = arch->next) |
252b5132 | 439 | { |
78f85fd7 L |
440 | found = ldfile_open_file_search (arch->name, entry, "lib", ".a"); |
441 | if (found) | |
442 | break; | |
252b5132 | 443 | #ifdef VMS |
78f85fd7 L |
444 | found = ldfile_open_file_search (arch->name, entry, ":lib", ".a"); |
445 | if (found) | |
446 | break; | |
252b5132 | 447 | #endif |
78f85fd7 L |
448 | found = ldemul_find_potential_libraries (arch->name, entry); |
449 | if (found) | |
450 | break; | |
252b5132 | 451 | } |
4de2d33d | 452 | |
78f85fd7 L |
453 | /* If we have found the file, we don't need to search directories |
454 | again. */ | |
455 | if (found) | |
66be1055 | 456 | entry->flags.search_dirs = FALSE; |
c4b78195 NC |
457 | else |
458 | { | |
66be1055 | 459 | if (entry->flags.sysrooted |
3fe38064 NC |
460 | && ld_sysroot |
461 | && IS_ABSOLUTE_PATH (entry->local_sym_name)) | |
c4b78195 NC |
462 | einfo (_("%P: cannot find %s inside %s\n"), |
463 | entry->local_sym_name, ld_sysroot); | |
23ae20f5 NC |
464 | #if SUPPORT_ERROR_HANDLING_SCRIPT |
465 | else if (error_handling_script != NULL) | |
466 | { | |
467 | char * argv[4]; | |
468 | const char * res; | |
469 | int status, err; | |
470 | ||
471 | argv[0] = error_handling_script; | |
472 | argv[1] = "missing-lib"; | |
473 | argv[2] = (char *) entry->local_sym_name; | |
474 | argv[3] = NULL; | |
475 | ||
476 | if (verbose) | |
477 | einfo (_("%P: About to run error handling script '%s' with arguments: '%s' '%s'\n"), | |
478 | argv[0], argv[1], argv[2]); | |
479 | ||
480 | res = pex_one (PEX_SEARCH, error_handling_script, argv, | |
481 | N_("error handling script"), | |
482 | NULL /* Send stdout to random, temp file. */, | |
483 | NULL /* Write to stderr. */, | |
484 | &status, &err); | |
485 | if (res != NULL) | |
486 | { | |
487 | einfo (_("%P: Failed to run error handling script '%s', reason: "), | |
488 | error_handling_script); | |
489 | /* FIXME: We assume here that errrno == err. */ | |
490 | perror (res); | |
491 | } | |
492 | else /* We ignore the return status of the script | |
493 | and always print the error message. */ | |
494 | einfo (_("%P: cannot find %s\n"), entry->local_sym_name); | |
495 | } | |
496 | #endif | |
c4b78195 NC |
497 | else |
498 | einfo (_("%P: cannot find %s\n"), entry->local_sym_name); | |
77bf7b53 NC |
499 | |
500 | /* PR 25747: Be kind to users who forgot to add the | |
501 | "lib" prefix to their library when it was created. */ | |
502 | for (arch = search_arch_head; arch != NULL; arch = arch->next) | |
503 | { | |
504 | if (ldfile_open_file_search (arch->name, entry, "", ".a")) | |
505 | { | |
506 | const char * base = lbasename (entry->filename); | |
507 | ||
4f5bd885 | 508 | einfo (_("%P: note to link with %s use -l:%s or rename it to lib%s\n"), |
77bf7b53 NC |
509 | entry->filename, base, base); |
510 | bfd_close (entry->the_bfd); | |
511 | entry->the_bfd = NULL; | |
512 | break; | |
513 | } | |
514 | } | |
23ae20f5 | 515 | |
66be1055 AM |
516 | entry->flags.missing_file = TRUE; |
517 | input_flags.missing_file = TRUE; | |
c4b78195 | 518 | } |
252b5132 RH |
519 | } |
520 | } | |
521 | ||
f4a23d42 | 522 | /* Try to open NAME. */ |
252b5132 RH |
523 | |
524 | static FILE * | |
f4a23d42 | 525 | try_open (const char *name, bfd_boolean *sysrooted) |
252b5132 RH |
526 | { |
527 | FILE *result; | |
252b5132 RH |
528 | |
529 | result = fopen (name, "r"); | |
4de2d33d | 530 | |
f4a23d42 AM |
531 | if (result != NULL) |
532 | *sysrooted = is_sysrooted_pathname (name); | |
533 | ||
cd6f1cf3 | 534 | if (verbose) |
252b5132 RH |
535 | { |
536 | if (result == NULL) | |
537 | info_msg (_("cannot find script file %s\n"), name); | |
538 | else | |
539 | info_msg (_("opened script file %s\n"), name); | |
540 | } | |
541 | ||
252b5132 RH |
542 | return result; |
543 | } | |
544 | ||
a8caa245 AM |
545 | /* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */ |
546 | ||
547 | static bfd_boolean | |
548 | check_for_scripts_dir (char *dir) | |
549 | { | |
550 | char *buf; | |
551 | struct stat s; | |
552 | bfd_boolean res; | |
553 | ||
554 | buf = concat (dir, "/ldscripts", (const char *) NULL); | |
555 | res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode); | |
556 | free (buf); | |
557 | return res; | |
558 | } | |
559 | ||
560 | /* Return the default directory for finding script files. | |
561 | We look for the "ldscripts" directory in: | |
562 | ||
563 | SCRIPTDIR (passed from Makefile) | |
564 | (adjusted according to the current location of the binary) | |
c38b10fa | 565 | the dir where this program is (for using it from the build tree). */ |
a8caa245 AM |
566 | |
567 | static char * | |
568 | find_scripts_dir (void) | |
569 | { | |
c38b10fa | 570 | char *dir; |
a8caa245 AM |
571 | |
572 | dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR); | |
573 | if (dir) | |
574 | { | |
575 | if (check_for_scripts_dir (dir)) | |
576 | return dir; | |
577 | free (dir); | |
578 | } | |
579 | ||
580 | dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR); | |
581 | if (dir) | |
582 | { | |
583 | if (check_for_scripts_dir (dir)) | |
584 | return dir; | |
585 | free (dir); | |
586 | } | |
587 | ||
a8caa245 | 588 | /* Look for "ldscripts" in the dir where our binary is. */ |
c38b10fa AM |
589 | dir = make_relative_prefix (program_name, ".", "."); |
590 | if (dir) | |
591 | { | |
592 | if (check_for_scripts_dir (dir)) | |
593 | return dir; | |
594 | free (dir); | |
595 | } | |
a8caa245 | 596 | |
a8caa245 AM |
597 | return NULL; |
598 | } | |
599 | ||
8c3e16f4 L |
600 | /* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for |
601 | it in directories specified with -L, then in the default script | |
f4a23d42 AM |
602 | directory. If DEFAULT_ONLY is true, the search is restricted to |
603 | the default script location. */ | |
252b5132 | 604 | |
279e75dc | 605 | static FILE * |
f4a23d42 AM |
606 | ldfile_find_command_file (const char *name, |
607 | bfd_boolean default_only, | |
608 | bfd_boolean *sysrooted) | |
252b5132 RH |
609 | { |
610 | search_dirs_type *search; | |
32252ac1 | 611 | FILE *result = NULL; |
f4a23d42 | 612 | char *path; |
a8caa245 | 613 | static search_dirs_type *script_search; |
252b5132 | 614 | |
8c3e16f4 L |
615 | if (!default_only) |
616 | { | |
617 | /* First try raw name. */ | |
f4a23d42 | 618 | result = try_open (name, sysrooted); |
8c3e16f4 L |
619 | if (result != NULL) |
620 | return result; | |
621 | } | |
a8caa245 AM |
622 | |
623 | if (!script_search) | |
1c64c4ed | 624 | { |
a8caa245 AM |
625 | char *script_dir = find_scripts_dir (); |
626 | if (script_dir) | |
1c64c4ed | 627 | { |
a8caa245 AM |
628 | search_dirs_type **save_tail_ptr = search_tail_ptr; |
629 | search_tail_ptr = &script_search; | |
630 | ldfile_add_library_path (script_dir, TRUE); | |
631 | search_tail_ptr = save_tail_ptr; | |
1c64c4ed | 632 | } |
a8caa245 AM |
633 | } |
634 | ||
7d24f02c KH |
635 | /* Temporarily append script_search to the path list so that the |
636 | paths specified with -L will be searched first. */ | |
637 | *search_tail_ptr = script_search; | |
638 | ||
a8caa245 | 639 | /* Try now prefixes. */ |
7d24f02c KH |
640 | for (search = default_only ? script_search : search_head; |
641 | search != NULL; | |
642 | search = search->next) | |
a8caa245 | 643 | { |
f4a23d42 AM |
644 | path = concat (search->name, slash, name, (const char *) NULL); |
645 | result = try_open (path, sysrooted); | |
646 | free (path); | |
a8caa245 AM |
647 | if (result) |
648 | break; | |
252b5132 | 649 | } |
4de2d33d | 650 | |
7d24f02c KH |
651 | /* Restore the original path list. */ |
652 | *search_tail_ptr = NULL; | |
653 | ||
252b5132 RH |
654 | return result; |
655 | } | |
656 | ||
82d7a6f4 AM |
657 | enum script_open_style { |
658 | script_nonT, | |
659 | script_T, | |
660 | script_defaultT | |
661 | }; | |
662 | ||
663 | struct script_name_list | |
664 | { | |
665 | struct script_name_list *next; | |
666 | enum script_open_style open_how; | |
667 | char name[1]; | |
668 | }; | |
669 | ||
7d24f02c KH |
670 | /* Open command file NAME. */ |
671 | ||
672 | static void | |
82d7a6f4 | 673 | ldfile_open_command_file_1 (const char *name, enum script_open_style open_how) |
252b5132 RH |
674 | { |
675 | FILE *ldlex_input_stack; | |
f4a23d42 | 676 | bfd_boolean sysrooted; |
82d7a6f4 AM |
677 | static struct script_name_list *processed_scripts = NULL; |
678 | struct script_name_list *script; | |
679 | size_t len; | |
f4a23d42 | 680 | |
82d7a6f4 AM |
681 | /* PR 24576: Catch the case where the user has accidentally included |
682 | the same linker script twice. */ | |
683 | for (script = processed_scripts; script != NULL; script = script->next) | |
6ec6968b | 684 | { |
82d7a6f4 AM |
685 | if ((open_how != script_nonT || script->open_how != script_nonT) |
686 | && strcmp (name, script->name) == 0) | |
6ec6968b | 687 | { |
82d7a6f4 AM |
688 | einfo (_("%F%P: error: linker script file '%s'" |
689 | " appears multiple times\n"), name); | |
690 | return; | |
6ec6968b | 691 | } |
6ec6968b NC |
692 | } |
693 | ||
82d7a6f4 AM |
694 | /* FIXME: This memory is never freed, but that should not really matter. |
695 | It will be released when the linker exits, and it is unlikely to ever | |
696 | be more than a few tens of bytes. */ | |
697 | len = strlen (name); | |
698 | script = xmalloc (sizeof (*script) + len); | |
699 | script->next = processed_scripts; | |
700 | script->open_how = open_how; | |
701 | memcpy (script->name, name, len + 1); | |
702 | processed_scripts = script; | |
703 | ||
704 | ldlex_input_stack = ldfile_find_command_file (name, | |
705 | open_how == script_defaultT, | |
706 | &sysrooted); | |
1579bae1 | 707 | if (ldlex_input_stack == NULL) |
1c64c4ed NC |
708 | { |
709 | bfd_set_error (bfd_error_system_call); | |
df5f2391 | 710 | einfo (_("%F%P: cannot open linker script file %s: %E\n"), name); |
3ab6909a | 711 | return; |
1c64c4ed | 712 | } |
4de2d33d | 713 | |
f37b21b4 RM |
714 | track_dependency_files (name); |
715 | ||
f4a23d42 | 716 | lex_push_file (ldlex_input_stack, name, sysrooted); |
4de2d33d | 717 | |
252b5132 | 718 | lineno = 1; |
b7a26f91 | 719 | |
b9a8de1e | 720 | saved_script_handle = ldlex_input_stack; |
252b5132 RH |
721 | } |
722 | ||
7d24f02c KH |
723 | /* Open command file NAME in the current directory, -L directories, |
724 | the default script location, in that order. */ | |
725 | ||
726 | void | |
727 | ldfile_open_command_file (const char *name) | |
728 | { | |
82d7a6f4 | 729 | ldfile_open_command_file_1 (name, script_nonT); |
6ec6968b NC |
730 | } |
731 | ||
732 | void | |
733 | ldfile_open_script_file (const char *name) | |
734 | { | |
82d7a6f4 | 735 | ldfile_open_command_file_1 (name, script_T); |
7d24f02c KH |
736 | } |
737 | ||
738 | /* Open command file NAME at the default script location. */ | |
739 | ||
740 | void | |
741 | ldfile_open_default_command_file (const char *name) | |
742 | { | |
82d7a6f4 | 743 | ldfile_open_command_file_1 (name, script_defaultT); |
7d24f02c KH |
744 | } |
745 | ||
252b5132 | 746 | void |
1579bae1 | 747 | ldfile_add_arch (const char *in_name) |
252b5132 | 748 | { |
d1b2b2dc | 749 | char *name = xstrdup (in_name); |
0aa7f586 AM |
750 | search_arch_type *new_arch |
751 | = (search_arch_type *) xmalloc (sizeof (search_arch_type)); | |
252b5132 RH |
752 | |
753 | ldfile_output_machine_name = in_name; | |
754 | ||
d3ce72d0 NC |
755 | new_arch->name = name; |
756 | new_arch->next = NULL; | |
252b5132 RH |
757 | while (*name) |
758 | { | |
3882b010 | 759 | *name = TOLOWER (*name); |
252b5132 RH |
760 | name++; |
761 | } | |
d3ce72d0 NC |
762 | *search_arch_tail_ptr = new_arch; |
763 | search_arch_tail_ptr = &new_arch->next; | |
252b5132 RH |
764 | |
765 | } | |
252b5132 | 766 | |
89cdebba KH |
767 | /* Set the output architecture. */ |
768 | ||
252b5132 | 769 | void |
5e2f1575 | 770 | ldfile_set_output_arch (const char *string, enum bfd_architecture defarch) |
252b5132 | 771 | { |
1c64c4ed NC |
772 | const bfd_arch_info_type *arch = bfd_scan_arch (string); |
773 | ||
774 | if (arch) | |
775 | { | |
776 | ldfile_output_architecture = arch->arch; | |
777 | ldfile_output_machine = arch->mach; | |
778 | ldfile_output_machine_name = arch->printable_name; | |
779 | } | |
5e2f1575 AM |
780 | else if (defarch != bfd_arch_unknown) |
781 | ldfile_output_architecture = defarch; | |
1c64c4ed | 782 | else |
df5f2391 | 783 | einfo (_("%F%P: cannot represent machine `%s'\n"), string); |
252b5132 | 784 | } |