1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2016 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 char **input_names
;
69 static char **output_names
;
70 static char **offload_names
;
71 static const char *offloadbegin
, *offloadend
;
72 static char *makefile
;
74 const char tool_name
[] = "lto-wrapper";
76 /* Delete tempfiles. Called from utils_cleanup. */
83 if (ltrans_output_file
)
84 maybe_unlink (ltrans_output_file
);
86 maybe_unlink (flto_out
);
88 maybe_unlink (makefile
);
89 for (i
= 0; i
< nr
; ++i
)
91 maybe_unlink (input_names
[i
]);
93 maybe_unlink (output_names
[i
]);
98 lto_wrapper_cleanup (void)
100 utils_cleanup (false);
103 /* Unlink a temporary LTRANS file unless requested otherwise. */
106 maybe_unlink (const char *file
)
110 if (unlink_if_ordinary (file
)
112 fatal_error (input_location
, "deleting LTRANS file %s: %m", file
);
115 fprintf (stderr
, "[Leaving LTRANS %s]\n", file
);
118 /* Template of LTRANS dumpbase suffix. */
119 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
121 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
122 environment according to LANG_MASK. */
125 get_options_from_collect_gcc_options (const char *collect_gcc
,
126 const char *collect_gcc_options
,
127 unsigned int lang_mask
,
128 struct cl_decoded_option
**decoded_options
,
129 unsigned int *decoded_options_count
)
131 struct obstack argv_obstack
;
136 argv_storage
= xstrdup (collect_gcc_options
);
137 obstack_init (&argv_obstack
);
138 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
140 for (j
= 0, k
= 0; argv_storage
[j
] != '\0'; ++j
)
142 if (argv_storage
[j
] == '\'')
144 obstack_ptr_grow (&argv_obstack
, &argv_storage
[k
]);
148 if (argv_storage
[j
] == '\0')
149 fatal_error (input_location
, "malformed COLLECT_GCC_OPTIONS");
150 else if (strncmp (&argv_storage
[j
], "'\\''", 4) == 0)
152 argv_storage
[k
++] = '\'';
155 else if (argv_storage
[j
] == '\'')
158 argv_storage
[k
++] = argv_storage
[j
++];
161 argv_storage
[k
++] = '\0';
165 obstack_ptr_grow (&argv_obstack
, NULL
);
166 argc
= obstack_object_size (&argv_obstack
) / sizeof (void *) - 1;
167 argv
= XOBFINISH (&argv_obstack
, const char **);
169 decode_cmdline_options_to_array (argc
, (const char **)argv
,
171 decoded_options
, decoded_options_count
);
172 obstack_free (&argv_obstack
, NULL
);
175 /* Append OPTION to the options array DECODED_OPTIONS with size
176 DECODED_OPTIONS_COUNT. */
179 append_option (struct cl_decoded_option
**decoded_options
,
180 unsigned int *decoded_options_count
,
181 struct cl_decoded_option
*option
)
183 ++*decoded_options_count
;
185 = (struct cl_decoded_option
*)
186 xrealloc (*decoded_options
,
187 (*decoded_options_count
188 * sizeof (struct cl_decoded_option
)));
189 memcpy (&(*decoded_options
)[*decoded_options_count
- 1], option
,
190 sizeof (struct cl_decoded_option
));
193 /* Try to merge and complain about options FDECODED_OPTIONS when applied
194 ontop of DECODED_OPTIONS. */
197 merge_and_complain (struct cl_decoded_option
**decoded_options
,
198 unsigned int *decoded_options_count
,
199 struct cl_decoded_option
*fdecoded_options
,
200 unsigned int fdecoded_options_count
)
204 /* ??? Merge options from files. Most cases can be
205 handled by either unioning or intersecting
206 (for example -fwrapv is a case for unioning,
207 -ffast-math is for intersection). Most complaints
208 about real conflicts between different options can
209 be deferred to the compiler proper. Options that
210 we can neither safely handle by intersection nor
211 unioning would need to be complained about here.
212 Ideally we'd have a flag in the opt files that
213 tells whether to union or intersect or reject.
214 In absence of that it's unclear what a good default is.
215 It's also difficult to get positional handling correct. */
217 /* The following does what the old LTO option code did,
218 union all target and a selected set of common options. */
219 for (i
= 0; i
< fdecoded_options_count
; ++i
)
221 struct cl_decoded_option
*foption
= &fdecoded_options
[i
];
222 switch (foption
->opt_index
)
224 case OPT_SPECIAL_unknown
:
225 case OPT_SPECIAL_ignore
:
226 case OPT_SPECIAL_program_name
:
227 case OPT_SPECIAL_input_file
:
231 if (!(cl_options
[foption
->opt_index
].flags
& CL_TARGET
))
235 case OPT_fdiagnostics_show_caret
:
236 case OPT_fdiagnostics_show_option
:
237 case OPT_fdiagnostics_show_location_
:
238 case OPT_fshow_column
:
244 case OPT_fexceptions
:
245 case OPT_fnon_call_exceptions
:
247 /* Do what the old LTO code did - collect exactly one option
248 setting per OPT code, we pick the first we encounter.
249 ??? This doesn't make too much sense, but when it doesn't
250 then we should complain. */
251 for (j
= 0; j
< *decoded_options_count
; ++j
)
252 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
254 if (j
== *decoded_options_count
)
255 append_option (decoded_options
, decoded_options_count
, foption
);
259 case OPT_fstrict_overflow
:
260 case OPT_ffp_contract_
:
261 /* For selected options we can merge conservatively. */
262 for (j
= 0; j
< *decoded_options_count
; ++j
)
263 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
265 if (j
== *decoded_options_count
)
266 append_option (decoded_options
, decoded_options_count
, foption
);
267 /* FP_CONTRACT_OFF < FP_CONTRACT_ON < FP_CONTRACT_FAST,
268 -fno-trapv < -ftrapv,
269 -fno-strict-overflow < -fstrict-overflow */
270 else if (foption
->value
< (*decoded_options
)[j
].value
)
271 (*decoded_options
)[j
] = *foption
;
274 case OPT_fmath_errno
:
275 case OPT_fsigned_zeros
:
276 case OPT_ftrapping_math
:
281 case OPT_fcheck_pointer_bounds
:
282 /* For selected options we can merge conservatively. */
283 for (j
= 0; j
< *decoded_options_count
; ++j
)
284 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
286 if (j
== *decoded_options_count
)
287 append_option (decoded_options
, decoded_options_count
, foption
);
288 /* -fmath-errno > -fno-math-errno,
289 -fsigned-zeros > -fno-signed-zeros,
290 -ftrapping-math > -fno-trapping-math,
291 -fwrapv > -fno-wrapv. */
292 else if (foption
->value
> (*decoded_options
)[j
].value
)
293 (*decoded_options
)[j
] = *foption
;
296 case OPT_fopenacc_dim_
:
297 /* Append or check identical. */
298 for (j
= 0; j
< *decoded_options_count
; ++j
)
299 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
301 if (j
== *decoded_options_count
)
302 append_option (decoded_options
, decoded_options_count
, foption
);
303 else if (strcmp ((*decoded_options
)[j
].arg
, foption
->arg
))
304 fatal_error (input_location
,
305 "Option %s with different values",
306 foption
->orig_option_with_args_text
);
309 case OPT_freg_struct_return
:
310 case OPT_fpcc_struct_return
:
311 for (j
= 0; j
< *decoded_options_count
; ++j
)
312 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
314 if (j
== *decoded_options_count
)
315 fatal_error (input_location
,
316 "Option %s not used consistently in all LTO input"
317 " files", foption
->orig_option_with_args_text
);
320 case OPT_foffload_abi_
:
321 for (j
= 0; j
< *decoded_options_count
; ++j
)
322 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
324 if (j
== *decoded_options_count
)
325 append_option (decoded_options
, decoded_options_count
, foption
);
326 else if (foption
->value
!= (*decoded_options
)[j
].value
)
327 fatal_error (input_location
,
328 "Option %s not used consistently in all LTO input"
329 " files", foption
->orig_option_with_args_text
);
336 for (j
= 0; j
< *decoded_options_count
; ++j
)
337 if ((*decoded_options
)[j
].opt_index
== OPT_O
338 || (*decoded_options
)[j
].opt_index
== OPT_Ofast
339 || (*decoded_options
)[j
].opt_index
== OPT_Og
340 || (*decoded_options
)[j
].opt_index
== OPT_Os
)
342 if (j
== *decoded_options_count
)
343 append_option (decoded_options
, decoded_options_count
, foption
);
344 else if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
345 && foption
->opt_index
!= OPT_O
)
346 /* Exact same options get merged. */
350 /* For mismatched option kinds preserve the optimization
351 level only, thus merge it as -On. This also handles
352 merging of same optimization level -On. */
354 switch (foption
->opt_index
)
357 if (foption
->arg
[0] == '\0')
358 level
= MAX (level
, 1);
360 level
= MAX (level
, atoi (foption
->arg
));
363 level
= MAX (level
, 3);
366 level
= MAX (level
, 1);
369 level
= MAX (level
, 2);
374 switch ((*decoded_options
)[j
].opt_index
)
377 if ((*decoded_options
)[j
].arg
[0] == '\0')
378 level
= MAX (level
, 1);
380 level
= MAX (level
, atoi ((*decoded_options
)[j
].arg
));
383 level
= MAX (level
, 3);
386 level
= MAX (level
, 1);
389 level
= MAX (level
, 2);
394 (*decoded_options
)[j
].opt_index
= OPT_O
;
396 tem
= xasprintf ("-O%d", level
);
397 (*decoded_options
)[j
].arg
= &tem
[2];
398 (*decoded_options
)[j
].canonical_option
[0] = tem
;
399 (*decoded_options
)[j
].value
= 1;
404 append_option (decoded_options
, decoded_options_count
, foption
);
410 /* Auxiliary function that frees elements of PTR and PTR itself.
411 N is number of elements to be freed. If PTR is NULL, nothing is freed.
412 If an element is NULL, subsequent elements are not freed. */
415 free_array_of_ptrs (void **ptr
, unsigned n
)
419 for (unsigned i
= 0; i
< n
; i
++)
429 /* Parse STR, saving found tokens into PVALUES and return their number.
430 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
431 append it to every token we find. */
434 parse_env_var (const char *str
, char ***pvalues
, const char *append
)
436 const char *curval
, *nextval
;
440 curval
= strchr (str
, ':');
444 curval
= strchr (curval
+ 1, ':');
447 values
= (char**) xmalloc (num
* sizeof (char*));
449 nextval
= strchr (curval
, ':');
451 nextval
= strchr (curval
, '\0');
453 int append_len
= append
? strlen (append
) : 0;
454 for (i
= 0; i
< num
; i
++)
456 int l
= nextval
- curval
;
457 values
[i
] = (char*) xmalloc (l
+ 1 + append_len
);
458 memcpy (values
[i
], curval
, l
);
461 strcat (values
[i
], append
);
462 curval
= nextval
+ 1;
463 nextval
= strchr (curval
, ':');
465 nextval
= strchr (curval
, '\0');
471 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
474 append_compiler_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
477 /* Append compiler driver arguments as far as they were merged. */
478 for (unsigned int j
= 1; j
< count
; ++j
)
480 struct cl_decoded_option
*option
= &opts
[j
];
482 /* File options have been properly filtered by lto-opts.c. */
483 switch (option
->opt_index
)
485 /* Drop arguments that we want to take from the link line. */
488 case OPT_flto_partition_
:
495 /* For now do what the original LTO option code was doing - pass
496 on any CL_TARGET flag and a few selected others. */
497 switch (option
->opt_index
)
499 case OPT_fdiagnostics_show_caret
:
500 case OPT_fdiagnostics_show_option
:
501 case OPT_fdiagnostics_show_location_
:
502 case OPT_fshow_column
:
508 case OPT_fexceptions
:
509 case OPT_fnon_call_exceptions
:
511 case OPT_freg_struct_return
:
512 case OPT_fpcc_struct_return
:
513 case OPT_ffp_contract_
:
514 case OPT_fmath_errno
:
515 case OPT_fsigned_zeros
:
516 case OPT_ftrapping_math
:
520 case OPT_fopenacc_dim_
:
523 case OPT_fstrict_overflow
:
524 case OPT_foffload_abi_
:
529 case OPT_fcheck_pointer_bounds
:
533 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
537 /* Pass the option on. */
538 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
539 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
543 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
546 append_diag_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
549 /* Append compiler driver arguments as far as they were merged. */
550 for (unsigned int j
= 1; j
< count
; ++j
)
552 struct cl_decoded_option
*option
= &opts
[j
];
554 switch (option
->opt_index
)
556 case OPT_fdiagnostics_color_
:
557 case OPT_fdiagnostics_show_caret
:
558 case OPT_fdiagnostics_show_option
:
559 case OPT_fdiagnostics_show_location_
:
560 case OPT_fshow_column
:
566 /* Pass the option on. */
567 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
568 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
573 /* Append linker options OPTS to ARGV_OBSTACK. */
576 append_linker_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
579 /* Append linker driver arguments. Compiler options from the linker
580 driver arguments will override / merge with those from the compiler. */
581 for (unsigned int j
= 1; j
< count
; ++j
)
583 struct cl_decoded_option
*option
= &opts
[j
];
585 /* Do not pass on frontend specific flags not suitable for lto. */
586 if (!(cl_options
[option
->opt_index
].flags
587 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
590 switch (option
->opt_index
)
595 /* We've handled these LTO options, do not pass them on. */
598 case OPT_freg_struct_return
:
599 case OPT_fpcc_struct_return
:
600 /* Ignore these, they are determined by the input files.
601 ??? We fail to diagnose a possible mismatch here. */
607 /* Ignore -fno-XXX form of these options, as otherwise
608 corresponding builtins will not be enabled. */
609 if (option
->value
== 0)
617 /* Pass the option on. */
618 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
619 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
623 /* Extract options for TARGET offload compiler from OPTIONS and append
624 them to ARGV_OBSTACK. */
627 append_offload_options (obstack
*argv_obstack
, const char *target
,
628 struct cl_decoded_option
*options
,
629 unsigned int options_count
)
631 for (unsigned i
= 0; i
< options_count
; i
++)
633 const char *cur
, *next
, *opts
;
636 struct cl_decoded_option
*option
= &options
[i
];
638 if (option
->opt_index
!= OPT_foffload_
)
641 /* If option argument starts with '-' then no target is specified. That
642 means offload options are specified for all targets, so we need to
644 if (option
->arg
[0] == '-')
648 opts
= strchr (option
->arg
, '=');
649 /* If there are offload targets specified, but no actual options,
650 there is nothing to do here. */
658 next
= strchr (cur
, ',');
661 next
= (next
> opts
) ? opts
: next
;
663 /* Are we looking for this offload target? */
664 if (strlen (target
) == (size_t) (next
- cur
)
665 && strncmp (target
, cur
, next
- cur
) == 0)
668 /* Skip the comma or equal sign. */
678 argv
= buildargv (opts
);
679 for (argc
= 0; argv
[argc
]; argc
++)
680 obstack_ptr_grow (argv_obstack
, argv
[argc
]);
684 /* Check whether NAME can be accessed in MODE. This is like access,
685 except that it never considers directories to be executable. */
688 access_check (const char *name
, int mode
)
694 if (stat (name
, &st
) < 0
695 || S_ISDIR (st
.st_mode
))
699 return access (name
, mode
);
702 /* Prepare a target image for offload TARGET, using mkoffload tool from
703 COMPILER_PATH. Return the name of the resultant object file. */
706 compile_offload_image (const char *target
, const char *compiler_path
,
707 unsigned in_argc
, char *in_argv
[],
708 struct cl_decoded_option
*compiler_opts
,
709 unsigned int compiler_opt_count
,
710 struct cl_decoded_option
*linker_opts
,
711 unsigned int linker_opt_count
)
713 char *filename
= NULL
;
716 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target
));
717 strcpy (suffix
, "/accel/");
718 strcat (suffix
, target
);
719 strcat (suffix
, "/mkoffload");
722 unsigned n_paths
= parse_env_var (compiler_path
, &paths
, suffix
);
724 const char *compiler
= NULL
;
725 for (unsigned i
= 0; i
< n_paths
; i
++)
726 if (access_check (paths
[i
], X_OK
) == 0)
734 /* Generate temporary output file name. */
735 filename
= make_temp_file (".target.o");
737 struct obstack argv_obstack
;
738 obstack_init (&argv_obstack
);
739 obstack_ptr_grow (&argv_obstack
, compiler
);
741 obstack_ptr_grow (&argv_obstack
, "-save-temps");
743 obstack_ptr_grow (&argv_obstack
, "-v");
744 obstack_ptr_grow (&argv_obstack
, "-o");
745 obstack_ptr_grow (&argv_obstack
, filename
);
747 /* Append names of input object files. */
748 for (unsigned i
= 0; i
< in_argc
; i
++)
749 obstack_ptr_grow (&argv_obstack
, in_argv
[i
]);
751 /* Append options from offload_lto sections. */
752 append_compiler_options (&argv_obstack
, compiler_opts
,
754 append_diag_options (&argv_obstack
, linker_opts
, linker_opt_count
);
756 /* Append options specified by -foffload last. In case of conflicting
757 options we expect offload compiler to choose the latest. */
758 append_offload_options (&argv_obstack
, target
, compiler_opts
,
760 append_offload_options (&argv_obstack
, target
, linker_opts
,
763 obstack_ptr_grow (&argv_obstack
, NULL
);
764 argv
= XOBFINISH (&argv_obstack
, char **);
765 fork_execute (argv
[0], argv
, true);
766 obstack_free (&argv_obstack
, NULL
);
769 free_array_of_ptrs ((void **) paths
, n_paths
);
774 /* The main routine dealing with offloading.
775 The routine builds a target image for each offload target. IN_ARGC and
776 IN_ARGV specify options and input object files. As all of them could contain
777 target sections, we pass them all to target compilers. */
780 compile_images_for_offload_targets (unsigned in_argc
, char *in_argv
[],
781 struct cl_decoded_option
*compiler_opts
,
782 unsigned int compiler_opt_count
,
783 struct cl_decoded_option
*linker_opts
,
784 unsigned int linker_opt_count
)
787 const char *target_names
= getenv (OFFLOAD_TARGET_NAMES_ENV
);
790 unsigned num_targets
= parse_env_var (target_names
, &names
, NULL
);
792 int next_name_entry
= 0;
793 const char *compiler_path
= getenv ("COMPILER_PATH");
797 /* Prepare an image for each target and save the name of the resultant object
798 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
799 offload_names
= XCNEWVEC (char *, num_targets
+ 1);
800 for (unsigned i
= 0; i
< num_targets
; i
++)
802 /* HSA does not use LTO-like streaming and a different compiler, skip
804 if (strcmp (names
[i
], "hsa") == 0)
807 offload_names
[next_name_entry
]
808 = compile_offload_image (names
[i
], compiler_path
, in_argc
, in_argv
,
809 compiler_opts
, compiler_opt_count
,
810 linker_opts
, linker_opt_count
);
811 if (!offload_names
[next_name_entry
])
812 fatal_error (input_location
,
813 "problem with building target image for %s\n", names
[i
]);
818 free_array_of_ptrs ((void **) names
, num_targets
);
821 /* Copy a file from SRC to DEST. */
824 copy_file (const char *dest
, const char *src
)
826 FILE *d
= fopen (dest
, "wb");
827 FILE *s
= fopen (src
, "rb");
831 size_t len
= fread (buffer
, 1, 512, s
);
833 fatal_error (input_location
, "reading input file");
836 fwrite (buffer
, 1, len
, d
);
838 fatal_error (input_location
, "writing output file");
843 /* Find the crtoffloadbegin.o and crtoffloadend.o files in LIBRARY_PATH, make
844 copies and store the names of the copies in offloadbegin and offloadend. */
847 find_offloadbeginend (void)
850 const char *library_path
= getenv ("LIBRARY_PATH");
853 unsigned n_paths
= parse_env_var (library_path
, &paths
, "/crtoffloadbegin.o");
856 for (i
= 0; i
< n_paths
; i
++)
857 if (access_check (paths
[i
], R_OK
) == 0)
859 size_t len
= strlen (paths
[i
]);
860 char *tmp
= xstrdup (paths
[i
]);
861 strcpy (paths
[i
] + len
- strlen ("begin.o"), "end.o");
862 if (access_check (paths
[i
], R_OK
) != 0)
863 fatal_error (input_location
,
864 "installation error, can't find crtoffloadend.o");
865 /* The linker will delete the filenames we give it, so make
867 offloadbegin
= make_temp_file (".o");
868 offloadend
= make_temp_file (".o");
869 copy_file (offloadbegin
, tmp
);
870 copy_file (offloadend
, paths
[i
]);
875 fatal_error (input_location
,
876 "installation error, can't find crtoffloadbegin.o");
878 free_array_of_ptrs ((void **) paths
, n_paths
);
881 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
882 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
883 and OPT_COUNT. Return true if we found a matchingn section, false
884 otherwise. COLLECT_GCC holds the value of the environment variable with
888 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
889 struct cl_decoded_option
**opts
,
890 unsigned int *opt_count
, const char *collect_gcc
)
892 off_t offset
, length
;
897 struct cl_decoded_option
*fdecoded_options
= *opts
;
898 unsigned int fdecoded_options_count
= *opt_count
;
900 simple_object_read
*sobj
;
901 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
906 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
907 strcpy (secname
, prefix
);
908 strcat (secname
, ".opts");
909 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
912 simple_object_release_read (sobj
);
916 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
917 data
= (char *)xmalloc (length
);
918 read (fd
, data
, length
);
922 struct cl_decoded_option
*f2decoded_options
;
923 unsigned int f2decoded_options_count
;
924 get_options_from_collect_gcc_options (collect_gcc
,
927 &f2decoded_options_count
);
928 if (!fdecoded_options
)
930 fdecoded_options
= f2decoded_options
;
931 fdecoded_options_count
= f2decoded_options_count
;
934 merge_and_complain (&fdecoded_options
,
935 &fdecoded_options_count
,
936 f2decoded_options
, f2decoded_options_count
);
938 fopts
+= strlen (fopts
) + 1;
940 while (fopts
- data
< length
);
943 simple_object_release_read (sobj
);
944 *opts
= fdecoded_options
;
945 *opt_count
= fdecoded_options_count
;
949 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
952 run_gcc (unsigned argc
, char *argv
[])
955 const char **new_argv
;
956 const char **argv_ptr
;
957 char *list_option_full
= NULL
;
958 const char *linker_output
= NULL
;
959 const char *collect_gcc
, *collect_gcc_options
;
962 bool no_partition
= false;
963 struct cl_decoded_option
*fdecoded_options
= NULL
;
964 struct cl_decoded_option
*offload_fdecoded_options
= NULL
;
965 unsigned int fdecoded_options_count
= 0;
966 unsigned int offload_fdecoded_options_count
= 0;
967 struct cl_decoded_option
*decoded_options
;
968 unsigned int decoded_options_count
;
969 struct obstack argv_obstack
;
971 bool have_lto
= false;
972 bool have_offload
= false;
973 unsigned lto_argc
= 0, offload_argc
= 0;
974 char **lto_argv
, **offload_argv
;
976 /* Get the driver and options. */
977 collect_gcc
= getenv ("COLLECT_GCC");
979 fatal_error (input_location
,
980 "environment variable COLLECT_GCC must be set");
981 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
982 if (!collect_gcc_options
)
983 fatal_error (input_location
,
984 "environment variable COLLECT_GCC_OPTIONS must be set");
985 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
988 &decoded_options_count
);
990 /* Allocate arrays for input object files with LTO or offload IL,
991 and for possible preceding arguments. */
992 lto_argv
= XNEWVEC (char *, argc
);
993 offload_argv
= XNEWVEC (char *, argc
);
995 /* Look at saved options in the IL files. */
996 for (i
= 1; i
< argc
; ++i
)
1000 off_t file_offset
= 0;
1003 char *filename
= argv
[i
];
1005 if ((p
= strrchr (argv
[i
], '@'))
1007 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1008 && strlen (p
) == (unsigned int) consumed
)
1010 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1011 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1012 filename
[p
- argv
[i
]] = '\0';
1013 file_offset
= (off_t
) loffset
;
1015 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1018 lto_argv
[lto_argc
++] = argv
[i
];
1022 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1023 &fdecoded_options
, &fdecoded_options_count
,
1027 lto_argv
[lto_argc
++] = argv
[i
];
1030 if (find_and_merge_options (fd
, file_offset
, OFFLOAD_SECTION_NAME_PREFIX
,
1031 &offload_fdecoded_options
,
1032 &offload_fdecoded_options_count
, collect_gcc
))
1034 have_offload
= true;
1035 offload_argv
[offload_argc
++] = argv
[i
];
1041 /* Initalize the common arguments for the driver. */
1042 obstack_init (&argv_obstack
);
1043 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1044 obstack_ptr_grow (&argv_obstack
, "-xlto");
1045 obstack_ptr_grow (&argv_obstack
, "-c");
1047 append_compiler_options (&argv_obstack
, fdecoded_options
,
1048 fdecoded_options_count
);
1049 append_linker_options (&argv_obstack
, decoded_options
, decoded_options_count
);
1051 /* Scan linker driver arguments for things that are of relevance to us. */
1052 for (j
= 1; j
< decoded_options_count
; ++j
)
1054 struct cl_decoded_option
*option
= &decoded_options
[j
];
1055 switch (option
->opt_index
)
1058 linker_output
= option
->arg
;
1061 case OPT_save_temps
:
1069 case OPT_flto_partition_
:
1070 if (strcmp (option
->arg
, "none") == 0)
1071 no_partition
= true;
1075 if (strcmp (option
->arg
, "jobserver") == 0)
1082 parallel
= atoi (option
->arg
);
1089 lto_mode
= LTO_MODE_WHOPR
;
1099 lto_mode
= LTO_MODE_LTO
;
1106 char *output_dir
, *base
, *name
;
1107 bool bit_bucket
= strcmp (linker_output
, HOST_BIT_BUCKET
) == 0;
1109 output_dir
= xstrdup (linker_output
);
1111 for (name
= base
; *name
; name
++)
1112 if (IS_DIR_SEPARATOR (*name
))
1116 linker_output
= &linker_output
[base
- output_dir
];
1117 if (*output_dir
== '\0')
1119 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1120 output_dir
= current_dir
;
1124 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1125 obstack_ptr_grow (&argv_obstack
, output_dir
);
1128 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1131 /* Remember at which point we can scrub args to re-use the commons. */
1132 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1136 compile_images_for_offload_targets (offload_argc
, offload_argv
,
1137 offload_fdecoded_options
,
1138 offload_fdecoded_options_count
,
1140 decoded_options_count
);
1143 find_offloadbeginend ();
1144 for (i
= 0; offload_names
[i
]; i
++)
1145 printf ("%s\n", offload_names
[i
]);
1146 free_array_of_ptrs ((void **) offload_names
, i
);
1151 printf ("%s\n", offloadbegin
);
1153 /* If object files contain offload sections, but do not contain LTO sections,
1154 then there is no need to perform a link-time recompilation, i.e.
1155 lto-wrapper is used only for a compilation of offload images. */
1156 if (have_offload
&& !have_lto
)
1158 for (i
= 1; i
< argc
; ++i
)
1159 if (strncmp (argv
[i
], "-fresolution=",
1160 sizeof ("-fresolution=") - 1) != 0
1161 && strncmp (argv
[i
], "-flinker-output=",
1162 sizeof ("-flinker-output=") - 1) != 0)
1165 /* Can be ".o" or ".so". */
1166 char *ext
= strrchr (argv
[i
], '.');
1168 out_file
= make_temp_file ("");
1170 out_file
= make_temp_file (ext
);
1171 /* The linker will delete the files we give it, so make copies. */
1172 copy_file (out_file
, argv
[i
]);
1173 printf ("%s\n", out_file
);
1178 if (lto_mode
== LTO_MODE_LTO
)
1180 flto_out
= make_temp_file (".lto.o");
1182 obstack_ptr_grow (&argv_obstack
, linker_output
);
1183 obstack_ptr_grow (&argv_obstack
, "-o");
1184 obstack_ptr_grow (&argv_obstack
, flto_out
);
1188 const char *list_option
= "-fltrans-output-list=";
1189 size_t list_option_len
= strlen (list_option
);
1194 char *dumpbase
= (char *) xmalloc (strlen (linker_output
)
1195 + sizeof (".wpa") + 1);
1196 strcpy (dumpbase
, linker_output
);
1197 strcat (dumpbase
, ".wpa");
1198 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1201 if (linker_output
&& save_temps
)
1203 ltrans_output_file
= (char *) xmalloc (strlen (linker_output
)
1204 + sizeof (".ltrans.out") + 1);
1205 strcpy (ltrans_output_file
, linker_output
);
1206 strcat (ltrans_output_file
, ".ltrans.out");
1209 ltrans_output_file
= make_temp_file (".ltrans.out");
1210 list_option_full
= (char *) xmalloc (sizeof (char) *
1211 (strlen (ltrans_output_file
) + list_option_len
+ 1));
1212 tmp
= list_option_full
;
1214 obstack_ptr_grow (&argv_obstack
, tmp
);
1215 strcpy (tmp
, list_option
);
1216 tmp
+= list_option_len
;
1217 strcpy (tmp
, ltrans_output_file
);
1220 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1221 else if (parallel
> 1)
1224 sprintf (buf
, "-fwpa=%i", parallel
);
1225 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1228 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1231 /* Append the input objects and possible preceding arguments. */
1232 for (i
= 0; i
< lto_argc
; ++i
)
1233 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1234 obstack_ptr_grow (&argv_obstack
, NULL
);
1236 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1237 argv_ptr
= &new_argv
[new_head_argc
];
1238 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true);
1240 if (lto_mode
== LTO_MODE_LTO
)
1242 printf ("%s\n", flto_out
);
1248 FILE *stream
= fopen (ltrans_output_file
, "r");
1249 FILE *mstream
= NULL
;
1250 struct obstack env_obstack
;
1253 fatal_error (input_location
, "fopen: %s: %m", ltrans_output_file
);
1255 /* Parse the list of LTRANS inputs from the WPA stage. */
1256 obstack_init (&env_obstack
);
1260 const unsigned piece
= 32;
1261 char *output_name
= NULL
;
1262 char *buf
, *input_name
= (char *)xmalloc (piece
);
1267 if (!fgets (buf
, piece
, stream
))
1269 len
= strlen (input_name
);
1270 if (input_name
[len
- 1] != '\n')
1272 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1273 buf
= input_name
+ len
;
1276 input_name
[len
- 1] = '\0';
1278 if (input_name
[0] == '*')
1279 output_name
= &input_name
[1];
1282 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1283 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1284 input_names
[nr
-1] = input_name
;
1285 output_names
[nr
-1] = output_name
;
1288 maybe_unlink (ltrans_output_file
);
1289 ltrans_output_file
= NULL
;
1293 makefile
= make_temp_file (".mk");
1294 mstream
= fopen (makefile
, "w");
1297 /* Execute the LTRANS stage for each input file (or prepare a
1298 makefile to invoke this in parallel). */
1299 for (i
= 0; i
< nr
; ++i
)
1302 char *input_name
= input_names
[i
];
1303 /* If it's a pass-through file do nothing. */
1304 if (output_names
[i
])
1307 /* Replace the .o suffix with a .ltrans.o suffix and write
1308 the resulting name to the LTRANS output list. */
1309 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1310 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1311 output_name
= XOBFINISH (&env_obstack
, char *);
1313 /* Adjust the dumpbase if the linker output file was seen. */
1317 = (char *) xmalloc (strlen (linker_output
)
1318 + sizeof (DUMPBASE_SUFFIX
) + 1);
1320 strlen (linker_output
) + sizeof (DUMPBASE_SUFFIX
),
1321 "%s.ltrans%u", linker_output
, i
);
1322 argv_ptr
[0] = dumpbase
;
1325 argv_ptr
[1] = "-fltrans";
1327 argv_ptr
[3] = output_name
;
1328 argv_ptr
[4] = input_name
;
1332 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1333 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1334 fprintf (mstream
, " '%s'", new_argv
[j
]);
1335 fprintf (mstream
, "\n");
1336 /* If we are not preserving the ltrans input files then
1337 truncate them as soon as we have processed it. This
1338 reduces temporary disk-space usage. */
1340 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1341 "&& mv %s.tem %s\n",
1342 input_name
, input_name
, input_name
, input_name
);
1346 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1348 maybe_unlink (input_name
);
1351 output_names
[i
] = output_name
;
1355 struct pex_obj
*pex
;
1358 fprintf (mstream
, "all:");
1359 for (i
= 0; i
< nr
; ++i
)
1360 fprintf (mstream
, " \\\n\t%s", output_names
[i
]);
1361 fprintf (mstream
, "\n");
1365 /* Avoid passing --jobserver-fd= and similar flags
1366 unless jobserver mode is explicitly enabled. */
1367 putenv (xstrdup ("MAKEFLAGS="));
1368 putenv (xstrdup ("MFLAGS="));
1370 new_argv
[0] = getenv ("MAKE");
1372 new_argv
[0] = "make";
1374 new_argv
[2] = makefile
;
1378 snprintf (jobs
, 31, "-j%d", parallel
);
1379 new_argv
[i
++] = jobs
;
1381 new_argv
[i
++] = "all";
1382 new_argv
[i
++] = NULL
;
1383 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1384 NULL
, NULL
, PEX_SEARCH
, false);
1385 do_wait (new_argv
[0], pex
);
1386 maybe_unlink (makefile
);
1388 for (i
= 0; i
< nr
; ++i
)
1389 maybe_unlink (input_names
[i
]);
1391 for (i
= 0; i
< nr
; ++i
)
1393 fputs (output_names
[i
], stdout
);
1394 putc ('\n', stdout
);
1395 free (input_names
[i
]);
1398 free (output_names
);
1400 free (list_option_full
);
1401 obstack_free (&env_obstack
, NULL
);
1406 printf ("%s\n", offloadend
);
1409 XDELETE (offload_argv
);
1410 obstack_free (&argv_obstack
, NULL
);
1417 main (int argc
, char *argv
[])
1421 init_opts_obstack ();
1423 p
= argv
[0] + strlen (argv
[0]);
1424 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
1428 xmalloc_set_program_name (progname
);
1430 gcc_init_libintl ();
1432 diagnostic_initialize (global_dc
, 0);
1434 if (atexit (lto_wrapper_cleanup
) != 0)
1435 fatal_error (input_location
, "atexit failed");
1437 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1438 signal (SIGINT
, fatal_signal
);
1440 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1441 signal (SIGHUP
, fatal_signal
);
1443 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
1444 signal (SIGTERM
, fatal_signal
);
1446 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
1447 signal (SIGPIPE
, fatal_signal
);
1450 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1451 receive the signal. A different setting is inheritable */
1452 signal (SIGCHLD
, SIG_DFL
);
1455 /* We may be called with all the arguments stored in some file and
1456 passed with @file. Expand them into argv before processing. */
1457 expandargv (&argc
, &argv
);
1459 run_gcc (argc
, argv
);