1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2020 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"
56 /* By default there is no special suffix for target executables. */
57 #ifdef TARGET_EXECUTABLE_SUFFIX
58 #define HAVE_TARGET_EXECUTABLE_SUFFIX
60 #define TARGET_EXECUTABLE_SUFFIX ""
64 LTO_MODE_NONE
, /* Not doing LTO. */
65 LTO_MODE_LTO
, /* Normal LTO. */
66 LTO_MODE_WHOPR
/* WHOPR. */
69 /* Current LTO mode. */
70 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
72 static char *ltrans_output_file
;
73 static char *flto_out
;
74 static unsigned int nr
;
75 static int *ltrans_priorities
;
76 static char **input_names
;
77 static char **output_names
;
78 static char **offload_names
;
79 static char *offload_objects_file_name
;
80 static char *makefile
;
81 static unsigned int num_deb_objs
;
82 static const char **early_debug_object_names
;
83 static bool xassembler_options_error
= false;
85 const char tool_name
[] = "lto-wrapper";
87 /* Delete tempfiles. Called from utils_cleanup. */
94 if (ltrans_output_file
)
95 maybe_unlink (ltrans_output_file
);
97 maybe_unlink (flto_out
);
98 if (offload_objects_file_name
)
99 maybe_unlink (offload_objects_file_name
);
101 maybe_unlink (makefile
);
102 if (early_debug_object_names
)
103 for (i
= 0; i
< num_deb_objs
; ++i
)
104 if (early_debug_object_names
[i
])
105 maybe_unlink (early_debug_object_names
[i
]);
106 for (i
= 0; i
< nr
; ++i
)
108 maybe_unlink (input_names
[i
]);
110 maybe_unlink (output_names
[i
]);
115 lto_wrapper_cleanup (void)
117 utils_cleanup (false);
120 /* Unlink a temporary LTRANS file unless requested otherwise. */
123 maybe_unlink (const char *file
)
127 if (unlink_if_ordinary (file
)
129 fatal_error (input_location
, "deleting LTRANS file %s: %m", file
);
132 fprintf (stderr
, "[Leaving LTRANS %s]\n", file
);
135 /* Template of LTRANS dumpbase suffix. */
136 #define DUMPBASE_SUFFIX "ltrans18446744073709551615"
138 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
142 get_options_from_collect_gcc_options (const char *collect_gcc
,
143 const char *collect_gcc_options
,
144 struct cl_decoded_option
**decoded_options
,
145 unsigned int *decoded_options_count
)
147 struct obstack argv_obstack
;
151 obstack_init (&argv_obstack
);
152 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
154 parse_options_from_collect_gcc_options (collect_gcc_options
,
155 &argv_obstack
, &argc
);
156 argv
= XOBFINISH (&argv_obstack
, const char **);
158 decode_cmdline_options_to_array (argc
, (const char **)argv
, CL_DRIVER
,
159 decoded_options
, decoded_options_count
);
160 obstack_free (&argv_obstack
, NULL
);
163 /* Append OPTION to the options array DECODED_OPTIONS with size
164 DECODED_OPTIONS_COUNT. */
167 append_option (struct cl_decoded_option
**decoded_options
,
168 unsigned int *decoded_options_count
,
169 struct cl_decoded_option
*option
)
171 ++*decoded_options_count
;
173 = (struct cl_decoded_option
*)
174 xrealloc (*decoded_options
,
175 (*decoded_options_count
176 * sizeof (struct cl_decoded_option
)));
177 memcpy (&(*decoded_options
)[*decoded_options_count
- 1], option
,
178 sizeof (struct cl_decoded_option
));
181 /* Remove option number INDEX from DECODED_OPTIONS, update
182 DECODED_OPTIONS_COUNT. */
185 remove_option (struct cl_decoded_option
**decoded_options
,
186 int index
, unsigned int *decoded_options_count
)
188 --*decoded_options_count
;
189 memmove (&(*decoded_options
)[index
+ 1],
190 &(*decoded_options
)[index
],
191 sizeof (struct cl_decoded_option
)
192 * (*decoded_options_count
- index
));
195 /* Try to merge and complain about options FDECODED_OPTIONS when applied
196 ontop of DECODED_OPTIONS. */
199 merge_and_complain (struct cl_decoded_option
**decoded_options
,
200 unsigned int *decoded_options_count
,
201 struct cl_decoded_option
*fdecoded_options
,
202 unsigned int fdecoded_options_count
)
205 struct cl_decoded_option
*pic_option
= NULL
;
206 struct cl_decoded_option
*pie_option
= NULL
;
208 /* ??? Merge options from files. Most cases can be
209 handled by either unioning or intersecting
210 (for example -fwrapv is a case for unioning,
211 -ffast-math is for intersection). Most complaints
212 about real conflicts between different options can
213 be deferred to the compiler proper. Options that
214 we can neither safely handle by intersection nor
215 unioning would need to be complained about here.
216 Ideally we'd have a flag in the opt files that
217 tells whether to union or intersect or reject.
218 In absence of that it's unclear what a good default is.
219 It's also difficult to get positional handling correct. */
221 /* The following does what the old LTO option code did,
222 union all target and a selected set of common options. */
223 for (i
= 0; i
< fdecoded_options_count
; ++i
)
225 struct cl_decoded_option
*foption
= &fdecoded_options
[i
];
226 switch (foption
->opt_index
)
228 case OPT_SPECIAL_unknown
:
229 case OPT_SPECIAL_ignore
:
230 case OPT_SPECIAL_warn_removed
:
231 case OPT_SPECIAL_program_name
:
232 case OPT_SPECIAL_input_file
:
236 if (!(cl_options
[foption
->opt_index
].flags
& CL_TARGET
))
240 case OPT_fdiagnostics_show_caret
:
241 case OPT_fdiagnostics_show_labels
:
242 case OPT_fdiagnostics_show_line_numbers
:
243 case OPT_fdiagnostics_show_option
:
244 case OPT_fdiagnostics_show_location_
:
245 case OPT_fshow_column
:
249 /* Do what the old LTO code did - collect exactly one option
250 setting per OPT code, we pick the first we encounter.
251 ??? This doesn't make too much sense, but when it doesn't
252 then we should complain. */
253 for (j
= 0; j
< *decoded_options_count
; ++j
)
254 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
256 if (j
== *decoded_options_count
)
257 append_option (decoded_options
, decoded_options_count
, foption
);
260 /* Figure out what PIC/PIE level wins and merge the results. */
263 pic_option
= foption
;
267 pie_option
= foption
;
272 /* For selected options we can merge conservatively. */
273 for (j
= 0; j
< *decoded_options_count
; ++j
)
274 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
276 if (j
== *decoded_options_count
)
277 append_option (decoded_options
, decoded_options_count
, foption
);
278 /* -fopenmp > -fno-openmp,
279 -fopenacc > -fno-openacc */
280 else if (foption
->value
> (*decoded_options
)[j
].value
)
281 (*decoded_options
)[j
] = *foption
;
284 case OPT_fopenacc_dim_
:
285 /* Append or check identical. */
286 for (j
= 0; j
< *decoded_options_count
; ++j
)
287 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
289 if (j
== *decoded_options_count
)
290 append_option (decoded_options
, decoded_options_count
, foption
);
291 else if (strcmp ((*decoded_options
)[j
].arg
, foption
->arg
))
292 fatal_error (input_location
,
293 "option %s with different values",
294 foption
->orig_option_with_args_text
);
301 for (j
= 0; j
< *decoded_options_count
; ++j
)
302 if ((*decoded_options
)[j
].opt_index
== OPT_O
303 || (*decoded_options
)[j
].opt_index
== OPT_Ofast
304 || (*decoded_options
)[j
].opt_index
== OPT_Og
305 || (*decoded_options
)[j
].opt_index
== OPT_Os
)
307 if (j
== *decoded_options_count
)
308 append_option (decoded_options
, decoded_options_count
, foption
);
309 else if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
310 && foption
->opt_index
!= OPT_O
)
311 /* Exact same options get merged. */
315 /* For mismatched option kinds preserve the optimization
316 level only, thus merge it as -On. This also handles
317 merging of same optimization level -On. */
319 switch (foption
->opt_index
)
322 if (foption
->arg
[0] == '\0')
323 level
= MAX (level
, 1);
325 level
= MAX (level
, atoi (foption
->arg
));
328 level
= MAX (level
, 3);
331 level
= MAX (level
, 1);
334 level
= MAX (level
, 2);
339 switch ((*decoded_options
)[j
].opt_index
)
342 if ((*decoded_options
)[j
].arg
[0] == '\0')
343 level
= MAX (level
, 1);
345 level
= MAX (level
, atoi ((*decoded_options
)[j
].arg
));
348 level
= MAX (level
, 3);
351 level
= MAX (level
, 1);
354 level
= MAX (level
, 2);
359 (*decoded_options
)[j
].opt_index
= OPT_O
;
361 tem
= xasprintf ("-O%d", level
);
362 (*decoded_options
)[j
].arg
= &tem
[2];
363 (*decoded_options
)[j
].canonical_option
[0] = tem
;
364 (*decoded_options
)[j
].value
= 1;
369 case OPT_foffload_abi_
:
370 for (j
= 0; j
< *decoded_options_count
; ++j
)
371 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
373 if (j
== *decoded_options_count
)
374 append_option (decoded_options
, decoded_options_count
, foption
);
375 else if (foption
->value
!= (*decoded_options
)[j
].value
)
376 fatal_error (input_location
,
377 "option %s not used consistently in all LTO input"
378 " files", foption
->orig_option_with_args_text
);
383 append_option (decoded_options
, decoded_options_count
, foption
);
388 /* Merge PIC options:
389 -fPIC + -fpic = -fpic
390 -fPIC + -fno-pic = -fno-pic
391 -fpic/-fPIC + nothing = nothing.
392 It is a common mistake to mix few -fPIC compiled objects into otherwise
393 non-PIC code. We do not want to build everything with PIC then.
395 Similarly we merge PIE options, however in addition we keep
396 -fPIC + -fPIE = -fPIE
397 -fpic + -fPIE = -fpie
398 -fPIC/-fpic + -fpie = -fpie
400 It would be good to warn on mismatches, but it is bit hard to do as
401 we do not know what nothing translates to. */
403 for (unsigned int j
= 0; j
< *decoded_options_count
;)
404 if ((*decoded_options
)[j
].opt_index
== OPT_fPIC
405 || (*decoded_options
)[j
].opt_index
== OPT_fpic
)
407 /* -fno-pic in one unit implies -fno-pic everywhere. */
408 if ((*decoded_options
)[j
].value
== 0)
410 /* If we have no pic option or merge in -fno-pic, we still may turn
411 existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */
412 else if ((pic_option
&& pic_option
->value
== 0)
417 bool big
= (*decoded_options
)[j
].opt_index
== OPT_fPIC
418 && pie_option
->opt_index
== OPT_fPIE
;
419 (*decoded_options
)[j
].opt_index
= big
? OPT_fPIE
: OPT_fpie
;
420 if (pie_option
->value
)
421 (*decoded_options
)[j
].canonical_option
[0]
422 = big
? "-fPIE" : "-fpie";
424 (*decoded_options
)[j
].canonical_option
[0] = "-fno-pie";
425 (*decoded_options
)[j
].value
= pie_option
->value
;
430 (*decoded_options
)[j
] = *pic_option
;
433 /* We do not know if target defaults to pic or not, so just remove
434 option if it is missing in one unit but enabled in other. */
436 remove_option (decoded_options
, j
, decoded_options_count
);
438 else if (pic_option
->opt_index
== OPT_fpic
439 && (*decoded_options
)[j
].opt_index
== OPT_fPIC
)
441 (*decoded_options
)[j
] = *pic_option
;
447 else if ((*decoded_options
)[j
].opt_index
== OPT_fPIE
448 || (*decoded_options
)[j
].opt_index
== OPT_fpie
)
450 /* -fno-pie in one unit implies -fno-pie everywhere. */
451 if ((*decoded_options
)[j
].value
== 0)
453 /* If we have no pie option or merge in -fno-pie, we still preserve
454 PIE/pie if pic/PIC is present. */
455 else if ((pie_option
&& pie_option
->value
== 0)
458 /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */
461 if (pic_option
->opt_index
== OPT_fpic
462 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
464 (*decoded_options
)[j
].opt_index
= OPT_fpie
;
465 (*decoded_options
)[j
].canonical_option
[0]
466 = pic_option
->value
? "-fpie" : "-fno-pie";
468 else if (!pic_option
->value
)
469 (*decoded_options
)[j
].canonical_option
[0] = "-fno-pie";
470 (*decoded_options
)[j
].value
= pic_option
->value
;
475 (*decoded_options
)[j
] = *pie_option
;
478 /* Because we always append pic/PIE options this code path should
479 not happen unless the LTO object was built by old lto1 which
480 did not contain that logic yet. */
482 remove_option (decoded_options
, j
, decoded_options_count
);
484 else if (pie_option
->opt_index
== OPT_fpie
485 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
487 (*decoded_options
)[j
] = *pie_option
;
496 if (!xassembler_options_error
)
497 for (i
= j
= 0; ; i
++, j
++)
499 for (; i
< *decoded_options_count
; i
++)
500 if ((*decoded_options
)[i
].opt_index
== OPT_Xassembler
)
503 for (; j
< fdecoded_options_count
; j
++)
504 if (fdecoded_options
[j
].opt_index
== OPT_Xassembler
)
507 if (i
== *decoded_options_count
&& j
== fdecoded_options_count
)
509 else if (i
< *decoded_options_count
&& j
== fdecoded_options_count
)
511 warning (0, "Extra option to -Xassembler: %s,"
512 " dropping all -Xassembler and -Wa options.",
513 (*decoded_options
)[i
].arg
);
514 xassembler_options_error
= true;
517 else if (i
== *decoded_options_count
&& j
< fdecoded_options_count
)
519 warning (0, "Extra option to -Xassembler: %s,"
520 " dropping all -Xassembler and -Wa options.",
521 fdecoded_options
[j
].arg
);
522 xassembler_options_error
= true;
525 else if (strcmp ((*decoded_options
)[i
].arg
, fdecoded_options
[j
].arg
))
527 warning (0, "Options to Xassembler do not match: %s, %s,"
528 " dropping all -Xassembler and -Wa options.",
529 (*decoded_options
)[i
].arg
, fdecoded_options
[j
].arg
);
530 xassembler_options_error
= true;
536 /* Auxiliary function that frees elements of PTR and PTR itself.
537 N is number of elements to be freed. If PTR is NULL, nothing is freed.
538 If an element is NULL, subsequent elements are not freed. */
541 free_array_of_ptrs (void **ptr
, unsigned n
)
545 for (unsigned i
= 0; i
< n
; i
++)
555 /* Parse STR, saving found tokens into PVALUES and return their number.
556 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
557 append it to every token we find. */
560 parse_env_var (const char *str
, char ***pvalues
, const char *append
)
562 const char *curval
, *nextval
;
566 curval
= strchr (str
, ':');
570 curval
= strchr (curval
+ 1, ':');
573 values
= (char**) xmalloc (num
* sizeof (char*));
575 nextval
= strchr (curval
, ':');
577 nextval
= strchr (curval
, '\0');
579 int append_len
= append
? strlen (append
) : 0;
580 for (i
= 0; i
< num
; i
++)
582 int l
= nextval
- curval
;
583 values
[i
] = (char*) xmalloc (l
+ 1 + append_len
);
584 memcpy (values
[i
], curval
, l
);
587 strcat (values
[i
], append
);
588 curval
= nextval
+ 1;
589 nextval
= strchr (curval
, ':');
591 nextval
= strchr (curval
, '\0');
597 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
600 append_compiler_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
603 /* Append compiler driver arguments as far as they were merged. */
604 for (unsigned int j
= 1; j
< count
; ++j
)
606 struct cl_decoded_option
*option
= &opts
[j
];
608 /* File options have been properly filtered by lto-opts.c. */
609 switch (option
->opt_index
)
611 /* Drop arguments that we want to take from the link line. */
614 case OPT_flto_partition_
:
621 /* For now do what the original LTO option code was doing - pass
622 on any CL_TARGET flag and a few selected others. */
623 switch (option
->opt_index
)
625 case OPT_fdiagnostics_show_caret
:
626 case OPT_fdiagnostics_show_labels
:
627 case OPT_fdiagnostics_show_line_numbers
:
628 case OPT_fdiagnostics_show_option
:
629 case OPT_fdiagnostics_show_location_
:
630 case OPT_fshow_column
:
639 case OPT_fopenacc_dim_
:
640 case OPT_foffload_abi_
:
649 /* When we detected a mismatch in assembler options between
650 the input TU's fall back to previous behavior of ignoring them. */
651 if (xassembler_options_error
)
656 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
660 /* Pass the option on. */
661 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
662 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
666 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
669 append_diag_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
672 /* Append compiler driver arguments as far as they were merged. */
673 for (unsigned int j
= 1; j
< count
; ++j
)
675 struct cl_decoded_option
*option
= &opts
[j
];
677 switch (option
->opt_index
)
679 case OPT_fdiagnostics_color_
:
680 case OPT_fdiagnostics_format_
:
681 case OPT_fdiagnostics_show_caret
:
682 case OPT_fdiagnostics_show_labels
:
683 case OPT_fdiagnostics_show_line_numbers
:
684 case OPT_fdiagnostics_show_option
:
685 case OPT_fdiagnostics_show_location_
:
686 case OPT_fshow_column
:
692 /* Pass the option on. */
693 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
694 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
699 /* Append linker options OPTS to ARGV_OBSTACK. */
702 append_linker_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
705 /* Append linker driver arguments. Compiler options from the linker
706 driver arguments will override / merge with those from the compiler. */
707 for (unsigned int j
= 1; j
< count
; ++j
)
709 struct cl_decoded_option
*option
= &opts
[j
];
711 /* Do not pass on frontend specific flags not suitable for lto. */
712 if (!(cl_options
[option
->opt_index
].flags
713 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
716 switch (option
->opt_index
)
721 /* We've handled these LTO options, do not pass them on. */
726 /* Ignore -fno-XXX form of these options, as otherwise
727 corresponding builtins will not be enabled. */
728 if (option
->value
== 0)
736 /* Pass the option on. */
737 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
738 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
742 /* Extract options for TARGET offload compiler from OPTIONS and append
743 them to ARGV_OBSTACK. */
746 append_offload_options (obstack
*argv_obstack
, const char *target
,
747 struct cl_decoded_option
*options
,
748 unsigned int options_count
)
750 for (unsigned i
= 0; i
< options_count
; i
++)
752 const char *cur
, *next
, *opts
;
755 struct cl_decoded_option
*option
= &options
[i
];
757 if (option
->opt_index
!= OPT_foffload_
)
760 /* If option argument starts with '-' then no target is specified. That
761 means offload options are specified for all targets, so we need to
763 if (option
->arg
[0] == '-')
767 opts
= strchr (option
->arg
, '=');
768 /* If there are offload targets specified, but no actual options,
769 there is nothing to do here. */
777 next
= strchr (cur
, ',');
780 next
= (next
> opts
) ? opts
: next
;
782 /* Are we looking for this offload target? */
783 if (strlen (target
) == (size_t) (next
- cur
)
784 && strncmp (target
, cur
, next
- cur
) == 0)
787 /* Skip the comma or equal sign. */
797 argv
= buildargv (opts
);
798 for (argc
= 0; argv
[argc
]; argc
++)
799 obstack_ptr_grow (argv_obstack
, argv
[argc
]);
803 /* Check whether NAME can be accessed in MODE. This is like access,
804 except that it never considers directories to be executable. */
807 access_check (const char *name
, int mode
)
813 if (stat (name
, &st
) < 0
814 || S_ISDIR (st
.st_mode
))
818 return access (name
, mode
);
821 /* Prepare a target image for offload TARGET, using mkoffload tool from
822 COMPILER_PATH. Return the name of the resultant object file. */
825 compile_offload_image (const char *target
, const char *compiler_path
,
826 unsigned in_argc
, char *in_argv
[],
827 struct cl_decoded_option
*compiler_opts
,
828 unsigned int compiler_opt_count
,
829 struct cl_decoded_option
*linker_opts
,
830 unsigned int linker_opt_count
)
832 char *filename
= NULL
;
835 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target
));
836 strcpy (suffix
, "/accel/");
837 strcat (suffix
, target
);
838 strcat (suffix
, "/mkoffload");
841 unsigned n_paths
= parse_env_var (compiler_path
, &paths
, suffix
);
843 const char *compiler
= NULL
;
844 for (unsigned i
= 0; i
< n_paths
; i
++)
845 if (access_check (paths
[i
], X_OK
) == 0)
852 fatal_error (input_location
,
853 "could not find %s in %s (consider using %<-B%>)",
854 suffix
+ 1, compiler_path
);
856 /* Generate temporary output file name. */
857 filename
= make_temp_file (".target.o");
859 struct obstack argv_obstack
;
860 obstack_init (&argv_obstack
);
861 obstack_ptr_grow (&argv_obstack
, compiler
);
863 obstack_ptr_grow (&argv_obstack
, "-save-temps");
865 obstack_ptr_grow (&argv_obstack
, "-v");
866 obstack_ptr_grow (&argv_obstack
, "-o");
867 obstack_ptr_grow (&argv_obstack
, filename
);
869 /* Append names of input object files. */
870 for (unsigned i
= 0; i
< in_argc
; i
++)
871 obstack_ptr_grow (&argv_obstack
, in_argv
[i
]);
873 /* Append options from offload_lto sections. */
874 append_compiler_options (&argv_obstack
, compiler_opts
,
876 append_diag_options (&argv_obstack
, linker_opts
, linker_opt_count
);
878 /* Append options specified by -foffload last. In case of conflicting
879 options we expect offload compiler to choose the latest. */
880 append_offload_options (&argv_obstack
, target
, compiler_opts
,
882 append_offload_options (&argv_obstack
, target
, linker_opts
,
885 obstack_ptr_grow (&argv_obstack
, NULL
);
886 argv
= XOBFINISH (&argv_obstack
, char **);
887 fork_execute (argv
[0], argv
, true);
888 obstack_free (&argv_obstack
, NULL
);
890 free_array_of_ptrs ((void **) paths
, n_paths
);
895 /* The main routine dealing with offloading.
896 The routine builds a target image for each offload target. IN_ARGC and
897 IN_ARGV specify options and input object files. As all of them could contain
898 target sections, we pass them all to target compilers. */
901 compile_images_for_offload_targets (unsigned in_argc
, char *in_argv
[],
902 struct cl_decoded_option
*compiler_opts
,
903 unsigned int compiler_opt_count
,
904 struct cl_decoded_option
*linker_opts
,
905 unsigned int linker_opt_count
)
908 const char *target_names
= getenv (OFFLOAD_TARGET_NAMES_ENV
);
911 unsigned num_targets
= parse_env_var (target_names
, &names
, NULL
);
913 int next_name_entry
= 0;
914 const char *compiler_path
= getenv ("COMPILER_PATH");
918 /* Prepare an image for each target and save the name of the resultant object
919 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
920 offload_names
= XCNEWVEC (char *, num_targets
+ 1);
921 for (unsigned i
= 0; i
< num_targets
; i
++)
923 /* HSA does not use LTO-like streaming and a different compiler, skip
925 if (strcmp (names
[i
], "hsa") == 0)
928 offload_names
[next_name_entry
]
929 = compile_offload_image (names
[i
], compiler_path
, in_argc
, in_argv
,
930 compiler_opts
, compiler_opt_count
,
931 linker_opts
, linker_opt_count
);
932 if (!offload_names
[next_name_entry
])
933 fatal_error (input_location
,
934 "problem with building target image for %s", names
[i
]);
939 free_array_of_ptrs ((void **) names
, num_targets
);
942 /* Copy a file from SRC to DEST. */
945 copy_file (const char *dest
, const char *src
)
947 FILE *d
= fopen (dest
, "wb");
948 FILE *s
= fopen (src
, "rb");
952 size_t len
= fread (buffer
, 1, 512, s
);
954 fatal_error (input_location
, "reading input file");
957 fwrite (buffer
, 1, len
, d
);
959 fatal_error (input_location
, "writing output file");
966 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
967 the copy to the linker. */
970 find_crtoffloadtable (void)
973 const char *library_path
= getenv ("LIBRARY_PATH");
976 unsigned n_paths
= parse_env_var (library_path
, &paths
, "/crtoffloadtable.o");
979 for (i
= 0; i
< n_paths
; i
++)
980 if (access_check (paths
[i
], R_OK
) == 0)
982 /* The linker will delete the filename we give it, so make a copy. */
983 char *crtoffloadtable
= make_temp_file (".crtoffloadtable.o");
984 copy_file (crtoffloadtable
, paths
[i
]);
985 printf ("%s\n", crtoffloadtable
);
986 XDELETEVEC (crtoffloadtable
);
990 fatal_error (input_location
,
991 "installation error, cannot find %<crtoffloadtable.o%>");
993 free_array_of_ptrs ((void **) paths
, n_paths
);
996 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
997 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
998 and OPT_COUNT. Return true if we found a matchingn section, false
999 otherwise. COLLECT_GCC holds the value of the environment variable with
1003 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
1004 struct cl_decoded_option
**opts
,
1005 unsigned int *opt_count
, const char *collect_gcc
)
1007 off_t offset
, length
;
1012 struct cl_decoded_option
*fdecoded_options
= *opts
;
1013 unsigned int fdecoded_options_count
= *opt_count
;
1015 simple_object_read
*sobj
;
1016 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
1021 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
1022 strcpy (secname
, prefix
);
1023 strcat (secname
, ".opts");
1024 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
1027 simple_object_release_read (sobj
);
1031 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
1032 data
= (char *)xmalloc (length
);
1033 read (fd
, data
, length
);
1037 struct cl_decoded_option
*f2decoded_options
;
1038 unsigned int f2decoded_options_count
;
1039 get_options_from_collect_gcc_options (collect_gcc
, fopts
,
1041 &f2decoded_options_count
);
1042 if (!fdecoded_options
)
1044 fdecoded_options
= f2decoded_options
;
1045 fdecoded_options_count
= f2decoded_options_count
;
1048 merge_and_complain (&fdecoded_options
,
1049 &fdecoded_options_count
,
1050 f2decoded_options
, f2decoded_options_count
);
1052 fopts
+= strlen (fopts
) + 1;
1054 while (fopts
- data
< length
);
1057 simple_object_release_read (sobj
);
1058 *opts
= fdecoded_options
;
1059 *opt_count
= fdecoded_options_count
;
1063 /* Copy early debug info sections from INFILE to a new file whose name
1064 is returned. Return NULL on error. */
1067 debug_objcopy (const char *infile
, bool rename
)
1074 const char *orig_infile
= infile
;
1078 if ((p
= strrchr (infile
, '@'))
1080 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1081 && strlen (p
) == (unsigned int) consumed
)
1083 char *fname
= xstrdup (infile
);
1084 fname
[p
- infile
] = '\0';
1086 inoff
= (off_t
) loffset
;
1088 int infd
= open (infile
, O_RDONLY
| O_BINARY
);
1091 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
1098 if (simple_object_find_section (inobj
, ".gnu.debuglto_.debug_info",
1099 &off
, &len
, &errmsg
, &err
) != 1)
1102 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1104 simple_object_release_read (inobj
);
1110 outfile
= concat (orig_infile
, ".debug.temp.o", NULL
);
1112 outfile
= make_temp_file (".debug.temp.o");
1113 errmsg
= simple_object_copy_lto_debug_sections (inobj
, outfile
, &err
, rename
);
1116 unlink_if_ordinary (outfile
);
1117 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1120 simple_object_release_read (inobj
);
1126 /* Helper for qsort: compare priorities for parallel compilation. */
1129 cmp_priority (const void *a
, const void *b
)
1131 return *((const int *)b
)-*((const int *)a
);
1134 /* Number of CPUs that can be used for parallel LTRANS phase. */
1136 static unsigned long nthreads_var
= 0;
1138 #ifdef HAVE_PTHREAD_AFFINITY_NP
1139 unsigned long cpuset_size
;
1140 static unsigned long get_cpuset_size
;
1144 static cpuset_popcount (unsigned long cpusetsize
, cpu_set_t
*cpusetp
)
1147 /* glibc 2.7 and above provide a macro for this. */
1148 return CPU_COUNT_S (cpusetsize
, cpusetp
);
1151 if (cpusetsize
== sizeof (cpu_set_t
))
1152 /* glibc 2.6 and above provide a macro for this. */
1153 return CPU_COUNT (cpusetp
);
1156 unsigned long ret
= 0;
1157 STATIC_ASSERT (sizeof (cpusetp
->__bits
[0]) == sizeof (unsigned long int));
1158 for (i
= 0; i
< cpusetsize
/ sizeof (cpusetp
->__bits
[0]); i
++)
1160 unsigned long int mask
= cpusetp
->__bits
[i
];
1163 ret
+= __builtin_popcountl (mask
);
1170 /* At startup, determine the default number of threads. It would seem
1171 this should be related to the number of cpus online. */
1174 init_num_threads (void)
1176 #ifdef HAVE_PTHREAD_AFFINITY_NP
1177 #if defined (_SC_NPROCESSORS_CONF) && defined (CPU_ALLOC_SIZE)
1178 cpuset_size
= sysconf (_SC_NPROCESSORS_CONF
);
1179 cpuset_size
= CPU_ALLOC_SIZE (cpuset_size
);
1181 cpuset_size
= sizeof (cpu_set_t
);
1184 cpusetp
= (cpu_set_t
*) xmalloc (gomp_cpuset_size
);
1187 int ret
= pthread_getaffinity_np (pthread_self (), gomp_cpuset_size
,
1191 /* Count only the CPUs this process can use. */
1192 nthreads_var
= cpuset_popcount (cpuset_size
, cpusetp
);
1193 if (nthreads_var
== 0)
1195 get_cpuset_size
= cpuset_size
;
1196 #ifdef CPU_ALLOC_SIZE
1198 for (i
= cpuset_size
* 8; i
; i
--)
1199 if (CPU_ISSET_S (i
- 1, cpuset_size
, cpusetp
))
1201 cpuset_size
= CPU_ALLOC_SIZE (i
);
1207 #ifdef CPU_ALLOC_SIZE
1208 if (cpuset_size
< sizeof (cpu_set_t
))
1209 cpuset_size
= sizeof (cpu_set_t
);
1211 cpuset_size
= cpuset_size
* 2;
1212 if (cpuset_size
< 8 * sizeof (cpu_set_t
))
1214 = (cpu_set_t
*) realloc (cpusetp
, cpuset_size
);
1217 /* Avoid fatal if too large memory allocation would be
1218 requested, e.g. kernel returning EINVAL all the time. */
1219 void *p
= realloc (cpusetp
, cpuset_size
);
1222 cpusetp
= (cpu_set_t
*) p
;
1234 #ifdef _SC_NPROCESSORS_ONLN
1235 nthreads_var
= sysconf (_SC_NPROCESSORS_ONLN
);
1239 /* FIXME: once using -std=c++11, we can use std::thread::hardware_concurrency. */
1241 /* Test and return reason why a jobserver cannot be detected. */
1244 jobserver_active_p (void)
1246 #define JS_PREFIX "jobserver is not available: "
1247 #define JS_NEEDLE "--jobserver-auth="
1249 const char *makeflags
= getenv ("MAKEFLAGS");
1250 if (makeflags
== NULL
)
1251 return JS_PREFIX
"%<MAKEFLAGS%> environment variable is unset";
1253 const char *n
= strstr (makeflags
, JS_NEEDLE
);
1255 return JS_PREFIX
"%<" JS_NEEDLE
"%> is not present in %<MAKEFLAGS%>";
1260 if (sscanf (n
+ strlen (JS_NEEDLE
), "%d,%d", &rfd
, &wfd
) == 2
1263 && is_valid_fd (rfd
)
1264 && is_valid_fd (wfd
))
1267 return JS_PREFIX
"cannot access %<" JS_NEEDLE
"%> file descriptors";
1270 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1273 run_gcc (unsigned argc
, char *argv
[])
1276 const char **new_argv
;
1277 const char **argv_ptr
;
1278 char *list_option_full
= NULL
;
1279 const char *linker_output
= NULL
;
1280 const char *collect_gcc
;
1281 char *collect_gcc_options
;
1284 int auto_parallel
= 0;
1285 bool no_partition
= false;
1286 struct cl_decoded_option
*fdecoded_options
= NULL
;
1287 struct cl_decoded_option
*offload_fdecoded_options
= NULL
;
1288 unsigned int fdecoded_options_count
= 0;
1289 unsigned int offload_fdecoded_options_count
= 0;
1290 struct cl_decoded_option
*decoded_options
;
1291 unsigned int decoded_options_count
;
1292 struct obstack argv_obstack
;
1294 bool have_lto
= false;
1295 bool have_offload
= false;
1296 unsigned lto_argc
= 0, ltoobj_argc
= 0;
1297 char **lto_argv
, **ltoobj_argv
;
1298 bool linker_output_rel
= false;
1299 bool skip_debug
= false;
1300 unsigned n_debugobj
;
1301 const char *dumppfx
= NULL
, *incoming_dumppfx
= NULL
;
1302 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1304 /* Get the driver and options. */
1305 collect_gcc
= getenv ("COLLECT_GCC");
1307 fatal_error (input_location
,
1308 "environment variable %<COLLECT_GCC%> must be set");
1309 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1310 if (!collect_gcc_options
)
1311 fatal_error (input_location
,
1312 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1314 char *collect_as_options
= getenv ("COLLECT_AS_OPTIONS");
1316 /* Prepend -Xassembler to each option, and append the string
1317 to collect_gcc_options. */
1318 if (collect_as_options
)
1320 obstack temporary_obstack
;
1321 obstack_init (&temporary_obstack
);
1323 prepend_xassembler_to_collect_as_options (collect_as_options
,
1324 &temporary_obstack
);
1325 obstack_1grow (&temporary_obstack
, '\0');
1327 char *xassembler_opts_string
1328 = XOBFINISH (&temporary_obstack
, char *);
1329 collect_gcc_options
= concat (collect_gcc_options
, xassembler_opts_string
,
1333 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
1335 &decoded_options_count
);
1337 /* Allocate array for input object files with LTO IL,
1338 and for possible preceding arguments. */
1339 lto_argv
= XNEWVEC (char *, argc
);
1340 ltoobj_argv
= XNEWVEC (char *, argc
);
1342 /* Look at saved options in the IL files. */
1343 for (i
= 1; i
< argc
; ++i
)
1347 off_t file_offset
= 0;
1350 char *filename
= argv
[i
];
1352 if (strncmp (argv
[i
], "-foffload-objects=",
1353 sizeof ("-foffload-objects=") - 1) == 0)
1355 have_offload
= true;
1356 offload_objects_file_name
1357 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1361 if ((p
= strrchr (argv
[i
], '@'))
1363 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1364 && strlen (p
) == (unsigned int) consumed
)
1366 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1367 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1368 filename
[p
- argv
[i
]] = '\0';
1369 file_offset
= (off_t
) loffset
;
1371 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1372 /* Linker plugin passes -fresolution and -flinker-output options.
1373 -flinker-output is passed only when user did not specify one and thus
1374 we do not need to worry about duplicities with the option handling
1378 lto_argv
[lto_argc
++] = argv
[i
];
1379 if (strcmp (argv
[i
], "-flinker-output=rel") == 0)
1380 linker_output_rel
= true;
1384 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1385 &fdecoded_options
, &fdecoded_options_count
,
1389 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1394 /* Initalize the common arguments for the driver. */
1395 obstack_init (&argv_obstack
);
1396 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1397 obstack_ptr_grow (&argv_obstack
, "-xlto");
1398 obstack_ptr_grow (&argv_obstack
, "-c");
1400 append_compiler_options (&argv_obstack
, fdecoded_options
,
1401 fdecoded_options_count
);
1402 append_linker_options (&argv_obstack
, decoded_options
, decoded_options_count
);
1404 /* Scan linker driver arguments for things that are of relevance to us. */
1405 for (j
= 1; j
< decoded_options_count
; ++j
)
1407 struct cl_decoded_option
*option
= &decoded_options
[j
];
1408 switch (option
->opt_index
)
1411 linker_output
= option
->arg
;
1414 /* We don't have to distinguish between -save-temps=* and
1415 -save-temps, -dumpdir already carries that
1417 case OPT_save_temps_
:
1418 case OPT_save_temps
:
1426 case OPT_flto_partition_
:
1427 if (strcmp (option
->arg
, "none") == 0)
1428 no_partition
= true;
1432 if (strcmp (option
->arg
, "jobserver") == 0)
1437 else if (strcmp (option
->arg
, "auto") == 0)
1444 parallel
= atoi (option
->arg
);
1451 lto_mode
= LTO_MODE_WHOPR
;
1454 case OPT_flinker_output_
:
1455 linker_output_rel
= !strcmp (option
->arg
, "rel");
1459 /* Recognize -g0. */
1460 skip_debug
= option
->arg
&& !strcmp (option
->arg
, "0");
1464 incoming_dumppfx
= dumppfx
= option
->arg
;
1472 /* Output lto-wrapper invocation command. */
1475 for (i
= 0; i
< argc
; ++i
)
1477 fputs (argv
[i
], stderr
);
1478 fputc (' ', stderr
);
1480 fputc ('\n', stderr
);
1483 if (linker_output_rel
)
1484 no_partition
= true;
1488 lto_mode
= LTO_MODE_LTO
;
1495 const char *jobserver_error
= jobserver_active_p ();
1496 if (jobserver
&& jobserver_error
!= NULL
)
1497 warning (0, jobserver_error
);
1498 else if (!jobserver
&& jobserver_error
== NULL
)
1508 || strcmp (linker_output
, HOST_BIT_BUCKET
) == 0)
1512 const char *obase
= lbasename (linker_output
), *temp
;
1514 /* Strip the executable extension. */
1515 size_t blen
= strlen (obase
), xlen
;
1516 if ((temp
= strrchr (obase
+ 1, '.'))
1517 && (xlen
= strlen (temp
))
1518 && (strcmp (temp
, ".exe") == 0
1519 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
1520 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
1522 || strcmp (obase
, "a.out") == 0))
1523 dumppfx
= xstrndup (linker_output
,
1524 obase
- linker_output
+ blen
- xlen
+ 1);
1526 dumppfx
= concat (linker_output
, ".", NULL
);
1530 /* If there's no directory component in the dumppfx, add one, so
1531 that, when it is used as -dumpbase, it overrides any occurrence
1532 of -dumpdir that might have been passed in. */
1533 if (!dumppfx
|| lbasename (dumppfx
) == dumppfx
)
1534 dumppfx
= concat (current_dir
, dumppfx
, NULL
);
1536 /* Make sure some -dumpdir is passed, so as to get predictable
1537 -dumpbase overriding semantics. If we got an incoming -dumpdir
1538 argument, we'll pass it on, so don't bother with another one
1540 if (!incoming_dumppfx
)
1542 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1543 obstack_ptr_grow (&argv_obstack
, "");
1545 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1547 /* Remember at which point we can scrub args to re-use the commons. */
1548 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1552 unsigned i
, num_offload_files
;
1553 char **offload_argv
;
1556 f
= fopen (offload_objects_file_name
, "r");
1558 fatal_error (input_location
, "cannot open %s: %m",
1559 offload_objects_file_name
);
1560 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1561 fatal_error (input_location
, "cannot read %s: %m",
1562 offload_objects_file_name
);
1563 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1565 /* Read names of object files with offload. */
1566 for (i
= 0; i
< num_offload_files
; i
++)
1568 const unsigned piece
= 32;
1569 char *buf
, *filename
= XNEWVEC (char, piece
);
1574 if (!fgets (buf
, piece
, f
))
1576 len
= strlen (filename
);
1577 if (filename
[len
- 1] != '\n')
1579 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1580 buf
= filename
+ len
;
1583 filename
[len
- 1] = '\0';
1584 offload_argv
[i
] = filename
;
1587 if (offload_argv
[num_offload_files
- 1] == NULL
)
1588 fatal_error (input_location
, "invalid format of %s",
1589 offload_objects_file_name
);
1590 maybe_unlink (offload_objects_file_name
);
1591 offload_objects_file_name
= NULL
;
1593 /* Look at saved offload options in files. */
1594 for (i
= 0; i
< num_offload_files
; i
++)
1599 off_t file_offset
= 0;
1600 char *filename
= offload_argv
[i
];
1602 if ((p
= strrchr (offload_argv
[i
], '@'))
1603 && p
!= offload_argv
[i
]
1604 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1605 && strlen (p
) == (unsigned int) consumed
)
1607 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1608 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1609 filename
[p
- offload_argv
[i
]] = '\0';
1610 file_offset
= (off_t
) loffset
;
1612 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1614 fatal_error (input_location
, "cannot open %s: %m", filename
);
1615 if (!find_and_merge_options (fd
, file_offset
,
1616 OFFLOAD_SECTION_NAME_PREFIX
,
1617 &offload_fdecoded_options
,
1618 &offload_fdecoded_options_count
,
1620 fatal_error (input_location
, "cannot read %s: %m", filename
);
1622 if (filename
!= offload_argv
[i
])
1623 XDELETEVEC (filename
);
1626 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1627 offload_fdecoded_options
,
1628 offload_fdecoded_options_count
,
1630 decoded_options_count
);
1632 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1636 find_crtoffloadtable ();
1637 for (i
= 0; offload_names
[i
]; i
++)
1638 printf ("%s\n", offload_names
[i
]);
1639 free_array_of_ptrs ((void **) offload_names
, i
);
1643 /* If object files contain offload sections, but do not contain LTO sections,
1644 then there is no need to perform a link-time recompilation, i.e.
1645 lto-wrapper is used only for a compilation of offload images. */
1646 if (have_offload
&& !have_lto
)
1649 if (lto_mode
== LTO_MODE_LTO
)
1651 /* -dumpbase argument for LTO. */
1652 flto_out
= concat (dumppfx
, "lto.o", NULL
);
1653 obstack_ptr_grow (&argv_obstack
, flto_out
);
1656 flto_out
= make_temp_file (".lto.o");
1657 obstack_ptr_grow (&argv_obstack
, "-o");
1658 obstack_ptr_grow (&argv_obstack
, flto_out
);
1662 const char *list_option
= "-fltrans-output-list=";
1664 /* -dumpbase argument for WPA. */
1665 char *dumpbase
= concat (dumppfx
, "wpa", NULL
);
1666 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1669 ltrans_output_file
= concat (dumppfx
, "ltrans.out", NULL
);
1671 ltrans_output_file
= make_temp_file (".ltrans.out");
1672 list_option_full
= concat (list_option
, ltrans_output_file
, NULL
);
1673 obstack_ptr_grow (&argv_obstack
, list_option_full
);
1678 fprintf (stderr
, "Using make jobserver\n");
1679 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1681 else if (auto_parallel
)
1684 init_num_threads ();
1686 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1688 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1689 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1691 else if (parallel
> 1)
1694 sprintf (buf
, "-fwpa=%i", parallel
);
1695 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1698 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1701 /* Append input arguments. */
1702 for (i
= 0; i
< lto_argc
; ++i
)
1703 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1704 /* Append the input objects. */
1705 for (i
= 0; i
< ltoobj_argc
; ++i
)
1706 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1707 obstack_ptr_grow (&argv_obstack
, NULL
);
1709 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1710 argv_ptr
= &new_argv
[new_head_argc
];
1711 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true);
1713 /* Copy the early generated debug info from the objects to temporary
1714 files and append those to the partial link commandline. */
1716 early_debug_object_names
= NULL
;
1719 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1720 num_deb_objs
= ltoobj_argc
;
1721 for (i
= 0; i
< ltoobj_argc
; ++i
)
1724 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1726 early_debug_object_names
[i
] = tem
;
1732 if (lto_mode
== LTO_MODE_LTO
)
1734 printf ("%s\n", flto_out
);
1737 for (i
= 0; i
< ltoobj_argc
; ++i
)
1738 if (early_debug_object_names
[i
] != NULL
)
1739 printf ("%s\n", early_debug_object_names
[i
]);
1741 /* These now belong to collect2. */
1744 free (early_debug_object_names
);
1745 early_debug_object_names
= NULL
;
1749 FILE *stream
= fopen (ltrans_output_file
, "r");
1750 FILE *mstream
= NULL
;
1751 struct obstack env_obstack
;
1755 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1757 /* Parse the list of LTRANS inputs from the WPA stage. */
1758 obstack_init (&env_obstack
);
1762 const unsigned piece
= 32;
1763 char *output_name
= NULL
;
1764 char *buf
, *input_name
= (char *)xmalloc (piece
);
1768 if (fscanf (stream
, "%i\n", &priority
) != 1)
1771 fatal_error (input_location
,
1772 "corrupted ltrans output file %s",
1773 ltrans_output_file
);
1777 if (!fgets (buf
, piece
, stream
))
1779 len
= strlen (input_name
);
1780 if (input_name
[len
- 1] != '\n')
1782 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1783 buf
= input_name
+ len
;
1786 input_name
[len
- 1] = '\0';
1788 if (input_name
[0] == '*')
1789 output_name
= &input_name
[1];
1793 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1794 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1795 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1796 ltrans_priorities
[(nr
-1)*2] = priority
;
1797 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1798 input_names
[nr
-1] = input_name
;
1799 output_names
[nr
-1] = output_name
;
1802 maybe_unlink (ltrans_output_file
);
1803 ltrans_output_file
= NULL
;
1807 makefile
= make_temp_file (".mk");
1808 mstream
= fopen (makefile
, "w");
1809 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1812 /* Execute the LTRANS stage for each input file (or prepare a
1813 makefile to invoke this in parallel). */
1814 for (i
= 0; i
< nr
; ++i
)
1817 char *input_name
= input_names
[i
];
1818 /* If it's a pass-through file do nothing. */
1819 if (output_names
[i
])
1822 /* Replace the .o suffix with a .ltrans.o suffix and write
1823 the resulting name to the LTRANS output list. */
1824 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1825 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1826 output_name
= XOBFINISH (&env_obstack
, char *);
1828 /* Adjust the dumpbase if the linker output file was seen. */
1829 int dumpbase_len
= (strlen (dumppfx
) + sizeof (DUMPBASE_SUFFIX
));
1830 char *dumpbase
= (char *) xmalloc (dumpbase_len
+ 1);
1831 snprintf (dumpbase
, dumpbase_len
, "%sltrans%u.ltrans", dumppfx
, i
);
1832 argv_ptr
[0] = dumpbase
;
1834 argv_ptr
[1] = "-fltrans";
1836 argv_ptr
[3] = output_name
;
1837 argv_ptr
[4] = input_name
;
1841 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1842 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1843 fprintf (mstream
, " '%s'", new_argv
[j
]);
1844 fprintf (mstream
, "\n");
1845 /* If we are not preserving the ltrans input files then
1846 truncate them as soon as we have processed it. This
1847 reduces temporary disk-space usage. */
1849 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1850 "&& mv %s.tem %s\n",
1851 input_name
, input_name
, input_name
, input_name
);
1855 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1857 maybe_unlink (input_name
);
1860 output_names
[i
] = output_name
;
1864 struct pex_obj
*pex
;
1870 for (i
= 0; i
< nr
; ++i
)
1872 int j
= ltrans_priorities
[i
*2 + 1];
1873 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1875 fprintf (mstream
, "\n");
1879 /* Avoid passing --jobserver-fd= and similar flags
1880 unless jobserver mode is explicitly enabled. */
1881 putenv (xstrdup ("MAKEFLAGS="));
1882 putenv (xstrdup ("MFLAGS="));
1885 char **make_argv
= buildargv (getenv ("MAKE"));
1888 for (unsigned argc
= 0; make_argv
[argc
]; argc
++)
1889 obstack_ptr_grow (&argv_obstack
, make_argv
[argc
]);
1892 obstack_ptr_grow (&argv_obstack
, "make");
1894 obstack_ptr_grow (&argv_obstack
, "-f");
1895 obstack_ptr_grow (&argv_obstack
, makefile
);
1898 snprintf (jobs
, 31, "-j%ld",
1899 auto_parallel
? nthreads_var
: parallel
);
1900 obstack_ptr_grow (&argv_obstack
, jobs
);
1902 obstack_ptr_grow (&argv_obstack
, "all");
1903 obstack_ptr_grow (&argv_obstack
, NULL
);
1904 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1906 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1907 NULL
, NULL
, PEX_SEARCH
, false);
1908 do_wait (new_argv
[0], pex
);
1909 freeargv (make_argv
);
1910 maybe_unlink (makefile
);
1912 for (i
= 0; i
< nr
; ++i
)
1913 maybe_unlink (input_names
[i
]);
1915 for (i
= 0; i
< nr
; ++i
)
1917 fputs (output_names
[i
], stdout
);
1918 putc ('\n', stdout
);
1919 free (input_names
[i
]);
1923 for (i
= 0; i
< ltoobj_argc
; ++i
)
1924 if (early_debug_object_names
[i
] != NULL
)
1925 printf ("%s\n", early_debug_object_names
[i
]);
1928 free (ltrans_priorities
);
1929 free (output_names
);
1930 output_names
= NULL
;
1931 free (early_debug_object_names
);
1932 early_debug_object_names
= NULL
;
1934 free (list_option_full
);
1935 obstack_free (&env_obstack
, NULL
);
1940 obstack_free (&argv_obstack
, NULL
);
1947 main (int argc
, char *argv
[])
1951 init_opts_obstack ();
1953 p
= argv
[0] + strlen (argv
[0]);
1954 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
1958 xmalloc_set_program_name (progname
);
1960 gcc_init_libintl ();
1962 diagnostic_initialize (global_dc
, 0);
1964 if (atexit (lto_wrapper_cleanup
) != 0)
1965 fatal_error (input_location
, "%<atexit%> failed");
1967 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1968 signal (SIGINT
, fatal_signal
);
1970 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1971 signal (SIGHUP
, fatal_signal
);
1973 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
1974 signal (SIGTERM
, fatal_signal
);
1976 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
1977 signal (SIGPIPE
, fatal_signal
);
1980 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1981 receive the signal. A different setting is inheritable */
1982 signal (SIGCHLD
, SIG_DFL
);
1985 /* We may be called with all the arguments stored in some file and
1986 passed with @file. Expand them into argv before processing. */
1987 expandargv (&argc
, &argv
);
1989 run_gcc (argc
, argv
);