1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2018 Free Software Foundation, Inc.
4 Factored out of collect2 by Rafael Espindola <espindola@google.com>
6 This file is part of GCC.
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
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
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/>. */
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.
30 $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto
32 The above will print something like
35 If WHOPR is used instead, more than one file might be produced
36 ./ccXj2DTk.lto.ltrans.o
37 ./ccCJuXGv.lto.ltrans.o
42 #include "coretypes.h"
44 #include "diagnostic.h"
48 #include "simple-object.h"
49 #include "lto-section-names.h"
50 #include "collect-utils.h"
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"
57 LTO_MODE_NONE, /* Not doing LTO. */
58 LTO_MODE_LTO, /* Normal LTO. */
59 LTO_MODE_WHOPR /* WHOPR. */
62 /* Current LTO mode. */
63 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
65 static char *ltrans_output_file;
66 static char *flto_out;
67 static unsigned int nr;
68 static int *ltrans_priorities;
69 static char **input_names;
70 static char **output_names;
71 static char **offload_names;
72 static char *offload_objects_file_name;
73 static char *makefile;
74 static char *debug_obj;
76 const char tool_name[] = "lto-wrapper";
78 /* Delete tempfiles. Called from utils_cleanup. */
85 if (ltrans_output_file)
86 maybe_unlink (ltrans_output_file);
88 maybe_unlink (flto_out);
89 if (offload_objects_file_name)
90 maybe_unlink (offload_objects_file_name);
92 maybe_unlink (makefile);
94 maybe_unlink (debug_obj);
95 for (i = 0; i < nr; ++i)
97 maybe_unlink (input_names[i]);
99 maybe_unlink (output_names[i]);
104 lto_wrapper_cleanup (void)
106 utils_cleanup (false);
109 /* Unlink a temporary LTRANS file unless requested otherwise. */
112 maybe_unlink (const char *file)
116 if (unlink_if_ordinary (file)
118 fatal_error (input_location, "deleting LTRANS file %s: %m", file);
121 fprintf (stderr, "[Leaving LTRANS %s]\n", file);
124 /* Template of LTRANS dumpbase suffix. */
125 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
127 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
128 environment according to LANG_MASK. */
131 get_options_from_collect_gcc_options (const char *collect_gcc,
132 const char *collect_gcc_options,
133 unsigned int lang_mask,
134 struct cl_decoded_option **decoded_options,
135 unsigned int *decoded_options_count)
137 struct obstack argv_obstack;
142 argv_storage = xstrdup (collect_gcc_options);
143 obstack_init (&argv_obstack);
144 obstack_ptr_grow (&argv_obstack, collect_gcc);
146 for (j = 0, k = 0; argv_storage[j] != '\0'; ++j)
148 if (argv_storage[j] == '\'')
150 obstack_ptr_grow (&argv_obstack, &argv_storage[k]);
154 if (argv_storage[j] == '\0')
155 fatal_error (input_location, "malformed COLLECT_GCC_OPTIONS");
156 else if (strncmp (&argv_storage[j], "'\\''", 4) == 0)
158 argv_storage[k++] = '\'';
161 else if (argv_storage[j] == '\'')
164 argv_storage[k++] = argv_storage[j++];
167 argv_storage[k++] = '\0';
171 obstack_ptr_grow (&argv_obstack, NULL);
172 argc = obstack_object_size (&argv_obstack) / sizeof (void *) - 1;
173 argv = XOBFINISH (&argv_obstack, const char **);
175 decode_cmdline_options_to_array (argc, (const char **)argv,
177 decoded_options, decoded_options_count);
178 obstack_free (&argv_obstack, NULL);
181 /* Append OPTION to the options array DECODED_OPTIONS with size
182 DECODED_OPTIONS_COUNT. */
185 append_option (struct cl_decoded_option **decoded_options,
186 unsigned int *decoded_options_count,
187 struct cl_decoded_option *option)
189 ++*decoded_options_count;
191 = (struct cl_decoded_option *)
192 xrealloc (*decoded_options,
193 (*decoded_options_count
194 * sizeof (struct cl_decoded_option)));
195 memcpy (&(*decoded_options)[*decoded_options_count - 1], option,
196 sizeof (struct cl_decoded_option));
199 /* Remove option number INDEX from DECODED_OPTIONS, update
200 DECODED_OPTIONS_COUNT. */
203 remove_option (struct cl_decoded_option **decoded_options,
204 int index, unsigned int *decoded_options_count)
206 --*decoded_options_count;
207 memmove (&(*decoded_options)[index + 1],
208 &(*decoded_options)[index],
209 sizeof (struct cl_decoded_option)
210 * (*decoded_options_count - index));
213 /* Try to merge and complain about options FDECODED_OPTIONS when applied
214 ontop of DECODED_OPTIONS. */
217 merge_and_complain (struct cl_decoded_option **decoded_options,
218 unsigned int *decoded_options_count,
219 struct cl_decoded_option *fdecoded_options,
220 unsigned int fdecoded_options_count)
223 struct cl_decoded_option *pic_option = NULL;
224 struct cl_decoded_option *pie_option = NULL;
226 /* ??? Merge options from files. Most cases can be
227 handled by either unioning or intersecting
228 (for example -fwrapv is a case for unioning,
229 -ffast-math is for intersection). Most complaints
230 about real conflicts between different options can
231 be deferred to the compiler proper. Options that
232 we can neither safely handle by intersection nor
233 unioning would need to be complained about here.
234 Ideally we'd have a flag in the opt files that
235 tells whether to union or intersect or reject.
236 In absence of that it's unclear what a good default is.
237 It's also difficult to get positional handling correct. */
239 /* The following does what the old LTO option code did,
240 union all target and a selected set of common options. */
241 for (i = 0; i < fdecoded_options_count; ++i)
243 struct cl_decoded_option *foption = &fdecoded_options[i];
244 switch (foption->opt_index)
246 case OPT_SPECIAL_unknown:
247 case OPT_SPECIAL_ignore:
248 case OPT_SPECIAL_program_name:
249 case OPT_SPECIAL_input_file:
253 if (!(cl_options[foption->opt_index].flags & CL_TARGET))
257 case OPT_fdiagnostics_show_caret:
258 case OPT_fdiagnostics_show_option:
259 case OPT_fdiagnostics_show_location_:
260 case OPT_fshow_column:
263 /* Do what the old LTO code did - collect exactly one option
264 setting per OPT code, we pick the first we encounter.
265 ??? This doesn't make too much sense, but when it doesn't
266 then we should complain. */
267 for (j = 0; j < *decoded_options_count; ++j)
268 if ((*decoded_options)[j].opt_index == foption->opt_index)
270 if (j == *decoded_options_count)
271 append_option (decoded_options, decoded_options_count, foption);
274 /* Figure out what PIC/PIE level wins and merge the results. */
277 pic_option = foption;
281 pie_option = foption;
286 case OPT_fcheck_pointer_bounds:
287 /* For selected options we can merge conservatively. */
288 for (j = 0; j < *decoded_options_count; ++j)
289 if ((*decoded_options)[j].opt_index == foption->opt_index)
291 if (j == *decoded_options_count)
292 append_option (decoded_options, decoded_options_count, foption);
293 /* -fopenmp > -fno-openmp,
294 -fopenacc > -fno-openacc,
295 -fcheck_pointer_bounds > -fcheck_pointer_bounds */
296 else if (foption->value > (*decoded_options)[j].value)
297 (*decoded_options)[j] = *foption;
300 case OPT_fopenacc_dim_:
301 /* Append or check identical. */
302 for (j = 0; j < *decoded_options_count; ++j)
303 if ((*decoded_options)[j].opt_index == foption->opt_index)
305 if (j == *decoded_options_count)
306 append_option (decoded_options, decoded_options_count, foption);
307 else if (strcmp ((*decoded_options)[j].arg, foption->arg))
308 fatal_error (input_location,
309 "Option %s with different values",
310 foption->orig_option_with_args_text);
317 for (j = 0; j < *decoded_options_count; ++j)
318 if ((*decoded_options)[j].opt_index == OPT_O
319 || (*decoded_options)[j].opt_index == OPT_Ofast
320 || (*decoded_options)[j].opt_index == OPT_Og
321 || (*decoded_options)[j].opt_index == OPT_Os)
323 if (j == *decoded_options_count)
324 append_option (decoded_options, decoded_options_count, foption);
325 else if ((*decoded_options)[j].opt_index == foption->opt_index
326 && foption->opt_index != OPT_O)
327 /* Exact same options get merged. */
331 /* For mismatched option kinds preserve the optimization
332 level only, thus merge it as -On. This also handles
333 merging of same optimization level -On. */
335 switch (foption->opt_index)
338 if (foption->arg[0] == '\0')
339 level = MAX (level, 1);
341 level = MAX (level, atoi (foption->arg));
344 level = MAX (level, 3);
347 level = MAX (level, 1);
350 level = MAX (level, 2);
355 switch ((*decoded_options)[j].opt_index)
358 if ((*decoded_options)[j].arg[0] == '\0')
359 level = MAX (level, 1);
361 level = MAX (level, atoi ((*decoded_options)[j].arg));
364 level = MAX (level, 3);
367 level = MAX (level, 1);
370 level = MAX (level, 2);
375 (*decoded_options)[j].opt_index = OPT_O;
377 tem = xasprintf ("-O%d", level);
378 (*decoded_options)[j].arg = &tem[2];
379 (*decoded_options)[j].canonical_option[0] = tem;
380 (*decoded_options)[j].value = 1;
385 case OPT_foffload_abi_:
386 for (j = 0; j < *decoded_options_count; ++j)
387 if ((*decoded_options)[j].opt_index == foption->opt_index)
389 if (j == *decoded_options_count)
390 append_option (decoded_options, decoded_options_count, foption);
391 else if (foption->value != (*decoded_options)[j].value)
392 fatal_error (input_location,
393 "Option %s not used consistently in all LTO input"
394 " files", foption->orig_option_with_args_text);
399 append_option (decoded_options, decoded_options_count, foption);
404 /* Merge PIC options:
405 -fPIC + -fpic = -fpic
406 -fPIC + -fno-pic = -fno-pic
407 -fpic/-fPIC + nothin = nothing.
408 It is a common mistake to mix few -fPIC compiled objects into otherwise
409 non-PIC code. We do not want to build everything with PIC then.
411 Similarly we merge PIE options, however in addition we keep
412 -fPIC + -fPIE = -fPIE
413 -fpic + -fPIE = -fpie
414 -fPIC/-fpic + -fpie = -fpie
416 It would be good to warn on mismatches, but it is bit hard to do as
417 we do not know what nothing translates to. */
419 for (unsigned int j = 0; j < *decoded_options_count;)
420 if ((*decoded_options)[j].opt_index == OPT_fPIC
421 || (*decoded_options)[j].opt_index == OPT_fpic)
423 /* -fno-pic in one unit implies -fno-pic everywhere. */
424 if ((*decoded_options)[j].value == 0)
426 /* If we have no pic option or merge in -fno-pic, we still may turn
427 existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */
428 else if ((pic_option && pic_option->value == 0)
433 bool big = (*decoded_options)[j].opt_index == OPT_fPIC
434 && pie_option->opt_index == OPT_fPIE;
435 (*decoded_options)[j].opt_index = big ? OPT_fPIE : OPT_fpie;
436 if (pie_option->value)
437 (*decoded_options)[j].canonical_option[0] = big ? "-fPIE" : "-fpie";
439 (*decoded_options)[j].canonical_option[0] = big ? "-fno-pie" : "-fno-pie";
440 (*decoded_options)[j].value = pie_option->value;
445 (*decoded_options)[j] = *pic_option;
448 /* We do not know if target defaults to pic or not, so just remove
449 option if it is missing in one unit but enabled in other. */
451 remove_option (decoded_options, j, decoded_options_count);
453 else if (pic_option->opt_index == OPT_fpic
454 && (*decoded_options)[j].opt_index == OPT_fPIC)
456 (*decoded_options)[j] = *pic_option;
462 else if ((*decoded_options)[j].opt_index == OPT_fPIE
463 || (*decoded_options)[j].opt_index == OPT_fpie)
465 /* -fno-pie in one unit implies -fno-pie everywhere. */
466 if ((*decoded_options)[j].value == 0)
468 /* If we have no pie option or merge in -fno-pie, we still preserve
469 PIE/pie if pic/PIC is present. */
470 else if ((pie_option && pie_option->value == 0)
473 /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */
476 if (pic_option->opt_index == OPT_fpic
477 && (*decoded_options)[j].opt_index == OPT_fPIE)
479 (*decoded_options)[j].opt_index = OPT_fpie;
480 (*decoded_options)[j].canonical_option[0]
481 = pic_option->value ? "-fpie" : "-fno-pie";
483 else if (!pic_option->value)
484 (*decoded_options)[j].canonical_option[0] = "-fno-pie";
485 (*decoded_options)[j].value = pic_option->value;
490 (*decoded_options)[j] = *pie_option;
493 /* Because we always append pic/PIE options this code path should
494 not happen unless the LTO object was built by old lto1 which
495 did not contain that logic yet. */
497 remove_option (decoded_options, j, decoded_options_count);
499 else if (pie_option->opt_index == OPT_fpie
500 && (*decoded_options)[j].opt_index == OPT_fPIE)
502 (*decoded_options)[j] = *pie_option;
512 /* Auxiliary function that frees elements of PTR and PTR itself.
513 N is number of elements to be freed. If PTR is NULL, nothing is freed.
514 If an element is NULL, subsequent elements are not freed. */
517 free_array_of_ptrs (void **ptr, unsigned n)
521 for (unsigned i = 0; i < n; i++)
531 /* Parse STR, saving found tokens into PVALUES and return their number.
532 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
533 append it to every token we find. */
536 parse_env_var (const char *str, char ***pvalues, const char *append)
538 const char *curval, *nextval;
542 curval = strchr (str, ':');
546 curval = strchr (curval + 1, ':');
549 values = (char**) xmalloc (num * sizeof (char*));
551 nextval = strchr (curval, ':');
553 nextval = strchr (curval, '\0');
555 int append_len = append ? strlen (append) : 0;
556 for (i = 0; i < num; i++)
558 int l = nextval - curval;
559 values[i] = (char*) xmalloc (l + 1 + append_len);
560 memcpy (values[i], curval, l);
563 strcat (values[i], append);
564 curval = nextval + 1;
565 nextval = strchr (curval, ':');
567 nextval = strchr (curval, '\0');
573 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
576 append_compiler_options (obstack *argv_obstack, struct cl_decoded_option *opts,
579 /* Append compiler driver arguments as far as they were merged. */
580 for (unsigned int j = 1; j < count; ++j)
582 struct cl_decoded_option *option = &opts[j];
584 /* File options have been properly filtered by lto-opts.c. */
585 switch (option->opt_index)
587 /* Drop arguments that we want to take from the link line. */
590 case OPT_flto_partition_:
597 /* For now do what the original LTO option code was doing - pass
598 on any CL_TARGET flag and a few selected others. */
599 switch (option->opt_index)
601 case OPT_fdiagnostics_show_caret:
602 case OPT_fdiagnostics_show_option:
603 case OPT_fdiagnostics_show_location_:
604 case OPT_fshow_column:
613 case OPT_fopenacc_dim_:
614 case OPT_foffload_abi_:
619 case OPT_fcheck_pointer_bounds:
623 if (!(cl_options[option->opt_index].flags & CL_TARGET))
627 /* Pass the option on. */
628 for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
629 obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
633 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
636 append_diag_options (obstack *argv_obstack, struct cl_decoded_option *opts,
639 /* Append compiler driver arguments as far as they were merged. */
640 for (unsigned int j = 1; j < count; ++j)
642 struct cl_decoded_option *option = &opts[j];
644 switch (option->opt_index)
646 case OPT_fdiagnostics_color_:
647 case OPT_fdiagnostics_show_caret:
648 case OPT_fdiagnostics_show_option:
649 case OPT_fdiagnostics_show_location_:
650 case OPT_fshow_column:
656 /* Pass the option on. */
657 for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
658 obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
663 /* Append linker options OPTS to ARGV_OBSTACK. */
666 append_linker_options (obstack *argv_obstack, struct cl_decoded_option *opts,
669 /* Append linker driver arguments. Compiler options from the linker
670 driver arguments will override / merge with those from the compiler. */
671 for (unsigned int j = 1; j < count; ++j)
673 struct cl_decoded_option *option = &opts[j];
675 /* Do not pass on frontend specific flags not suitable for lto. */
676 if (!(cl_options[option->opt_index].flags
677 & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
680 switch (option->opt_index)
685 /* We've handled these LTO options, do not pass them on. */
690 /* Ignore -fno-XXX form of these options, as otherwise
691 corresponding builtins will not be enabled. */
692 if (option->value == 0)
700 /* Pass the option on. */
701 for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
702 obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
706 /* Extract options for TARGET offload compiler from OPTIONS and append
707 them to ARGV_OBSTACK. */
710 append_offload_options (obstack *argv_obstack, const char *target,
711 struct cl_decoded_option *options,
712 unsigned int options_count)
714 for (unsigned i = 0; i < options_count; i++)
716 const char *cur, *next, *opts;
719 struct cl_decoded_option *option = &options[i];
721 if (option->opt_index != OPT_foffload_)
724 /* If option argument starts with '-' then no target is specified. That
725 means offload options are specified for all targets, so we need to
727 if (option->arg[0] == '-')
731 opts = strchr (option->arg, '=');
732 /* If there are offload targets specified, but no actual options,
733 there is nothing to do here. */
741 next = strchr (cur, ',');
744 next = (next > opts) ? opts : next;
746 /* Are we looking for this offload target? */
747 if (strlen (target) == (size_t) (next - cur)
748 && strncmp (target, cur, next - cur) == 0)
751 /* Skip the comma or equal sign. */
761 argv = buildargv (opts);
762 for (argc = 0; argv[argc]; argc++)
763 obstack_ptr_grow (argv_obstack, argv[argc]);
767 /* Check whether NAME can be accessed in MODE. This is like access,
768 except that it never considers directories to be executable. */
771 access_check (const char *name, int mode)
777 if (stat (name, &st) < 0
778 || S_ISDIR (st.st_mode))
782 return access (name, mode);
785 /* Prepare a target image for offload TARGET, using mkoffload tool from
786 COMPILER_PATH. Return the name of the resultant object file. */
789 compile_offload_image (const char *target, const char *compiler_path,
790 unsigned in_argc, char *in_argv[],
791 struct cl_decoded_option *compiler_opts,
792 unsigned int compiler_opt_count,
793 struct cl_decoded_option *linker_opts,
794 unsigned int linker_opt_count)
796 char *filename = NULL;
799 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target));
800 strcpy (suffix, "/accel/");
801 strcat (suffix, target);
802 strcat (suffix, "/mkoffload");
805 unsigned n_paths = parse_env_var (compiler_path, &paths, suffix);
807 const char *compiler = NULL;
808 for (unsigned i = 0; i < n_paths; i++)
809 if (access_check (paths[i], X_OK) == 0)
817 /* Generate temporary output file name. */
818 filename = make_temp_file (".target.o");
820 struct obstack argv_obstack;
821 obstack_init (&argv_obstack);
822 obstack_ptr_grow (&argv_obstack, compiler);
824 obstack_ptr_grow (&argv_obstack, "-save-temps");
826 obstack_ptr_grow (&argv_obstack, "-v");
827 obstack_ptr_grow (&argv_obstack, "-o");
828 obstack_ptr_grow (&argv_obstack, filename);
830 /* Append names of input object files. */
831 for (unsigned i = 0; i < in_argc; i++)
832 obstack_ptr_grow (&argv_obstack, in_argv[i]);
834 /* Append options from offload_lto sections. */
835 append_compiler_options (&argv_obstack, compiler_opts,
837 append_diag_options (&argv_obstack, linker_opts, linker_opt_count);
839 /* Append options specified by -foffload last. In case of conflicting
840 options we expect offload compiler to choose the latest. */
841 append_offload_options (&argv_obstack, target, compiler_opts,
843 append_offload_options (&argv_obstack, target, linker_opts,
846 obstack_ptr_grow (&argv_obstack, NULL);
847 argv = XOBFINISH (&argv_obstack, char **);
848 fork_execute (argv[0], argv, true);
849 obstack_free (&argv_obstack, NULL);
852 free_array_of_ptrs ((void **) paths, n_paths);
857 /* The main routine dealing with offloading.
858 The routine builds a target image for each offload target. IN_ARGC and
859 IN_ARGV specify options and input object files. As all of them could contain
860 target sections, we pass them all to target compilers. */
863 compile_images_for_offload_targets (unsigned in_argc, char *in_argv[],
864 struct cl_decoded_option *compiler_opts,
865 unsigned int compiler_opt_count,
866 struct cl_decoded_option *linker_opts,
867 unsigned int linker_opt_count)
870 const char *target_names = getenv (OFFLOAD_TARGET_NAMES_ENV);
873 unsigned num_targets = parse_env_var (target_names, &names, NULL);
875 int next_name_entry = 0;
876 const char *compiler_path = getenv ("COMPILER_PATH");
880 /* Prepare an image for each target and save the name of the resultant object
881 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
882 offload_names = XCNEWVEC (char *, num_targets + 1);
883 for (unsigned i = 0; i < num_targets; i++)
885 /* HSA does not use LTO-like streaming and a different compiler, skip
887 if (strcmp (names[i], "hsa") == 0)
890 offload_names[next_name_entry]
891 = compile_offload_image (names[i], compiler_path, in_argc, in_argv,
892 compiler_opts, compiler_opt_count,
893 linker_opts, linker_opt_count);
894 if (!offload_names[next_name_entry])
895 fatal_error (input_location,
896 "problem with building target image for %s\n", names[i]);
901 free_array_of_ptrs ((void **) names, num_targets);
904 /* Copy a file from SRC to DEST. */
907 copy_file (const char *dest, const char *src)
909 FILE *d = fopen (dest, "wb");
910 FILE *s = fopen (src, "rb");
914 size_t len = fread (buffer, 1, 512, s);
916 fatal_error (input_location, "reading input file");
919 fwrite (buffer, 1, len, d);
921 fatal_error (input_location, "writing output file");
928 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
929 the copy to the linker. */
932 find_crtoffloadtable (void)
935 const char *library_path = getenv ("LIBRARY_PATH");
938 unsigned n_paths = parse_env_var (library_path, &paths, "/crtoffloadtable.o");
941 for (i = 0; i < n_paths; i++)
942 if (access_check (paths[i], R_OK) == 0)
944 /* The linker will delete the filename we give it, so make a copy. */
945 char *crtoffloadtable = make_temp_file (".crtoffloadtable.o");
946 copy_file (crtoffloadtable, paths[i]);
947 printf ("%s\n", crtoffloadtable);
948 XDELETEVEC (crtoffloadtable);
952 fatal_error (input_location,
953 "installation error, can't find crtoffloadtable.o");
955 free_array_of_ptrs ((void **) paths, n_paths);
958 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
959 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
960 and OPT_COUNT. Return true if we found a matchingn section, false
961 otherwise. COLLECT_GCC holds the value of the environment variable with
965 find_and_merge_options (int fd, off_t file_offset, const char *prefix,
966 struct cl_decoded_option **opts,
967 unsigned int *opt_count, const char *collect_gcc)
969 off_t offset, length;
974 struct cl_decoded_option *fdecoded_options = *opts;
975 unsigned int fdecoded_options_count = *opt_count;
977 simple_object_read *sobj;
978 sobj = simple_object_start_read (fd, file_offset, "__GNU_LTO",
983 char *secname = XALLOCAVEC (char, strlen (prefix) + sizeof (".opts"));
984 strcpy (secname, prefix);
985 strcat (secname, ".opts");
986 if (!simple_object_find_section (sobj, secname, &offset, &length,
989 simple_object_release_read (sobj);
993 lseek (fd, file_offset + offset, SEEK_SET);
994 data = (char *)xmalloc (length);
995 read (fd, data, length);
999 struct cl_decoded_option *f2decoded_options;
1000 unsigned int f2decoded_options_count;
1001 get_options_from_collect_gcc_options (collect_gcc,
1004 &f2decoded_options_count);
1005 if (!fdecoded_options)
1007 fdecoded_options = f2decoded_options;
1008 fdecoded_options_count = f2decoded_options_count;
1011 merge_and_complain (&fdecoded_options,
1012 &fdecoded_options_count,
1013 f2decoded_options, f2decoded_options_count);
1015 fopts += strlen (fopts) + 1;
1017 while (fopts - data < length);
1020 simple_object_release_read (sobj);
1021 *opts = fdecoded_options;
1022 *opt_count = fdecoded_options_count;
1026 /* Copy early debug info sections from INFILE to a new file whose name
1027 is returned. Return NULL on error. */
1030 debug_objcopy (const char *infile)
1032 const char *outfile;
1040 if ((p = strrchr (infile, '@'))
1042 && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
1043 && strlen (p) == (unsigned int) consumed)
1045 char *fname = xstrdup (infile);
1046 fname[p - infile] = '\0';
1048 inoff = (off_t) loffset;
1050 int infd = open (infile, O_RDONLY | O_BINARY);
1053 simple_object_read *inobj = simple_object_start_read (infd, inoff,
1060 if (simple_object_find_section (inobj, ".gnu.debuglto_.debug_info",
1061 &off, &len, &errmsg, &err) != 1)
1064 fatal_error (0, "%s: %s\n", errmsg, xstrerror (err));
1066 simple_object_release_read (inobj);
1071 outfile = make_temp_file ("debugobjtem");
1072 errmsg = simple_object_copy_lto_debug_sections (inobj, outfile, &err);
1075 unlink_if_ordinary (outfile);
1076 fatal_error (0, "%s: %s\n", errmsg, xstrerror (err));
1079 simple_object_release_read (inobj);
1085 /* Helper for qsort: compare priorities for parallel compilation. */
1088 cmp_priority (const void *a, const void *b)
1090 return *((const int *)b)-*((const int *)a);
1094 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1097 run_gcc (unsigned argc, char *argv[])
1100 const char **new_argv;
1101 const char **argv_ptr;
1102 char *list_option_full = NULL;
1103 const char *linker_output = NULL;
1104 const char *collect_gcc, *collect_gcc_options;
1107 bool no_partition = false;
1108 struct cl_decoded_option *fdecoded_options = NULL;
1109 struct cl_decoded_option *offload_fdecoded_options = NULL;
1110 unsigned int fdecoded_options_count = 0;
1111 unsigned int offload_fdecoded_options_count = 0;
1112 struct cl_decoded_option *decoded_options;
1113 unsigned int decoded_options_count;
1114 struct obstack argv_obstack;
1116 bool have_lto = false;
1117 bool have_offload = false;
1118 unsigned lto_argc = 0, ltoobj_argc = 0;
1119 char **lto_argv, **ltoobj_argv;
1120 bool skip_debug = false;
1121 unsigned n_debugobj;
1123 /* Get the driver and options. */
1124 collect_gcc = getenv ("COLLECT_GCC");
1126 fatal_error (input_location,
1127 "environment variable COLLECT_GCC must be set");
1128 collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
1129 if (!collect_gcc_options)
1130 fatal_error (input_location,
1131 "environment variable COLLECT_GCC_OPTIONS must be set");
1132 get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options,
1135 &decoded_options_count);
1137 /* Allocate array for input object files with LTO IL,
1138 and for possible preceding arguments. */
1139 lto_argv = XNEWVEC (char *, argc);
1140 ltoobj_argv = XNEWVEC (char *, argc);
1142 /* Look at saved options in the IL files. */
1143 for (i = 1; i < argc; ++i)
1147 off_t file_offset = 0;
1150 char *filename = argv[i];
1152 if (strncmp (argv[i], "-foffload-objects=",
1153 sizeof ("-foffload-objects=") - 1) == 0)
1155 have_offload = true;
1156 offload_objects_file_name
1157 = argv[i] + sizeof ("-foffload-objects=") - 1;
1161 if ((p = strrchr (argv[i], '@'))
1163 && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
1164 && strlen (p) == (unsigned int) consumed)
1166 filename = XNEWVEC (char, p - argv[i] + 1);
1167 memcpy (filename, argv[i], p - argv[i]);
1168 filename[p - argv[i]] = '\0';
1169 file_offset = (off_t) loffset;
1171 fd = open (filename, O_RDONLY | O_BINARY);
1174 lto_argv[lto_argc++] = argv[i];
1178 if (find_and_merge_options (fd, file_offset, LTO_SECTION_NAME_PREFIX,
1179 &fdecoded_options, &fdecoded_options_count,
1183 ltoobj_argv[ltoobj_argc++] = argv[i];
1188 /* Initalize the common arguments for the driver. */
1189 obstack_init (&argv_obstack);
1190 obstack_ptr_grow (&argv_obstack, collect_gcc);
1191 obstack_ptr_grow (&argv_obstack, "-xlto");
1192 obstack_ptr_grow (&argv_obstack, "-c");
1194 append_compiler_options (&argv_obstack, fdecoded_options,
1195 fdecoded_options_count);
1196 append_linker_options (&argv_obstack, decoded_options, decoded_options_count);
1198 /* Scan linker driver arguments for things that are of relevance to us. */
1199 for (j = 1; j < decoded_options_count; ++j)
1201 struct cl_decoded_option *option = &decoded_options[j];
1202 switch (option->opt_index)
1205 linker_output = option->arg;
1208 case OPT_save_temps:
1216 case OPT_flto_partition_:
1217 if (strcmp (option->arg, "none") == 0)
1218 no_partition = true;
1222 if (strcmp (option->arg, "jobserver") == 0)
1229 parallel = atoi (option->arg);
1236 lto_mode = LTO_MODE_WHOPR;
1244 /* Output lto-wrapper invocation command. */
1247 for (i = 0; i < argc; ++i)
1249 fputs (argv[i], stderr);
1250 fputc (' ', stderr);
1252 fputc ('\n', stderr);
1257 lto_mode = LTO_MODE_LTO;
1264 char *output_dir, *base, *name;
1265 bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0;
1267 output_dir = xstrdup (linker_output);
1269 for (name = base; *name; name++)
1270 if (IS_DIR_SEPARATOR (*name))
1274 linker_output = &linker_output[base - output_dir];
1275 if (*output_dir == '\0')
1277 static char current_dir[] = { '.', DIR_SEPARATOR, '\0' };
1278 output_dir = current_dir;
1282 obstack_ptr_grow (&argv_obstack, "-dumpdir");
1283 obstack_ptr_grow (&argv_obstack, output_dir);
1286 obstack_ptr_grow (&argv_obstack, "-dumpbase");
1289 /* Remember at which point we can scrub args to re-use the commons. */
1290 new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *);
1294 unsigned i, num_offload_files;
1295 char **offload_argv;
1298 f = fopen (offload_objects_file_name, "r");
1300 fatal_error (input_location, "cannot open %s: %m",
1301 offload_objects_file_name);
1302 if (fscanf (f, "%u ", &num_offload_files) != 1)
1303 fatal_error (input_location, "cannot read %s: %m",
1304 offload_objects_file_name);
1305 offload_argv = XCNEWVEC (char *, num_offload_files);
1307 /* Read names of object files with offload. */
1308 for (i = 0; i < num_offload_files; i++)
1310 const unsigned piece = 32;
1311 char *buf, *filename = XNEWVEC (char, piece);
1316 if (!fgets (buf, piece, f))
1318 len = strlen (filename);
1319 if (filename[len - 1] != '\n')
1321 filename = XRESIZEVEC (char, filename, len + piece);
1322 buf = filename + len;
1325 filename[len - 1] = '\0';
1326 offload_argv[i] = filename;
1329 if (offload_argv[num_offload_files - 1] == NULL)
1330 fatal_error (input_location, "invalid format of %s",
1331 offload_objects_file_name);
1332 maybe_unlink (offload_objects_file_name);
1333 offload_objects_file_name = NULL;
1335 /* Look at saved offload options in files. */
1336 for (i = 0; i < num_offload_files; i++)
1341 off_t file_offset = 0;
1342 char *filename = offload_argv[i];
1344 if ((p = strrchr (offload_argv[i], '@'))
1345 && p != offload_argv[i]
1346 && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
1347 && strlen (p) == (unsigned int) consumed)
1349 filename = XNEWVEC (char, p - offload_argv[i] + 1);
1350 memcpy (filename, offload_argv[i], p - offload_argv[i]);
1351 filename[p - offload_argv[i]] = '\0';
1352 file_offset = (off_t) loffset;
1354 fd = open (filename, O_RDONLY | O_BINARY);
1356 fatal_error (input_location, "cannot open %s: %m", filename);
1357 if (!find_and_merge_options (fd, file_offset,
1358 OFFLOAD_SECTION_NAME_PREFIX,
1359 &offload_fdecoded_options,
1360 &offload_fdecoded_options_count,
1362 fatal_error (input_location, "cannot read %s: %m", filename);
1364 if (filename != offload_argv[i])
1365 XDELETEVEC (filename);
1368 compile_images_for_offload_targets (num_offload_files, offload_argv,
1369 offload_fdecoded_options,
1370 offload_fdecoded_options_count,
1372 decoded_options_count);
1374 free_array_of_ptrs ((void **) offload_argv, num_offload_files);
1378 find_crtoffloadtable ();
1379 for (i = 0; offload_names[i]; i++)
1380 printf ("%s\n", offload_names[i]);
1381 free_array_of_ptrs ((void **) offload_names, i);
1385 /* If object files contain offload sections, but do not contain LTO sections,
1386 then there is no need to perform a link-time recompilation, i.e.
1387 lto-wrapper is used only for a compilation of offload images. */
1388 if (have_offload && !have_lto)
1391 if (lto_mode == LTO_MODE_LTO)
1393 flto_out = make_temp_file (".lto.o");
1395 obstack_ptr_grow (&argv_obstack, linker_output);
1396 obstack_ptr_grow (&argv_obstack, "-o");
1397 obstack_ptr_grow (&argv_obstack, flto_out);
1401 const char *list_option = "-fltrans-output-list=";
1402 size_t list_option_len = strlen (list_option);
1407 char *dumpbase = (char *) xmalloc (strlen (linker_output)
1408 + sizeof (".wpa") + 1);
1409 strcpy (dumpbase, linker_output);
1410 strcat (dumpbase, ".wpa");
1411 obstack_ptr_grow (&argv_obstack, dumpbase);
1414 if (linker_output && save_temps)
1416 ltrans_output_file = (char *) xmalloc (strlen (linker_output)
1417 + sizeof (".ltrans.out") + 1);
1418 strcpy (ltrans_output_file, linker_output);
1419 strcat (ltrans_output_file, ".ltrans.out");
1422 ltrans_output_file = make_temp_file (".ltrans.out");
1423 list_option_full = (char *) xmalloc (sizeof (char) *
1424 (strlen (ltrans_output_file) + list_option_len + 1));
1425 tmp = list_option_full;
1427 obstack_ptr_grow (&argv_obstack, tmp);
1428 strcpy (tmp, list_option);
1429 tmp += list_option_len;
1430 strcpy (tmp, ltrans_output_file);
1433 obstack_ptr_grow (&argv_obstack, xstrdup ("-fwpa=jobserver"));
1434 else if (parallel > 1)
1437 sprintf (buf, "-fwpa=%i", parallel);
1438 obstack_ptr_grow (&argv_obstack, xstrdup (buf));
1441 obstack_ptr_grow (&argv_obstack, "-fwpa");
1444 /* Append input arguments. */
1445 for (i = 0; i < lto_argc; ++i)
1446 obstack_ptr_grow (&argv_obstack, lto_argv[i]);
1447 /* Append the input objects. */
1448 for (i = 0; i < ltoobj_argc; ++i)
1449 obstack_ptr_grow (&argv_obstack, ltoobj_argv[i]);
1450 obstack_ptr_grow (&argv_obstack, NULL);
1452 new_argv = XOBFINISH (&argv_obstack, const char **);
1453 argv_ptr = &new_argv[new_head_argc];
1454 fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true);
1456 /* Handle early generated debug information. At compile-time
1457 we output early DWARF debug info into .gnu.debuglto_ prefixed
1458 sections. LTRANS object DWARF debug info refers to that.
1459 So we need to transfer the .gnu.debuglto_ sections to the final
1460 link. Ideally the linker plugin interface would allow us to
1461 not claim those sections and instruct the linker to keep
1462 them, renaming them in the process. For now we extract and
1463 rename those sections via a simple-object interface to produce
1464 regular objects containing only the early debug info. We
1465 then partially link those to a single early debug info object
1466 and pass that as additional output back to the linker plugin. */
1468 /* Prepare the partial link to gather the compile-time generated
1469 debug-info into a single input for the final link. */
1470 debug_obj = make_temp_file ("debugobj");
1471 obstack_ptr_grow (&argv_obstack, collect_gcc);
1472 for (i = 1; i < decoded_options_count; ++i)
1474 /* Retain linker choice and -B. */
1475 if (decoded_options[i].opt_index == OPT_B
1476 || decoded_options[i].opt_index == OPT_fuse_ld_bfd
1477 || decoded_options[i].opt_index == OPT_fuse_ld_gold)
1478 append_linker_options (&argv_obstack, &decoded_options[i-1], 2);
1479 /* Retain all target options, this preserves -m32 for example. */
1480 if (cl_options[decoded_options[i].opt_index].flags & CL_TARGET)
1481 append_linker_options (&argv_obstack, &decoded_options[i-1], 2);
1482 /* Recognize -g0. */
1483 if (decoded_options[i].opt_index == OPT_g
1484 && strcmp (decoded_options[i].arg, "0") == 0)
1487 obstack_ptr_grow (&argv_obstack, "-r");
1488 obstack_ptr_grow (&argv_obstack, "-nostdlib");
1489 obstack_ptr_grow (&argv_obstack, "-o");
1490 obstack_ptr_grow (&argv_obstack, debug_obj);
1492 /* Copy the early generated debug info from the objects to temporary
1493 files and append those to the partial link commandline. */
1496 for (i = 0; i < ltoobj_argc; ++i)
1499 if ((tem = debug_objcopy (ltoobj_argv[i])))
1501 obstack_ptr_grow (&argv_obstack, tem);
1506 /* Link them all into a single object. Ideally this would reduce
1507 disk space usage mainly due to .debug_str merging but unfortunately
1508 GNU ld doesn't perform this with -r. */
1511 obstack_ptr_grow (&argv_obstack, NULL);
1512 const char **debug_link_argv = XOBFINISH (&argv_obstack, const char **);
1513 fork_execute (debug_link_argv[0],
1514 CONST_CAST (char **, debug_link_argv), false);
1516 /* And dispose the temporaries. */
1517 for (i = 0; debug_link_argv[i]; ++i)
1519 for (--i; i > 0; --i)
1521 if (strcmp (debug_link_argv[i], debug_obj) == 0)
1523 maybe_unlink (debug_link_argv[i]);
1528 unlink_if_ordinary (debug_obj);
1534 if (lto_mode == LTO_MODE_LTO)
1536 printf ("%s\n", flto_out);
1539 printf ("%s\n", debug_obj);
1548 FILE *stream = fopen (ltrans_output_file, "r");
1549 FILE *mstream = NULL;
1550 struct obstack env_obstack;
1554 fatal_error (input_location, "fopen: %s: %m", ltrans_output_file);
1556 /* Parse the list of LTRANS inputs from the WPA stage. */
1557 obstack_init (&env_obstack);
1561 const unsigned piece = 32;
1562 char *output_name = NULL;
1563 char *buf, *input_name = (char *)xmalloc (piece);
1567 if (fscanf (stream, "%i\n", &priority) != 1)
1570 fatal_error (input_location,
1571 "Corrupted ltrans output file %s",
1572 ltrans_output_file);
1576 if (!fgets (buf, piece, stream))
1578 len = strlen (input_name);
1579 if (input_name[len - 1] != '\n')
1581 input_name = (char *)xrealloc (input_name, len + piece);
1582 buf = input_name + len;
1585 input_name[len - 1] = '\0';
1587 if (input_name[0] == '*')
1588 output_name = &input_name[1];
1592 = (int *)xrealloc (ltrans_priorities, nr * sizeof (int) * 2);
1593 input_names = (char **)xrealloc (input_names, nr * sizeof (char *));
1594 output_names = (char **)xrealloc (output_names, nr * sizeof (char *));
1595 ltrans_priorities[(nr-1)*2] = priority;
1596 ltrans_priorities[(nr-1)*2+1] = nr-1;
1597 input_names[nr-1] = input_name;
1598 output_names[nr-1] = output_name;
1601 maybe_unlink (ltrans_output_file);
1602 ltrans_output_file = NULL;
1606 makefile = make_temp_file (".mk");
1607 mstream = fopen (makefile, "w");
1608 qsort (ltrans_priorities, nr, sizeof (int) * 2, cmp_priority);
1611 /* Execute the LTRANS stage for each input file (or prepare a
1612 makefile to invoke this in parallel). */
1613 for (i = 0; i < nr; ++i)
1616 char *input_name = input_names[i];
1617 /* If it's a pass-through file do nothing. */
1618 if (output_names[i])
1621 /* Replace the .o suffix with a .ltrans.o suffix and write
1622 the resulting name to the LTRANS output list. */
1623 obstack_grow (&env_obstack, input_name, strlen (input_name) - 2);
1624 obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
1625 output_name = XOBFINISH (&env_obstack, char *);
1627 /* Adjust the dumpbase if the linker output file was seen. */
1631 = (char *) xmalloc (strlen (linker_output)
1632 + sizeof (DUMPBASE_SUFFIX) + 1);
1634 strlen (linker_output) + sizeof (DUMPBASE_SUFFIX),
1635 "%s.ltrans%u", linker_output, i);
1636 argv_ptr[0] = dumpbase;
1639 argv_ptr[1] = "-fltrans";
1641 argv_ptr[3] = output_name;
1642 argv_ptr[4] = input_name;
1646 fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]);
1647 for (j = 1; new_argv[j] != NULL; ++j)
1648 fprintf (mstream, " '%s'", new_argv[j]);
1649 fprintf (mstream, "\n");
1650 /* If we are not preserving the ltrans input files then
1651 truncate them as soon as we have processed it. This
1652 reduces temporary disk-space usage. */
1654 fprintf (mstream, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1655 "&& mv %s.tem %s\n",
1656 input_name, input_name, input_name, input_name);
1660 fork_execute (new_argv[0], CONST_CAST (char **, new_argv),
1662 maybe_unlink (input_name);
1665 output_names[i] = output_name;
1669 struct pex_obj *pex;
1675 for (i = 0; i < nr; ++i)
1677 int j = ltrans_priorities[i*2 + 1];
1678 fprintf (mstream, " \\\n\t%s", output_names[j]);
1680 fprintf (mstream, "\n");
1684 /* Avoid passing --jobserver-fd= and similar flags
1685 unless jobserver mode is explicitly enabled. */
1686 putenv (xstrdup ("MAKEFLAGS="));
1687 putenv (xstrdup ("MFLAGS="));
1689 new_argv[0] = getenv ("MAKE");
1691 new_argv[0] = "make";
1693 new_argv[2] = makefile;
1697 snprintf (jobs, 31, "-j%d", parallel);
1698 new_argv[i++] = jobs;
1700 new_argv[i++] = "all";
1701 new_argv[i++] = NULL;
1702 pex = collect_execute (new_argv[0], CONST_CAST (char **, new_argv),
1703 NULL, NULL, PEX_SEARCH, false);
1704 do_wait (new_argv[0], pex);
1705 maybe_unlink (makefile);
1707 for (i = 0; i < nr; ++i)
1708 maybe_unlink (input_names[i]);
1712 printf ("%s\n", debug_obj);
1716 for (i = 0; i < nr; ++i)
1718 fputs (output_names[i], stdout);
1719 putc ('\n', stdout);
1720 free (input_names[i]);
1723 free (ltrans_priorities);
1724 free (output_names);
1726 free (list_option_full);
1727 obstack_free (&env_obstack, NULL);
1732 obstack_free (&argv_obstack, NULL);
1739 main (int argc, char *argv[])
1743 init_opts_obstack ();
1745 p = argv[0] + strlen (argv[0]);
1746 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
1750 xmalloc_set_program_name (progname);
1752 gcc_init_libintl ();
1754 diagnostic_initialize (global_dc, 0);
1756 if (atexit (lto_wrapper_cleanup) != 0)
1757 fatal_error (input_location, "atexit failed");
1759 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1760 signal (SIGINT, fatal_signal);
1762 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1763 signal (SIGHUP, fatal_signal);
1765 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
1766 signal (SIGTERM, fatal_signal);
1768 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
1769 signal (SIGPIPE, fatal_signal);
1772 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1773 receive the signal. A different setting is inheritable */
1774 signal (SIGCHLD, SIG_DFL);
1777 /* We may be called with all the arguments stored in some file and
1778 passed with @file. Expand them into argv before processing. */
1779 expandargv (&argc, &argv);
1781 run_gcc (argc, argv);