]>
Commit | Line | Data |
---|---|---|
d7f09764 | 1 | /* Wrapper to call lto. Used by collect2 and the linker plugin. |
aeee4812 | 2 | Copyright (C) 2009-2023 Free Software Foundation, Inc. |
d7f09764 DN |
3 | |
4 | Factored out of collect2 by Rafael Espindola <espindola@google.com> | |
5 | ||
6 | This file is part of GCC. | |
7 | ||
8 | GCC is free software; you can redistribute it and/or modify it under | |
9 | the terms of the GNU General Public License as published by the Free | |
10 | Software Foundation; either version 3, or (at your option) any later | |
11 | version. | |
12 | ||
13 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
14 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 | for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with GCC; see the file COPYING3. If not see | |
20 | <http://www.gnu.org/licenses/>. */ | |
21 | ||
22 | ||
23 | /* This program is passed a gcc, a list of gcc arguments and a list of | |
24 | object files containing IL. It scans the argument list to check if | |
25 | we are in whopr mode or not modifies the arguments and needed and | |
26 | prints a list of output files on stdout. | |
27 | ||
28 | Example: | |
29 | ||
30 | $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto | |
31 | ||
32 | The above will print something like | |
33 | /tmp/ccwbQ8B2.lto.o | |
34 | ||
014d92e1 | 35 | If WHOPR is used instead, more than one file might be produced |
d7f09764 DN |
36 | ./ccXj2DTk.lto.ltrans.o |
37 | ./ccCJuXGv.lto.ltrans.o | |
38 | */ | |
39 | ||
1270ccda | 40 | #define INCLUDE_STRING |
d7f09764 DN |
41 | #include "config.h" |
42 | #include "system.h" | |
10692477 | 43 | #include "coretypes.h" |
d7f09764 | 44 | #include "intl.h" |
2691e6d7 | 45 | #include "diagnostic.h" |
48cf395b | 46 | #include "obstack.h" |
f31c0018 RG |
47 | #include "opts.h" |
48 | #include "options.h" | |
52a35ef7 | 49 | #include "simple-object.h" |
4000360e | 50 | #include "lto-section-names.h" |
a185856a | 51 | #include "collect-utils.h" |
7d7d925d | 52 | #include "opts-diagnostic.h" |
1270ccda ML |
53 | #include "opt-suggestions.h" |
54 | #include "opts-jobserver.h" | |
d7f09764 | 55 | |
fc8b3540 IV |
56 | /* Environment variable, used for passing the names of offload targets from GCC |
57 | driver to lto-wrapper. */ | |
58 | #define OFFLOAD_TARGET_NAMES_ENV "OFFLOAD_TARGET_NAMES" | |
fe5bfa67 | 59 | #define OFFLOAD_TARGET_DEFAULT_ENV "OFFLOAD_TARGET_DEFAULT" |
fc8b3540 | 60 | |
1dedc12d AO |
61 | /* By default there is no special suffix for target executables. */ |
62 | #ifdef TARGET_EXECUTABLE_SUFFIX | |
63 | #define HAVE_TARGET_EXECUTABLE_SUFFIX | |
64 | #else | |
65 | #define TARGET_EXECUTABLE_SUFFIX "" | |
66 | #endif | |
67 | ||
d7f09764 | 68 | enum lto_mode_d { |
cf96bae7 RG |
69 | LTO_MODE_NONE, /* Not doing LTO. */ |
70 | LTO_MODE_LTO, /* Normal LTO. */ | |
71 | LTO_MODE_WHOPR /* WHOPR. */ | |
d7f09764 DN |
72 | }; |
73 | ||
74 | /* Current LTO mode. */ | |
75 | static enum lto_mode_d lto_mode = LTO_MODE_NONE; | |
76 | ||
b1b07c92 RG |
77 | static char *ltrans_output_file; |
78 | static char *flto_out; | |
50ee30d5 | 79 | static unsigned int nr; |
b6e33d73 | 80 | static int *ltrans_priorities; |
50ee30d5 RG |
81 | static char **input_names; |
82 | static char **output_names; | |
fc8b3540 | 83 | static char **offload_names; |
e6861a99 | 84 | static char *offload_objects_file_name; |
50ee30d5 | 85 | static char *makefile; |
b5327e50 IS |
86 | static unsigned int num_deb_objs; |
87 | static const char **early_debug_object_names; | |
f1a681a1 | 88 | static bool xassembler_options_error = false; |
b1b07c92 | 89 | |
a185856a | 90 | const char tool_name[] = "lto-wrapper"; |
b1b07c92 | 91 | |
e228683b TB |
92 | /* Auxiliary function that frees elements of PTR and PTR itself. |
93 | N is number of elements to be freed. If PTR is NULL, nothing is freed. | |
94 | If an element is NULL, subsequent elements are not freed. */ | |
95 | ||
96 | static void ** | |
97 | free_array_of_ptrs (void **ptr, unsigned n) | |
98 | { | |
99 | if (!ptr) | |
100 | return NULL; | |
101 | for (unsigned i = 0; i < n; i++) | |
102 | { | |
103 | if (!ptr[i]) | |
104 | break; | |
105 | free (ptr[i]); | |
106 | } | |
107 | free (ptr); | |
108 | return NULL; | |
109 | } | |
110 | ||
a185856a | 111 | /* Delete tempfiles. Called from utils_cleanup. */ |
b1b07c92 | 112 | |
a185856a | 113 | void |
5f0ad6a5 | 114 | tool_cleanup (bool) |
b1b07c92 | 115 | { |
396717c9 RG |
116 | unsigned int i; |
117 | ||
396717c9 | 118 | if (ltrans_output_file) |
a185856a | 119 | maybe_unlink (ltrans_output_file); |
396717c9 | 120 | if (flto_out) |
a185856a | 121 | maybe_unlink (flto_out); |
e6861a99 IV |
122 | if (offload_objects_file_name) |
123 | maybe_unlink (offload_objects_file_name); | |
396717c9 | 124 | if (makefile) |
a185856a | 125 | maybe_unlink (makefile); |
b5327e50 IS |
126 | if (early_debug_object_names) |
127 | for (i = 0; i < num_deb_objs; ++i) | |
128 | if (early_debug_object_names[i]) | |
129 | maybe_unlink (early_debug_object_names[i]); | |
396717c9 | 130 | for (i = 0; i < nr; ++i) |
8aea79e6 | 131 | { |
a185856a | 132 | maybe_unlink (input_names[i]); |
396717c9 | 133 | if (output_names[i]) |
a185856a | 134 | maybe_unlink (output_names[i]); |
8aea79e6 | 135 | } |
e228683b TB |
136 | if (offload_names) |
137 | { | |
138 | for (i = 0; offload_names[i]; i++) | |
139 | maybe_unlink (offload_names[i]); | |
140 | free_array_of_ptrs ((void **) offload_names, i); | |
141 | } | |
396717c9 RG |
142 | } |
143 | ||
144 | static void | |
a185856a | 145 | lto_wrapper_cleanup (void) |
d7f09764 | 146 | { |
5f0ad6a5 | 147 | utils_cleanup (false); |
d7f09764 DN |
148 | } |
149 | ||
d7f09764 DN |
150 | /* Unlink a temporary LTRANS file unless requested otherwise. */ |
151 | ||
a185856a BS |
152 | void |
153 | maybe_unlink (const char *file) | |
d7f09764 | 154 | { |
608508a6 | 155 | if (!save_temps) |
d7f09764 | 156 | { |
62116e60 RG |
157 | if (unlink_if_ordinary (file) |
158 | && errno != ENOENT) | |
40fecdd6 | 159 | fatal_error (input_location, "deleting LTRANS file %s: %m", file); |
d7f09764 | 160 | } |
eba14fca | 161 | else if (verbose) |
d7f09764 DN |
162 | fprintf (stderr, "[Leaving LTRANS %s]\n", file); |
163 | } | |
164 | ||
48cf395b | 165 | /* Template of LTRANS dumpbase suffix. */ |
1dedc12d | 166 | #define DUMPBASE_SUFFIX "ltrans18446744073709551615" |
d7f09764 | 167 | |
f31c0018 | 168 | /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS |
8508ae1d | 169 | environment. */ |
f31c0018 | 170 | |
227a2ecf | 171 | static vec<cl_decoded_option> |
f31c0018 | 172 | get_options_from_collect_gcc_options (const char *collect_gcc, |
227a2ecf | 173 | const char *collect_gcc_options) |
f31c0018 | 174 | { |
227a2ecf ML |
175 | cl_decoded_option *decoded_options; |
176 | unsigned int decoded_options_count; | |
969d578c | 177 | struct obstack argv_obstack; |
f31c0018 | 178 | const char **argv; |
f1a681a1 | 179 | int argc; |
969d578c | 180 | |
969d578c RG |
181 | obstack_init (&argv_obstack); |
182 | obstack_ptr_grow (&argv_obstack, collect_gcc); | |
183 | ||
f1a681a1 PK |
184 | parse_options_from_collect_gcc_options (collect_gcc_options, |
185 | &argv_obstack, &argc); | |
969d578c | 186 | argv = XOBFINISH (&argv_obstack, const char **); |
f31c0018 | 187 | |
8508ae1d | 188 | decode_cmdline_options_to_array (argc, (const char **)argv, CL_DRIVER, |
227a2ecf ML |
189 | &decoded_options, &decoded_options_count); |
190 | vec<cl_decoded_option> decoded; | |
191 | decoded.create (decoded_options_count); | |
192 | for (unsigned i = 0; i < decoded_options_count; ++i) | |
193 | decoded.quick_push (decoded_options[i]); | |
194 | free (decoded_options); | |
195 | ||
969d578c | 196 | obstack_free (&argv_obstack, NULL); |
227a2ecf ML |
197 | |
198 | return decoded; | |
f31c0018 RG |
199 | } |
200 | ||
8a8ee37a JM |
201 | /* Find option in OPTIONS based on OPT_INDEX, starting at START. -1 |
202 | value is returned if the option is not present. */ | |
52a35ef7 | 203 | |
227a2ecf | 204 | static int |
8a8ee37a JM |
205 | find_option (vec<cl_decoded_option> &options, size_t opt_index, |
206 | unsigned start = 0) | |
52a35ef7 | 207 | { |
8a8ee37a | 208 | for (unsigned i = start; i < options.length (); ++i) |
227a2ecf ML |
209 | if (options[i].opt_index == opt_index) |
210 | return i; | |
52a35ef7 | 211 | |
227a2ecf ML |
212 | return -1; |
213 | } | |
472a2536 | 214 | |
227a2ecf ML |
215 | static int |
216 | find_option (vec<cl_decoded_option> &options, cl_decoded_option *option) | |
472a2536 | 217 | { |
227a2ecf | 218 | return find_option (options, option->opt_index); |
472a2536 JH |
219 | } |
220 | ||
3cbcb5d0 ML |
221 | /* Merge -flto FOPTION into vector of DECODED_OPTIONS. */ |
222 | ||
223 | static void | |
224 | merge_flto_options (vec<cl_decoded_option> &decoded_options, | |
225 | cl_decoded_option *foption) | |
226 | { | |
227 | int existing_opt = find_option (decoded_options, foption); | |
228 | if (existing_opt == -1) | |
229 | decoded_options.safe_push (*foption); | |
230 | else | |
231 | { | |
232 | if (strcmp (foption->arg, decoded_options[existing_opt].arg) != 0) | |
233 | { | |
234 | /* -flto=auto is preferred. */ | |
235 | if (strcmp (decoded_options[existing_opt].arg, "auto") == 0) | |
236 | ; | |
237 | else if (strcmp (foption->arg, "auto") == 0 | |
238 | || strcmp (foption->arg, "jobserver") == 0) | |
239 | decoded_options[existing_opt].arg = foption->arg; | |
240 | else if (strcmp (decoded_options[existing_opt].arg, | |
241 | "jobserver") != 0) | |
242 | { | |
243 | int n = atoi (foption->arg); | |
244 | int original_n = atoi (decoded_options[existing_opt].arg); | |
245 | if (n > original_n) | |
246 | decoded_options[existing_opt].arg = foption->arg; | |
247 | } | |
248 | } | |
249 | } | |
250 | } | |
251 | ||
52a35ef7 RG |
252 | /* Try to merge and complain about options FDECODED_OPTIONS when applied |
253 | ontop of DECODED_OPTIONS. */ | |
254 | ||
255 | static void | |
c905e724 | 256 | merge_and_complain (vec<cl_decoded_option> &decoded_options, |
227a2ecf ML |
257 | vec<cl_decoded_option> fdecoded_options, |
258 | vec<cl_decoded_option> decoded_cl_options) | |
52a35ef7 RG |
259 | { |
260 | unsigned int i, j; | |
227a2ecf ML |
261 | cl_decoded_option *pic_option = NULL; |
262 | cl_decoded_option *pie_option = NULL; | |
263 | cl_decoded_option *cf_protection_option = NULL; | |
52a35ef7 RG |
264 | |
265 | /* ??? Merge options from files. Most cases can be | |
266 | handled by either unioning or intersecting | |
267 | (for example -fwrapv is a case for unioning, | |
268 | -ffast-math is for intersection). Most complaints | |
269 | about real conflicts between different options can | |
270 | be deferred to the compiler proper. Options that | |
271 | we can neither safely handle by intersection nor | |
272 | unioning would need to be complained about here. | |
273 | Ideally we'd have a flag in the opt files that | |
274 | tells whether to union or intersect or reject. | |
275 | In absence of that it's unclear what a good default is. | |
276 | It's also difficult to get positional handling correct. */ | |
277 | ||
6a48d124 MK |
278 | /* Look for a -fcf-protection option in the link-time options |
279 | which overrides any -fcf-protection from the lto sections. */ | |
227a2ecf | 280 | for (i = 0; i < decoded_cl_options.length (); ++i) |
6a48d124 | 281 | { |
227a2ecf | 282 | cl_decoded_option *foption = &decoded_cl_options[i]; |
6a48d124 MK |
283 | if (foption->opt_index == OPT_fcf_protection_) |
284 | { | |
285 | cf_protection_option = foption; | |
286 | } | |
287 | } | |
288 | ||
52a35ef7 RG |
289 | /* The following does what the old LTO option code did, |
290 | union all target and a selected set of common options. */ | |
227a2ecf | 291 | for (i = 0; i < fdecoded_options.length (); ++i) |
52a35ef7 | 292 | { |
227a2ecf ML |
293 | cl_decoded_option *foption = &fdecoded_options[i]; |
294 | int existing_opt = find_option (decoded_options, foption); | |
52a35ef7 RG |
295 | switch (foption->opt_index) |
296 | { | |
169d8507 L |
297 | case OPT_SPECIAL_unknown: |
298 | case OPT_SPECIAL_ignore: | |
68a57628 | 299 | case OPT_SPECIAL_warn_removed: |
169d8507 L |
300 | case OPT_SPECIAL_program_name: |
301 | case OPT_SPECIAL_input_file: | |
302 | break; | |
303 | ||
52a35ef7 RG |
304 | default: |
305 | if (!(cl_options[foption->opt_index].flags & CL_TARGET)) | |
306 | break; | |
307 | ||
308 | /* Fallthru. */ | |
eb472171 | 309 | case OPT_fdiagnostics_show_caret: |
96e6ae57 | 310 | case OPT_fdiagnostics_show_labels: |
56b61d7f | 311 | case OPT_fdiagnostics_show_line_numbers: |
eb472171 CLT |
312 | case OPT_fdiagnostics_show_option: |
313 | case OPT_fdiagnostics_show_location_: | |
314 | case OPT_fshow_column: | |
52a35ef7 | 315 | case OPT_fcommon: |
aad038ca | 316 | case OPT_fgnu_tm: |
5a307ee5 | 317 | case OPT_g: |
52a35ef7 RG |
318 | /* Do what the old LTO code did - collect exactly one option |
319 | setting per OPT code, we pick the first we encounter. | |
320 | ??? This doesn't make too much sense, but when it doesn't | |
321 | then we should complain. */ | |
227a2ecf ML |
322 | if (existing_opt == -1) |
323 | decoded_options.safe_push (*foption); | |
52a35ef7 | 324 | break; |
8bb50e5c | 325 | |
472a2536 JH |
326 | /* Figure out what PIC/PIE level wins and merge the results. */ |
327 | case OPT_fPIC: | |
328 | case OPT_fpic: | |
329 | pic_option = foption; | |
330 | break; | |
331 | case OPT_fPIE: | |
332 | case OPT_fpie: | |
333 | pie_option = foption; | |
334 | break; | |
335 | ||
1506ae0e | 336 | case OPT_fopenmp: |
a0c88d06 | 337 | case OPT_fopenacc: |
9453e3cd AS |
338 | case OPT_fasynchronous_unwind_tables: |
339 | case OPT_funwind_tables: | |
4094757e | 340 | /* For selected options we can merge conservatively. */ |
227a2ecf ML |
341 | if (existing_opt == -1) |
342 | decoded_options.safe_push (*foption); | |
2fff1c81 | 343 | /* -fopenmp > -fno-openmp, |
c0c12356 | 344 | -fopenacc > -fno-openacc */ |
227a2ecf ML |
345 | else if (foption->value > decoded_options[existing_opt].value) |
346 | decoded_options[existing_opt] = *foption; | |
4094757e RB |
347 | break; |
348 | ||
b6adbb9f NS |
349 | case OPT_fopenacc_dim_: |
350 | /* Append or check identical. */ | |
227a2ecf ML |
351 | if (existing_opt == -1) |
352 | decoded_options.safe_push (*foption); | |
353 | else if (strcmp (decoded_options[existing_opt].arg, foption->arg)) | |
b6adbb9f | 354 | fatal_error (input_location, |
a9c697b8 | 355 | "option %s with different values", |
b6adbb9f NS |
356 | foption->orig_option_with_args_text); |
357 | break; | |
358 | ||
6a48d124 MK |
359 | case OPT_fcf_protection_: |
360 | /* Default to link-time option, else append or check identical. */ | |
c4c22e83 L |
361 | if (!cf_protection_option |
362 | || cf_protection_option->value == CF_CHECK) | |
6a48d124 | 363 | { |
227a2ecf ML |
364 | if (existing_opt == -1) |
365 | decoded_options.safe_push (*foption); | |
366 | else if (decoded_options[existing_opt].value != foption->value) | |
c4c22e83 L |
367 | { |
368 | if (cf_protection_option | |
369 | && cf_protection_option->value == CF_CHECK) | |
370 | fatal_error (input_location, | |
ca23341b | 371 | "option %qs with mismatching values" |
c4c22e83 | 372 | " (%s, %s)", |
ca23341b | 373 | "-fcf-protection", |
227a2ecf ML |
374 | decoded_options[existing_opt].arg, |
375 | foption->arg); | |
c4c22e83 L |
376 | else |
377 | { | |
378 | /* Merge and update the -fcf-protection option. */ | |
227a2ecf ML |
379 | decoded_options[existing_opt].value |
380 | &= (foption->value & CF_FULL); | |
381 | switch (decoded_options[existing_opt].value) | |
c4c22e83 L |
382 | { |
383 | case CF_NONE: | |
227a2ecf | 384 | decoded_options[existing_opt].arg = "none"; |
c4c22e83 L |
385 | break; |
386 | case CF_BRANCH: | |
227a2ecf | 387 | decoded_options[existing_opt].arg = "branch"; |
c4c22e83 L |
388 | break; |
389 | case CF_RETURN: | |
227a2ecf | 390 | decoded_options[existing_opt].arg = "return"; |
c4c22e83 L |
391 | break; |
392 | default: | |
393 | gcc_unreachable (); | |
394 | } | |
395 | } | |
396 | } | |
6a48d124 | 397 | } |
c4c22e83 | 398 | break; |
6a48d124 | 399 | |
f3ba16d0 RB |
400 | case OPT_O: |
401 | case OPT_Ofast: | |
402 | case OPT_Og: | |
403 | case OPT_Os: | |
e742722f | 404 | case OPT_Oz: |
227a2ecf ML |
405 | existing_opt = -1; |
406 | for (j = 0; j < decoded_options.length (); ++j) | |
407 | if (decoded_options[j].opt_index == OPT_O | |
408 | || decoded_options[j].opt_index == OPT_Ofast | |
409 | || decoded_options[j].opt_index == OPT_Og | |
e742722f RS |
410 | || decoded_options[j].opt_index == OPT_Os |
411 | || decoded_options[j].opt_index == OPT_Oz) | |
227a2ecf ML |
412 | { |
413 | existing_opt = j; | |
414 | break; | |
415 | } | |
416 | if (existing_opt == -1) | |
417 | decoded_options.safe_push (*foption); | |
418 | else if (decoded_options[existing_opt].opt_index == foption->opt_index | |
f3ba16d0 RB |
419 | && foption->opt_index != OPT_O) |
420 | /* Exact same options get merged. */ | |
421 | ; | |
422 | else | |
423 | { | |
424 | /* For mismatched option kinds preserve the optimization | |
425 | level only, thus merge it as -On. This also handles | |
426 | merging of same optimization level -On. */ | |
427 | int level = 0; | |
428 | switch (foption->opt_index) | |
429 | { | |
430 | case OPT_O: | |
431 | if (foption->arg[0] == '\0') | |
432 | level = MAX (level, 1); | |
433 | else | |
434 | level = MAX (level, atoi (foption->arg)); | |
435 | break; | |
436 | case OPT_Ofast: | |
437 | level = MAX (level, 3); | |
438 | break; | |
439 | case OPT_Og: | |
440 | level = MAX (level, 1); | |
441 | break; | |
442 | case OPT_Os: | |
e742722f | 443 | case OPT_Oz: |
f3ba16d0 RB |
444 | level = MAX (level, 2); |
445 | break; | |
446 | default: | |
447 | gcc_unreachable (); | |
448 | } | |
227a2ecf | 449 | switch (decoded_options[existing_opt].opt_index) |
f3ba16d0 RB |
450 | { |
451 | case OPT_O: | |
227a2ecf | 452 | if (decoded_options[existing_opt].arg[0] == '\0') |
f3ba16d0 RB |
453 | level = MAX (level, 1); |
454 | else | |
227a2ecf ML |
455 | level = MAX (level, |
456 | atoi (decoded_options[existing_opt].arg)); | |
f3ba16d0 RB |
457 | break; |
458 | case OPT_Ofast: | |
459 | level = MAX (level, 3); | |
460 | break; | |
461 | case OPT_Og: | |
462 | level = MAX (level, 1); | |
463 | break; | |
464 | case OPT_Os: | |
e742722f | 465 | case OPT_Oz: |
f3ba16d0 RB |
466 | level = MAX (level, 2); |
467 | break; | |
468 | default: | |
469 | gcc_unreachable (); | |
470 | } | |
227a2ecf | 471 | decoded_options[existing_opt].opt_index = OPT_O; |
f3ba16d0 | 472 | char *tem; |
582f770b | 473 | tem = xasprintf ("-O%d", level); |
227a2ecf ML |
474 | decoded_options[existing_opt].arg = &tem[2]; |
475 | decoded_options[existing_opt].canonical_option[0] = tem; | |
476 | decoded_options[existing_opt].value = 1; | |
f3ba16d0 RB |
477 | } |
478 | break; | |
472a2536 JH |
479 | |
480 | ||
481 | case OPT_foffload_abi_: | |
227a2ecf ML |
482 | if (existing_opt == -1) |
483 | decoded_options.safe_push (*foption); | |
484 | else if (foption->value != decoded_options[existing_opt].value) | |
472a2536 | 485 | fatal_error (input_location, |
a9c697b8 | 486 | "option %s not used consistently in all LTO input" |
472a2536 JH |
487 | " files", foption->orig_option_with_args_text); |
488 | break; | |
489 | ||
c713ddc0 | 490 | |
33c4e466 | 491 | case OPT_foffload_options_: |
227a2ecf | 492 | decoded_options.safe_push (*foption); |
c713ddc0 | 493 | break; |
3835aa0e ML |
494 | |
495 | case OPT_flto_: | |
3cbcb5d0 | 496 | merge_flto_options (decoded_options, foption); |
3835aa0e | 497 | break; |
52a35ef7 RG |
498 | } |
499 | } | |
472a2536 JH |
500 | |
501 | /* Merge PIC options: | |
502 | -fPIC + -fpic = -fpic | |
503 | -fPIC + -fno-pic = -fno-pic | |
5afa32b8 | 504 | -fpic/-fPIC + nothing = nothing. |
472a2536 JH |
505 | It is a common mistake to mix few -fPIC compiled objects into otherwise |
506 | non-PIC code. We do not want to build everything with PIC then. | |
507 | ||
4e6a9380 JH |
508 | Similarly we merge PIE options, however in addition we keep |
509 | -fPIC + -fPIE = -fPIE | |
510 | -fpic + -fPIE = -fpie | |
511 | -fPIC/-fpic + -fpie = -fpie | |
512 | ||
472a2536 JH |
513 | It would be good to warn on mismatches, but it is bit hard to do as |
514 | we do not know what nothing translates to. */ | |
515 | ||
227a2ecf ML |
516 | for (unsigned int j = 0; j < decoded_options.length ();) |
517 | if (decoded_options[j].opt_index == OPT_fPIC | |
518 | || decoded_options[j].opt_index == OPT_fpic) | |
472a2536 | 519 | { |
4e6a9380 | 520 | /* -fno-pic in one unit implies -fno-pic everywhere. */ |
227a2ecf | 521 | if (decoded_options[j].value == 0) |
4e6a9380 JH |
522 | j++; |
523 | /* If we have no pic option or merge in -fno-pic, we still may turn | |
524 | existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */ | |
525 | else if ((pic_option && pic_option->value == 0) | |
526 | || !pic_option) | |
527 | { | |
528 | if (pie_option) | |
529 | { | |
227a2ecf | 530 | bool big = decoded_options[j].opt_index == OPT_fPIC |
4e6a9380 | 531 | && pie_option->opt_index == OPT_fPIE; |
227a2ecf | 532 | decoded_options[j].opt_index = big ? OPT_fPIE : OPT_fpie; |
4e6a9380 | 533 | if (pie_option->value) |
227a2ecf | 534 | decoded_options[j].canonical_option[0] |
5afa32b8 | 535 | = big ? "-fPIE" : "-fpie"; |
4e6a9380 | 536 | else |
227a2ecf ML |
537 | decoded_options[j].canonical_option[0] = "-fno-pie"; |
538 | decoded_options[j].value = pie_option->value; | |
539 | j++; | |
4e6a9380 JH |
540 | } |
541 | else if (pic_option) | |
542 | { | |
227a2ecf ML |
543 | decoded_options[j] = *pic_option; |
544 | j++; | |
4e6a9380 JH |
545 | } |
546 | /* We do not know if target defaults to pic or not, so just remove | |
547 | option if it is missing in one unit but enabled in other. */ | |
548 | else | |
227a2ecf | 549 | decoded_options.ordered_remove (j); |
4e6a9380 JH |
550 | } |
551 | else if (pic_option->opt_index == OPT_fpic | |
227a2ecf | 552 | && decoded_options[j].opt_index == OPT_fPIC) |
472a2536 | 553 | { |
227a2ecf | 554 | decoded_options[j] = *pic_option; |
472a2536 JH |
555 | j++; |
556 | } | |
557 | else | |
558 | j++; | |
559 | } | |
227a2ecf ML |
560 | else if (decoded_options[j].opt_index == OPT_fPIE |
561 | || decoded_options[j].opt_index == OPT_fpie) | |
472a2536 | 562 | { |
4e6a9380 | 563 | /* -fno-pie in one unit implies -fno-pie everywhere. */ |
227a2ecf | 564 | if (decoded_options[j].value == 0) |
4e6a9380 JH |
565 | j++; |
566 | /* If we have no pie option or merge in -fno-pie, we still preserve | |
567 | PIE/pie if pic/PIC is present. */ | |
568 | else if ((pie_option && pie_option->value == 0) | |
569 | || !pie_option) | |
570 | { | |
571 | /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */ | |
572 | if (pic_option) | |
573 | { | |
574 | if (pic_option->opt_index == OPT_fpic | |
227a2ecf | 575 | && decoded_options[j].opt_index == OPT_fPIE) |
4e6a9380 | 576 | { |
227a2ecf ML |
577 | decoded_options[j].opt_index = OPT_fpie; |
578 | decoded_options[j].canonical_option[0] | |
5afa32b8 | 579 | = pic_option->value ? "-fpie" : "-fno-pie"; |
4e6a9380 JH |
580 | } |
581 | else if (!pic_option->value) | |
227a2ecf ML |
582 | decoded_options[j].canonical_option[0] = "-fno-pie"; |
583 | decoded_options[j].value = pic_option->value; | |
4e6a9380 JH |
584 | j++; |
585 | } | |
586 | else if (pie_option) | |
587 | { | |
227a2ecf | 588 | decoded_options[j] = *pie_option; |
4e6a9380 JH |
589 | j++; |
590 | } | |
591 | /* Because we always append pic/PIE options this code path should | |
592 | not happen unless the LTO object was built by old lto1 which | |
593 | did not contain that logic yet. */ | |
594 | else | |
227a2ecf | 595 | decoded_options.ordered_remove (j); |
4e6a9380 JH |
596 | } |
597 | else if (pie_option->opt_index == OPT_fpie | |
227a2ecf | 598 | && decoded_options[j].opt_index == OPT_fPIE) |
472a2536 | 599 | { |
227a2ecf | 600 | decoded_options[j] = *pie_option; |
472a2536 JH |
601 | j++; |
602 | } | |
603 | else | |
604 | j++; | |
605 | } | |
606 | else | |
607 | j++; | |
f1a681a1 | 608 | |
8a8ee37a | 609 | int existing_opt_index, existing_opt2_index; |
f1a681a1 | 610 | if (!xassembler_options_error) |
8a8ee37a JM |
611 | for (existing_opt_index = existing_opt2_index = 0; ; |
612 | existing_opt_index++, existing_opt2_index++) | |
f1a681a1 | 613 | { |
8a8ee37a JM |
614 | existing_opt_index |
615 | = find_option (decoded_options, OPT_Xassembler, existing_opt_index); | |
616 | existing_opt2_index | |
617 | = find_option (fdecoded_options, OPT_Xassembler, | |
618 | existing_opt2_index); | |
227a2ecf ML |
619 | |
620 | cl_decoded_option *existing_opt = NULL; | |
621 | cl_decoded_option *existing_opt2 = NULL; | |
622 | if (existing_opt_index != -1) | |
623 | existing_opt = &decoded_options[existing_opt_index]; | |
624 | if (existing_opt2_index != -1) | |
625 | existing_opt2 = &fdecoded_options[existing_opt2_index]; | |
626 | ||
627 | if (existing_opt == NULL && existing_opt2 == NULL) | |
f1a681a1 | 628 | break; |
227a2ecf | 629 | else if (existing_opt != NULL && existing_opt2 == NULL) |
f1a681a1 | 630 | { |
47fe9634 ML |
631 | warning (0, "Extra option to %<-Xassembler%>: %s," |
632 | " dropping all %<-Xassembler%> and %<-Wa%> options.", | |
227a2ecf | 633 | existing_opt->arg); |
f1a681a1 PK |
634 | xassembler_options_error = true; |
635 | break; | |
636 | } | |
227a2ecf | 637 | else if (existing_opt == NULL && existing_opt2 != NULL) |
f1a681a1 | 638 | { |
47fe9634 ML |
639 | warning (0, "Extra option to %<-Xassembler%>: %s," |
640 | " dropping all %<-Xassembler%> and %<-Wa%> options.", | |
227a2ecf | 641 | existing_opt2->arg); |
f1a681a1 PK |
642 | xassembler_options_error = true; |
643 | break; | |
644 | } | |
227a2ecf | 645 | else if (strcmp (existing_opt->arg, existing_opt2->arg) != 0) |
f1a681a1 | 646 | { |
47fe9634 ML |
647 | warning (0, "Options to %<-Xassembler%> do not match: %s, %s," |
648 | " dropping all %<-Xassembler%> and %<-Wa%> options.", | |
227a2ecf | 649 | existing_opt->arg, existing_opt2->arg); |
f1a681a1 PK |
650 | xassembler_options_error = true; |
651 | break; | |
652 | } | |
653 | } | |
52a35ef7 | 654 | } |
f31c0018 | 655 | |
fc8b3540 IV |
656 | /* Parse STR, saving found tokens into PVALUES and return their number. |
657 | Tokens are assumed to be delimited by ':'. If APPEND is non-null, | |
658 | append it to every token we find. */ | |
659 | ||
660 | static unsigned | |
661 | parse_env_var (const char *str, char ***pvalues, const char *append) | |
662 | { | |
663 | const char *curval, *nextval; | |
664 | char **values; | |
665 | unsigned num = 1, i; | |
666 | ||
667 | curval = strchr (str, ':'); | |
668 | while (curval) | |
669 | { | |
670 | num++; | |
671 | curval = strchr (curval + 1, ':'); | |
672 | } | |
673 | ||
674 | values = (char**) xmalloc (num * sizeof (char*)); | |
675 | curval = str; | |
b08dec2f DH |
676 | nextval = strchr (curval, ':'); |
677 | if (nextval == NULL) | |
678 | nextval = strchr (curval, '\0'); | |
fc8b3540 IV |
679 | |
680 | int append_len = append ? strlen (append) : 0; | |
681 | for (i = 0; i < num; i++) | |
682 | { | |
683 | int l = nextval - curval; | |
684 | values[i] = (char*) xmalloc (l + 1 + append_len); | |
685 | memcpy (values[i], curval, l); | |
686 | values[i][l] = 0; | |
687 | if (append) | |
688 | strcat (values[i], append); | |
689 | curval = nextval + 1; | |
b08dec2f DH |
690 | nextval = strchr (curval, ':'); |
691 | if (nextval == NULL) | |
692 | nextval = strchr (curval, '\0'); | |
fc8b3540 IV |
693 | } |
694 | *pvalues = values; | |
695 | return num; | |
696 | } | |
697 | ||
c713ddc0 BS |
698 | /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */ |
699 | ||
700 | static void | |
227a2ecf | 701 | append_compiler_options (obstack *argv_obstack, vec<cl_decoded_option> opts) |
c713ddc0 BS |
702 | { |
703 | /* Append compiler driver arguments as far as they were merged. */ | |
227a2ecf | 704 | for (unsigned int j = 1; j < opts.length (); ++j) |
c713ddc0 | 705 | { |
227a2ecf | 706 | cl_decoded_option *option = &opts[j]; |
c713ddc0 | 707 | |
e53b6e56 | 708 | /* File options have been properly filtered by lto-opts.cc. */ |
c713ddc0 BS |
709 | switch (option->opt_index) |
710 | { | |
711 | /* Drop arguments that we want to take from the link line. */ | |
712 | case OPT_flto_: | |
713 | case OPT_flto: | |
714 | case OPT_flto_partition_: | |
715 | continue; | |
716 | ||
717 | default: | |
718 | break; | |
719 | } | |
720 | ||
721 | /* For now do what the original LTO option code was doing - pass | |
722 | on any CL_TARGET flag and a few selected others. */ | |
723 | switch (option->opt_index) | |
724 | { | |
eb472171 | 725 | case OPT_fdiagnostics_show_caret: |
96e6ae57 | 726 | case OPT_fdiagnostics_show_labels: |
56b61d7f | 727 | case OPT_fdiagnostics_show_line_numbers: |
eb472171 CLT |
728 | case OPT_fdiagnostics_show_option: |
729 | case OPT_fdiagnostics_show_location_: | |
730 | case OPT_fshow_column: | |
c713ddc0 BS |
731 | case OPT_fPIC: |
732 | case OPT_fpic: | |
733 | case OPT_fPIE: | |
734 | case OPT_fpie: | |
735 | case OPT_fcommon: | |
c713ddc0 | 736 | case OPT_fgnu_tm: |
1506ae0e | 737 | case OPT_fopenmp: |
a0c88d06 | 738 | case OPT_fopenacc: |
b6adbb9f | 739 | case OPT_fopenacc_dim_: |
c713ddc0 | 740 | case OPT_foffload_abi_: |
6a48d124 | 741 | case OPT_fcf_protection_: |
9453e3cd AS |
742 | case OPT_fasynchronous_unwind_tables: |
743 | case OPT_funwind_tables: | |
5a307ee5 | 744 | case OPT_g: |
c713ddc0 BS |
745 | case OPT_O: |
746 | case OPT_Ofast: | |
747 | case OPT_Og: | |
748 | case OPT_Os: | |
e742722f | 749 | case OPT_Oz: |
c713ddc0 BS |
750 | break; |
751 | ||
f1a681a1 PK |
752 | case OPT_Xassembler: |
753 | /* When we detected a mismatch in assembler options between | |
754 | the input TU's fall back to previous behavior of ignoring them. */ | |
755 | if (xassembler_options_error) | |
756 | continue; | |
757 | break; | |
758 | ||
c713ddc0 BS |
759 | default: |
760 | if (!(cl_options[option->opt_index].flags & CL_TARGET)) | |
761 | continue; | |
762 | } | |
763 | ||
764 | /* Pass the option on. */ | |
765 | for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i) | |
766 | obstack_ptr_grow (argv_obstack, option->canonical_option[i]); | |
767 | } | |
768 | } | |
769 | ||
227a2ecf | 770 | /* Append diag options in OPTS to ARGV_OBSTACK. */ |
34df756c TV |
771 | |
772 | static void | |
227a2ecf | 773 | append_diag_options (obstack *argv_obstack, vec<cl_decoded_option> opts) |
34df756c TV |
774 | { |
775 | /* Append compiler driver arguments as far as they were merged. */ | |
227a2ecf | 776 | for (unsigned int j = 1; j < opts.length (); ++j) |
34df756c | 777 | { |
227a2ecf | 778 | cl_decoded_option *option = &opts[j]; |
34df756c TV |
779 | |
780 | switch (option->opt_index) | |
781 | { | |
782 | case OPT_fdiagnostics_color_: | |
478dd60d | 783 | case OPT_fdiagnostics_format_: |
34df756c | 784 | case OPT_fdiagnostics_show_caret: |
96e6ae57 | 785 | case OPT_fdiagnostics_show_labels: |
56b61d7f | 786 | case OPT_fdiagnostics_show_line_numbers: |
34df756c TV |
787 | case OPT_fdiagnostics_show_option: |
788 | case OPT_fdiagnostics_show_location_: | |
789 | case OPT_fshow_column: | |
790 | break; | |
791 | default: | |
792 | continue; | |
793 | } | |
794 | ||
795 | /* Pass the option on. */ | |
796 | for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i) | |
797 | obstack_ptr_grow (argv_obstack, option->canonical_option[i]); | |
798 | } | |
799 | } | |
800 | ||
801 | ||
c713ddc0 BS |
802 | /* Append linker options OPTS to ARGV_OBSTACK. */ |
803 | ||
804 | static void | |
227a2ecf | 805 | append_linker_options (obstack *argv_obstack, vec<cl_decoded_option> opts) |
c713ddc0 BS |
806 | { |
807 | /* Append linker driver arguments. Compiler options from the linker | |
808 | driver arguments will override / merge with those from the compiler. */ | |
227a2ecf | 809 | for (unsigned int j = 1; j < opts.length (); ++j) |
c713ddc0 | 810 | { |
227a2ecf | 811 | cl_decoded_option *option = &opts[j]; |
c713ddc0 BS |
812 | |
813 | /* Do not pass on frontend specific flags not suitable for lto. */ | |
814 | if (!(cl_options[option->opt_index].flags | |
815 | & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO))) | |
816 | continue; | |
817 | ||
818 | switch (option->opt_index) | |
819 | { | |
820 | case OPT_o: | |
821 | case OPT_flto_: | |
822 | case OPT_flto: | |
823 | /* We've handled these LTO options, do not pass them on. */ | |
824 | continue; | |
825 | ||
b0b35f86 JJ |
826 | case OPT_fopenmp: |
827 | case OPT_fopenacc: | |
b0b35f86 JJ |
828 | /* Ignore -fno-XXX form of these options, as otherwise |
829 | corresponding builtins will not be enabled. */ | |
830 | if (option->value == 0) | |
831 | continue; | |
832 | break; | |
833 | ||
c713ddc0 BS |
834 | default: |
835 | break; | |
836 | } | |
837 | ||
838 | /* Pass the option on. */ | |
839 | for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i) | |
840 | obstack_ptr_grow (argv_obstack, option->canonical_option[i]); | |
841 | } | |
842 | } | |
843 | ||
844 | /* Extract options for TARGET offload compiler from OPTIONS and append | |
845 | them to ARGV_OBSTACK. */ | |
846 | ||
847 | static void | |
848 | append_offload_options (obstack *argv_obstack, const char *target, | |
227a2ecf | 849 | vec<cl_decoded_option> options) |
c713ddc0 | 850 | { |
227a2ecf | 851 | for (unsigned i = 0; i < options.length (); i++) |
c713ddc0 BS |
852 | { |
853 | const char *cur, *next, *opts; | |
854 | char **argv; | |
855 | unsigned argc; | |
227a2ecf | 856 | cl_decoded_option *option = &options[i]; |
c713ddc0 | 857 | |
33c4e466 | 858 | if (option->opt_index != OPT_foffload_options_) |
c713ddc0 BS |
859 | continue; |
860 | ||
861 | /* If option argument starts with '-' then no target is specified. That | |
862 | means offload options are specified for all targets, so we need to | |
863 | append them. */ | |
864 | if (option->arg[0] == '-') | |
865 | opts = option->arg; | |
866 | else | |
867 | { | |
868 | opts = strchr (option->arg, '='); | |
33c4e466 | 869 | gcc_assert (opts); |
c713ddc0 BS |
870 | cur = option->arg; |
871 | ||
872 | while (cur < opts) | |
873 | { | |
b08dec2f DH |
874 | next = strchr (cur, ','); |
875 | if (next == NULL) | |
191ec640 | 876 | next = opts; |
c713ddc0 BS |
877 | next = (next > opts) ? opts : next; |
878 | ||
64186aad | 879 | /* Are we looking for this offload target? */ |
c713ddc0 BS |
880 | if (strlen (target) == (size_t) (next - cur) |
881 | && strncmp (target, cur, next - cur) == 0) | |
882 | break; | |
883 | ||
64186aad | 884 | /* Skip the comma or equal sign. */ |
c713ddc0 BS |
885 | cur = next + 1; |
886 | } | |
887 | ||
888 | if (cur >= opts) | |
889 | continue; | |
890 | ||
891 | opts++; | |
892 | } | |
893 | ||
894 | argv = buildargv (opts); | |
895 | for (argc = 0; argv[argc]; argc++) | |
896 | obstack_ptr_grow (argv_obstack, argv[argc]); | |
897 | } | |
898 | } | |
899 | ||
fc8b3540 IV |
900 | /* Check whether NAME can be accessed in MODE. This is like access, |
901 | except that it never considers directories to be executable. */ | |
902 | ||
903 | static int | |
904 | access_check (const char *name, int mode) | |
905 | { | |
906 | if (mode == X_OK) | |
907 | { | |
908 | struct stat st; | |
909 | ||
910 | if (stat (name, &st) < 0 | |
911 | || S_ISDIR (st.st_mode)) | |
912 | return -1; | |
913 | } | |
914 | ||
915 | return access (name, mode); | |
916 | } | |
917 | ||
918 | /* Prepare a target image for offload TARGET, using mkoffload tool from | |
919 | COMPILER_PATH. Return the name of the resultant object file. */ | |
920 | ||
e228683b | 921 | static const char * |
fc8b3540 | 922 | compile_offload_image (const char *target, const char *compiler_path, |
c713ddc0 | 923 | unsigned in_argc, char *in_argv[], |
227a2ecf | 924 | vec<cl_decoded_option> compiler_opts, |
e228683b TB |
925 | vec<cl_decoded_option> linker_opts, |
926 | char **filename) | |
fc8b3540 | 927 | { |
efc16503 | 928 | char *dumpbase; |
fc8b3540 IV |
929 | char **argv; |
930 | char *suffix | |
931 | = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target)); | |
932 | strcpy (suffix, "/accel/"); | |
933 | strcat (suffix, target); | |
934 | strcat (suffix, "/mkoffload"); | |
e228683b | 935 | *filename = NULL; |
fc8b3540 IV |
936 | |
937 | char **paths = NULL; | |
938 | unsigned n_paths = parse_env_var (compiler_path, &paths, suffix); | |
939 | ||
940 | const char *compiler = NULL; | |
941 | for (unsigned i = 0; i < n_paths; i++) | |
942 | if (access_check (paths[i], X_OK) == 0) | |
943 | { | |
944 | compiler = paths[i]; | |
945 | break; | |
946 | } | |
fe5bfa67 TB |
947 | #if OFFLOAD_DEFAULTED |
948 | if (!compiler && getenv (OFFLOAD_TARGET_DEFAULT_ENV)) | |
949 | { | |
950 | free_array_of_ptrs ((void **) paths, n_paths); | |
951 | return NULL; | |
952 | } | |
953 | #endif | |
fc8b3540 | 954 | |
c2e1580c TV |
955 | if (!compiler) |
956 | fatal_error (input_location, | |
a9c697b8 | 957 | "could not find %s in %s (consider using %<-B%>)", |
904f3daa | 958 | suffix + 1, compiler_path); |
c2e1580c | 959 | |
efc16503 AO |
960 | dumpbase = concat (dumppfx, "x", target, NULL); |
961 | ||
c2e1580c | 962 | /* Generate temporary output file name. */ |
efc16503 | 963 | if (save_temps) |
e228683b | 964 | *filename = concat (dumpbase, ".o", NULL); |
efc16503 | 965 | else |
e228683b | 966 | *filename = make_temp_file (".target.o"); |
c2e1580c TV |
967 | |
968 | struct obstack argv_obstack; | |
969 | obstack_init (&argv_obstack); | |
970 | obstack_ptr_grow (&argv_obstack, compiler); | |
971 | if (save_temps) | |
972 | obstack_ptr_grow (&argv_obstack, "-save-temps"); | |
973 | if (verbose) | |
974 | obstack_ptr_grow (&argv_obstack, "-v"); | |
975 | obstack_ptr_grow (&argv_obstack, "-o"); | |
e228683b | 976 | obstack_ptr_grow (&argv_obstack, *filename); |
c2e1580c TV |
977 | |
978 | /* Append names of input object files. */ | |
979 | for (unsigned i = 0; i < in_argc; i++) | |
980 | obstack_ptr_grow (&argv_obstack, in_argv[i]); | |
981 | ||
982 | /* Append options from offload_lto sections. */ | |
227a2ecf ML |
983 | append_compiler_options (&argv_obstack, compiler_opts); |
984 | append_diag_options (&argv_obstack, linker_opts); | |
c2e1580c | 985 | |
efc16503 AO |
986 | obstack_ptr_grow (&argv_obstack, "-dumpbase"); |
987 | obstack_ptr_grow (&argv_obstack, dumpbase); | |
988 | ||
c2e1580c TV |
989 | /* Append options specified by -foffload last. In case of conflicting |
990 | options we expect offload compiler to choose the latest. */ | |
227a2ecf ML |
991 | append_offload_options (&argv_obstack, target, compiler_opts); |
992 | append_offload_options (&argv_obstack, target, linker_opts); | |
c2e1580c TV |
993 | |
994 | obstack_ptr_grow (&argv_obstack, NULL); | |
995 | argv = XOBFINISH (&argv_obstack, char **); | |
b3032d1b | 996 | fork_execute (argv[0], argv, true, "offload_args"); |
c2e1580c | 997 | obstack_free (&argv_obstack, NULL); |
fc8b3540 IV |
998 | |
999 | free_array_of_ptrs ((void **) paths, n_paths); | |
e228683b | 1000 | return *filename; |
fc8b3540 IV |
1001 | } |
1002 | ||
1003 | ||
1004 | /* The main routine dealing with offloading. | |
1005 | The routine builds a target image for each offload target. IN_ARGC and | |
1006 | IN_ARGV specify options and input object files. As all of them could contain | |
1007 | target sections, we pass them all to target compilers. */ | |
1008 | ||
1009 | static void | |
c713ddc0 | 1010 | compile_images_for_offload_targets (unsigned in_argc, char *in_argv[], |
227a2ecf ML |
1011 | vec<cl_decoded_option> compiler_opts, |
1012 | vec<cl_decoded_option> linker_opts) | |
fc8b3540 IV |
1013 | { |
1014 | char **names = NULL; | |
1015 | const char *target_names = getenv (OFFLOAD_TARGET_NAMES_ENV); | |
1016 | if (!target_names) | |
1017 | return; | |
1018 | unsigned num_targets = parse_env_var (target_names, &names, NULL); | |
fe5bfa67 | 1019 | int next_name_entry = 0; |
fc8b3540 IV |
1020 | |
1021 | const char *compiler_path = getenv ("COMPILER_PATH"); | |
1022 | if (!compiler_path) | |
1023 | goto out; | |
1024 | ||
1025 | /* Prepare an image for each target and save the name of the resultant object | |
1026 | file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */ | |
1027 | offload_names = XCNEWVEC (char *, num_targets + 1); | |
1028 | for (unsigned i = 0; i < num_targets; i++) | |
1029 | { | |
e228683b TB |
1030 | if (!compile_offload_image (names[i], compiler_path, in_argc, in_argv, |
1031 | compiler_opts, linker_opts, | |
1032 | &offload_names[next_name_entry])) | |
fe5bfa67 TB |
1033 | #if OFFLOAD_DEFAULTED |
1034 | continue; | |
1035 | #else | |
40fecdd6 | 1036 | fatal_error (input_location, |
a9c697b8 | 1037 | "problem with building target image for %s", names[i]); |
fe5bfa67 TB |
1038 | #endif |
1039 | next_name_entry++; | |
fc8b3540 IV |
1040 | } |
1041 | ||
fe5bfa67 TB |
1042 | #if OFFLOAD_DEFAULTED |
1043 | if (next_name_entry == 0) | |
1044 | { | |
1045 | free (offload_names); | |
1046 | offload_names = NULL; | |
1047 | } | |
1048 | #endif | |
1049 | ||
fc8b3540 IV |
1050 | out: |
1051 | free_array_of_ptrs ((void **) names, num_targets); | |
1052 | } | |
1053 | ||
1054 | /* Copy a file from SRC to DEST. */ | |
1055 | ||
1056 | static void | |
1057 | copy_file (const char *dest, const char *src) | |
1058 | { | |
1059 | FILE *d = fopen (dest, "wb"); | |
1060 | FILE *s = fopen (src, "rb"); | |
1061 | char buffer[512]; | |
1062 | while (!feof (s)) | |
1063 | { | |
1064 | size_t len = fread (buffer, 1, 512, s); | |
1065 | if (ferror (s) != 0) | |
40fecdd6 | 1066 | fatal_error (input_location, "reading input file"); |
fc8b3540 IV |
1067 | if (len > 0) |
1068 | { | |
1069 | fwrite (buffer, 1, len, d); | |
1070 | if (ferror (d) != 0) | |
40fecdd6 | 1071 | fatal_error (input_location, "writing output file"); |
fc8b3540 IV |
1072 | } |
1073 | } | |
367e91e1 SL |
1074 | fclose (d); |
1075 | fclose (s); | |
fc8b3540 IV |
1076 | } |
1077 | ||
e6861a99 IV |
1078 | /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of |
1079 | the copy to the linker. */ | |
fc8b3540 IV |
1080 | |
1081 | static void | |
7287cf18 | 1082 | find_crtoffloadtable (int save_temps, const char *dumppfx) |
fc8b3540 IV |
1083 | { |
1084 | char **paths = NULL; | |
1085 | const char *library_path = getenv ("LIBRARY_PATH"); | |
1086 | if (!library_path) | |
1087 | return; | |
e6861a99 | 1088 | unsigned n_paths = parse_env_var (library_path, &paths, "/crtoffloadtable.o"); |
fc8b3540 IV |
1089 | |
1090 | unsigned i; | |
1091 | for (i = 0; i < n_paths; i++) | |
1092 | if (access_check (paths[i], R_OK) == 0) | |
1093 | { | |
e6861a99 | 1094 | /* The linker will delete the filename we give it, so make a copy. */ |
7287cf18 TB |
1095 | char *crtoffloadtable; |
1096 | if (!save_temps) | |
1097 | crtoffloadtable = make_temp_file (".crtoffloadtable.o"); | |
1098 | else | |
8311899e | 1099 | crtoffloadtable = concat (dumppfx, "crtoffloadtable.o", NULL); |
e6861a99 IV |
1100 | copy_file (crtoffloadtable, paths[i]); |
1101 | printf ("%s\n", crtoffloadtable); | |
1102 | XDELETEVEC (crtoffloadtable); | |
fc8b3540 IV |
1103 | break; |
1104 | } | |
1105 | if (i == n_paths) | |
40fecdd6 | 1106 | fatal_error (input_location, |
a9c697b8 | 1107 | "installation error, cannot find %<crtoffloadtable.o%>"); |
fc8b3540 IV |
1108 | |
1109 | free_array_of_ptrs ((void **) paths, n_paths); | |
1110 | } | |
1111 | ||
c713ddc0 | 1112 | /* A subroutine of run_gcc. Examine the open file FD for lto sections with |
227a2ecf ML |
1113 | name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS. |
1114 | Return true if we found a matching section, false | |
c713ddc0 BS |
1115 | otherwise. COLLECT_GCC holds the value of the environment variable with |
1116 | the same name. */ | |
1117 | ||
1118 | static bool | |
1119 | find_and_merge_options (int fd, off_t file_offset, const char *prefix, | |
8a8ee37a | 1120 | vec<cl_decoded_option> decoded_cl_options, bool first, |
227a2ecf | 1121 | vec<cl_decoded_option> *opts, const char *collect_gcc) |
c713ddc0 BS |
1122 | { |
1123 | off_t offset, length; | |
1124 | char *data; | |
1125 | char *fopts; | |
1126 | const char *errmsg; | |
1127 | int err; | |
227a2ecf | 1128 | vec<cl_decoded_option> fdecoded_options; |
c713ddc0 | 1129 | |
8a8ee37a JM |
1130 | if (!first) |
1131 | fdecoded_options = *opts; | |
1132 | ||
c713ddc0 BS |
1133 | simple_object_read *sobj; |
1134 | sobj = simple_object_start_read (fd, file_offset, "__GNU_LTO", | |
1135 | &errmsg, &err); | |
1136 | if (!sobj) | |
1137 | return false; | |
1138 | ||
1139 | char *secname = XALLOCAVEC (char, strlen (prefix) + sizeof (".opts")); | |
1140 | strcpy (secname, prefix); | |
1141 | strcat (secname, ".opts"); | |
1142 | if (!simple_object_find_section (sobj, secname, &offset, &length, | |
1143 | &errmsg, &err)) | |
1144 | { | |
1145 | simple_object_release_read (sobj); | |
1146 | return false; | |
1147 | } | |
1148 | ||
1149 | lseek (fd, file_offset + offset, SEEK_SET); | |
1150 | data = (char *)xmalloc (length); | |
1151 | read (fd, data, length); | |
1152 | fopts = data; | |
1153 | do | |
1154 | { | |
227a2ecf ML |
1155 | vec<cl_decoded_option> f2decoded_options |
1156 | = get_options_from_collect_gcc_options (collect_gcc, fopts); | |
1157 | if (first) | |
1158 | { | |
1159 | fdecoded_options = f2decoded_options; | |
1160 | first = false; | |
1161 | } | |
c713ddc0 | 1162 | else |
227a2ecf ML |
1163 | merge_and_complain (fdecoded_options, f2decoded_options, |
1164 | decoded_cl_options); | |
c713ddc0 BS |
1165 | |
1166 | fopts += strlen (fopts) + 1; | |
1167 | } | |
1168 | while (fopts - data < length); | |
1169 | ||
1170 | free (data); | |
1171 | simple_object_release_read (sobj); | |
1172 | *opts = fdecoded_options; | |
c713ddc0 BS |
1173 | return true; |
1174 | } | |
1175 | ||
1ea85365 RB |
1176 | /* Copy early debug info sections from INFILE to a new file whose name |
1177 | is returned. Return NULL on error. */ | |
1178 | ||
1179 | const char * | |
0df8dc6e | 1180 | debug_objcopy (const char *infile, bool rename) |
1ea85365 | 1181 | { |
b5327e50 | 1182 | char *outfile; |
1ea85365 RB |
1183 | const char *errmsg; |
1184 | int err; | |
1185 | ||
1186 | const char *p; | |
fe267711 | 1187 | const char *orig_infile = infile; |
1ea85365 RB |
1188 | off_t inoff = 0; |
1189 | long loffset; | |
1190 | int consumed; | |
1191 | if ((p = strrchr (infile, '@')) | |
1192 | && p != infile | |
1193 | && sscanf (p, "@%li%n", &loffset, &consumed) >= 1 | |
1194 | && strlen (p) == (unsigned int) consumed) | |
1195 | { | |
1196 | char *fname = xstrdup (infile); | |
1197 | fname[p - infile] = '\0'; | |
1198 | infile = fname; | |
1199 | inoff = (off_t) loffset; | |
1200 | } | |
dc0e0c6b | 1201 | int infd = open (infile, O_RDONLY | O_BINARY); |
1ea85365 RB |
1202 | if (infd == -1) |
1203 | return NULL; | |
1204 | simple_object_read *inobj = simple_object_start_read (infd, inoff, | |
1205 | "__GNU_LTO", | |
1206 | &errmsg, &err); | |
1207 | if (!inobj) | |
1208 | return NULL; | |
1209 | ||
1210 | off_t off, len; | |
1211 | if (simple_object_find_section (inobj, ".gnu.debuglto_.debug_info", | |
1212 | &off, &len, &errmsg, &err) != 1) | |
1213 | { | |
1214 | if (errmsg) | |
a9c697b8 | 1215 | fatal_error (0, "%s: %s", errmsg, xstrerror (err)); |
1ea85365 RB |
1216 | |
1217 | simple_object_release_read (inobj); | |
1218 | close (infd); | |
1219 | return NULL; | |
1220 | } | |
1221 | ||
b5327e50 | 1222 | if (save_temps) |
1dedc12d | 1223 | outfile = concat (orig_infile, ".debug.temp.o", NULL); |
b5327e50 IS |
1224 | else |
1225 | outfile = make_temp_file (".debug.temp.o"); | |
0df8dc6e | 1226 | errmsg = simple_object_copy_lto_debug_sections (inobj, outfile, &err, rename); |
1ea85365 RB |
1227 | if (errmsg) |
1228 | { | |
1229 | unlink_if_ordinary (outfile); | |
a9c697b8 | 1230 | fatal_error (0, "%s: %s", errmsg, xstrerror (err)); |
1ea85365 RB |
1231 | } |
1232 | ||
1233 | simple_object_release_read (inobj); | |
1234 | close (infd); | |
1235 | ||
1236 | return outfile; | |
1237 | } | |
1238 | ||
b6e33d73 JH |
1239 | /* Helper for qsort: compare priorities for parallel compilation. */ |
1240 | ||
1241 | int | |
1242 | cmp_priority (const void *a, const void *b) | |
1243 | { | |
1244 | return *((const int *)b)-*((const int *)a); | |
1245 | } | |
1ea85365 | 1246 | |
f2b4f212 ML |
1247 | /* Number of CPUs that can be used for parallel LTRANS phase. */ |
1248 | ||
1249 | static unsigned long nthreads_var = 0; | |
1250 | ||
1251 | #ifdef HAVE_PTHREAD_AFFINITY_NP | |
1252 | unsigned long cpuset_size; | |
1253 | static unsigned long get_cpuset_size; | |
1254 | cpu_set_t *cpusetp; | |
1255 | ||
1256 | unsigned long | |
1257 | static cpuset_popcount (unsigned long cpusetsize, cpu_set_t *cpusetp) | |
1258 | { | |
1259 | #ifdef CPU_COUNT_S | |
1260 | /* glibc 2.7 and above provide a macro for this. */ | |
1261 | return CPU_COUNT_S (cpusetsize, cpusetp); | |
1262 | #else | |
1263 | #ifdef CPU_COUNT | |
1264 | if (cpusetsize == sizeof (cpu_set_t)) | |
1265 | /* glibc 2.6 and above provide a macro for this. */ | |
1266 | return CPU_COUNT (cpusetp); | |
1267 | #endif | |
1268 | size_t i; | |
1269 | unsigned long ret = 0; | |
1270 | STATIC_ASSERT (sizeof (cpusetp->__bits[0]) == sizeof (unsigned long int)); | |
1271 | for (i = 0; i < cpusetsize / sizeof (cpusetp->__bits[0]); i++) | |
1272 | { | |
1273 | unsigned long int mask = cpusetp->__bits[i]; | |
1274 | if (mask == 0) | |
1275 | continue; | |
1276 | ret += __builtin_popcountl (mask); | |
1277 | } | |
1278 | return ret; | |
1279 | #endif | |
1280 | } | |
1281 | #endif | |
1282 | ||
1283 | /* At startup, determine the default number of threads. It would seem | |
1284 | this should be related to the number of cpus online. */ | |
1285 | ||
1286 | static void | |
1287 | init_num_threads (void) | |
1288 | { | |
1289 | #ifdef HAVE_PTHREAD_AFFINITY_NP | |
1290 | #if defined (_SC_NPROCESSORS_CONF) && defined (CPU_ALLOC_SIZE) | |
1291 | cpuset_size = sysconf (_SC_NPROCESSORS_CONF); | |
1292 | cpuset_size = CPU_ALLOC_SIZE (cpuset_size); | |
1293 | #else | |
1294 | cpuset_size = sizeof (cpu_set_t); | |
1295 | #endif | |
1296 | ||
1297 | cpusetp = (cpu_set_t *) xmalloc (gomp_cpuset_size); | |
1298 | do | |
1299 | { | |
1300 | int ret = pthread_getaffinity_np (pthread_self (), gomp_cpuset_size, | |
1301 | cpusetp); | |
1302 | if (ret == 0) | |
1303 | { | |
1304 | /* Count only the CPUs this process can use. */ | |
1305 | nthreads_var = cpuset_popcount (cpuset_size, cpusetp); | |
1306 | if (nthreads_var == 0) | |
1307 | break; | |
1308 | get_cpuset_size = cpuset_size; | |
1309 | #ifdef CPU_ALLOC_SIZE | |
1310 | unsigned long i; | |
1311 | for (i = cpuset_size * 8; i; i--) | |
1312 | if (CPU_ISSET_S (i - 1, cpuset_size, cpusetp)) | |
1313 | break; | |
1314 | cpuset_size = CPU_ALLOC_SIZE (i); | |
1315 | #endif | |
1316 | return; | |
1317 | } | |
1318 | if (ret != EINVAL) | |
1319 | break; | |
1320 | #ifdef CPU_ALLOC_SIZE | |
1321 | if (cpuset_size < sizeof (cpu_set_t)) | |
1322 | cpuset_size = sizeof (cpu_set_t); | |
1323 | else | |
1324 | cpuset_size = cpuset_size * 2; | |
1325 | if (cpuset_size < 8 * sizeof (cpu_set_t)) | |
1326 | cpusetp | |
1327 | = (cpu_set_t *) realloc (cpusetp, cpuset_size); | |
1328 | else | |
1329 | { | |
1330 | /* Avoid fatal if too large memory allocation would be | |
1331 | requested, e.g. kernel returning EINVAL all the time. */ | |
1332 | void *p = realloc (cpusetp, cpuset_size); | |
1333 | if (p == NULL) | |
1334 | break; | |
1335 | cpusetp = (cpu_set_t *) p; | |
1336 | } | |
1337 | #else | |
1338 | break; | |
1339 | #endif | |
1340 | } | |
1341 | while (1); | |
1342 | cpuset_size = 0; | |
1343 | nthreads_var = 1; | |
1344 | free (cpusetp); | |
1345 | cpusetp = NULL; | |
1346 | #endif | |
1347 | #ifdef _SC_NPROCESSORS_ONLN | |
1348 | nthreads_var = sysconf (_SC_NPROCESSORS_ONLN); | |
1349 | #endif | |
1350 | } | |
1351 | ||
7d7d925d ML |
1352 | /* Print link to -flto documentation with a hint message. */ |
1353 | ||
1354 | void | |
1355 | print_lto_docs_link () | |
1356 | { | |
cd4acb8c ML |
1357 | bool print_url = global_dc->printer->url_format != URL_FORMAT_NONE; |
1358 | const char *url = global_dc->get_option_url (global_dc, OPT_flto); | |
7d7d925d ML |
1359 | |
1360 | pretty_printer pp; | |
1361 | pp.url_format = URL_FORMAT_DEFAULT; | |
1362 | pp_string (&pp, "see the "); | |
cd4acb8c ML |
1363 | if (print_url) |
1364 | pp_begin_url (&pp, url); | |
7d7d925d | 1365 | pp_string (&pp, "%<-flto%> option documentation"); |
cd4acb8c ML |
1366 | if (print_url) |
1367 | pp_end_url (&pp); | |
7d7d925d ML |
1368 | pp_string (&pp, " for more information"); |
1369 | inform (UNKNOWN_LOCATION, pp_formatted_text (&pp)); | |
1370 | } | |
1371 | ||
6fade5a6 ML |
1372 | /* Test that a make command is present and working, return true if so. */ |
1373 | ||
1374 | static bool | |
1375 | make_exists (void) | |
1376 | { | |
1377 | const char *make = "make"; | |
1378 | char **make_argv = buildargv (getenv ("MAKE")); | |
1379 | if (make_argv) | |
1380 | make = make_argv[0]; | |
1381 | const char *make_args[] = {make, "--version", NULL}; | |
1382 | ||
1383 | int exit_status = 0; | |
1384 | int err = 0; | |
1385 | const char *errmsg | |
1386 | = pex_one (PEX_SEARCH, make_args[0], CONST_CAST (char **, make_args), | |
1387 | "make", NULL, NULL, &exit_status, &err); | |
1388 | freeargv (make_argv); | |
1389 | return errmsg == NULL && exit_status == 0 && err == 0; | |
1390 | } | |
1391 | ||
d7f09764 DN |
1392 | /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */ |
1393 | ||
1394 | static void | |
1395 | run_gcc (unsigned argc, char *argv[]) | |
1396 | { | |
cf96bae7 | 1397 | unsigned i, j; |
d7f09764 DN |
1398 | const char **new_argv; |
1399 | const char **argv_ptr; | |
d7f09764 | 1400 | char *list_option_full = NULL; |
cf96bae7 | 1401 | const char *linker_output = NULL; |
f1a681a1 PK |
1402 | const char *collect_gcc; |
1403 | char *collect_gcc_options; | |
279dc7a3 | 1404 | int parallel = 0; |
a478ffff | 1405 | int jobserver = 0; |
7d7d925d | 1406 | bool jobserver_requested = false; |
200b0e7e | 1407 | int auto_parallel = 0; |
014d92e1 | 1408 | bool no_partition = false; |
8a8ee37a | 1409 | bool fdecoded_options_first = true; |
227a2ecf ML |
1410 | vec<cl_decoded_option> fdecoded_options; |
1411 | fdecoded_options.create (16); | |
8a8ee37a | 1412 | bool offload_fdecoded_options_first = true; |
227a2ecf | 1413 | vec<cl_decoded_option> offload_fdecoded_options = vNULL; |
ef6f874e RG |
1414 | struct obstack argv_obstack; |
1415 | int new_head_argc; | |
fc8b3540 IV |
1416 | bool have_lto = false; |
1417 | bool have_offload = false; | |
1ea85365 RB |
1418 | unsigned lto_argc = 0, ltoobj_argc = 0; |
1419 | char **lto_argv, **ltoobj_argv; | |
0df8dc6e | 1420 | bool linker_output_rel = false; |
1ea85365 | 1421 | bool skip_debug = false; |
efc16503 | 1422 | const char *incoming_dumppfx = dumppfx = NULL; |
1dedc12d | 1423 | static char current_dir[] = { '.', DIR_SEPARATOR, '\0' }; |
cf96bae7 RG |
1424 | |
1425 | /* Get the driver and options. */ | |
1426 | collect_gcc = getenv ("COLLECT_GCC"); | |
1427 | if (!collect_gcc) | |
40fecdd6 | 1428 | fatal_error (input_location, |
a9c697b8 | 1429 | "environment variable %<COLLECT_GCC%> must be set"); |
cf96bae7 RG |
1430 | collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS"); |
1431 | if (!collect_gcc_options) | |
40fecdd6 | 1432 | fatal_error (input_location, |
a9c697b8 | 1433 | "environment variable %<COLLECT_GCC_OPTIONS%> must be set"); |
f1a681a1 PK |
1434 | |
1435 | char *collect_as_options = getenv ("COLLECT_AS_OPTIONS"); | |
1436 | ||
1437 | /* Prepend -Xassembler to each option, and append the string | |
1438 | to collect_gcc_options. */ | |
1439 | if (collect_as_options) | |
1440 | { | |
1441 | obstack temporary_obstack; | |
1442 | obstack_init (&temporary_obstack); | |
1443 | ||
1444 | prepend_xassembler_to_collect_as_options (collect_as_options, | |
1445 | &temporary_obstack); | |
1446 | obstack_1grow (&temporary_obstack, '\0'); | |
1447 | ||
1448 | char *xassembler_opts_string | |
1449 | = XOBFINISH (&temporary_obstack, char *); | |
98ff89d1 ML |
1450 | collect_gcc_options = concat (collect_gcc_options, xassembler_opts_string, |
1451 | NULL); | |
f1a681a1 PK |
1452 | } |
1453 | ||
227a2ecf ML |
1454 | vec<cl_decoded_option> decoded_options |
1455 | = get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options); | |
cf96bae7 | 1456 | |
e6861a99 | 1457 | /* Allocate array for input object files with LTO IL, |
443743fd IV |
1458 | and for possible preceding arguments. */ |
1459 | lto_argv = XNEWVEC (char *, argc); | |
1ea85365 | 1460 | ltoobj_argv = XNEWVEC (char *, argc); |
443743fd | 1461 | |
52a35ef7 RG |
1462 | /* Look at saved options in the IL files. */ |
1463 | for (i = 1; i < argc; ++i) | |
1464 | { | |
c713ddc0 | 1465 | char *p; |
52a35ef7 | 1466 | int fd; |
c713ddc0 | 1467 | off_t file_offset = 0; |
52a35ef7 | 1468 | long loffset; |
52a35ef7 | 1469 | int consumed; |
52a35ef7 | 1470 | char *filename = argv[i]; |
c713ddc0 | 1471 | |
6ba3079d | 1472 | if (startswith (argv[i], "-foffload-objects=")) |
e6861a99 IV |
1473 | { |
1474 | have_offload = true; | |
1475 | offload_objects_file_name | |
1476 | = argv[i] + sizeof ("-foffload-objects=") - 1; | |
1477 | continue; | |
1478 | } | |
1479 | ||
52a35ef7 RG |
1480 | if ((p = strrchr (argv[i], '@')) |
1481 | && p != argv[i] | |
1482 | && sscanf (p, "@%li%n", &loffset, &consumed) >= 1 | |
1483 | && strlen (p) == (unsigned int) consumed) | |
1484 | { | |
1485 | filename = XNEWVEC (char, p - argv[i] + 1); | |
1486 | memcpy (filename, argv[i], p - argv[i]); | |
1487 | filename[p - argv[i]] = '\0'; | |
1488 | file_offset = (off_t) loffset; | |
1489 | } | |
1473ab9a | 1490 | fd = open (filename, O_RDONLY | O_BINARY); |
0df8dc6e JH |
1491 | /* Linker plugin passes -fresolution and -flinker-output options. |
1492 | -flinker-output is passed only when user did not specify one and thus | |
1493 | we do not need to worry about duplicities with the option handling | |
1494 | below. */ | |
52a35ef7 | 1495 | if (fd == -1) |
443743fd IV |
1496 | { |
1497 | lto_argv[lto_argc++] = argv[i]; | |
0df8dc6e JH |
1498 | if (strcmp (argv[i], "-flinker-output=rel") == 0) |
1499 | linker_output_rel = true; | |
443743fd IV |
1500 | continue; |
1501 | } | |
1502 | ||
1503 | if (find_and_merge_options (fd, file_offset, LTO_SECTION_NAME_PREFIX, | |
8a8ee37a JM |
1504 | decoded_options, fdecoded_options_first, |
1505 | &fdecoded_options, | |
443743fd IV |
1506 | collect_gcc)) |
1507 | { | |
1508 | have_lto = true; | |
1ea85365 | 1509 | ltoobj_argv[ltoobj_argc++] = argv[i]; |
8a8ee37a | 1510 | fdecoded_options_first = false; |
443743fd | 1511 | } |
52a35ef7 RG |
1512 | close (fd); |
1513 | } | |
1514 | ||
cf96bae7 | 1515 | /* Initalize the common arguments for the driver. */ |
ef6f874e RG |
1516 | obstack_init (&argv_obstack); |
1517 | obstack_ptr_grow (&argv_obstack, collect_gcc); | |
1518 | obstack_ptr_grow (&argv_obstack, "-xlto"); | |
1519 | obstack_ptr_grow (&argv_obstack, "-c"); | |
52a35ef7 | 1520 | |
227a2ecf ML |
1521 | append_compiler_options (&argv_obstack, fdecoded_options); |
1522 | append_linker_options (&argv_obstack, decoded_options); | |
52a35ef7 | 1523 | |
c713ddc0 | 1524 | /* Scan linker driver arguments for things that are of relevance to us. */ |
227a2ecf | 1525 | for (j = 1; j < decoded_options.length (); ++j) |
f31c0018 | 1526 | { |
227a2ecf | 1527 | cl_decoded_option *option = &decoded_options[j]; |
f31c0018 RG |
1528 | switch (option->opt_index) |
1529 | { | |
1530 | case OPT_o: | |
1531 | linker_output = option->arg; | |
c713ddc0 | 1532 | break; |
f31c0018 | 1533 | |
1dedc12d AO |
1534 | /* We don't have to distinguish between -save-temps=* and |
1535 | -save-temps, -dumpdir already carries that | |
1536 | information. */ | |
1537 | case OPT_save_temps_: | |
f31c0018 | 1538 | case OPT_save_temps: |
608508a6 | 1539 | save_temps = 1; |
f31c0018 RG |
1540 | break; |
1541 | ||
1542 | case OPT_v: | |
cf96bae7 | 1543 | verbose = 1; |
f31c0018 | 1544 | break; |
cf96bae7 | 1545 | |
783dab6b RB |
1546 | case OPT_flto_partition_: |
1547 | if (strcmp (option->arg, "none") == 0) | |
1548 | no_partition = true; | |
f31c0018 RG |
1549 | break; |
1550 | ||
1551 | case OPT_flto_: | |
3cbcb5d0 ML |
1552 | /* Merge linker -flto= option with what we have in IL files. */ |
1553 | merge_flto_options (fdecoded_options, option); | |
f31c0018 | 1554 | if (strcmp (option->arg, "jobserver") == 0) |
3835aa0e | 1555 | jobserver_requested = true; |
c713ddc0 | 1556 | break; |
8bb50e5c | 1557 | |
0df8dc6e JH |
1558 | case OPT_flinker_output_: |
1559 | linker_output_rel = !strcmp (option->arg, "rel"); | |
1560 | break; | |
1561 | ||
5a307ee5 RB |
1562 | case OPT_g: |
1563 | /* Recognize -g0. */ | |
1564 | skip_debug = option->arg && !strcmp (option->arg, "0"); | |
1565 | break; | |
0df8dc6e | 1566 | |
1dedc12d AO |
1567 | case OPT_dumpdir: |
1568 | incoming_dumppfx = dumppfx = option->arg; | |
1569 | break; | |
1570 | ||
cd4acb8c ML |
1571 | case OPT_fdiagnostics_urls_: |
1572 | diagnostic_urls_init (global_dc, option->value); | |
1573 | break; | |
1574 | ||
1575 | case OPT_fdiagnostics_color_: | |
1576 | diagnostic_color_init (global_dc, option->value); | |
1577 | break; | |
1578 | ||
f31c0018 RG |
1579 | default: |
1580 | break; | |
1581 | } | |
f31c0018 RG |
1582 | } |
1583 | ||
3cbcb5d0 ML |
1584 | /* Process LTO-related options on merged options. */ |
1585 | for (j = 1; j < fdecoded_options.length (); ++j) | |
1586 | { | |
1587 | cl_decoded_option *option = &fdecoded_options[j]; | |
1588 | switch (option->opt_index) | |
1589 | { | |
1590 | case OPT_flto_: | |
1591 | if (strcmp (option->arg, "jobserver") == 0) | |
1592 | { | |
1593 | parallel = 1; | |
1594 | jobserver = 1; | |
1595 | } | |
1596 | else if (strcmp (option->arg, "auto") == 0) | |
1597 | { | |
1598 | parallel = 1; | |
1599 | auto_parallel = 1; | |
1600 | } | |
1601 | else | |
1602 | { | |
1603 | parallel = atoi (option->arg); | |
1604 | if (parallel <= 1) | |
1605 | parallel = 0; | |
1606 | } | |
1607 | /* Fallthru. */ | |
1608 | ||
1609 | case OPT_flto: | |
1610 | lto_mode = LTO_MODE_WHOPR; | |
1611 | break; | |
1612 | } | |
1613 | } | |
1614 | ||
1ea85365 RB |
1615 | /* Output lto-wrapper invocation command. */ |
1616 | if (verbose) | |
1617 | { | |
1618 | for (i = 0; i < argc; ++i) | |
1619 | { | |
1620 | fputs (argv[i], stderr); | |
1621 | fputc (' ', stderr); | |
1622 | } | |
1623 | fputc ('\n', stderr); | |
1624 | } | |
1625 | ||
0df8dc6e JH |
1626 | if (linker_output_rel) |
1627 | no_partition = true; | |
1628 | ||
014d92e1 JH |
1629 | if (no_partition) |
1630 | { | |
1631 | lto_mode = LTO_MODE_LTO; | |
1632 | jobserver = 0; | |
7d7d925d | 1633 | jobserver_requested = false; |
200b0e7e | 1634 | auto_parallel = 0; |
014d92e1 JH |
1635 | parallel = 0; |
1636 | } | |
0f62caf5 | 1637 | else |
19566bdd | 1638 | { |
1270ccda ML |
1639 | jobserver_info jinfo; |
1640 | if (jobserver && !jinfo.is_active) | |
11929537 | 1641 | { |
7f9b7ccf | 1642 | /* Fall back to auto parallelism. */ |
11929537 | 1643 | jobserver = 0; |
7f9b7ccf | 1644 | auto_parallel = 1; |
11929537 | 1645 | } |
1270ccda | 1646 | else if (!jobserver && jinfo.is_active) |
0f62caf5 ML |
1647 | { |
1648 | parallel = 1; | |
1649 | jobserver = 1; | |
1650 | } | |
19566bdd | 1651 | } |
cf96bae7 | 1652 | |
6fade5a6 ML |
1653 | /* We need make working for a parallel execution. */ |
1654 | if (parallel && !make_exists ()) | |
1655 | parallel = 0; | |
1656 | ||
1dedc12d | 1657 | if (!dumppfx) |
cf96bae7 | 1658 | { |
1dedc12d AO |
1659 | if (!linker_output |
1660 | || strcmp (linker_output, HOST_BIT_BUCKET) == 0) | |
1661 | dumppfx = "a."; | |
1662 | else | |
dd3b31fb | 1663 | { |
1dedc12d AO |
1664 | const char *obase = lbasename (linker_output), *temp; |
1665 | ||
1666 | /* Strip the executable extension. */ | |
1667 | size_t blen = strlen (obase), xlen; | |
1668 | if ((temp = strrchr (obase + 1, '.')) | |
1669 | && (xlen = strlen (temp)) | |
1670 | && (strcmp (temp, ".exe") == 0 | |
1671 | #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) | |
1672 | || strcmp (temp, TARGET_EXECUTABLE_SUFFIX) == 0 | |
1673 | #endif | |
1674 | || strcmp (obase, "a.out") == 0)) | |
1675 | dumppfx = xstrndup (linker_output, | |
1676 | obase - linker_output + blen - xlen + 1); | |
1677 | else | |
1678 | dumppfx = concat (linker_output, ".", NULL); | |
dd3b31fb | 1679 | } |
1dedc12d | 1680 | } |
cf96bae7 | 1681 | |
1dedc12d AO |
1682 | /* If there's no directory component in the dumppfx, add one, so |
1683 | that, when it is used as -dumpbase, it overrides any occurrence | |
1684 | of -dumpdir that might have been passed in. */ | |
1685 | if (!dumppfx || lbasename (dumppfx) == dumppfx) | |
1686 | dumppfx = concat (current_dir, dumppfx, NULL); | |
1687 | ||
1688 | /* Make sure some -dumpdir is passed, so as to get predictable | |
1689 | -dumpbase overriding semantics. If we got an incoming -dumpdir | |
1690 | argument, we'll pass it on, so don't bother with another one | |
1691 | then. */ | |
1692 | if (!incoming_dumppfx) | |
1693 | { | |
1694 | obstack_ptr_grow (&argv_obstack, "-dumpdir"); | |
1695 | obstack_ptr_grow (&argv_obstack, ""); | |
cf96bae7 | 1696 | } |
1dedc12d | 1697 | obstack_ptr_grow (&argv_obstack, "-dumpbase"); |
ef6f874e RG |
1698 | |
1699 | /* Remember at which point we can scrub args to re-use the commons. */ | |
1700 | new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *); | |
d7f09764 | 1701 | |
fc8b3540 IV |
1702 | if (have_offload) |
1703 | { | |
e6861a99 IV |
1704 | unsigned i, num_offload_files; |
1705 | char **offload_argv; | |
1706 | FILE *f; | |
1707 | ||
1708 | f = fopen (offload_objects_file_name, "r"); | |
1709 | if (f == NULL) | |
1710 | fatal_error (input_location, "cannot open %s: %m", | |
1711 | offload_objects_file_name); | |
1712 | if (fscanf (f, "%u ", &num_offload_files) != 1) | |
1713 | fatal_error (input_location, "cannot read %s: %m", | |
1714 | offload_objects_file_name); | |
1715 | offload_argv = XCNEWVEC (char *, num_offload_files); | |
1716 | ||
1717 | /* Read names of object files with offload. */ | |
1718 | for (i = 0; i < num_offload_files; i++) | |
1719 | { | |
1720 | const unsigned piece = 32; | |
1721 | char *buf, *filename = XNEWVEC (char, piece); | |
1722 | size_t len; | |
1723 | ||
1724 | buf = filename; | |
1725 | cont1: | |
1726 | if (!fgets (buf, piece, f)) | |
1727 | break; | |
1728 | len = strlen (filename); | |
1729 | if (filename[len - 1] != '\n') | |
1730 | { | |
1731 | filename = XRESIZEVEC (char, filename, len + piece); | |
1732 | buf = filename + len; | |
1733 | goto cont1; | |
1734 | } | |
1735 | filename[len - 1] = '\0'; | |
1736 | offload_argv[i] = filename; | |
1737 | } | |
1738 | fclose (f); | |
1739 | if (offload_argv[num_offload_files - 1] == NULL) | |
1740 | fatal_error (input_location, "invalid format of %s", | |
1741 | offload_objects_file_name); | |
1742 | maybe_unlink (offload_objects_file_name); | |
1743 | offload_objects_file_name = NULL; | |
1744 | ||
1745 | /* Look at saved offload options in files. */ | |
1746 | for (i = 0; i < num_offload_files; i++) | |
1747 | { | |
1748 | char *p; | |
1749 | long loffset; | |
1750 | int fd, consumed; | |
1751 | off_t file_offset = 0; | |
1752 | char *filename = offload_argv[i]; | |
1753 | ||
1754 | if ((p = strrchr (offload_argv[i], '@')) | |
1755 | && p != offload_argv[i] | |
1756 | && sscanf (p, "@%li%n", &loffset, &consumed) >= 1 | |
1757 | && strlen (p) == (unsigned int) consumed) | |
1758 | { | |
1759 | filename = XNEWVEC (char, p - offload_argv[i] + 1); | |
1760 | memcpy (filename, offload_argv[i], p - offload_argv[i]); | |
1761 | filename[p - offload_argv[i]] = '\0'; | |
1762 | file_offset = (off_t) loffset; | |
1763 | } | |
1764 | fd = open (filename, O_RDONLY | O_BINARY); | |
1765 | if (fd == -1) | |
1766 | fatal_error (input_location, "cannot open %s: %m", filename); | |
1767 | if (!find_and_merge_options (fd, file_offset, | |
1768 | OFFLOAD_SECTION_NAME_PREFIX, | |
8a8ee37a JM |
1769 | decoded_options, |
1770 | offload_fdecoded_options_first, | |
1771 | &offload_fdecoded_options, | |
e6861a99 IV |
1772 | collect_gcc)) |
1773 | fatal_error (input_location, "cannot read %s: %m", filename); | |
8a8ee37a | 1774 | offload_fdecoded_options_first = false; |
e6861a99 IV |
1775 | close (fd); |
1776 | if (filename != offload_argv[i]) | |
1777 | XDELETEVEC (filename); | |
1778 | } | |
1779 | ||
1780 | compile_images_for_offload_targets (num_offload_files, offload_argv, | |
227a2ecf | 1781 | offload_fdecoded_options, decoded_options); |
e6861a99 IV |
1782 | |
1783 | free_array_of_ptrs ((void **) offload_argv, num_offload_files); | |
1784 | ||
fc8b3540 IV |
1785 | if (offload_names) |
1786 | { | |
7287cf18 | 1787 | find_crtoffloadtable (save_temps, dumppfx); |
fc8b3540 IV |
1788 | for (i = 0; offload_names[i]; i++) |
1789 | printf ("%s\n", offload_names[i]); | |
1790 | free_array_of_ptrs ((void **) offload_names, i); | |
e228683b | 1791 | offload_names = NULL; |
fc8b3540 IV |
1792 | } |
1793 | } | |
1794 | ||
fc8b3540 IV |
1795 | /* If object files contain offload sections, but do not contain LTO sections, |
1796 | then there is no need to perform a link-time recompilation, i.e. | |
1797 | lto-wrapper is used only for a compilation of offload images. */ | |
1798 | if (have_offload && !have_lto) | |
e6861a99 | 1799 | goto finish; |
fc8b3540 | 1800 | |
d7f09764 DN |
1801 | if (lto_mode == LTO_MODE_LTO) |
1802 | { | |
1dedc12d AO |
1803 | /* -dumpbase argument for LTO. */ |
1804 | flto_out = concat (dumppfx, "lto.o", NULL); | |
1805 | obstack_ptr_grow (&argv_obstack, flto_out); | |
1806 | ||
1807 | if (!save_temps) | |
b5327e50 | 1808 | flto_out = make_temp_file (".lto.o"); |
ef6f874e RG |
1809 | obstack_ptr_grow (&argv_obstack, "-o"); |
1810 | obstack_ptr_grow (&argv_obstack, flto_out); | |
d7f09764 | 1811 | } |
be286227 | 1812 | else |
d7f09764 DN |
1813 | { |
1814 | const char *list_option = "-fltrans-output-list="; | |
d7f09764 | 1815 | |
1dedc12d AO |
1816 | /* -dumpbase argument for WPA. */ |
1817 | char *dumpbase = concat (dumppfx, "wpa", NULL); | |
1818 | obstack_ptr_grow (&argv_obstack, dumpbase); | |
cf96bae7 | 1819 | |
1dedc12d AO |
1820 | if (save_temps) |
1821 | ltrans_output_file = concat (dumppfx, "ltrans.out", NULL); | |
b5611987 | 1822 | else |
1dedc12d AO |
1823 | ltrans_output_file = make_temp_file (".ltrans.out"); |
1824 | list_option_full = concat (list_option, ltrans_output_file, NULL); | |
1825 | obstack_ptr_grow (&argv_obstack, list_option_full); | |
d7f09764 | 1826 | |
f300e7b8 | 1827 | if (jobserver) |
200b0e7e ML |
1828 | { |
1829 | if (verbose) | |
1830 | fprintf (stderr, "Using make jobserver\n"); | |
1831 | obstack_ptr_grow (&argv_obstack, xstrdup ("-fwpa=jobserver")); | |
1832 | } | |
1833 | else if (auto_parallel) | |
1834 | { | |
1835 | char buf[256]; | |
f2b4f212 | 1836 | init_num_threads (); |
cab1b0eb ML |
1837 | if (nthreads_var == 0) |
1838 | nthreads_var = 1; | |
200b0e7e ML |
1839 | if (verbose) |
1840 | fprintf (stderr, "LTO parallelism level set to %ld\n", | |
1841 | nthreads_var); | |
1842 | sprintf (buf, "-fwpa=%ld", nthreads_var); | |
1843 | obstack_ptr_grow (&argv_obstack, xstrdup (buf)); | |
1844 | } | |
f300e7b8 JH |
1845 | else if (parallel > 1) |
1846 | { | |
1847 | char buf[256]; | |
1848 | sprintf (buf, "-fwpa=%i", parallel); | |
1849 | obstack_ptr_grow (&argv_obstack, xstrdup (buf)); | |
1850 | } | |
1851 | else | |
1852 | obstack_ptr_grow (&argv_obstack, "-fwpa"); | |
d7f09764 | 1853 | } |
d7f09764 | 1854 | |
1ea85365 | 1855 | /* Append input arguments. */ |
443743fd IV |
1856 | for (i = 0; i < lto_argc; ++i) |
1857 | obstack_ptr_grow (&argv_obstack, lto_argv[i]); | |
1ea85365 RB |
1858 | /* Append the input objects. */ |
1859 | for (i = 0; i < ltoobj_argc; ++i) | |
1860 | obstack_ptr_grow (&argv_obstack, ltoobj_argv[i]); | |
ef6f874e | 1861 | obstack_ptr_grow (&argv_obstack, NULL); |
d7f09764 | 1862 | |
ef6f874e RG |
1863 | new_argv = XOBFINISH (&argv_obstack, const char **); |
1864 | argv_ptr = &new_argv[new_head_argc]; | |
b3032d1b TB |
1865 | fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true, |
1866 | "ltrans_args"); | |
48cf395b | 1867 | |
1ea85365 RB |
1868 | /* Copy the early generated debug info from the objects to temporary |
1869 | files and append those to the partial link commandline. */ | |
b5327e50 | 1870 | early_debug_object_names = NULL; |
1ea85365 | 1871 | if (! skip_debug) |
1ea85365 | 1872 | { |
b5327e50 IS |
1873 | early_debug_object_names = XCNEWVEC (const char *, ltoobj_argc+ 1); |
1874 | num_deb_objs = ltoobj_argc; | |
1875 | for (i = 0; i < ltoobj_argc; ++i) | |
1ea85365 | 1876 | { |
b5327e50 IS |
1877 | const char *tem; |
1878 | if ((tem = debug_objcopy (ltoobj_argv[i], !linker_output_rel))) | |
880456ed | 1879 | early_debug_object_names[i] = tem; |
1ea85365 RB |
1880 | } |
1881 | } | |
1ea85365 | 1882 | |
d7f09764 DN |
1883 | if (lto_mode == LTO_MODE_LTO) |
1884 | { | |
c3284718 | 1885 | printf ("%s\n", flto_out); |
1ea85365 RB |
1886 | if (!skip_debug) |
1887 | { | |
b5327e50 IS |
1888 | for (i = 0; i < ltoobj_argc; ++i) |
1889 | if (early_debug_object_names[i] != NULL) | |
1890 | printf ("%s\n", early_debug_object_names[i]); | |
1ea85365 | 1891 | } |
b5327e50 | 1892 | /* These now belong to collect2. */ |
d7f09764 DN |
1893 | free (flto_out); |
1894 | flto_out = NULL; | |
b5327e50 IS |
1895 | free (early_debug_object_names); |
1896 | early_debug_object_names = NULL; | |
d7f09764 | 1897 | } |
be286227 | 1898 | else |
d7f09764 DN |
1899 | { |
1900 | FILE *stream = fopen (ltrans_output_file, "r"); | |
c04b6b38 | 1901 | FILE *mstream = NULL; |
4559db79 | 1902 | struct obstack env_obstack; |
b6e33d73 | 1903 | int priority; |
d7f09764 DN |
1904 | |
1905 | if (!stream) | |
a9c697b8 | 1906 | fatal_error (input_location, "%<fopen%>: %s: %m", ltrans_output_file); |
d7f09764 | 1907 | |
50ee30d5 | 1908 | /* Parse the list of LTRANS inputs from the WPA stage. */ |
4559db79 | 1909 | obstack_init (&env_obstack); |
50ee30d5 | 1910 | nr = 0; |
48cf395b RB |
1911 | for (;;) |
1912 | { | |
1913 | const unsigned piece = 32; | |
50ee30d5 | 1914 | char *output_name = NULL; |
48cf395b RB |
1915 | char *buf, *input_name = (char *)xmalloc (piece); |
1916 | size_t len; | |
1917 | ||
1918 | buf = input_name; | |
b6e33d73 JH |
1919 | if (fscanf (stream, "%i\n", &priority) != 1) |
1920 | { | |
1921 | if (!feof (stream)) | |
1922 | fatal_error (input_location, | |
a9c697b8 | 1923 | "corrupted ltrans output file %s", |
b6e33d73 JH |
1924 | ltrans_output_file); |
1925 | break; | |
1926 | } | |
48cf395b RB |
1927 | cont: |
1928 | if (!fgets (buf, piece, stream)) | |
1929 | break; | |
1930 | len = strlen (input_name); | |
1931 | if (input_name[len - 1] != '\n') | |
1932 | { | |
1933 | input_name = (char *)xrealloc (input_name, len + piece); | |
1934 | buf = input_name + len; | |
1935 | goto cont; | |
1936 | } | |
1937 | input_name[len - 1] = '\0'; | |
1938 | ||
1939 | if (input_name[0] == '*') | |
c04b6b38 | 1940 | output_name = &input_name[1]; |
48cf395b | 1941 | |
c04b6b38 | 1942 | nr++; |
b6e33d73 JH |
1943 | ltrans_priorities |
1944 | = (int *)xrealloc (ltrans_priorities, nr * sizeof (int) * 2); | |
c04b6b38 RG |
1945 | input_names = (char **)xrealloc (input_names, nr * sizeof (char *)); |
1946 | output_names = (char **)xrealloc (output_names, nr * sizeof (char *)); | |
b6e33d73 JH |
1947 | ltrans_priorities[(nr-1)*2] = priority; |
1948 | ltrans_priorities[(nr-1)*2+1] = nr-1; | |
c04b6b38 RG |
1949 | input_names[nr-1] = input_name; |
1950 | output_names[nr-1] = output_name; | |
1951 | } | |
50ee30d5 | 1952 | fclose (stream); |
a185856a | 1953 | maybe_unlink (ltrans_output_file); |
50ee30d5 RG |
1954 | ltrans_output_file = NULL; |
1955 | ||
7d7d925d ML |
1956 | if (nr > 1) |
1957 | { | |
1270ccda ML |
1958 | jobserver_info jinfo; |
1959 | if (jobserver_requested && !jinfo.is_active) | |
7d7d925d | 1960 | { |
1270ccda | 1961 | warning (0, jinfo.error_msg.c_str ()); |
7d7d925d ML |
1962 | print_lto_docs_link (); |
1963 | } | |
1964 | else if (parallel == 0) | |
1965 | { | |
1966 | warning (0, "using serial compilation of %d LTRANS jobs", nr); | |
1967 | print_lto_docs_link (); | |
1968 | } | |
1969 | } | |
1970 | ||
50ee30d5 RG |
1971 | if (parallel) |
1972 | { | |
1973 | makefile = make_temp_file (".mk"); | |
1974 | mstream = fopen (makefile, "w"); | |
b6e33d73 | 1975 | qsort (ltrans_priorities, nr, sizeof (int) * 2, cmp_priority); |
50ee30d5 RG |
1976 | } |
1977 | ||
1978 | /* Execute the LTRANS stage for each input file (or prepare a | |
1979 | makefile to invoke this in parallel). */ | |
1980 | for (i = 0; i < nr; ++i) | |
1981 | { | |
1982 | char *output_name; | |
1983 | char *input_name = input_names[i]; | |
1984 | /* If it's a pass-through file do nothing. */ | |
1985 | if (output_names[i]) | |
1986 | continue; | |
1987 | ||
1988 | /* Replace the .o suffix with a .ltrans.o suffix and write | |
1989 | the resulting name to the LTRANS output list. */ | |
50ee30d5 RG |
1990 | obstack_grow (&env_obstack, input_name, strlen (input_name) - 2); |
1991 | obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o")); | |
1992 | output_name = XOBFINISH (&env_obstack, char *); | |
1993 | ||
1994 | /* Adjust the dumpbase if the linker output file was seen. */ | |
f5440ac7 AH |
1995 | int dumpbase_len = (strlen (dumppfx) |
1996 | + sizeof (DUMPBASE_SUFFIX) | |
1997 | + sizeof (".ltrans")); | |
1dedc12d AO |
1998 | char *dumpbase = (char *) xmalloc (dumpbase_len + 1); |
1999 | snprintf (dumpbase, dumpbase_len, "%sltrans%u.ltrans", dumppfx, i); | |
2000 | argv_ptr[0] = dumpbase; | |
50ee30d5 RG |
2001 | |
2002 | argv_ptr[1] = "-fltrans"; | |
2003 | argv_ptr[2] = "-o"; | |
2004 | argv_ptr[3] = output_name; | |
2005 | argv_ptr[4] = input_name; | |
2006 | argv_ptr[5] = NULL; | |
2007 | if (parallel) | |
2008 | { | |
2009 | fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]); | |
2010 | for (j = 1; new_argv[j] != NULL; ++j) | |
2011 | fprintf (mstream, " '%s'", new_argv[j]); | |
2012 | fprintf (mstream, "\n"); | |
9d69847d RG |
2013 | /* If we are not preserving the ltrans input files then |
2014 | truncate them as soon as we have processed it. This | |
2015 | reduces temporary disk-space usage. */ | |
608508a6 | 2016 | if (! save_temps) |
47db37ed TS |
2017 | fprintf (mstream, "\t@-touch -r \"%s\" \"%s.tem\" > /dev/null " |
2018 | "2>&1 && mv \"%s.tem\" \"%s\"\n", | |
9d69847d | 2019 | input_name, input_name, input_name, input_name); |
50ee30d5 RG |
2020 | } |
2021 | else | |
9d69847d | 2022 | { |
f5440ac7 AH |
2023 | char argsuffix[sizeof (DUMPBASE_SUFFIX) |
2024 | + sizeof (".ltrans_args") + 1]; | |
b3032d1b | 2025 | if (save_temps) |
f5440ac7 AH |
2026 | snprintf (argsuffix, |
2027 | sizeof (DUMPBASE_SUFFIX) + sizeof (".ltrans_args"), | |
b3032d1b | 2028 | "ltrans%u.ltrans_args", i); |
5f0ad6a5 | 2029 | fork_execute (new_argv[0], CONST_CAST (char **, new_argv), |
b3032d1b | 2030 | true, save_temps ? argsuffix : NULL); |
a185856a | 2031 | maybe_unlink (input_name); |
9d69847d | 2032 | } |
50ee30d5 RG |
2033 | |
2034 | output_names[i] = output_name; | |
2035 | } | |
c04b6b38 RG |
2036 | if (parallel) |
2037 | { | |
2038 | struct pex_obj *pex; | |
2039 | char jobs[32]; | |
a478ffff | 2040 | |
bb52a82a RB |
2041 | fprintf (mstream, |
2042 | ".PHONY: all\n" | |
2043 | "all:"); | |
c04b6b38 | 2044 | for (i = 0; i < nr; ++i) |
b6e33d73 JH |
2045 | { |
2046 | int j = ltrans_priorities[i*2 + 1]; | |
2047 | fprintf (mstream, " \\\n\t%s", output_names[j]); | |
2048 | } | |
c04b6b38 RG |
2049 | fprintf (mstream, "\n"); |
2050 | fclose (mstream); | |
a478ffff AK |
2051 | if (!jobserver) |
2052 | { | |
2053 | /* Avoid passing --jobserver-fd= and similar flags | |
2054 | unless jobserver mode is explicitly enabled. */ | |
2055 | putenv (xstrdup ("MAKEFLAGS=")); | |
2056 | putenv (xstrdup ("MFLAGS=")); | |
2057 | } | |
b24fc8a6 ML |
2058 | |
2059 | char **make_argv = buildargv (getenv ("MAKE")); | |
2060 | if (make_argv) | |
2061 | { | |
2062 | for (unsigned argc = 0; make_argv[argc]; argc++) | |
2063 | obstack_ptr_grow (&argv_obstack, make_argv[argc]); | |
2064 | } | |
2065 | else | |
2066 | obstack_ptr_grow (&argv_obstack, "make"); | |
2067 | ||
2068 | obstack_ptr_grow (&argv_obstack, "-f"); | |
2069 | obstack_ptr_grow (&argv_obstack, makefile); | |
a478ffff AK |
2070 | if (!jobserver) |
2071 | { | |
200b0e7e ML |
2072 | snprintf (jobs, 31, "-j%ld", |
2073 | auto_parallel ? nthreads_var : parallel); | |
b24fc8a6 | 2074 | obstack_ptr_grow (&argv_obstack, jobs); |
a478ffff | 2075 | } |
b24fc8a6 ML |
2076 | obstack_ptr_grow (&argv_obstack, "all"); |
2077 | obstack_ptr_grow (&argv_obstack, NULL); | |
2078 | new_argv = XOBFINISH (&argv_obstack, const char **); | |
2079 | ||
5f0ad6a5 | 2080 | pex = collect_execute (new_argv[0], CONST_CAST (char **, new_argv), |
b3032d1b | 2081 | NULL, NULL, PEX_SEARCH, false, NULL); |
5f0ad6a5 | 2082 | do_wait (new_argv[0], pex); |
b24fc8a6 | 2083 | freeargv (make_argv); |
a185856a | 2084 | maybe_unlink (makefile); |
50ee30d5 | 2085 | makefile = NULL; |
9d69847d | 2086 | for (i = 0; i < nr; ++i) |
a185856a | 2087 | maybe_unlink (input_names[i]); |
c04b6b38 RG |
2088 | } |
2089 | for (i = 0; i < nr; ++i) | |
2090 | { | |
2091 | fputs (output_names[i], stdout); | |
48cf395b | 2092 | putc ('\n', stdout); |
c04b6b38 | 2093 | free (input_names[i]); |
48cf395b | 2094 | } |
b5327e50 IS |
2095 | if (!skip_debug) |
2096 | { | |
2097 | for (i = 0; i < ltoobj_argc; ++i) | |
2098 | if (early_debug_object_names[i] != NULL) | |
2099 | printf ("%s\n", early_debug_object_names[i]); | |
2100 | } | |
50ee30d5 | 2101 | nr = 0; |
b6e33d73 | 2102 | free (ltrans_priorities); |
c04b6b38 | 2103 | free (output_names); |
b5327e50 IS |
2104 | output_names = NULL; |
2105 | free (early_debug_object_names); | |
2106 | early_debug_object_names = NULL; | |
c04b6b38 | 2107 | free (input_names); |
d7f09764 | 2108 | free (list_option_full); |
4559db79 | 2109 | obstack_free (&env_obstack, NULL); |
d7f09764 | 2110 | } |
ef6f874e | 2111 | |
fc8b3540 | 2112 | finish: |
443743fd | 2113 | XDELETE (lto_argv); |
ef6f874e | 2114 | obstack_free (&argv_obstack, NULL); |
d7f09764 DN |
2115 | } |
2116 | ||
2117 | ||
2118 | /* Entry point. */ | |
2119 | ||
2120 | int | |
2121 | main (int argc, char *argv[]) | |
2122 | { | |
2691e6d7 JM |
2123 | const char *p; |
2124 | ||
de5672fc | 2125 | init_opts_obstack (); |
dc357798 | 2126 | |
2691e6d7 JM |
2127 | p = argv[0] + strlen (argv[0]); |
2128 | while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) | |
2129 | --p; | |
2130 | progname = p; | |
2131 | ||
2132 | xmalloc_set_program_name (progname); | |
2133 | ||
d7f09764 DN |
2134 | gcc_init_libintl (); |
2135 | ||
2691e6d7 | 2136 | diagnostic_initialize (global_dc, 0); |
cd4acb8c ML |
2137 | diagnostic_color_init (global_dc); |
2138 | diagnostic_urls_init (global_dc); | |
2139 | global_dc->get_option_url = get_option_url; | |
2691e6d7 | 2140 | |
877088b7 | 2141 | if (atexit (lto_wrapper_cleanup) != 0) |
a9c697b8 | 2142 | fatal_error (input_location, "%<atexit%> failed"); |
877088b7 | 2143 | |
2dc6782a | 2144 | setup_signals (); |
396717c9 | 2145 | |
d7f09764 DN |
2146 | /* We may be called with all the arguments stored in some file and |
2147 | passed with @file. Expand them into argv before processing. */ | |
2148 | expandargv (&argc, &argv); | |
f31c0018 | 2149 | |
cf96bae7 | 2150 | run_gcc (argc, argv); |
d7f09764 DN |
2151 | |
2152 | return 0; | |
2153 | } |