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