]>
Commit | Line | Data |
---|---|---|
7bfefa9d | 1 | /* Wrapper to call lto. Used by collect2 and the linker plugin. |
fbd26352 | 2 | Copyright (C) 2009-2019 Free Software Foundation, Inc. |
7bfefa9d | 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 | ||
cbcf2791 | 35 | If WHOPR is used instead, more than one file might be produced |
7bfefa9d | 36 | ./ccXj2DTk.lto.ltrans.o |
37 | ./ccCJuXGv.lto.ltrans.o | |
38 | */ | |
39 | ||
40 | #include "config.h" | |
41 | #include "system.h" | |
960ebfe7 | 42 | #include "coretypes.h" |
7bfefa9d | 43 | #include "intl.h" |
0b4f4daf | 44 | #include "diagnostic.h" |
264cbb51 | 45 | #include "obstack.h" |
00d389c8 | 46 | #include "opts.h" |
47 | #include "options.h" | |
954825c9 | 48 | #include "simple-object.h" |
47131315 | 49 | #include "lto-section-names.h" |
eb9ccb01 | 50 | #include "collect-utils.h" |
7bfefa9d | 51 | |
77415571 | 52 | /* Environment variable, used for passing the names of offload targets from GCC |
53 | driver to lto-wrapper. */ | |
54 | #define OFFLOAD_TARGET_NAMES_ENV "OFFLOAD_TARGET_NAMES" | |
55 | ||
7bfefa9d | 56 | enum lto_mode_d { |
c8c65e07 | 57 | LTO_MODE_NONE, /* Not doing LTO. */ |
58 | LTO_MODE_LTO, /* Normal LTO. */ | |
59 | LTO_MODE_WHOPR /* WHOPR. */ | |
7bfefa9d | 60 | }; |
61 | ||
62 | /* Current LTO mode. */ | |
63 | static enum lto_mode_d lto_mode = LTO_MODE_NONE; | |
64 | ||
c515f146 | 65 | static char *ltrans_output_file; |
66 | static char *flto_out; | |
4062f557 | 67 | static unsigned int nr; |
747c1878 | 68 | static int *ltrans_priorities; |
4062f557 | 69 | static char **input_names; |
70 | static char **output_names; | |
77415571 | 71 | static char **offload_names; |
e59c8b12 | 72 | static char *offload_objects_file_name; |
4062f557 | 73 | static char *makefile; |
6dc407e1 | 74 | static unsigned int num_deb_objs; |
75 | static const char **early_debug_object_names; | |
c515f146 | 76 | |
eb9ccb01 | 77 | const char tool_name[] = "lto-wrapper"; |
c515f146 | 78 | |
eb9ccb01 | 79 | /* Delete tempfiles. Called from utils_cleanup. */ |
c515f146 | 80 | |
eb9ccb01 | 81 | void |
39ef03bb | 82 | tool_cleanup (bool) |
c515f146 | 83 | { |
c04a3a63 | 84 | unsigned int i; |
85 | ||
c04a3a63 | 86 | if (ltrans_output_file) |
eb9ccb01 | 87 | maybe_unlink (ltrans_output_file); |
c04a3a63 | 88 | if (flto_out) |
eb9ccb01 | 89 | maybe_unlink (flto_out); |
e59c8b12 | 90 | if (offload_objects_file_name) |
91 | maybe_unlink (offload_objects_file_name); | |
c04a3a63 | 92 | if (makefile) |
eb9ccb01 | 93 | maybe_unlink (makefile); |
6dc407e1 | 94 | if (early_debug_object_names) |
95 | for (i = 0; i < num_deb_objs; ++i) | |
96 | if (early_debug_object_names[i]) | |
97 | maybe_unlink (early_debug_object_names[i]); | |
c04a3a63 | 98 | for (i = 0; i < nr; ++i) |
3c1d5969 | 99 | { |
eb9ccb01 | 100 | maybe_unlink (input_names[i]); |
c04a3a63 | 101 | if (output_names[i]) |
eb9ccb01 | 102 | maybe_unlink (output_names[i]); |
3c1d5969 | 103 | } |
c04a3a63 | 104 | } |
105 | ||
106 | static void | |
eb9ccb01 | 107 | lto_wrapper_cleanup (void) |
7bfefa9d | 108 | { |
39ef03bb | 109 | utils_cleanup (false); |
7bfefa9d | 110 | } |
111 | ||
7bfefa9d | 112 | /* Unlink a temporary LTRANS file unless requested otherwise. */ |
113 | ||
eb9ccb01 | 114 | void |
115 | maybe_unlink (const char *file) | |
7bfefa9d | 116 | { |
572cae00 | 117 | if (!save_temps) |
7bfefa9d | 118 | { |
411503bd | 119 | if (unlink_if_ordinary (file) |
120 | && errno != ENOENT) | |
c05be867 | 121 | fatal_error (input_location, "deleting LTRANS file %s: %m", file); |
7bfefa9d | 122 | } |
472d4060 | 123 | else if (verbose) |
7bfefa9d | 124 | fprintf (stderr, "[Leaving LTRANS %s]\n", file); |
125 | } | |
126 | ||
264cbb51 | 127 | /* Template of LTRANS dumpbase suffix. */ |
128 | #define DUMPBASE_SUFFIX ".ltrans18446744073709551615" | |
7bfefa9d | 129 | |
00d389c8 | 130 | /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS |
131 | environment according to LANG_MASK. */ | |
132 | ||
133 | static void | |
134 | get_options_from_collect_gcc_options (const char *collect_gcc, | |
135 | const char *collect_gcc_options, | |
136 | unsigned int lang_mask, | |
137 | struct cl_decoded_option **decoded_options, | |
138 | unsigned int *decoded_options_count) | |
139 | { | |
05f1abc2 | 140 | struct obstack argv_obstack; |
00d389c8 | 141 | char *argv_storage; |
142 | const char **argv; | |
05f1abc2 | 143 | int j, k, argc; |
144 | ||
00d389c8 | 145 | argv_storage = xstrdup (collect_gcc_options); |
05f1abc2 | 146 | obstack_init (&argv_obstack); |
147 | obstack_ptr_grow (&argv_obstack, collect_gcc); | |
148 | ||
149 | for (j = 0, k = 0; argv_storage[j] != '\0'; ++j) | |
00d389c8 | 150 | { |
151 | if (argv_storage[j] == '\'') | |
152 | { | |
05f1abc2 | 153 | obstack_ptr_grow (&argv_obstack, &argv_storage[k]); |
154 | ++j; | |
155 | do | |
156 | { | |
157 | if (argv_storage[j] == '\0') | |
85b9be9b | 158 | fatal_error (input_location, |
159 | "malformed %<COLLECT_GCC_OPTIONS%>"); | |
05f1abc2 | 160 | else if (strncmp (&argv_storage[j], "'\\''", 4) == 0) |
161 | { | |
162 | argv_storage[k++] = '\''; | |
163 | j += 4; | |
164 | } | |
165 | else if (argv_storage[j] == '\'') | |
166 | break; | |
167 | else | |
168 | argv_storage[k++] = argv_storage[j++]; | |
169 | } | |
170 | while (1); | |
171 | argv_storage[k++] = '\0'; | |
00d389c8 | 172 | } |
173 | } | |
05f1abc2 | 174 | |
175 | obstack_ptr_grow (&argv_obstack, NULL); | |
176 | argc = obstack_object_size (&argv_obstack) / sizeof (void *) - 1; | |
177 | argv = XOBFINISH (&argv_obstack, const char **); | |
00d389c8 | 178 | |
179 | decode_cmdline_options_to_array (argc, (const char **)argv, | |
180 | lang_mask, | |
181 | decoded_options, decoded_options_count); | |
05f1abc2 | 182 | obstack_free (&argv_obstack, NULL); |
00d389c8 | 183 | } |
184 | ||
954825c9 | 185 | /* Append OPTION to the options array DECODED_OPTIONS with size |
186 | DECODED_OPTIONS_COUNT. */ | |
187 | ||
188 | static void | |
189 | append_option (struct cl_decoded_option **decoded_options, | |
190 | unsigned int *decoded_options_count, | |
191 | struct cl_decoded_option *option) | |
192 | { | |
193 | ++*decoded_options_count; | |
194 | *decoded_options | |
195 | = (struct cl_decoded_option *) | |
196 | xrealloc (*decoded_options, | |
197 | (*decoded_options_count | |
198 | * sizeof (struct cl_decoded_option))); | |
199 | memcpy (&(*decoded_options)[*decoded_options_count - 1], option, | |
200 | sizeof (struct cl_decoded_option)); | |
201 | } | |
202 | ||
06e0d439 | 203 | /* Remove option number INDEX from DECODED_OPTIONS, update |
204 | DECODED_OPTIONS_COUNT. */ | |
205 | ||
206 | static void | |
207 | remove_option (struct cl_decoded_option **decoded_options, | |
208 | int index, unsigned int *decoded_options_count) | |
209 | { | |
210 | --*decoded_options_count; | |
211 | memmove (&(*decoded_options)[index + 1], | |
212 | &(*decoded_options)[index], | |
213 | sizeof (struct cl_decoded_option) | |
214 | * (*decoded_options_count - index)); | |
215 | } | |
216 | ||
954825c9 | 217 | /* Try to merge and complain about options FDECODED_OPTIONS when applied |
218 | ontop of DECODED_OPTIONS. */ | |
219 | ||
220 | static void | |
221 | merge_and_complain (struct cl_decoded_option **decoded_options, | |
222 | unsigned int *decoded_options_count, | |
223 | struct cl_decoded_option *fdecoded_options, | |
224 | unsigned int fdecoded_options_count) | |
225 | { | |
226 | unsigned int i, j; | |
06e0d439 | 227 | struct cl_decoded_option *pic_option = NULL; |
228 | struct cl_decoded_option *pie_option = NULL; | |
954825c9 | 229 | |
230 | /* ??? Merge options from files. Most cases can be | |
231 | handled by either unioning or intersecting | |
232 | (for example -fwrapv is a case for unioning, | |
233 | -ffast-math is for intersection). Most complaints | |
234 | about real conflicts between different options can | |
235 | be deferred to the compiler proper. Options that | |
236 | we can neither safely handle by intersection nor | |
237 | unioning would need to be complained about here. | |
238 | Ideally we'd have a flag in the opt files that | |
239 | tells whether to union or intersect or reject. | |
240 | In absence of that it's unclear what a good default is. | |
241 | It's also difficult to get positional handling correct. */ | |
242 | ||
243 | /* The following does what the old LTO option code did, | |
244 | union all target and a selected set of common options. */ | |
245 | for (i = 0; i < fdecoded_options_count; ++i) | |
246 | { | |
247 | struct cl_decoded_option *foption = &fdecoded_options[i]; | |
248 | switch (foption->opt_index) | |
249 | { | |
645c2597 | 250 | case OPT_SPECIAL_unknown: |
251 | case OPT_SPECIAL_ignore: | |
0c46a085 | 252 | case OPT_SPECIAL_deprecated: |
645c2597 | 253 | case OPT_SPECIAL_program_name: |
254 | case OPT_SPECIAL_input_file: | |
255 | break; | |
256 | ||
954825c9 | 257 | default: |
258 | if (!(cl_options[foption->opt_index].flags & CL_TARGET)) | |
259 | break; | |
260 | ||
261 | /* Fallthru. */ | |
d50ea280 | 262 | case OPT_fdiagnostics_show_caret: |
b7bb5264 | 263 | case OPT_fdiagnostics_show_labels: |
ff7410b8 | 264 | case OPT_fdiagnostics_show_line_numbers: |
d50ea280 | 265 | case OPT_fdiagnostics_show_option: |
266 | case OPT_fdiagnostics_show_location_: | |
267 | case OPT_fshow_column: | |
954825c9 | 268 | case OPT_fcommon: |
50f418ca | 269 | case OPT_fgnu_tm: |
954825c9 | 270 | /* Do what the old LTO code did - collect exactly one option |
271 | setting per OPT code, we pick the first we encounter. | |
272 | ??? This doesn't make too much sense, but when it doesn't | |
273 | then we should complain. */ | |
274 | for (j = 0; j < *decoded_options_count; ++j) | |
275 | if ((*decoded_options)[j].opt_index == foption->opt_index) | |
276 | break; | |
277 | if (j == *decoded_options_count) | |
278 | append_option (decoded_options, decoded_options_count, foption); | |
279 | break; | |
940a2ab8 | 280 | |
06e0d439 | 281 | /* Figure out what PIC/PIE level wins and merge the results. */ |
282 | case OPT_fPIC: | |
283 | case OPT_fpic: | |
284 | pic_option = foption; | |
285 | break; | |
286 | case OPT_fPIE: | |
287 | case OPT_fpie: | |
288 | pie_option = foption; | |
289 | break; | |
290 | ||
fa175926 | 291 | case OPT_fopenmp: |
85977647 | 292 | case OPT_fopenacc: |
e38bbd96 | 293 | /* For selected options we can merge conservatively. */ |
294 | for (j = 0; j < *decoded_options_count; ++j) | |
295 | if ((*decoded_options)[j].opt_index == foption->opt_index) | |
296 | break; | |
297 | if (j == *decoded_options_count) | |
298 | append_option (decoded_options, decoded_options_count, foption); | |
505329dd | 299 | /* -fopenmp > -fno-openmp, |
0c46a085 | 300 | -fopenacc > -fno-openacc */ |
e38bbd96 | 301 | else if (foption->value > (*decoded_options)[j].value) |
302 | (*decoded_options)[j] = *foption; | |
303 | break; | |
304 | ||
948eee2f | 305 | case OPT_fopenacc_dim_: |
306 | /* Append or check identical. */ | |
307 | for (j = 0; j < *decoded_options_count; ++j) | |
308 | if ((*decoded_options)[j].opt_index == foption->opt_index) | |
309 | break; | |
310 | if (j == *decoded_options_count) | |
311 | append_option (decoded_options, decoded_options_count, foption); | |
312 | else if (strcmp ((*decoded_options)[j].arg, foption->arg)) | |
313 | fatal_error (input_location, | |
85b9be9b | 314 | "option %s with different values", |
948eee2f | 315 | foption->orig_option_with_args_text); |
316 | break; | |
317 | ||
958d7687 | 318 | case OPT_O: |
319 | case OPT_Ofast: | |
320 | case OPT_Og: | |
321 | case OPT_Os: | |
322 | for (j = 0; j < *decoded_options_count; ++j) | |
323 | if ((*decoded_options)[j].opt_index == OPT_O | |
324 | || (*decoded_options)[j].opt_index == OPT_Ofast | |
325 | || (*decoded_options)[j].opt_index == OPT_Og | |
326 | || (*decoded_options)[j].opt_index == OPT_Os) | |
327 | break; | |
328 | if (j == *decoded_options_count) | |
329 | append_option (decoded_options, decoded_options_count, foption); | |
330 | else if ((*decoded_options)[j].opt_index == foption->opt_index | |
331 | && foption->opt_index != OPT_O) | |
332 | /* Exact same options get merged. */ | |
333 | ; | |
334 | else | |
335 | { | |
336 | /* For mismatched option kinds preserve the optimization | |
337 | level only, thus merge it as -On. This also handles | |
338 | merging of same optimization level -On. */ | |
339 | int level = 0; | |
340 | switch (foption->opt_index) | |
341 | { | |
342 | case OPT_O: | |
343 | if (foption->arg[0] == '\0') | |
344 | level = MAX (level, 1); | |
345 | else | |
346 | level = MAX (level, atoi (foption->arg)); | |
347 | break; | |
348 | case OPT_Ofast: | |
349 | level = MAX (level, 3); | |
350 | break; | |
351 | case OPT_Og: | |
352 | level = MAX (level, 1); | |
353 | break; | |
354 | case OPT_Os: | |
355 | level = MAX (level, 2); | |
356 | break; | |
357 | default: | |
358 | gcc_unreachable (); | |
359 | } | |
360 | switch ((*decoded_options)[j].opt_index) | |
361 | { | |
362 | case OPT_O: | |
363 | if ((*decoded_options)[j].arg[0] == '\0') | |
364 | level = MAX (level, 1); | |
365 | else | |
366 | level = MAX (level, atoi ((*decoded_options)[j].arg)); | |
367 | break; | |
368 | case OPT_Ofast: | |
369 | level = MAX (level, 3); | |
370 | break; | |
371 | case OPT_Og: | |
372 | level = MAX (level, 1); | |
373 | break; | |
374 | case OPT_Os: | |
375 | level = MAX (level, 2); | |
376 | break; | |
377 | default: | |
378 | gcc_unreachable (); | |
379 | } | |
380 | (*decoded_options)[j].opt_index = OPT_O; | |
381 | char *tem; | |
5e9ac72e | 382 | tem = xasprintf ("-O%d", level); |
958d7687 | 383 | (*decoded_options)[j].arg = &tem[2]; |
384 | (*decoded_options)[j].canonical_option[0] = tem; | |
385 | (*decoded_options)[j].value = 1; | |
386 | } | |
387 | break; | |
06e0d439 | 388 | |
389 | ||
390 | case OPT_foffload_abi_: | |
391 | for (j = 0; j < *decoded_options_count; ++j) | |
392 | if ((*decoded_options)[j].opt_index == foption->opt_index) | |
393 | break; | |
394 | if (j == *decoded_options_count) | |
395 | append_option (decoded_options, decoded_options_count, foption); | |
396 | else if (foption->value != (*decoded_options)[j].value) | |
397 | fatal_error (input_location, | |
85b9be9b | 398 | "option %s not used consistently in all LTO input" |
06e0d439 | 399 | " files", foption->orig_option_with_args_text); |
400 | break; | |
401 | ||
38e21583 | 402 | |
403 | case OPT_foffload_: | |
404 | append_option (decoded_options, decoded_options_count, foption); | |
405 | break; | |
954825c9 | 406 | } |
407 | } | |
06e0d439 | 408 | |
409 | /* Merge PIC options: | |
410 | -fPIC + -fpic = -fpic | |
411 | -fPIC + -fno-pic = -fno-pic | |
412 | -fpic/-fPIC + nothin = nothing. | |
413 | It is a common mistake to mix few -fPIC compiled objects into otherwise | |
414 | non-PIC code. We do not want to build everything with PIC then. | |
415 | ||
995068e4 | 416 | Similarly we merge PIE options, however in addition we keep |
417 | -fPIC + -fPIE = -fPIE | |
418 | -fpic + -fPIE = -fpie | |
419 | -fPIC/-fpic + -fpie = -fpie | |
420 | ||
06e0d439 | 421 | It would be good to warn on mismatches, but it is bit hard to do as |
422 | we do not know what nothing translates to. */ | |
423 | ||
424 | for (unsigned int j = 0; j < *decoded_options_count;) | |
425 | if ((*decoded_options)[j].opt_index == OPT_fPIC | |
426 | || (*decoded_options)[j].opt_index == OPT_fpic) | |
427 | { | |
995068e4 | 428 | /* -fno-pic in one unit implies -fno-pic everywhere. */ |
429 | if ((*decoded_options)[j].value == 0) | |
430 | j++; | |
431 | /* If we have no pic option or merge in -fno-pic, we still may turn | |
432 | existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */ | |
433 | else if ((pic_option && pic_option->value == 0) | |
434 | || !pic_option) | |
435 | { | |
436 | if (pie_option) | |
437 | { | |
438 | bool big = (*decoded_options)[j].opt_index == OPT_fPIC | |
439 | && pie_option->opt_index == OPT_fPIE; | |
440 | (*decoded_options)[j].opt_index = big ? OPT_fPIE : OPT_fpie; | |
441 | if (pie_option->value) | |
442 | (*decoded_options)[j].canonical_option[0] = big ? "-fPIE" : "-fpie"; | |
443 | else | |
444 | (*decoded_options)[j].canonical_option[0] = big ? "-fno-pie" : "-fno-pie"; | |
445 | (*decoded_options)[j].value = pie_option->value; | |
446 | j++; | |
447 | } | |
448 | else if (pic_option) | |
449 | { | |
450 | (*decoded_options)[j] = *pic_option; | |
451 | j++; | |
452 | } | |
453 | /* We do not know if target defaults to pic or not, so just remove | |
454 | option if it is missing in one unit but enabled in other. */ | |
455 | else | |
456 | remove_option (decoded_options, j, decoded_options_count); | |
457 | } | |
458 | else if (pic_option->opt_index == OPT_fpic | |
459 | && (*decoded_options)[j].opt_index == OPT_fPIC) | |
06e0d439 | 460 | { |
461 | (*decoded_options)[j] = *pic_option; | |
462 | j++; | |
463 | } | |
464 | else | |
465 | j++; | |
466 | } | |
467 | else if ((*decoded_options)[j].opt_index == OPT_fPIE | |
468 | || (*decoded_options)[j].opt_index == OPT_fpie) | |
469 | { | |
995068e4 | 470 | /* -fno-pie in one unit implies -fno-pie everywhere. */ |
471 | if ((*decoded_options)[j].value == 0) | |
472 | j++; | |
473 | /* If we have no pie option or merge in -fno-pie, we still preserve | |
474 | PIE/pie if pic/PIC is present. */ | |
475 | else if ((pie_option && pie_option->value == 0) | |
476 | || !pie_option) | |
477 | { | |
478 | /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */ | |
479 | if (pic_option) | |
480 | { | |
481 | if (pic_option->opt_index == OPT_fpic | |
482 | && (*decoded_options)[j].opt_index == OPT_fPIE) | |
483 | { | |
484 | (*decoded_options)[j].opt_index = OPT_fpie; | |
485 | (*decoded_options)[j].canonical_option[0] | |
486 | = pic_option->value ? "-fpie" : "-fno-pie"; | |
487 | } | |
488 | else if (!pic_option->value) | |
489 | (*decoded_options)[j].canonical_option[0] = "-fno-pie"; | |
490 | (*decoded_options)[j].value = pic_option->value; | |
491 | j++; | |
492 | } | |
493 | else if (pie_option) | |
494 | { | |
495 | (*decoded_options)[j] = *pie_option; | |
496 | j++; | |
497 | } | |
498 | /* Because we always append pic/PIE options this code path should | |
499 | not happen unless the LTO object was built by old lto1 which | |
500 | did not contain that logic yet. */ | |
501 | else | |
502 | remove_option (decoded_options, j, decoded_options_count); | |
503 | } | |
504 | else if (pie_option->opt_index == OPT_fpie | |
505 | && (*decoded_options)[j].opt_index == OPT_fPIE) | |
06e0d439 | 506 | { |
507 | (*decoded_options)[j] = *pie_option; | |
508 | j++; | |
509 | } | |
510 | else | |
511 | j++; | |
512 | } | |
513 | else | |
514 | j++; | |
954825c9 | 515 | } |
00d389c8 | 516 | |
77415571 | 517 | /* Auxiliary function that frees elements of PTR and PTR itself. |
518 | N is number of elements to be freed. If PTR is NULL, nothing is freed. | |
519 | If an element is NULL, subsequent elements are not freed. */ | |
520 | ||
521 | static void ** | |
522 | free_array_of_ptrs (void **ptr, unsigned n) | |
523 | { | |
524 | if (!ptr) | |
525 | return NULL; | |
526 | for (unsigned i = 0; i < n; i++) | |
527 | { | |
528 | if (!ptr[i]) | |
529 | break; | |
530 | free (ptr[i]); | |
531 | } | |
532 | free (ptr); | |
533 | return NULL; | |
534 | } | |
535 | ||
536 | /* Parse STR, saving found tokens into PVALUES and return their number. | |
537 | Tokens are assumed to be delimited by ':'. If APPEND is non-null, | |
538 | append it to every token we find. */ | |
539 | ||
540 | static unsigned | |
541 | parse_env_var (const char *str, char ***pvalues, const char *append) | |
542 | { | |
543 | const char *curval, *nextval; | |
544 | char **values; | |
545 | unsigned num = 1, i; | |
546 | ||
547 | curval = strchr (str, ':'); | |
548 | while (curval) | |
549 | { | |
550 | num++; | |
551 | curval = strchr (curval + 1, ':'); | |
552 | } | |
553 | ||
554 | values = (char**) xmalloc (num * sizeof (char*)); | |
555 | curval = str; | |
44ee4fad | 556 | nextval = strchr (curval, ':'); |
557 | if (nextval == NULL) | |
558 | nextval = strchr (curval, '\0'); | |
77415571 | 559 | |
560 | int append_len = append ? strlen (append) : 0; | |
561 | for (i = 0; i < num; i++) | |
562 | { | |
563 | int l = nextval - curval; | |
564 | values[i] = (char*) xmalloc (l + 1 + append_len); | |
565 | memcpy (values[i], curval, l); | |
566 | values[i][l] = 0; | |
567 | if (append) | |
568 | strcat (values[i], append); | |
569 | curval = nextval + 1; | |
44ee4fad | 570 | nextval = strchr (curval, ':'); |
571 | if (nextval == NULL) | |
572 | nextval = strchr (curval, '\0'); | |
77415571 | 573 | } |
574 | *pvalues = values; | |
575 | return num; | |
576 | } | |
577 | ||
38e21583 | 578 | /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */ |
579 | ||
580 | static void | |
581 | append_compiler_options (obstack *argv_obstack, struct cl_decoded_option *opts, | |
582 | unsigned int count) | |
583 | { | |
584 | /* Append compiler driver arguments as far as they were merged. */ | |
585 | for (unsigned int j = 1; j < count; ++j) | |
586 | { | |
587 | struct cl_decoded_option *option = &opts[j]; | |
588 | ||
589 | /* File options have been properly filtered by lto-opts.c. */ | |
590 | switch (option->opt_index) | |
591 | { | |
592 | /* Drop arguments that we want to take from the link line. */ | |
593 | case OPT_flto_: | |
594 | case OPT_flto: | |
595 | case OPT_flto_partition_: | |
596 | continue; | |
597 | ||
598 | default: | |
599 | break; | |
600 | } | |
601 | ||
602 | /* For now do what the original LTO option code was doing - pass | |
603 | on any CL_TARGET flag and a few selected others. */ | |
604 | switch (option->opt_index) | |
605 | { | |
d50ea280 | 606 | case OPT_fdiagnostics_show_caret: |
b7bb5264 | 607 | case OPT_fdiagnostics_show_labels: |
ff7410b8 | 608 | case OPT_fdiagnostics_show_line_numbers: |
d50ea280 | 609 | case OPT_fdiagnostics_show_option: |
610 | case OPT_fdiagnostics_show_location_: | |
611 | case OPT_fshow_column: | |
38e21583 | 612 | case OPT_fPIC: |
613 | case OPT_fpic: | |
614 | case OPT_fPIE: | |
615 | case OPT_fpie: | |
616 | case OPT_fcommon: | |
38e21583 | 617 | case OPT_fgnu_tm: |
fa175926 | 618 | case OPT_fopenmp: |
85977647 | 619 | case OPT_fopenacc: |
948eee2f | 620 | case OPT_fopenacc_dim_: |
38e21583 | 621 | case OPT_foffload_abi_: |
622 | case OPT_O: | |
623 | case OPT_Ofast: | |
624 | case OPT_Og: | |
625 | case OPT_Os: | |
626 | break; | |
627 | ||
628 | default: | |
629 | if (!(cl_options[option->opt_index].flags & CL_TARGET)) | |
630 | continue; | |
631 | } | |
632 | ||
633 | /* Pass the option on. */ | |
634 | for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i) | |
635 | obstack_ptr_grow (argv_obstack, option->canonical_option[i]); | |
636 | } | |
637 | } | |
638 | ||
9913e2a6 | 639 | /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */ |
640 | ||
641 | static void | |
642 | append_diag_options (obstack *argv_obstack, struct cl_decoded_option *opts, | |
643 | unsigned int count) | |
644 | { | |
645 | /* Append compiler driver arguments as far as they were merged. */ | |
646 | for (unsigned int j = 1; j < count; ++j) | |
647 | { | |
648 | struct cl_decoded_option *option = &opts[j]; | |
649 | ||
650 | switch (option->opt_index) | |
651 | { | |
652 | case OPT_fdiagnostics_color_: | |
1bcc5c64 | 653 | case OPT_fdiagnostics_format_: |
9913e2a6 | 654 | case OPT_fdiagnostics_show_caret: |
b7bb5264 | 655 | case OPT_fdiagnostics_show_labels: |
ff7410b8 | 656 | case OPT_fdiagnostics_show_line_numbers: |
9913e2a6 | 657 | case OPT_fdiagnostics_show_option: |
658 | case OPT_fdiagnostics_show_location_: | |
659 | case OPT_fshow_column: | |
660 | break; | |
661 | default: | |
662 | continue; | |
663 | } | |
664 | ||
665 | /* Pass the option on. */ | |
666 | for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i) | |
667 | obstack_ptr_grow (argv_obstack, option->canonical_option[i]); | |
668 | } | |
669 | } | |
670 | ||
671 | ||
38e21583 | 672 | /* Append linker options OPTS to ARGV_OBSTACK. */ |
673 | ||
674 | static void | |
675 | append_linker_options (obstack *argv_obstack, struct cl_decoded_option *opts, | |
676 | unsigned int count) | |
677 | { | |
678 | /* Append linker driver arguments. Compiler options from the linker | |
679 | driver arguments will override / merge with those from the compiler. */ | |
680 | for (unsigned int j = 1; j < count; ++j) | |
681 | { | |
682 | struct cl_decoded_option *option = &opts[j]; | |
683 | ||
684 | /* Do not pass on frontend specific flags not suitable for lto. */ | |
685 | if (!(cl_options[option->opt_index].flags | |
686 | & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO))) | |
687 | continue; | |
688 | ||
689 | switch (option->opt_index) | |
690 | { | |
691 | case OPT_o: | |
692 | case OPT_flto_: | |
693 | case OPT_flto: | |
694 | /* We've handled these LTO options, do not pass them on. */ | |
695 | continue; | |
696 | ||
105958a9 | 697 | case OPT_fopenmp: |
698 | case OPT_fopenacc: | |
105958a9 | 699 | /* Ignore -fno-XXX form of these options, as otherwise |
700 | corresponding builtins will not be enabled. */ | |
701 | if (option->value == 0) | |
702 | continue; | |
703 | break; | |
704 | ||
38e21583 | 705 | default: |
706 | break; | |
707 | } | |
708 | ||
709 | /* Pass the option on. */ | |
710 | for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i) | |
711 | obstack_ptr_grow (argv_obstack, option->canonical_option[i]); | |
712 | } | |
713 | } | |
714 | ||
715 | /* Extract options for TARGET offload compiler from OPTIONS and append | |
716 | them to ARGV_OBSTACK. */ | |
717 | ||
718 | static void | |
719 | append_offload_options (obstack *argv_obstack, const char *target, | |
720 | struct cl_decoded_option *options, | |
721 | unsigned int options_count) | |
722 | { | |
723 | for (unsigned i = 0; i < options_count; i++) | |
724 | { | |
725 | const char *cur, *next, *opts; | |
726 | char **argv; | |
727 | unsigned argc; | |
728 | struct cl_decoded_option *option = &options[i]; | |
729 | ||
730 | if (option->opt_index != OPT_foffload_) | |
731 | continue; | |
732 | ||
733 | /* If option argument starts with '-' then no target is specified. That | |
734 | means offload options are specified for all targets, so we need to | |
735 | append them. */ | |
736 | if (option->arg[0] == '-') | |
737 | opts = option->arg; | |
738 | else | |
739 | { | |
740 | opts = strchr (option->arg, '='); | |
daa8f58f | 741 | /* If there are offload targets specified, but no actual options, |
742 | there is nothing to do here. */ | |
38e21583 | 743 | if (!opts) |
744 | continue; | |
745 | ||
746 | cur = option->arg; | |
747 | ||
748 | while (cur < opts) | |
749 | { | |
44ee4fad | 750 | next = strchr (cur, ','); |
751 | if (next == NULL) | |
6a892749 | 752 | next = opts; |
38e21583 | 753 | next = (next > opts) ? opts : next; |
754 | ||
daa8f58f | 755 | /* Are we looking for this offload target? */ |
38e21583 | 756 | if (strlen (target) == (size_t) (next - cur) |
757 | && strncmp (target, cur, next - cur) == 0) | |
758 | break; | |
759 | ||
daa8f58f | 760 | /* Skip the comma or equal sign. */ |
38e21583 | 761 | cur = next + 1; |
762 | } | |
763 | ||
764 | if (cur >= opts) | |
765 | continue; | |
766 | ||
767 | opts++; | |
768 | } | |
769 | ||
770 | argv = buildargv (opts); | |
771 | for (argc = 0; argv[argc]; argc++) | |
772 | obstack_ptr_grow (argv_obstack, argv[argc]); | |
773 | } | |
774 | } | |
775 | ||
77415571 | 776 | /* Check whether NAME can be accessed in MODE. This is like access, |
777 | except that it never considers directories to be executable. */ | |
778 | ||
779 | static int | |
780 | access_check (const char *name, int mode) | |
781 | { | |
782 | if (mode == X_OK) | |
783 | { | |
784 | struct stat st; | |
785 | ||
786 | if (stat (name, &st) < 0 | |
787 | || S_ISDIR (st.st_mode)) | |
788 | return -1; | |
789 | } | |
790 | ||
791 | return access (name, mode); | |
792 | } | |
793 | ||
794 | /* Prepare a target image for offload TARGET, using mkoffload tool from | |
795 | COMPILER_PATH. Return the name of the resultant object file. */ | |
796 | ||
797 | static char * | |
798 | compile_offload_image (const char *target, const char *compiler_path, | |
38e21583 | 799 | unsigned in_argc, char *in_argv[], |
800 | struct cl_decoded_option *compiler_opts, | |
801 | unsigned int compiler_opt_count, | |
802 | struct cl_decoded_option *linker_opts, | |
803 | unsigned int linker_opt_count) | |
77415571 | 804 | { |
805 | char *filename = NULL; | |
806 | char **argv; | |
807 | char *suffix | |
808 | = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target)); | |
809 | strcpy (suffix, "/accel/"); | |
810 | strcat (suffix, target); | |
811 | strcat (suffix, "/mkoffload"); | |
812 | ||
813 | char **paths = NULL; | |
814 | unsigned n_paths = parse_env_var (compiler_path, &paths, suffix); | |
815 | ||
816 | const char *compiler = NULL; | |
817 | for (unsigned i = 0; i < n_paths; i++) | |
818 | if (access_check (paths[i], X_OK) == 0) | |
819 | { | |
820 | compiler = paths[i]; | |
821 | break; | |
822 | } | |
823 | ||
f6b7f3cf | 824 | if (!compiler) |
825 | fatal_error (input_location, | |
85b9be9b | 826 | "could not find %s in %s (consider using %<-B%>)", |
a0b58a70 | 827 | suffix + 1, compiler_path); |
f6b7f3cf | 828 | |
829 | /* Generate temporary output file name. */ | |
830 | filename = make_temp_file (".target.o"); | |
831 | ||
832 | struct obstack argv_obstack; | |
833 | obstack_init (&argv_obstack); | |
834 | obstack_ptr_grow (&argv_obstack, compiler); | |
835 | if (save_temps) | |
836 | obstack_ptr_grow (&argv_obstack, "-save-temps"); | |
837 | if (verbose) | |
838 | obstack_ptr_grow (&argv_obstack, "-v"); | |
839 | obstack_ptr_grow (&argv_obstack, "-o"); | |
840 | obstack_ptr_grow (&argv_obstack, filename); | |
841 | ||
842 | /* Append names of input object files. */ | |
843 | for (unsigned i = 0; i < in_argc; i++) | |
844 | obstack_ptr_grow (&argv_obstack, in_argv[i]); | |
845 | ||
846 | /* Append options from offload_lto sections. */ | |
847 | append_compiler_options (&argv_obstack, compiler_opts, | |
848 | compiler_opt_count); | |
849 | append_diag_options (&argv_obstack, linker_opts, linker_opt_count); | |
850 | ||
851 | /* Append options specified by -foffload last. In case of conflicting | |
852 | options we expect offload compiler to choose the latest. */ | |
853 | append_offload_options (&argv_obstack, target, compiler_opts, | |
854 | compiler_opt_count); | |
855 | append_offload_options (&argv_obstack, target, linker_opts, | |
856 | linker_opt_count); | |
857 | ||
858 | obstack_ptr_grow (&argv_obstack, NULL); | |
859 | argv = XOBFINISH (&argv_obstack, char **); | |
860 | fork_execute (argv[0], argv, true); | |
861 | obstack_free (&argv_obstack, NULL); | |
77415571 | 862 | |
863 | free_array_of_ptrs ((void **) paths, n_paths); | |
864 | return filename; | |
865 | } | |
866 | ||
867 | ||
868 | /* The main routine dealing with offloading. | |
869 | The routine builds a target image for each offload target. IN_ARGC and | |
870 | IN_ARGV specify options and input object files. As all of them could contain | |
871 | target sections, we pass them all to target compilers. */ | |
872 | ||
873 | static void | |
38e21583 | 874 | compile_images_for_offload_targets (unsigned in_argc, char *in_argv[], |
875 | struct cl_decoded_option *compiler_opts, | |
876 | unsigned int compiler_opt_count, | |
877 | struct cl_decoded_option *linker_opts, | |
878 | unsigned int linker_opt_count) | |
77415571 | 879 | { |
880 | char **names = NULL; | |
881 | const char *target_names = getenv (OFFLOAD_TARGET_NAMES_ENV); | |
882 | if (!target_names) | |
883 | return; | |
884 | unsigned num_targets = parse_env_var (target_names, &names, NULL); | |
885 | ||
56686608 | 886 | int next_name_entry = 0; |
77415571 | 887 | const char *compiler_path = getenv ("COMPILER_PATH"); |
888 | if (!compiler_path) | |
889 | goto out; | |
890 | ||
891 | /* Prepare an image for each target and save the name of the resultant object | |
892 | file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */ | |
893 | offload_names = XCNEWVEC (char *, num_targets + 1); | |
894 | for (unsigned i = 0; i < num_targets; i++) | |
895 | { | |
56686608 | 896 | /* HSA does not use LTO-like streaming and a different compiler, skip |
897 | it. */ | |
898 | if (strcmp (names[i], "hsa") == 0) | |
899 | continue; | |
900 | ||
901 | offload_names[next_name_entry] | |
38e21583 | 902 | = compile_offload_image (names[i], compiler_path, in_argc, in_argv, |
903 | compiler_opts, compiler_opt_count, | |
904 | linker_opts, linker_opt_count); | |
56686608 | 905 | if (!offload_names[next_name_entry]) |
c05be867 | 906 | fatal_error (input_location, |
85b9be9b | 907 | "problem with building target image for %s", names[i]); |
56686608 | 908 | next_name_entry++; |
77415571 | 909 | } |
910 | ||
911 | out: | |
912 | free_array_of_ptrs ((void **) names, num_targets); | |
913 | } | |
914 | ||
915 | /* Copy a file from SRC to DEST. */ | |
916 | ||
917 | static void | |
918 | copy_file (const char *dest, const char *src) | |
919 | { | |
920 | FILE *d = fopen (dest, "wb"); | |
921 | FILE *s = fopen (src, "rb"); | |
922 | char buffer[512]; | |
923 | while (!feof (s)) | |
924 | { | |
925 | size_t len = fread (buffer, 1, 512, s); | |
926 | if (ferror (s) != 0) | |
c05be867 | 927 | fatal_error (input_location, "reading input file"); |
77415571 | 928 | if (len > 0) |
929 | { | |
930 | fwrite (buffer, 1, len, d); | |
931 | if (ferror (d) != 0) | |
c05be867 | 932 | fatal_error (input_location, "writing output file"); |
77415571 | 933 | } |
934 | } | |
2443f8fd | 935 | fclose (d); |
936 | fclose (s); | |
77415571 | 937 | } |
938 | ||
e59c8b12 | 939 | /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of |
940 | the copy to the linker. */ | |
77415571 | 941 | |
942 | static void | |
e59c8b12 | 943 | find_crtoffloadtable (void) |
77415571 | 944 | { |
945 | char **paths = NULL; | |
946 | const char *library_path = getenv ("LIBRARY_PATH"); | |
947 | if (!library_path) | |
948 | return; | |
e59c8b12 | 949 | unsigned n_paths = parse_env_var (library_path, &paths, "/crtoffloadtable.o"); |
77415571 | 950 | |
951 | unsigned i; | |
952 | for (i = 0; i < n_paths; i++) | |
953 | if (access_check (paths[i], R_OK) == 0) | |
954 | { | |
e59c8b12 | 955 | /* The linker will delete the filename we give it, so make a copy. */ |
956 | char *crtoffloadtable = make_temp_file (".crtoffloadtable.o"); | |
957 | copy_file (crtoffloadtable, paths[i]); | |
958 | printf ("%s\n", crtoffloadtable); | |
959 | XDELETEVEC (crtoffloadtable); | |
77415571 | 960 | break; |
961 | } | |
962 | if (i == n_paths) | |
c05be867 | 963 | fatal_error (input_location, |
85b9be9b | 964 | "installation error, cannot find %<crtoffloadtable.o%>"); |
77415571 | 965 | |
966 | free_array_of_ptrs ((void **) paths, n_paths); | |
967 | } | |
968 | ||
38e21583 | 969 | /* A subroutine of run_gcc. Examine the open file FD for lto sections with |
970 | name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS | |
971 | and OPT_COUNT. Return true if we found a matchingn section, false | |
972 | otherwise. COLLECT_GCC holds the value of the environment variable with | |
973 | the same name. */ | |
974 | ||
975 | static bool | |
976 | find_and_merge_options (int fd, off_t file_offset, const char *prefix, | |
977 | struct cl_decoded_option **opts, | |
978 | unsigned int *opt_count, const char *collect_gcc) | |
979 | { | |
980 | off_t offset, length; | |
981 | char *data; | |
982 | char *fopts; | |
983 | const char *errmsg; | |
984 | int err; | |
985 | struct cl_decoded_option *fdecoded_options = *opts; | |
986 | unsigned int fdecoded_options_count = *opt_count; | |
987 | ||
988 | simple_object_read *sobj; | |
989 | sobj = simple_object_start_read (fd, file_offset, "__GNU_LTO", | |
990 | &errmsg, &err); | |
991 | if (!sobj) | |
992 | return false; | |
993 | ||
994 | char *secname = XALLOCAVEC (char, strlen (prefix) + sizeof (".opts")); | |
995 | strcpy (secname, prefix); | |
996 | strcat (secname, ".opts"); | |
997 | if (!simple_object_find_section (sobj, secname, &offset, &length, | |
998 | &errmsg, &err)) | |
999 | { | |
1000 | simple_object_release_read (sobj); | |
1001 | return false; | |
1002 | } | |
1003 | ||
1004 | lseek (fd, file_offset + offset, SEEK_SET); | |
1005 | data = (char *)xmalloc (length); | |
1006 | read (fd, data, length); | |
1007 | fopts = data; | |
1008 | do | |
1009 | { | |
1010 | struct cl_decoded_option *f2decoded_options; | |
1011 | unsigned int f2decoded_options_count; | |
1012 | get_options_from_collect_gcc_options (collect_gcc, | |
1013 | fopts, CL_LANG_ALL, | |
1014 | &f2decoded_options, | |
1015 | &f2decoded_options_count); | |
1016 | if (!fdecoded_options) | |
1017 | { | |
1018 | fdecoded_options = f2decoded_options; | |
1019 | fdecoded_options_count = f2decoded_options_count; | |
1020 | } | |
1021 | else | |
1022 | merge_and_complain (&fdecoded_options, | |
1023 | &fdecoded_options_count, | |
1024 | f2decoded_options, f2decoded_options_count); | |
1025 | ||
1026 | fopts += strlen (fopts) + 1; | |
1027 | } | |
1028 | while (fopts - data < length); | |
1029 | ||
1030 | free (data); | |
1031 | simple_object_release_read (sobj); | |
1032 | *opts = fdecoded_options; | |
1033 | *opt_count = fdecoded_options_count; | |
1034 | return true; | |
1035 | } | |
1036 | ||
7b53e714 | 1037 | /* Copy early debug info sections from INFILE to a new file whose name |
1038 | is returned. Return NULL on error. */ | |
1039 | ||
1040 | const char * | |
5ab17bfb | 1041 | debug_objcopy (const char *infile, bool rename) |
7b53e714 | 1042 | { |
6dc407e1 | 1043 | char *outfile; |
7b53e714 | 1044 | const char *errmsg; |
1045 | int err; | |
1046 | ||
1047 | const char *p; | |
01e388ac | 1048 | const char *orig_infile = infile; |
7b53e714 | 1049 | off_t inoff = 0; |
1050 | long loffset; | |
1051 | int consumed; | |
1052 | if ((p = strrchr (infile, '@')) | |
1053 | && p != infile | |
1054 | && sscanf (p, "@%li%n", &loffset, &consumed) >= 1 | |
1055 | && strlen (p) == (unsigned int) consumed) | |
1056 | { | |
1057 | char *fname = xstrdup (infile); | |
1058 | fname[p - infile] = '\0'; | |
1059 | infile = fname; | |
1060 | inoff = (off_t) loffset; | |
1061 | } | |
b50dd1e4 | 1062 | int infd = open (infile, O_RDONLY | O_BINARY); |
7b53e714 | 1063 | if (infd == -1) |
1064 | return NULL; | |
1065 | simple_object_read *inobj = simple_object_start_read (infd, inoff, | |
1066 | "__GNU_LTO", | |
1067 | &errmsg, &err); | |
1068 | if (!inobj) | |
1069 | return NULL; | |
1070 | ||
1071 | off_t off, len; | |
1072 | if (simple_object_find_section (inobj, ".gnu.debuglto_.debug_info", | |
1073 | &off, &len, &errmsg, &err) != 1) | |
1074 | { | |
1075 | if (errmsg) | |
85b9be9b | 1076 | fatal_error (0, "%s: %s", errmsg, xstrerror (err)); |
7b53e714 | 1077 | |
1078 | simple_object_release_read (inobj); | |
1079 | close (infd); | |
1080 | return NULL; | |
1081 | } | |
1082 | ||
6dc407e1 | 1083 | if (save_temps) |
1084 | { | |
01e388ac | 1085 | outfile = (char *) xmalloc (strlen (orig_infile) |
6dc407e1 | 1086 | + sizeof (".debug.temp.o") + 1); |
01e388ac | 1087 | strcpy (outfile, orig_infile); |
6dc407e1 | 1088 | strcat (outfile, ".debug.temp.o"); |
1089 | } | |
1090 | else | |
1091 | outfile = make_temp_file (".debug.temp.o"); | |
5ab17bfb | 1092 | errmsg = simple_object_copy_lto_debug_sections (inobj, outfile, &err, rename); |
7b53e714 | 1093 | if (errmsg) |
1094 | { | |
1095 | unlink_if_ordinary (outfile); | |
85b9be9b | 1096 | fatal_error (0, "%s: %s", errmsg, xstrerror (err)); |
7b53e714 | 1097 | } |
1098 | ||
1099 | simple_object_release_read (inobj); | |
1100 | close (infd); | |
1101 | ||
1102 | return outfile; | |
1103 | } | |
1104 | ||
747c1878 | 1105 | /* Helper for qsort: compare priorities for parallel compilation. */ |
1106 | ||
1107 | int | |
1108 | cmp_priority (const void *a, const void *b) | |
1109 | { | |
1110 | return *((const int *)b)-*((const int *)a); | |
1111 | } | |
7b53e714 | 1112 | |
1113 | ||
7bfefa9d | 1114 | /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */ |
1115 | ||
1116 | static void | |
1117 | run_gcc (unsigned argc, char *argv[]) | |
1118 | { | |
c8c65e07 | 1119 | unsigned i, j; |
7bfefa9d | 1120 | const char **new_argv; |
1121 | const char **argv_ptr; | |
7bfefa9d | 1122 | char *list_option_full = NULL; |
c8c65e07 | 1123 | const char *linker_output = NULL; |
00d389c8 | 1124 | const char *collect_gcc, *collect_gcc_options; |
cba6710d | 1125 | int parallel = 0; |
442bd81c | 1126 | int jobserver = 0; |
cbcf2791 | 1127 | bool no_partition = false; |
954825c9 | 1128 | struct cl_decoded_option *fdecoded_options = NULL; |
38e21583 | 1129 | struct cl_decoded_option *offload_fdecoded_options = NULL; |
954825c9 | 1130 | unsigned int fdecoded_options_count = 0; |
38e21583 | 1131 | unsigned int offload_fdecoded_options_count = 0; |
00d389c8 | 1132 | struct cl_decoded_option *decoded_options; |
1133 | unsigned int decoded_options_count; | |
b84346c6 | 1134 | struct obstack argv_obstack; |
1135 | int new_head_argc; | |
77415571 | 1136 | bool have_lto = false; |
1137 | bool have_offload = false; | |
7b53e714 | 1138 | unsigned lto_argc = 0, ltoobj_argc = 0; |
1139 | char **lto_argv, **ltoobj_argv; | |
5ab17bfb | 1140 | bool linker_output_rel = false; |
7b53e714 | 1141 | bool skip_debug = false; |
1142 | unsigned n_debugobj; | |
c8c65e07 | 1143 | |
1144 | /* Get the driver and options. */ | |
1145 | collect_gcc = getenv ("COLLECT_GCC"); | |
1146 | if (!collect_gcc) | |
c05be867 | 1147 | fatal_error (input_location, |
85b9be9b | 1148 | "environment variable %<COLLECT_GCC%> must be set"); |
c8c65e07 | 1149 | collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS"); |
1150 | if (!collect_gcc_options) | |
c05be867 | 1151 | fatal_error (input_location, |
85b9be9b | 1152 | "environment variable %<COLLECT_GCC_OPTIONS%> must be set"); |
00d389c8 | 1153 | get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options, |
1154 | CL_LANG_ALL, | |
1155 | &decoded_options, | |
1156 | &decoded_options_count); | |
c8c65e07 | 1157 | |
e59c8b12 | 1158 | /* Allocate array for input object files with LTO IL, |
e02afbb7 | 1159 | and for possible preceding arguments. */ |
1160 | lto_argv = XNEWVEC (char *, argc); | |
7b53e714 | 1161 | ltoobj_argv = XNEWVEC (char *, argc); |
e02afbb7 | 1162 | |
954825c9 | 1163 | /* Look at saved options in the IL files. */ |
1164 | for (i = 1; i < argc; ++i) | |
1165 | { | |
38e21583 | 1166 | char *p; |
954825c9 | 1167 | int fd; |
38e21583 | 1168 | off_t file_offset = 0; |
954825c9 | 1169 | long loffset; |
954825c9 | 1170 | int consumed; |
954825c9 | 1171 | char *filename = argv[i]; |
38e21583 | 1172 | |
e59c8b12 | 1173 | if (strncmp (argv[i], "-foffload-objects=", |
1174 | sizeof ("-foffload-objects=") - 1) == 0) | |
1175 | { | |
1176 | have_offload = true; | |
1177 | offload_objects_file_name | |
1178 | = argv[i] + sizeof ("-foffload-objects=") - 1; | |
1179 | continue; | |
1180 | } | |
1181 | ||
954825c9 | 1182 | if ((p = strrchr (argv[i], '@')) |
1183 | && p != argv[i] | |
1184 | && sscanf (p, "@%li%n", &loffset, &consumed) >= 1 | |
1185 | && strlen (p) == (unsigned int) consumed) | |
1186 | { | |
1187 | filename = XNEWVEC (char, p - argv[i] + 1); | |
1188 | memcpy (filename, argv[i], p - argv[i]); | |
1189 | filename[p - argv[i]] = '\0'; | |
1190 | file_offset = (off_t) loffset; | |
1191 | } | |
0d64e1fb | 1192 | fd = open (filename, O_RDONLY | O_BINARY); |
5ab17bfb | 1193 | /* Linker plugin passes -fresolution and -flinker-output options. |
1194 | -flinker-output is passed only when user did not specify one and thus | |
1195 | we do not need to worry about duplicities with the option handling | |
1196 | below. */ | |
954825c9 | 1197 | if (fd == -1) |
e02afbb7 | 1198 | { |
1199 | lto_argv[lto_argc++] = argv[i]; | |
5ab17bfb | 1200 | if (strcmp (argv[i], "-flinker-output=rel") == 0) |
1201 | linker_output_rel = true; | |
e02afbb7 | 1202 | continue; |
1203 | } | |
1204 | ||
1205 | if (find_and_merge_options (fd, file_offset, LTO_SECTION_NAME_PREFIX, | |
1206 | &fdecoded_options, &fdecoded_options_count, | |
1207 | collect_gcc)) | |
1208 | { | |
1209 | have_lto = true; | |
7b53e714 | 1210 | ltoobj_argv[ltoobj_argc++] = argv[i]; |
e02afbb7 | 1211 | } |
954825c9 | 1212 | close (fd); |
1213 | } | |
1214 | ||
c8c65e07 | 1215 | /* Initalize the common arguments for the driver. */ |
b84346c6 | 1216 | obstack_init (&argv_obstack); |
1217 | obstack_ptr_grow (&argv_obstack, collect_gcc); | |
1218 | obstack_ptr_grow (&argv_obstack, "-xlto"); | |
1219 | obstack_ptr_grow (&argv_obstack, "-c"); | |
954825c9 | 1220 | |
38e21583 | 1221 | append_compiler_options (&argv_obstack, fdecoded_options, |
1222 | fdecoded_options_count); | |
1223 | append_linker_options (&argv_obstack, decoded_options, decoded_options_count); | |
954825c9 | 1224 | |
38e21583 | 1225 | /* Scan linker driver arguments for things that are of relevance to us. */ |
00d389c8 | 1226 | for (j = 1; j < decoded_options_count; ++j) |
1227 | { | |
1228 | struct cl_decoded_option *option = &decoded_options[j]; | |
00d389c8 | 1229 | switch (option->opt_index) |
1230 | { | |
1231 | case OPT_o: | |
1232 | linker_output = option->arg; | |
38e21583 | 1233 | break; |
00d389c8 | 1234 | |
1235 | case OPT_save_temps: | |
572cae00 | 1236 | save_temps = 1; |
00d389c8 | 1237 | break; |
1238 | ||
1239 | case OPT_v: | |
c8c65e07 | 1240 | verbose = 1; |
00d389c8 | 1241 | break; |
c8c65e07 | 1242 | |
4a137074 | 1243 | case OPT_flto_partition_: |
1244 | if (strcmp (option->arg, "none") == 0) | |
1245 | no_partition = true; | |
00d389c8 | 1246 | break; |
1247 | ||
1248 | case OPT_flto_: | |
1249 | if (strcmp (option->arg, "jobserver") == 0) | |
1250 | { | |
1251 | jobserver = 1; | |
1252 | parallel = 1; | |
1253 | } | |
1254 | else | |
1255 | { | |
1256 | parallel = atoi (option->arg); | |
1257 | if (parallel <= 1) | |
1258 | parallel = 0; | |
1259 | } | |
1260 | /* Fallthru. */ | |
1261 | ||
1262 | case OPT_flto: | |
1263 | lto_mode = LTO_MODE_WHOPR; | |
38e21583 | 1264 | break; |
940a2ab8 | 1265 | |
5ab17bfb | 1266 | case OPT_flinker_output_: |
1267 | linker_output_rel = !strcmp (option->arg, "rel"); | |
1268 | break; | |
1269 | ||
1270 | ||
00d389c8 | 1271 | default: |
1272 | break; | |
1273 | } | |
00d389c8 | 1274 | } |
1275 | ||
7b53e714 | 1276 | /* Output lto-wrapper invocation command. */ |
1277 | if (verbose) | |
1278 | { | |
1279 | for (i = 0; i < argc; ++i) | |
1280 | { | |
1281 | fputs (argv[i], stderr); | |
1282 | fputc (' ', stderr); | |
1283 | } | |
1284 | fputc ('\n', stderr); | |
1285 | } | |
1286 | ||
5ab17bfb | 1287 | if (linker_output_rel) |
1288 | no_partition = true; | |
1289 | ||
cbcf2791 | 1290 | if (no_partition) |
1291 | { | |
1292 | lto_mode = LTO_MODE_LTO; | |
1293 | jobserver = 0; | |
1294 | parallel = 0; | |
1295 | } | |
c8c65e07 | 1296 | |
1297 | if (linker_output) | |
1298 | { | |
1299 | char *output_dir, *base, *name; | |
ad905e43 | 1300 | bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0; |
7bfefa9d | 1301 | |
c8c65e07 | 1302 | output_dir = xstrdup (linker_output); |
1303 | base = output_dir; | |
1304 | for (name = base; *name; name++) | |
1305 | if (IS_DIR_SEPARATOR (*name)) | |
1306 | base = name + 1; | |
1307 | *base = '\0'; | |
1308 | ||
1309 | linker_output = &linker_output[base - output_dir]; | |
1310 | if (*output_dir == '\0') | |
1311 | { | |
1312 | static char current_dir[] = { '.', DIR_SEPARATOR, '\0' }; | |
1313 | output_dir = current_dir; | |
1314 | } | |
ad905e43 | 1315 | if (!bit_bucket) |
1316 | { | |
b84346c6 | 1317 | obstack_ptr_grow (&argv_obstack, "-dumpdir"); |
1318 | obstack_ptr_grow (&argv_obstack, output_dir); | |
ad905e43 | 1319 | } |
c8c65e07 | 1320 | |
b84346c6 | 1321 | obstack_ptr_grow (&argv_obstack, "-dumpbase"); |
c8c65e07 | 1322 | } |
b84346c6 | 1323 | |
1324 | /* Remember at which point we can scrub args to re-use the commons. */ | |
1325 | new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *); | |
7bfefa9d | 1326 | |
77415571 | 1327 | if (have_offload) |
1328 | { | |
e59c8b12 | 1329 | unsigned i, num_offload_files; |
1330 | char **offload_argv; | |
1331 | FILE *f; | |
1332 | ||
1333 | f = fopen (offload_objects_file_name, "r"); | |
1334 | if (f == NULL) | |
1335 | fatal_error (input_location, "cannot open %s: %m", | |
1336 | offload_objects_file_name); | |
1337 | if (fscanf (f, "%u ", &num_offload_files) != 1) | |
1338 | fatal_error (input_location, "cannot read %s: %m", | |
1339 | offload_objects_file_name); | |
1340 | offload_argv = XCNEWVEC (char *, num_offload_files); | |
1341 | ||
1342 | /* Read names of object files with offload. */ | |
1343 | for (i = 0; i < num_offload_files; i++) | |
1344 | { | |
1345 | const unsigned piece = 32; | |
1346 | char *buf, *filename = XNEWVEC (char, piece); | |
1347 | size_t len; | |
1348 | ||
1349 | buf = filename; | |
1350 | cont1: | |
1351 | if (!fgets (buf, piece, f)) | |
1352 | break; | |
1353 | len = strlen (filename); | |
1354 | if (filename[len - 1] != '\n') | |
1355 | { | |
1356 | filename = XRESIZEVEC (char, filename, len + piece); | |
1357 | buf = filename + len; | |
1358 | goto cont1; | |
1359 | } | |
1360 | filename[len - 1] = '\0'; | |
1361 | offload_argv[i] = filename; | |
1362 | } | |
1363 | fclose (f); | |
1364 | if (offload_argv[num_offload_files - 1] == NULL) | |
1365 | fatal_error (input_location, "invalid format of %s", | |
1366 | offload_objects_file_name); | |
1367 | maybe_unlink (offload_objects_file_name); | |
1368 | offload_objects_file_name = NULL; | |
1369 | ||
1370 | /* Look at saved offload options in files. */ | |
1371 | for (i = 0; i < num_offload_files; i++) | |
1372 | { | |
1373 | char *p; | |
1374 | long loffset; | |
1375 | int fd, consumed; | |
1376 | off_t file_offset = 0; | |
1377 | char *filename = offload_argv[i]; | |
1378 | ||
1379 | if ((p = strrchr (offload_argv[i], '@')) | |
1380 | && p != offload_argv[i] | |
1381 | && sscanf (p, "@%li%n", &loffset, &consumed) >= 1 | |
1382 | && strlen (p) == (unsigned int) consumed) | |
1383 | { | |
1384 | filename = XNEWVEC (char, p - offload_argv[i] + 1); | |
1385 | memcpy (filename, offload_argv[i], p - offload_argv[i]); | |
1386 | filename[p - offload_argv[i]] = '\0'; | |
1387 | file_offset = (off_t) loffset; | |
1388 | } | |
1389 | fd = open (filename, O_RDONLY | O_BINARY); | |
1390 | if (fd == -1) | |
1391 | fatal_error (input_location, "cannot open %s: %m", filename); | |
1392 | if (!find_and_merge_options (fd, file_offset, | |
1393 | OFFLOAD_SECTION_NAME_PREFIX, | |
1394 | &offload_fdecoded_options, | |
1395 | &offload_fdecoded_options_count, | |
1396 | collect_gcc)) | |
1397 | fatal_error (input_location, "cannot read %s: %m", filename); | |
1398 | close (fd); | |
1399 | if (filename != offload_argv[i]) | |
1400 | XDELETEVEC (filename); | |
1401 | } | |
1402 | ||
1403 | compile_images_for_offload_targets (num_offload_files, offload_argv, | |
e02afbb7 | 1404 | offload_fdecoded_options, |
38e21583 | 1405 | offload_fdecoded_options_count, |
1406 | decoded_options, | |
1407 | decoded_options_count); | |
e59c8b12 | 1408 | |
1409 | free_array_of_ptrs ((void **) offload_argv, num_offload_files); | |
1410 | ||
77415571 | 1411 | if (offload_names) |
1412 | { | |
e59c8b12 | 1413 | find_crtoffloadtable (); |
77415571 | 1414 | for (i = 0; offload_names[i]; i++) |
1415 | printf ("%s\n", offload_names[i]); | |
1416 | free_array_of_ptrs ((void **) offload_names, i); | |
1417 | } | |
1418 | } | |
1419 | ||
77415571 | 1420 | /* If object files contain offload sections, but do not contain LTO sections, |
1421 | then there is no need to perform a link-time recompilation, i.e. | |
1422 | lto-wrapper is used only for a compilation of offload images. */ | |
1423 | if (have_offload && !have_lto) | |
e59c8b12 | 1424 | goto finish; |
77415571 | 1425 | |
7bfefa9d | 1426 | if (lto_mode == LTO_MODE_LTO) |
1427 | { | |
c8c65e07 | 1428 | if (linker_output) |
6dc407e1 | 1429 | { |
1430 | obstack_ptr_grow (&argv_obstack, linker_output); | |
1431 | flto_out = (char *) xmalloc (strlen (linker_output) | |
1432 | + sizeof (".lto.o") + 1); | |
1433 | strcpy (flto_out, linker_output); | |
1434 | strcat (flto_out, ".lto.o"); | |
1435 | } | |
1436 | else | |
1437 | flto_out = make_temp_file (".lto.o"); | |
b84346c6 | 1438 | obstack_ptr_grow (&argv_obstack, "-o"); |
1439 | obstack_ptr_grow (&argv_obstack, flto_out); | |
7bfefa9d | 1440 | } |
c7d28f13 | 1441 | else |
7bfefa9d | 1442 | { |
1443 | const char *list_option = "-fltrans-output-list="; | |
1444 | size_t list_option_len = strlen (list_option); | |
1445 | char *tmp; | |
1446 | ||
c8c65e07 | 1447 | if (linker_output) |
1448 | { | |
1449 | char *dumpbase = (char *) xmalloc (strlen (linker_output) | |
2024fa7d | 1450 | + sizeof (".wpa") + 1); |
c8c65e07 | 1451 | strcpy (dumpbase, linker_output); |
1452 | strcat (dumpbase, ".wpa"); | |
b84346c6 | 1453 | obstack_ptr_grow (&argv_obstack, dumpbase); |
c8c65e07 | 1454 | } |
1455 | ||
572cae00 | 1456 | if (linker_output && save_temps) |
2024fa7d | 1457 | { |
1458 | ltrans_output_file = (char *) xmalloc (strlen (linker_output) | |
1459 | + sizeof (".ltrans.out") + 1); | |
1460 | strcpy (ltrans_output_file, linker_output); | |
1461 | strcat (ltrans_output_file, ".ltrans.out"); | |
1462 | } | |
1463 | else | |
14ad4d70 | 1464 | { |
1465 | char *prefix = NULL; | |
1466 | if (linker_output) | |
1467 | { | |
1468 | prefix = (char *) xmalloc (strlen (linker_output) + 2); | |
1469 | strcpy (prefix, linker_output); | |
1470 | strcat (prefix, "."); | |
1471 | } | |
1472 | ||
1473 | ltrans_output_file = make_temp_file_with_prefix (prefix, | |
1474 | ".ltrans.out"); | |
1475 | free (prefix); | |
1476 | } | |
7bfefa9d | 1477 | list_option_full = (char *) xmalloc (sizeof (char) * |
1478 | (strlen (ltrans_output_file) + list_option_len + 1)); | |
1479 | tmp = list_option_full; | |
1480 | ||
b84346c6 | 1481 | obstack_ptr_grow (&argv_obstack, tmp); |
7bfefa9d | 1482 | strcpy (tmp, list_option); |
1483 | tmp += list_option_len; | |
1484 | strcpy (tmp, ltrans_output_file); | |
1485 | ||
3e17769e | 1486 | if (jobserver) |
1487 | obstack_ptr_grow (&argv_obstack, xstrdup ("-fwpa=jobserver")); | |
1488 | else if (parallel > 1) | |
1489 | { | |
1490 | char buf[256]; | |
1491 | sprintf (buf, "-fwpa=%i", parallel); | |
1492 | obstack_ptr_grow (&argv_obstack, xstrdup (buf)); | |
1493 | } | |
1494 | else | |
1495 | obstack_ptr_grow (&argv_obstack, "-fwpa"); | |
7bfefa9d | 1496 | } |
7bfefa9d | 1497 | |
7b53e714 | 1498 | /* Append input arguments. */ |
e02afbb7 | 1499 | for (i = 0; i < lto_argc; ++i) |
1500 | obstack_ptr_grow (&argv_obstack, lto_argv[i]); | |
7b53e714 | 1501 | /* Append the input objects. */ |
1502 | for (i = 0; i < ltoobj_argc; ++i) | |
1503 | obstack_ptr_grow (&argv_obstack, ltoobj_argv[i]); | |
b84346c6 | 1504 | obstack_ptr_grow (&argv_obstack, NULL); |
7bfefa9d | 1505 | |
b84346c6 | 1506 | new_argv = XOBFINISH (&argv_obstack, const char **); |
1507 | argv_ptr = &new_argv[new_head_argc]; | |
39ef03bb | 1508 | fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true); |
264cbb51 | 1509 | |
7b53e714 | 1510 | /* Copy the early generated debug info from the objects to temporary |
1511 | files and append those to the partial link commandline. */ | |
1512 | n_debugobj = 0; | |
6dc407e1 | 1513 | early_debug_object_names = NULL; |
7b53e714 | 1514 | if (! skip_debug) |
7b53e714 | 1515 | { |
6dc407e1 | 1516 | early_debug_object_names = XCNEWVEC (const char *, ltoobj_argc+ 1); |
1517 | num_deb_objs = ltoobj_argc; | |
1518 | for (i = 0; i < ltoobj_argc; ++i) | |
7b53e714 | 1519 | { |
6dc407e1 | 1520 | const char *tem; |
1521 | if ((tem = debug_objcopy (ltoobj_argv[i], !linker_output_rel))) | |
1522 | { | |
1523 | early_debug_object_names[i] = tem; | |
1524 | n_debugobj++; | |
1525 | } | |
7b53e714 | 1526 | } |
1527 | } | |
7b53e714 | 1528 | |
7bfefa9d | 1529 | if (lto_mode == LTO_MODE_LTO) |
1530 | { | |
9af5ce0c | 1531 | printf ("%s\n", flto_out); |
7b53e714 | 1532 | if (!skip_debug) |
1533 | { | |
6dc407e1 | 1534 | for (i = 0; i < ltoobj_argc; ++i) |
1535 | if (early_debug_object_names[i] != NULL) | |
1536 | printf ("%s\n", early_debug_object_names[i]); | |
7b53e714 | 1537 | } |
6dc407e1 | 1538 | /* These now belong to collect2. */ |
7bfefa9d | 1539 | free (flto_out); |
1540 | flto_out = NULL; | |
6dc407e1 | 1541 | free (early_debug_object_names); |
1542 | early_debug_object_names = NULL; | |
7bfefa9d | 1543 | } |
c7d28f13 | 1544 | else |
7bfefa9d | 1545 | { |
1546 | FILE *stream = fopen (ltrans_output_file, "r"); | |
cba6710d | 1547 | FILE *mstream = NULL; |
eefcf076 | 1548 | struct obstack env_obstack; |
747c1878 | 1549 | int priority; |
7bfefa9d | 1550 | |
1551 | if (!stream) | |
85b9be9b | 1552 | fatal_error (input_location, "%<fopen%>: %s: %m", ltrans_output_file); |
7bfefa9d | 1553 | |
4062f557 | 1554 | /* Parse the list of LTRANS inputs from the WPA stage. */ |
eefcf076 | 1555 | obstack_init (&env_obstack); |
4062f557 | 1556 | nr = 0; |
264cbb51 | 1557 | for (;;) |
1558 | { | |
1559 | const unsigned piece = 32; | |
4062f557 | 1560 | char *output_name = NULL; |
264cbb51 | 1561 | char *buf, *input_name = (char *)xmalloc (piece); |
1562 | size_t len; | |
1563 | ||
1564 | buf = input_name; | |
747c1878 | 1565 | if (fscanf (stream, "%i\n", &priority) != 1) |
1566 | { | |
1567 | if (!feof (stream)) | |
1568 | fatal_error (input_location, | |
85b9be9b | 1569 | "corrupted ltrans output file %s", |
747c1878 | 1570 | ltrans_output_file); |
1571 | break; | |
1572 | } | |
264cbb51 | 1573 | cont: |
1574 | if (!fgets (buf, piece, stream)) | |
1575 | break; | |
1576 | len = strlen (input_name); | |
1577 | if (input_name[len - 1] != '\n') | |
1578 | { | |
1579 | input_name = (char *)xrealloc (input_name, len + piece); | |
1580 | buf = input_name + len; | |
1581 | goto cont; | |
1582 | } | |
1583 | input_name[len - 1] = '\0'; | |
1584 | ||
1585 | if (input_name[0] == '*') | |
cba6710d | 1586 | output_name = &input_name[1]; |
264cbb51 | 1587 | |
cba6710d | 1588 | nr++; |
747c1878 | 1589 | ltrans_priorities |
1590 | = (int *)xrealloc (ltrans_priorities, nr * sizeof (int) * 2); | |
cba6710d | 1591 | input_names = (char **)xrealloc (input_names, nr * sizeof (char *)); |
1592 | output_names = (char **)xrealloc (output_names, nr * sizeof (char *)); | |
747c1878 | 1593 | ltrans_priorities[(nr-1)*2] = priority; |
1594 | ltrans_priorities[(nr-1)*2+1] = nr-1; | |
cba6710d | 1595 | input_names[nr-1] = input_name; |
1596 | output_names[nr-1] = output_name; | |
1597 | } | |
4062f557 | 1598 | fclose (stream); |
eb9ccb01 | 1599 | maybe_unlink (ltrans_output_file); |
4062f557 | 1600 | ltrans_output_file = NULL; |
1601 | ||
1602 | if (parallel) | |
1603 | { | |
1604 | makefile = make_temp_file (".mk"); | |
1605 | mstream = fopen (makefile, "w"); | |
747c1878 | 1606 | qsort (ltrans_priorities, nr, sizeof (int) * 2, cmp_priority); |
4062f557 | 1607 | } |
1608 | ||
1609 | /* Execute the LTRANS stage for each input file (or prepare a | |
1610 | makefile to invoke this in parallel). */ | |
1611 | for (i = 0; i < nr; ++i) | |
1612 | { | |
1613 | char *output_name; | |
1614 | char *input_name = input_names[i]; | |
1615 | /* If it's a pass-through file do nothing. */ | |
1616 | if (output_names[i]) | |
1617 | continue; | |
1618 | ||
1619 | /* Replace the .o suffix with a .ltrans.o suffix and write | |
1620 | the resulting name to the LTRANS output list. */ | |
4062f557 | 1621 | obstack_grow (&env_obstack, input_name, strlen (input_name) - 2); |
1622 | obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o")); | |
1623 | output_name = XOBFINISH (&env_obstack, char *); | |
1624 | ||
1625 | /* Adjust the dumpbase if the linker output file was seen. */ | |
1626 | if (linker_output) | |
1627 | { | |
1628 | char *dumpbase | |
1629 | = (char *) xmalloc (strlen (linker_output) | |
9af5ce0c | 1630 | + sizeof (DUMPBASE_SUFFIX) + 1); |
4062f557 | 1631 | snprintf (dumpbase, |
9af5ce0c | 1632 | strlen (linker_output) + sizeof (DUMPBASE_SUFFIX), |
2024fa7d | 1633 | "%s.ltrans%u", linker_output, i); |
4062f557 | 1634 | argv_ptr[0] = dumpbase; |
1635 | } | |
1636 | ||
1637 | argv_ptr[1] = "-fltrans"; | |
1638 | argv_ptr[2] = "-o"; | |
1639 | argv_ptr[3] = output_name; | |
1640 | argv_ptr[4] = input_name; | |
1641 | argv_ptr[5] = NULL; | |
1642 | if (parallel) | |
1643 | { | |
1644 | fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]); | |
1645 | for (j = 1; new_argv[j] != NULL; ++j) | |
1646 | fprintf (mstream, " '%s'", new_argv[j]); | |
1647 | fprintf (mstream, "\n"); | |
4fe86c66 | 1648 | /* If we are not preserving the ltrans input files then |
1649 | truncate them as soon as we have processed it. This | |
1650 | reduces temporary disk-space usage. */ | |
572cae00 | 1651 | if (! save_temps) |
4fe86c66 | 1652 | fprintf (mstream, "\t@-touch -r %s %s.tem > /dev/null 2>&1 " |
1653 | "&& mv %s.tem %s\n", | |
1654 | input_name, input_name, input_name, input_name); | |
4062f557 | 1655 | } |
1656 | else | |
4fe86c66 | 1657 | { |
39ef03bb | 1658 | fork_execute (new_argv[0], CONST_CAST (char **, new_argv), |
1659 | true); | |
eb9ccb01 | 1660 | maybe_unlink (input_name); |
4fe86c66 | 1661 | } |
4062f557 | 1662 | |
1663 | output_names[i] = output_name; | |
1664 | } | |
cba6710d | 1665 | if (parallel) |
1666 | { | |
1667 | struct pex_obj *pex; | |
1668 | char jobs[32]; | |
442bd81c | 1669 | |
24ca56d6 | 1670 | fprintf (mstream, |
1671 | ".PHONY: all\n" | |
1672 | "all:"); | |
cba6710d | 1673 | for (i = 0; i < nr; ++i) |
747c1878 | 1674 | { |
1675 | int j = ltrans_priorities[i*2 + 1]; | |
1676 | fprintf (mstream, " \\\n\t%s", output_names[j]); | |
1677 | } | |
cba6710d | 1678 | fprintf (mstream, "\n"); |
1679 | fclose (mstream); | |
442bd81c | 1680 | if (!jobserver) |
1681 | { | |
1682 | /* Avoid passing --jobserver-fd= and similar flags | |
1683 | unless jobserver mode is explicitly enabled. */ | |
1684 | putenv (xstrdup ("MAKEFLAGS=")); | |
1685 | putenv (xstrdup ("MFLAGS=")); | |
1686 | } | |
c335b5fe | 1687 | new_argv[0] = getenv ("MAKE"); |
1688 | if (!new_argv[0]) | |
1689 | new_argv[0] = "make"; | |
cba6710d | 1690 | new_argv[1] = "-f"; |
1691 | new_argv[2] = makefile; | |
442bd81c | 1692 | i = 3; |
1693 | if (!jobserver) | |
1694 | { | |
1695 | snprintf (jobs, 31, "-j%d", parallel); | |
1696 | new_argv[i++] = jobs; | |
1697 | } | |
1698 | new_argv[i++] = "all"; | |
1699 | new_argv[i++] = NULL; | |
39ef03bb | 1700 | pex = collect_execute (new_argv[0], CONST_CAST (char **, new_argv), |
1701 | NULL, NULL, PEX_SEARCH, false); | |
1702 | do_wait (new_argv[0], pex); | |
eb9ccb01 | 1703 | maybe_unlink (makefile); |
4062f557 | 1704 | makefile = NULL; |
4fe86c66 | 1705 | for (i = 0; i < nr; ++i) |
eb9ccb01 | 1706 | maybe_unlink (input_names[i]); |
cba6710d | 1707 | } |
1708 | for (i = 0; i < nr; ++i) | |
1709 | { | |
1710 | fputs (output_names[i], stdout); | |
264cbb51 | 1711 | putc ('\n', stdout); |
cba6710d | 1712 | free (input_names[i]); |
264cbb51 | 1713 | } |
6dc407e1 | 1714 | if (!skip_debug) |
1715 | { | |
1716 | for (i = 0; i < ltoobj_argc; ++i) | |
1717 | if (early_debug_object_names[i] != NULL) | |
1718 | printf ("%s\n", early_debug_object_names[i]); | |
1719 | } | |
4062f557 | 1720 | nr = 0; |
747c1878 | 1721 | free (ltrans_priorities); |
cba6710d | 1722 | free (output_names); |
6dc407e1 | 1723 | output_names = NULL; |
1724 | free (early_debug_object_names); | |
1725 | early_debug_object_names = NULL; | |
cba6710d | 1726 | free (input_names); |
7bfefa9d | 1727 | free (list_option_full); |
eefcf076 | 1728 | obstack_free (&env_obstack, NULL); |
7bfefa9d | 1729 | } |
b84346c6 | 1730 | |
77415571 | 1731 | finish: |
e02afbb7 | 1732 | XDELETE (lto_argv); |
b84346c6 | 1733 | obstack_free (&argv_obstack, NULL); |
7bfefa9d | 1734 | } |
1735 | ||
1736 | ||
1737 | /* Entry point. */ | |
1738 | ||
1739 | int | |
1740 | main (int argc, char *argv[]) | |
1741 | { | |
0b4f4daf | 1742 | const char *p; |
1743 | ||
25faed34 | 1744 | init_opts_obstack (); |
ba30d337 | 1745 | |
0b4f4daf | 1746 | p = argv[0] + strlen (argv[0]); |
1747 | while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) | |
1748 | --p; | |
1749 | progname = p; | |
1750 | ||
1751 | xmalloc_set_program_name (progname); | |
1752 | ||
7bfefa9d | 1753 | gcc_init_libintl (); |
1754 | ||
0b4f4daf | 1755 | diagnostic_initialize (global_dc, 0); |
1756 | ||
bb7acc76 | 1757 | if (atexit (lto_wrapper_cleanup) != 0) |
85b9be9b | 1758 | fatal_error (input_location, "%<atexit%> failed"); |
bb7acc76 | 1759 | |
c04a3a63 | 1760 | if (signal (SIGINT, SIG_IGN) != SIG_IGN) |
1761 | signal (SIGINT, fatal_signal); | |
1762 | #ifdef SIGHUP | |
1763 | if (signal (SIGHUP, SIG_IGN) != SIG_IGN) | |
1764 | signal (SIGHUP, fatal_signal); | |
1765 | #endif | |
1766 | if (signal (SIGTERM, SIG_IGN) != SIG_IGN) | |
1767 | signal (SIGTERM, fatal_signal); | |
1768 | #ifdef SIGPIPE | |
1769 | if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) | |
1770 | signal (SIGPIPE, fatal_signal); | |
1771 | #endif | |
1772 | #ifdef SIGCHLD | |
1773 | /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will | |
1774 | receive the signal. A different setting is inheritable */ | |
1775 | signal (SIGCHLD, SIG_DFL); | |
1776 | #endif | |
1777 | ||
7bfefa9d | 1778 | /* We may be called with all the arguments stored in some file and |
1779 | passed with @file. Expand them into argv before processing. */ | |
1780 | expandargv (&argc, &argv); | |
00d389c8 | 1781 | |
c8c65e07 | 1782 | run_gcc (argc, argv); |
7bfefa9d | 1783 | |
1784 | return 0; | |
1785 | } |