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
,
203 struct cl_decoded_option
*decoded_cl_options
,
204 unsigned int decoded_cl_options_count
)
207 struct cl_decoded_option
*pic_option
= NULL
;
208 struct cl_decoded_option
*pie_option
= NULL
;
209 struct cl_decoded_option
*cf_protection_option
= NULL
;
211 /* ??? Merge options from files. Most cases can be
212 handled by either unioning or intersecting
213 (for example -fwrapv is a case for unioning,
214 -ffast-math is for intersection). Most complaints
215 about real conflicts between different options can
216 be deferred to the compiler proper. Options that
217 we can neither safely handle by intersection nor
218 unioning would need to be complained about here.
219 Ideally we'd have a flag in the opt files that
220 tells whether to union or intersect or reject.
221 In absence of that it's unclear what a good default is.
222 It's also difficult to get positional handling correct. */
224 /* Look for a -fcf-protection option in the link-time options
225 which overrides any -fcf-protection from the lto sections. */
226 for (i
= 0; i
< decoded_cl_options_count
; ++i
)
228 struct cl_decoded_option
*foption
= &decoded_cl_options
[i
];
229 if (foption
->opt_index
== OPT_fcf_protection_
)
231 cf_protection_option
= foption
;
235 /* The following does what the old LTO option code did,
236 union all target and a selected set of common options. */
237 for (i
= 0; i
< fdecoded_options_count
; ++i
)
239 struct cl_decoded_option
*foption
= &fdecoded_options
[i
];
240 switch (foption
->opt_index
)
242 case OPT_SPECIAL_unknown
:
243 case OPT_SPECIAL_ignore
:
244 case OPT_SPECIAL_warn_removed
:
245 case OPT_SPECIAL_program_name
:
246 case OPT_SPECIAL_input_file
:
250 if (!(cl_options
[foption
->opt_index
].flags
& CL_TARGET
))
254 case OPT_fdiagnostics_show_caret
:
255 case OPT_fdiagnostics_show_labels
:
256 case OPT_fdiagnostics_show_line_numbers
:
257 case OPT_fdiagnostics_show_option
:
258 case OPT_fdiagnostics_show_location_
:
259 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 /* For selected options we can merge conservatively. */
287 for (j
= 0; j
< *decoded_options_count
; ++j
)
288 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
290 if (j
== *decoded_options_count
)
291 append_option (decoded_options
, decoded_options_count
, foption
);
292 /* -fopenmp > -fno-openmp,
293 -fopenacc > -fno-openacc */
294 else if (foption
->value
> (*decoded_options
)[j
].value
)
295 (*decoded_options
)[j
] = *foption
;
298 case OPT_fopenacc_dim_
:
299 /* Append or check identical. */
300 for (j
= 0; j
< *decoded_options_count
; ++j
)
301 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
303 if (j
== *decoded_options_count
)
304 append_option (decoded_options
, decoded_options_count
, foption
);
305 else if (strcmp ((*decoded_options
)[j
].arg
, foption
->arg
))
306 fatal_error (input_location
,
307 "option %s with different values",
308 foption
->orig_option_with_args_text
);
311 case OPT_fcf_protection_
:
312 /* Default to link-time option, else append or check identical. */
313 if (!cf_protection_option
314 || cf_protection_option
->value
== CF_CHECK
)
316 for (j
= 0; j
< *decoded_options_count
; ++j
)
317 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
319 if (j
== *decoded_options_count
)
320 append_option (decoded_options
, decoded_options_count
, foption
);
321 else if ((*decoded_options
)[j
].value
!= foption
->value
)
323 if (cf_protection_option
324 && cf_protection_option
->value
== CF_CHECK
)
325 fatal_error (input_location
,
326 "option -fcf-protection with mismatching values"
328 (*decoded_options
)[j
].arg
, foption
->arg
);
331 /* Merge and update the -fcf-protection option. */
332 (*decoded_options
)[j
].value
&= (foption
->value
334 switch ((*decoded_options
)[j
].value
)
337 (*decoded_options
)[j
].arg
= "none";
340 (*decoded_options
)[j
].arg
= "branch";
343 (*decoded_options
)[j
].arg
= "return";
357 for (j
= 0; j
< *decoded_options_count
; ++j
)
358 if ((*decoded_options
)[j
].opt_index
== OPT_O
359 || (*decoded_options
)[j
].opt_index
== OPT_Ofast
360 || (*decoded_options
)[j
].opt_index
== OPT_Og
361 || (*decoded_options
)[j
].opt_index
== OPT_Os
)
363 if (j
== *decoded_options_count
)
364 append_option (decoded_options
, decoded_options_count
, foption
);
365 else if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
366 && foption
->opt_index
!= OPT_O
)
367 /* Exact same options get merged. */
371 /* For mismatched option kinds preserve the optimization
372 level only, thus merge it as -On. This also handles
373 merging of same optimization level -On. */
375 switch (foption
->opt_index
)
378 if (foption
->arg
[0] == '\0')
379 level
= MAX (level
, 1);
381 level
= MAX (level
, atoi (foption
->arg
));
384 level
= MAX (level
, 3);
387 level
= MAX (level
, 1);
390 level
= MAX (level
, 2);
395 switch ((*decoded_options
)[j
].opt_index
)
398 if ((*decoded_options
)[j
].arg
[0] == '\0')
399 level
= MAX (level
, 1);
401 level
= MAX (level
, atoi ((*decoded_options
)[j
].arg
));
404 level
= MAX (level
, 3);
407 level
= MAX (level
, 1);
410 level
= MAX (level
, 2);
415 (*decoded_options
)[j
].opt_index
= OPT_O
;
417 tem
= xasprintf ("-O%d", level
);
418 (*decoded_options
)[j
].arg
= &tem
[2];
419 (*decoded_options
)[j
].canonical_option
[0] = tem
;
420 (*decoded_options
)[j
].value
= 1;
425 case OPT_foffload_abi_
:
426 for (j
= 0; j
< *decoded_options_count
; ++j
)
427 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
429 if (j
== *decoded_options_count
)
430 append_option (decoded_options
, decoded_options_count
, foption
);
431 else if (foption
->value
!= (*decoded_options
)[j
].value
)
432 fatal_error (input_location
,
433 "option %s not used consistently in all LTO input"
434 " files", foption
->orig_option_with_args_text
);
439 append_option (decoded_options
, decoded_options_count
, foption
);
444 /* Merge PIC options:
445 -fPIC + -fpic = -fpic
446 -fPIC + -fno-pic = -fno-pic
447 -fpic/-fPIC + nothing = nothing.
448 It is a common mistake to mix few -fPIC compiled objects into otherwise
449 non-PIC code. We do not want to build everything with PIC then.
451 Similarly we merge PIE options, however in addition we keep
452 -fPIC + -fPIE = -fPIE
453 -fpic + -fPIE = -fpie
454 -fPIC/-fpic + -fpie = -fpie
456 It would be good to warn on mismatches, but it is bit hard to do as
457 we do not know what nothing translates to. */
459 for (unsigned int j
= 0; j
< *decoded_options_count
;)
460 if ((*decoded_options
)[j
].opt_index
== OPT_fPIC
461 || (*decoded_options
)[j
].opt_index
== OPT_fpic
)
463 /* -fno-pic in one unit implies -fno-pic everywhere. */
464 if ((*decoded_options
)[j
].value
== 0)
466 /* If we have no pic option or merge in -fno-pic, we still may turn
467 existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */
468 else if ((pic_option
&& pic_option
->value
== 0)
473 bool big
= (*decoded_options
)[j
].opt_index
== OPT_fPIC
474 && pie_option
->opt_index
== OPT_fPIE
;
475 (*decoded_options
)[j
].opt_index
= big
? OPT_fPIE
: OPT_fpie
;
476 if (pie_option
->value
)
477 (*decoded_options
)[j
].canonical_option
[0]
478 = big
? "-fPIE" : "-fpie";
480 (*decoded_options
)[j
].canonical_option
[0] = "-fno-pie";
481 (*decoded_options
)[j
].value
= pie_option
->value
;
486 (*decoded_options
)[j
] = *pic_option
;
489 /* We do not know if target defaults to pic or not, so just remove
490 option if it is missing in one unit but enabled in other. */
492 remove_option (decoded_options
, j
, decoded_options_count
);
494 else if (pic_option
->opt_index
== OPT_fpic
495 && (*decoded_options
)[j
].opt_index
== OPT_fPIC
)
497 (*decoded_options
)[j
] = *pic_option
;
503 else if ((*decoded_options
)[j
].opt_index
== OPT_fPIE
504 || (*decoded_options
)[j
].opt_index
== OPT_fpie
)
506 /* -fno-pie in one unit implies -fno-pie everywhere. */
507 if ((*decoded_options
)[j
].value
== 0)
509 /* If we have no pie option or merge in -fno-pie, we still preserve
510 PIE/pie if pic/PIC is present. */
511 else if ((pie_option
&& pie_option
->value
== 0)
514 /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */
517 if (pic_option
->opt_index
== OPT_fpic
518 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
520 (*decoded_options
)[j
].opt_index
= OPT_fpie
;
521 (*decoded_options
)[j
].canonical_option
[0]
522 = pic_option
->value
? "-fpie" : "-fno-pie";
524 else if (!pic_option
->value
)
525 (*decoded_options
)[j
].canonical_option
[0] = "-fno-pie";
526 (*decoded_options
)[j
].value
= pic_option
->value
;
531 (*decoded_options
)[j
] = *pie_option
;
534 /* Because we always append pic/PIE options this code path should
535 not happen unless the LTO object was built by old lto1 which
536 did not contain that logic yet. */
538 remove_option (decoded_options
, j
, decoded_options_count
);
540 else if (pie_option
->opt_index
== OPT_fpie
541 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
543 (*decoded_options
)[j
] = *pie_option
;
552 if (!xassembler_options_error
)
553 for (i
= j
= 0; ; i
++, j
++)
555 for (; i
< *decoded_options_count
; i
++)
556 if ((*decoded_options
)[i
].opt_index
== OPT_Xassembler
)
559 for (; j
< fdecoded_options_count
; j
++)
560 if (fdecoded_options
[j
].opt_index
== OPT_Xassembler
)
563 if (i
== *decoded_options_count
&& j
== fdecoded_options_count
)
565 else if (i
< *decoded_options_count
&& j
== fdecoded_options_count
)
567 warning (0, "Extra option to %<-Xassembler%>: %s,"
568 " dropping all %<-Xassembler%> and %<-Wa%> options.",
569 (*decoded_options
)[i
].arg
);
570 xassembler_options_error
= true;
573 else if (i
== *decoded_options_count
&& j
< fdecoded_options_count
)
575 warning (0, "Extra option to %<-Xassembler%>: %s,"
576 " dropping all %<-Xassembler%> and %<-Wa%> options.",
577 fdecoded_options
[j
].arg
);
578 xassembler_options_error
= true;
581 else if (strcmp ((*decoded_options
)[i
].arg
, fdecoded_options
[j
].arg
))
583 warning (0, "Options to %<-Xassembler%> do not match: %s, %s,"
584 " dropping all %<-Xassembler%> and %<-Wa%> options.",
585 (*decoded_options
)[i
].arg
, fdecoded_options
[j
].arg
);
586 xassembler_options_error
= true;
592 /* Auxiliary function that frees elements of PTR and PTR itself.
593 N is number of elements to be freed. If PTR is NULL, nothing is freed.
594 If an element is NULL, subsequent elements are not freed. */
597 free_array_of_ptrs (void **ptr
, unsigned n
)
601 for (unsigned i
= 0; i
< n
; i
++)
611 /* Parse STR, saving found tokens into PVALUES and return their number.
612 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
613 append it to every token we find. */
616 parse_env_var (const char *str
, char ***pvalues
, const char *append
)
618 const char *curval
, *nextval
;
622 curval
= strchr (str
, ':');
626 curval
= strchr (curval
+ 1, ':');
629 values
= (char**) xmalloc (num
* sizeof (char*));
631 nextval
= strchr (curval
, ':');
633 nextval
= strchr (curval
, '\0');
635 int append_len
= append
? strlen (append
) : 0;
636 for (i
= 0; i
< num
; i
++)
638 int l
= nextval
- curval
;
639 values
[i
] = (char*) xmalloc (l
+ 1 + append_len
);
640 memcpy (values
[i
], curval
, l
);
643 strcat (values
[i
], append
);
644 curval
= nextval
+ 1;
645 nextval
= strchr (curval
, ':');
647 nextval
= strchr (curval
, '\0');
653 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
656 append_compiler_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
659 /* Append compiler driver arguments as far as they were merged. */
660 for (unsigned int j
= 1; j
< count
; ++j
)
662 struct cl_decoded_option
*option
= &opts
[j
];
664 /* File options have been properly filtered by lto-opts.c. */
665 switch (option
->opt_index
)
667 /* Drop arguments that we want to take from the link line. */
670 case OPT_flto_partition_
:
677 /* For now do what the original LTO option code was doing - pass
678 on any CL_TARGET flag and a few selected others. */
679 switch (option
->opt_index
)
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
:
695 case OPT_fopenacc_dim_
:
696 case OPT_foffload_abi_
:
697 case OPT_fcf_protection_
:
706 /* When we detected a mismatch in assembler options between
707 the input TU's fall back to previous behavior of ignoring them. */
708 if (xassembler_options_error
)
713 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
717 /* Pass the option on. */
718 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
719 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
723 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
726 append_diag_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
729 /* Append compiler driver arguments as far as they were merged. */
730 for (unsigned int j
= 1; j
< count
; ++j
)
732 struct cl_decoded_option
*option
= &opts
[j
];
734 switch (option
->opt_index
)
736 case OPT_fdiagnostics_color_
:
737 case OPT_fdiagnostics_format_
:
738 case OPT_fdiagnostics_show_caret
:
739 case OPT_fdiagnostics_show_labels
:
740 case OPT_fdiagnostics_show_line_numbers
:
741 case OPT_fdiagnostics_show_option
:
742 case OPT_fdiagnostics_show_location_
:
743 case OPT_fshow_column
:
749 /* Pass the option on. */
750 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
751 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
756 /* Append linker options OPTS to ARGV_OBSTACK. */
759 append_linker_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
762 /* Append linker driver arguments. Compiler options from the linker
763 driver arguments will override / merge with those from the compiler. */
764 for (unsigned int j
= 1; j
< count
; ++j
)
766 struct cl_decoded_option
*option
= &opts
[j
];
768 /* Do not pass on frontend specific flags not suitable for lto. */
769 if (!(cl_options
[option
->opt_index
].flags
770 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
773 switch (option
->opt_index
)
778 /* We've handled these LTO options, do not pass them on. */
783 /* Ignore -fno-XXX form of these options, as otherwise
784 corresponding builtins will not be enabled. */
785 if (option
->value
== 0)
793 /* Pass the option on. */
794 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
795 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
799 /* Extract options for TARGET offload compiler from OPTIONS and append
800 them to ARGV_OBSTACK. */
803 append_offload_options (obstack
*argv_obstack
, const char *target
,
804 struct cl_decoded_option
*options
,
805 unsigned int options_count
)
807 for (unsigned i
= 0; i
< options_count
; i
++)
809 const char *cur
, *next
, *opts
;
812 struct cl_decoded_option
*option
= &options
[i
];
814 if (option
->opt_index
!= OPT_foffload_
)
817 /* If option argument starts with '-' then no target is specified. That
818 means offload options are specified for all targets, so we need to
820 if (option
->arg
[0] == '-')
824 opts
= strchr (option
->arg
, '=');
825 /* If there are offload targets specified, but no actual options,
826 there is nothing to do here. */
834 next
= strchr (cur
, ',');
837 next
= (next
> opts
) ? opts
: next
;
839 /* Are we looking for this offload target? */
840 if (strlen (target
) == (size_t) (next
- cur
)
841 && strncmp (target
, cur
, next
- cur
) == 0)
844 /* Skip the comma or equal sign. */
854 argv
= buildargv (opts
);
855 for (argc
= 0; argv
[argc
]; argc
++)
856 obstack_ptr_grow (argv_obstack
, argv
[argc
]);
860 /* Check whether NAME can be accessed in MODE. This is like access,
861 except that it never considers directories to be executable. */
864 access_check (const char *name
, int mode
)
870 if (stat (name
, &st
) < 0
871 || S_ISDIR (st
.st_mode
))
875 return access (name
, mode
);
878 /* Prepare a target image for offload TARGET, using mkoffload tool from
879 COMPILER_PATH. Return the name of the resultant object file. */
882 compile_offload_image (const char *target
, const char *compiler_path
,
883 unsigned in_argc
, char *in_argv
[],
884 struct cl_decoded_option
*compiler_opts
,
885 unsigned int compiler_opt_count
,
886 struct cl_decoded_option
*linker_opts
,
887 unsigned int linker_opt_count
)
889 char *filename
= NULL
;
893 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target
));
894 strcpy (suffix
, "/accel/");
895 strcat (suffix
, target
);
896 strcat (suffix
, "/mkoffload");
899 unsigned n_paths
= parse_env_var (compiler_path
, &paths
, suffix
);
901 const char *compiler
= NULL
;
902 for (unsigned i
= 0; i
< n_paths
; i
++)
903 if (access_check (paths
[i
], X_OK
) == 0)
910 fatal_error (input_location
,
911 "could not find %s in %s (consider using %<-B%>)",
912 suffix
+ 1, compiler_path
);
914 dumpbase
= concat (dumppfx
, "x", target
, NULL
);
916 /* Generate temporary output file name. */
918 filename
= concat (dumpbase
, ".o", NULL
);
920 filename
= make_temp_file (".target.o");
922 struct obstack argv_obstack
;
923 obstack_init (&argv_obstack
);
924 obstack_ptr_grow (&argv_obstack
, compiler
);
926 obstack_ptr_grow (&argv_obstack
, "-save-temps");
928 obstack_ptr_grow (&argv_obstack
, "-v");
929 obstack_ptr_grow (&argv_obstack
, "-o");
930 obstack_ptr_grow (&argv_obstack
, filename
);
932 /* Append names of input object files. */
933 for (unsigned i
= 0; i
< in_argc
; i
++)
934 obstack_ptr_grow (&argv_obstack
, in_argv
[i
]);
936 /* Append options from offload_lto sections. */
937 append_compiler_options (&argv_obstack
, compiler_opts
,
939 append_diag_options (&argv_obstack
, linker_opts
, linker_opt_count
);
941 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
942 obstack_ptr_grow (&argv_obstack
, dumpbase
);
944 /* Append options specified by -foffload last. In case of conflicting
945 options we expect offload compiler to choose the latest. */
946 append_offload_options (&argv_obstack
, target
, compiler_opts
,
948 append_offload_options (&argv_obstack
, target
, linker_opts
,
951 obstack_ptr_grow (&argv_obstack
, NULL
);
952 argv
= XOBFINISH (&argv_obstack
, char **);
953 fork_execute (argv
[0], argv
, true);
954 obstack_free (&argv_obstack
, NULL
);
956 free_array_of_ptrs ((void **) paths
, n_paths
);
961 /* The main routine dealing with offloading.
962 The routine builds a target image for each offload target. IN_ARGC and
963 IN_ARGV specify options and input object files. As all of them could contain
964 target sections, we pass them all to target compilers. */
967 compile_images_for_offload_targets (unsigned in_argc
, char *in_argv
[],
968 struct cl_decoded_option
*compiler_opts
,
969 unsigned int compiler_opt_count
,
970 struct cl_decoded_option
*linker_opts
,
971 unsigned int linker_opt_count
)
974 const char *target_names
= getenv (OFFLOAD_TARGET_NAMES_ENV
);
977 unsigned num_targets
= parse_env_var (target_names
, &names
, NULL
);
979 const char *compiler_path
= getenv ("COMPILER_PATH");
983 /* Prepare an image for each target and save the name of the resultant object
984 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
985 offload_names
= XCNEWVEC (char *, num_targets
+ 1);
986 for (unsigned i
= 0; i
< num_targets
; i
++)
989 = compile_offload_image (names
[i
], compiler_path
, in_argc
, in_argv
,
990 compiler_opts
, compiler_opt_count
,
991 linker_opts
, linker_opt_count
);
992 if (!offload_names
[i
])
993 fatal_error (input_location
,
994 "problem with building target image for %s", names
[i
]);
998 free_array_of_ptrs ((void **) names
, num_targets
);
1001 /* Copy a file from SRC to DEST. */
1004 copy_file (const char *dest
, const char *src
)
1006 FILE *d
= fopen (dest
, "wb");
1007 FILE *s
= fopen (src
, "rb");
1011 size_t len
= fread (buffer
, 1, 512, s
);
1012 if (ferror (s
) != 0)
1013 fatal_error (input_location
, "reading input file");
1016 fwrite (buffer
, 1, len
, d
);
1017 if (ferror (d
) != 0)
1018 fatal_error (input_location
, "writing output file");
1025 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
1026 the copy to the linker. */
1029 find_crtoffloadtable (void)
1031 char **paths
= NULL
;
1032 const char *library_path
= getenv ("LIBRARY_PATH");
1035 unsigned n_paths
= parse_env_var (library_path
, &paths
, "/crtoffloadtable.o");
1038 for (i
= 0; i
< n_paths
; i
++)
1039 if (access_check (paths
[i
], R_OK
) == 0)
1041 /* The linker will delete the filename we give it, so make a copy. */
1042 char *crtoffloadtable
= make_temp_file (".crtoffloadtable.o");
1043 copy_file (crtoffloadtable
, paths
[i
]);
1044 printf ("%s\n", crtoffloadtable
);
1045 XDELETEVEC (crtoffloadtable
);
1049 fatal_error (input_location
,
1050 "installation error, cannot find %<crtoffloadtable.o%>");
1052 free_array_of_ptrs ((void **) paths
, n_paths
);
1055 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
1056 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
1057 and OPT_COUNT. Return true if we found a matching section, false
1058 otherwise. COLLECT_GCC holds the value of the environment variable with
1062 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
1063 struct cl_decoded_option
*decoded_cl_options
,
1064 unsigned int decoded_cl_options_count
,
1065 struct cl_decoded_option
**opts
,
1066 unsigned int *opt_count
, const char *collect_gcc
)
1068 off_t offset
, length
;
1073 struct cl_decoded_option
*fdecoded_options
= *opts
;
1074 unsigned int fdecoded_options_count
= *opt_count
;
1076 simple_object_read
*sobj
;
1077 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
1082 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
1083 strcpy (secname
, prefix
);
1084 strcat (secname
, ".opts");
1085 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
1088 simple_object_release_read (sobj
);
1092 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
1093 data
= (char *)xmalloc (length
);
1094 read (fd
, data
, length
);
1098 struct cl_decoded_option
*f2decoded_options
;
1099 unsigned int f2decoded_options_count
;
1100 get_options_from_collect_gcc_options (collect_gcc
, fopts
,
1102 &f2decoded_options_count
);
1103 if (!fdecoded_options
)
1105 fdecoded_options
= f2decoded_options
;
1106 fdecoded_options_count
= f2decoded_options_count
;
1109 merge_and_complain (&fdecoded_options
,
1110 &fdecoded_options_count
,
1111 f2decoded_options
, f2decoded_options_count
,
1113 decoded_cl_options_count
);
1115 fopts
+= strlen (fopts
) + 1;
1117 while (fopts
- data
< length
);
1120 simple_object_release_read (sobj
);
1121 *opts
= fdecoded_options
;
1122 *opt_count
= fdecoded_options_count
;
1126 /* Copy early debug info sections from INFILE to a new file whose name
1127 is returned. Return NULL on error. */
1130 debug_objcopy (const char *infile
, bool rename
)
1137 const char *orig_infile
= infile
;
1141 if ((p
= strrchr (infile
, '@'))
1143 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1144 && strlen (p
) == (unsigned int) consumed
)
1146 char *fname
= xstrdup (infile
);
1147 fname
[p
- infile
] = '\0';
1149 inoff
= (off_t
) loffset
;
1151 int infd
= open (infile
, O_RDONLY
| O_BINARY
);
1154 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
1161 if (simple_object_find_section (inobj
, ".gnu.debuglto_.debug_info",
1162 &off
, &len
, &errmsg
, &err
) != 1)
1165 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1167 simple_object_release_read (inobj
);
1173 outfile
= concat (orig_infile
, ".debug.temp.o", NULL
);
1175 outfile
= make_temp_file (".debug.temp.o");
1176 errmsg
= simple_object_copy_lto_debug_sections (inobj
, outfile
, &err
, rename
);
1179 unlink_if_ordinary (outfile
);
1180 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1183 simple_object_release_read (inobj
);
1189 /* Helper for qsort: compare priorities for parallel compilation. */
1192 cmp_priority (const void *a
, const void *b
)
1194 return *((const int *)b
)-*((const int *)a
);
1197 /* Number of CPUs that can be used for parallel LTRANS phase. */
1199 static unsigned long nthreads_var
= 0;
1201 #ifdef HAVE_PTHREAD_AFFINITY_NP
1202 unsigned long cpuset_size
;
1203 static unsigned long get_cpuset_size
;
1207 static cpuset_popcount (unsigned long cpusetsize
, cpu_set_t
*cpusetp
)
1210 /* glibc 2.7 and above provide a macro for this. */
1211 return CPU_COUNT_S (cpusetsize
, cpusetp
);
1214 if (cpusetsize
== sizeof (cpu_set_t
))
1215 /* glibc 2.6 and above provide a macro for this. */
1216 return CPU_COUNT (cpusetp
);
1219 unsigned long ret
= 0;
1220 STATIC_ASSERT (sizeof (cpusetp
->__bits
[0]) == sizeof (unsigned long int));
1221 for (i
= 0; i
< cpusetsize
/ sizeof (cpusetp
->__bits
[0]); i
++)
1223 unsigned long int mask
= cpusetp
->__bits
[i
];
1226 ret
+= __builtin_popcountl (mask
);
1233 /* At startup, determine the default number of threads. It would seem
1234 this should be related to the number of cpus online. */
1237 init_num_threads (void)
1239 #ifdef HAVE_PTHREAD_AFFINITY_NP
1240 #if defined (_SC_NPROCESSORS_CONF) && defined (CPU_ALLOC_SIZE)
1241 cpuset_size
= sysconf (_SC_NPROCESSORS_CONF
);
1242 cpuset_size
= CPU_ALLOC_SIZE (cpuset_size
);
1244 cpuset_size
= sizeof (cpu_set_t
);
1247 cpusetp
= (cpu_set_t
*) xmalloc (gomp_cpuset_size
);
1250 int ret
= pthread_getaffinity_np (pthread_self (), gomp_cpuset_size
,
1254 /* Count only the CPUs this process can use. */
1255 nthreads_var
= cpuset_popcount (cpuset_size
, cpusetp
);
1256 if (nthreads_var
== 0)
1258 get_cpuset_size
= cpuset_size
;
1259 #ifdef CPU_ALLOC_SIZE
1261 for (i
= cpuset_size
* 8; i
; i
--)
1262 if (CPU_ISSET_S (i
- 1, cpuset_size
, cpusetp
))
1264 cpuset_size
= CPU_ALLOC_SIZE (i
);
1270 #ifdef CPU_ALLOC_SIZE
1271 if (cpuset_size
< sizeof (cpu_set_t
))
1272 cpuset_size
= sizeof (cpu_set_t
);
1274 cpuset_size
= cpuset_size
* 2;
1275 if (cpuset_size
< 8 * sizeof (cpu_set_t
))
1277 = (cpu_set_t
*) realloc (cpusetp
, cpuset_size
);
1280 /* Avoid fatal if too large memory allocation would be
1281 requested, e.g. kernel returning EINVAL all the time. */
1282 void *p
= realloc (cpusetp
, cpuset_size
);
1285 cpusetp
= (cpu_set_t
*) p
;
1297 #ifdef _SC_NPROCESSORS_ONLN
1298 nthreads_var
= sysconf (_SC_NPROCESSORS_ONLN
);
1302 /* FIXME: once using -std=c++11, we can use std::thread::hardware_concurrency. */
1304 /* Test and return reason why a jobserver cannot be detected. */
1307 jobserver_active_p (void)
1309 #define JS_PREFIX "jobserver is not available: "
1310 #define JS_NEEDLE "--jobserver-auth="
1312 const char *makeflags
= getenv ("MAKEFLAGS");
1313 if (makeflags
== NULL
)
1314 return JS_PREFIX
"%<MAKEFLAGS%> environment variable is unset";
1316 const char *n
= strstr (makeflags
, JS_NEEDLE
);
1318 return JS_PREFIX
"%<" JS_NEEDLE
"%> is not present in %<MAKEFLAGS%>";
1323 if (sscanf (n
+ strlen (JS_NEEDLE
), "%d,%d", &rfd
, &wfd
) == 2
1326 && is_valid_fd (rfd
)
1327 && is_valid_fd (wfd
))
1330 return JS_PREFIX
"cannot access %<" JS_NEEDLE
"%> file descriptors";
1333 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1336 run_gcc (unsigned argc
, char *argv
[])
1339 const char **new_argv
;
1340 const char **argv_ptr
;
1341 char *list_option_full
= NULL
;
1342 const char *linker_output
= NULL
;
1343 const char *collect_gcc
;
1344 char *collect_gcc_options
;
1347 int auto_parallel
= 0;
1348 bool no_partition
= false;
1349 struct cl_decoded_option
*fdecoded_options
= NULL
;
1350 struct cl_decoded_option
*offload_fdecoded_options
= NULL
;
1351 unsigned int fdecoded_options_count
= 0;
1352 unsigned int offload_fdecoded_options_count
= 0;
1353 struct cl_decoded_option
*decoded_options
;
1354 unsigned int decoded_options_count
;
1355 struct obstack argv_obstack
;
1357 bool have_lto
= false;
1358 bool have_offload
= false;
1359 unsigned lto_argc
= 0, ltoobj_argc
= 0;
1360 char **lto_argv
, **ltoobj_argv
;
1361 bool linker_output_rel
= false;
1362 bool skip_debug
= false;
1363 unsigned n_debugobj
;
1364 const char *incoming_dumppfx
= dumppfx
= NULL
;
1365 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1367 /* Get the driver and options. */
1368 collect_gcc
= getenv ("COLLECT_GCC");
1370 fatal_error (input_location
,
1371 "environment variable %<COLLECT_GCC%> must be set");
1372 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1373 if (!collect_gcc_options
)
1374 fatal_error (input_location
,
1375 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1377 char *collect_as_options
= getenv ("COLLECT_AS_OPTIONS");
1379 /* Prepend -Xassembler to each option, and append the string
1380 to collect_gcc_options. */
1381 if (collect_as_options
)
1383 obstack temporary_obstack
;
1384 obstack_init (&temporary_obstack
);
1386 prepend_xassembler_to_collect_as_options (collect_as_options
,
1387 &temporary_obstack
);
1388 obstack_1grow (&temporary_obstack
, '\0');
1390 char *xassembler_opts_string
1391 = XOBFINISH (&temporary_obstack
, char *);
1392 collect_gcc_options
= concat (collect_gcc_options
, xassembler_opts_string
,
1396 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
1398 &decoded_options_count
);
1400 /* Allocate array for input object files with LTO IL,
1401 and for possible preceding arguments. */
1402 lto_argv
= XNEWVEC (char *, argc
);
1403 ltoobj_argv
= XNEWVEC (char *, argc
);
1405 /* Look at saved options in the IL files. */
1406 for (i
= 1; i
< argc
; ++i
)
1410 off_t file_offset
= 0;
1413 char *filename
= argv
[i
];
1415 if (strncmp (argv
[i
], "-foffload-objects=",
1416 sizeof ("-foffload-objects=") - 1) == 0)
1418 have_offload
= true;
1419 offload_objects_file_name
1420 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1424 if ((p
= strrchr (argv
[i
], '@'))
1426 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1427 && strlen (p
) == (unsigned int) consumed
)
1429 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1430 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1431 filename
[p
- argv
[i
]] = '\0';
1432 file_offset
= (off_t
) loffset
;
1434 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1435 /* Linker plugin passes -fresolution and -flinker-output options.
1436 -flinker-output is passed only when user did not specify one and thus
1437 we do not need to worry about duplicities with the option handling
1441 lto_argv
[lto_argc
++] = argv
[i
];
1442 if (strcmp (argv
[i
], "-flinker-output=rel") == 0)
1443 linker_output_rel
= true;
1447 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1448 decoded_options
, decoded_options_count
,
1449 &fdecoded_options
, &fdecoded_options_count
,
1453 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1458 /* Initalize the common arguments for the driver. */
1459 obstack_init (&argv_obstack
);
1460 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1461 obstack_ptr_grow (&argv_obstack
, "-xlto");
1462 obstack_ptr_grow (&argv_obstack
, "-c");
1464 append_compiler_options (&argv_obstack
, fdecoded_options
,
1465 fdecoded_options_count
);
1466 append_linker_options (&argv_obstack
, decoded_options
, decoded_options_count
);
1468 /* Scan linker driver arguments for things that are of relevance to us. */
1469 for (j
= 1; j
< decoded_options_count
; ++j
)
1471 struct cl_decoded_option
*option
= &decoded_options
[j
];
1472 switch (option
->opt_index
)
1475 linker_output
= option
->arg
;
1478 /* We don't have to distinguish between -save-temps=* and
1479 -save-temps, -dumpdir already carries that
1481 case OPT_save_temps_
:
1482 case OPT_save_temps
:
1490 case OPT_flto_partition_
:
1491 if (strcmp (option
->arg
, "none") == 0)
1492 no_partition
= true;
1496 if (strcmp (option
->arg
, "jobserver") == 0)
1501 else if (strcmp (option
->arg
, "auto") == 0)
1508 parallel
= atoi (option
->arg
);
1515 lto_mode
= LTO_MODE_WHOPR
;
1518 case OPT_flinker_output_
:
1519 linker_output_rel
= !strcmp (option
->arg
, "rel");
1523 /* Recognize -g0. */
1524 skip_debug
= option
->arg
&& !strcmp (option
->arg
, "0");
1528 incoming_dumppfx
= dumppfx
= option
->arg
;
1536 /* Output lto-wrapper invocation command. */
1539 for (i
= 0; i
< argc
; ++i
)
1541 fputs (argv
[i
], stderr
);
1542 fputc (' ', stderr
);
1544 fputc ('\n', stderr
);
1547 if (linker_output_rel
)
1548 no_partition
= true;
1552 lto_mode
= LTO_MODE_LTO
;
1559 const char *jobserver_error
= jobserver_active_p ();
1560 if (jobserver
&& jobserver_error
!= NULL
)
1561 warning (0, jobserver_error
);
1562 else if (!jobserver
&& jobserver_error
== NULL
)
1572 || strcmp (linker_output
, HOST_BIT_BUCKET
) == 0)
1576 const char *obase
= lbasename (linker_output
), *temp
;
1578 /* Strip the executable extension. */
1579 size_t blen
= strlen (obase
), xlen
;
1580 if ((temp
= strrchr (obase
+ 1, '.'))
1581 && (xlen
= strlen (temp
))
1582 && (strcmp (temp
, ".exe") == 0
1583 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
1584 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
1586 || strcmp (obase
, "a.out") == 0))
1587 dumppfx
= xstrndup (linker_output
,
1588 obase
- linker_output
+ blen
- xlen
+ 1);
1590 dumppfx
= concat (linker_output
, ".", NULL
);
1594 /* If there's no directory component in the dumppfx, add one, so
1595 that, when it is used as -dumpbase, it overrides any occurrence
1596 of -dumpdir that might have been passed in. */
1597 if (!dumppfx
|| lbasename (dumppfx
) == dumppfx
)
1598 dumppfx
= concat (current_dir
, dumppfx
, NULL
);
1600 /* Make sure some -dumpdir is passed, so as to get predictable
1601 -dumpbase overriding semantics. If we got an incoming -dumpdir
1602 argument, we'll pass it on, so don't bother with another one
1604 if (!incoming_dumppfx
)
1606 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1607 obstack_ptr_grow (&argv_obstack
, "");
1609 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1611 /* Remember at which point we can scrub args to re-use the commons. */
1612 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1616 unsigned i
, num_offload_files
;
1617 char **offload_argv
;
1620 f
= fopen (offload_objects_file_name
, "r");
1622 fatal_error (input_location
, "cannot open %s: %m",
1623 offload_objects_file_name
);
1624 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1625 fatal_error (input_location
, "cannot read %s: %m",
1626 offload_objects_file_name
);
1627 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1629 /* Read names of object files with offload. */
1630 for (i
= 0; i
< num_offload_files
; i
++)
1632 const unsigned piece
= 32;
1633 char *buf
, *filename
= XNEWVEC (char, piece
);
1638 if (!fgets (buf
, piece
, f
))
1640 len
= strlen (filename
);
1641 if (filename
[len
- 1] != '\n')
1643 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1644 buf
= filename
+ len
;
1647 filename
[len
- 1] = '\0';
1648 offload_argv
[i
] = filename
;
1651 if (offload_argv
[num_offload_files
- 1] == NULL
)
1652 fatal_error (input_location
, "invalid format of %s",
1653 offload_objects_file_name
);
1654 maybe_unlink (offload_objects_file_name
);
1655 offload_objects_file_name
= NULL
;
1657 /* Look at saved offload options in files. */
1658 for (i
= 0; i
< num_offload_files
; i
++)
1663 off_t file_offset
= 0;
1664 char *filename
= offload_argv
[i
];
1666 if ((p
= strrchr (offload_argv
[i
], '@'))
1667 && p
!= offload_argv
[i
]
1668 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1669 && strlen (p
) == (unsigned int) consumed
)
1671 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1672 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1673 filename
[p
- offload_argv
[i
]] = '\0';
1674 file_offset
= (off_t
) loffset
;
1676 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1678 fatal_error (input_location
, "cannot open %s: %m", filename
);
1679 if (!find_and_merge_options (fd
, file_offset
,
1680 OFFLOAD_SECTION_NAME_PREFIX
,
1681 decoded_options
, decoded_options_count
,
1682 &offload_fdecoded_options
,
1683 &offload_fdecoded_options_count
,
1685 fatal_error (input_location
, "cannot read %s: %m", filename
);
1687 if (filename
!= offload_argv
[i
])
1688 XDELETEVEC (filename
);
1691 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1692 offload_fdecoded_options
,
1693 offload_fdecoded_options_count
,
1695 decoded_options_count
);
1697 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1701 find_crtoffloadtable ();
1702 for (i
= 0; offload_names
[i
]; i
++)
1703 printf ("%s\n", offload_names
[i
]);
1704 free_array_of_ptrs ((void **) offload_names
, i
);
1708 /* If object files contain offload sections, but do not contain LTO sections,
1709 then there is no need to perform a link-time recompilation, i.e.
1710 lto-wrapper is used only for a compilation of offload images. */
1711 if (have_offload
&& !have_lto
)
1714 if (lto_mode
== LTO_MODE_LTO
)
1716 /* -dumpbase argument for LTO. */
1717 flto_out
= concat (dumppfx
, "lto.o", NULL
);
1718 obstack_ptr_grow (&argv_obstack
, flto_out
);
1721 flto_out
= make_temp_file (".lto.o");
1722 obstack_ptr_grow (&argv_obstack
, "-o");
1723 obstack_ptr_grow (&argv_obstack
, flto_out
);
1727 const char *list_option
= "-fltrans-output-list=";
1729 /* -dumpbase argument for WPA. */
1730 char *dumpbase
= concat (dumppfx
, "wpa", NULL
);
1731 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1734 ltrans_output_file
= concat (dumppfx
, "ltrans.out", NULL
);
1736 ltrans_output_file
= make_temp_file (".ltrans.out");
1737 list_option_full
= concat (list_option
, ltrans_output_file
, NULL
);
1738 obstack_ptr_grow (&argv_obstack
, list_option_full
);
1743 fprintf (stderr
, "Using make jobserver\n");
1744 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1746 else if (auto_parallel
)
1749 init_num_threads ();
1751 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1753 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1754 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1756 else if (parallel
> 1)
1759 sprintf (buf
, "-fwpa=%i", parallel
);
1760 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1763 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1766 /* Append input arguments. */
1767 for (i
= 0; i
< lto_argc
; ++i
)
1768 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1769 /* Append the input objects. */
1770 for (i
= 0; i
< ltoobj_argc
; ++i
)
1771 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1772 obstack_ptr_grow (&argv_obstack
, NULL
);
1774 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1775 argv_ptr
= &new_argv
[new_head_argc
];
1776 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true);
1778 /* Copy the early generated debug info from the objects to temporary
1779 files and append those to the partial link commandline. */
1781 early_debug_object_names
= NULL
;
1784 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1785 num_deb_objs
= ltoobj_argc
;
1786 for (i
= 0; i
< ltoobj_argc
; ++i
)
1789 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1791 early_debug_object_names
[i
] = tem
;
1797 if (lto_mode
== LTO_MODE_LTO
)
1799 printf ("%s\n", flto_out
);
1802 for (i
= 0; i
< ltoobj_argc
; ++i
)
1803 if (early_debug_object_names
[i
] != NULL
)
1804 printf ("%s\n", early_debug_object_names
[i
]);
1806 /* These now belong to collect2. */
1809 free (early_debug_object_names
);
1810 early_debug_object_names
= NULL
;
1814 FILE *stream
= fopen (ltrans_output_file
, "r");
1815 FILE *mstream
= NULL
;
1816 struct obstack env_obstack
;
1820 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1822 /* Parse the list of LTRANS inputs from the WPA stage. */
1823 obstack_init (&env_obstack
);
1827 const unsigned piece
= 32;
1828 char *output_name
= NULL
;
1829 char *buf
, *input_name
= (char *)xmalloc (piece
);
1833 if (fscanf (stream
, "%i\n", &priority
) != 1)
1836 fatal_error (input_location
,
1837 "corrupted ltrans output file %s",
1838 ltrans_output_file
);
1842 if (!fgets (buf
, piece
, stream
))
1844 len
= strlen (input_name
);
1845 if (input_name
[len
- 1] != '\n')
1847 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1848 buf
= input_name
+ len
;
1851 input_name
[len
- 1] = '\0';
1853 if (input_name
[0] == '*')
1854 output_name
= &input_name
[1];
1858 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1859 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1860 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1861 ltrans_priorities
[(nr
-1)*2] = priority
;
1862 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1863 input_names
[nr
-1] = input_name
;
1864 output_names
[nr
-1] = output_name
;
1867 maybe_unlink (ltrans_output_file
);
1868 ltrans_output_file
= NULL
;
1872 makefile
= make_temp_file (".mk");
1873 mstream
= fopen (makefile
, "w");
1874 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1877 /* Execute the LTRANS stage for each input file (or prepare a
1878 makefile to invoke this in parallel). */
1879 for (i
= 0; i
< nr
; ++i
)
1882 char *input_name
= input_names
[i
];
1883 /* If it's a pass-through file do nothing. */
1884 if (output_names
[i
])
1887 /* Replace the .o suffix with a .ltrans.o suffix and write
1888 the resulting name to the LTRANS output list. */
1889 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1890 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1891 output_name
= XOBFINISH (&env_obstack
, char *);
1893 /* Adjust the dumpbase if the linker output file was seen. */
1894 int dumpbase_len
= (strlen (dumppfx
) + sizeof (DUMPBASE_SUFFIX
));
1895 char *dumpbase
= (char *) xmalloc (dumpbase_len
+ 1);
1896 snprintf (dumpbase
, dumpbase_len
, "%sltrans%u.ltrans", dumppfx
, i
);
1897 argv_ptr
[0] = dumpbase
;
1899 argv_ptr
[1] = "-fltrans";
1901 argv_ptr
[3] = output_name
;
1902 argv_ptr
[4] = input_name
;
1906 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1907 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1908 fprintf (mstream
, " '%s'", new_argv
[j
]);
1909 fprintf (mstream
, "\n");
1910 /* If we are not preserving the ltrans input files then
1911 truncate them as soon as we have processed it. This
1912 reduces temporary disk-space usage. */
1914 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1915 "&& mv %s.tem %s\n",
1916 input_name
, input_name
, input_name
, input_name
);
1920 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1922 maybe_unlink (input_name
);
1925 output_names
[i
] = output_name
;
1929 struct pex_obj
*pex
;
1935 for (i
= 0; i
< nr
; ++i
)
1937 int j
= ltrans_priorities
[i
*2 + 1];
1938 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1940 fprintf (mstream
, "\n");
1944 /* Avoid passing --jobserver-fd= and similar flags
1945 unless jobserver mode is explicitly enabled. */
1946 putenv (xstrdup ("MAKEFLAGS="));
1947 putenv (xstrdup ("MFLAGS="));
1950 char **make_argv
= buildargv (getenv ("MAKE"));
1953 for (unsigned argc
= 0; make_argv
[argc
]; argc
++)
1954 obstack_ptr_grow (&argv_obstack
, make_argv
[argc
]);
1957 obstack_ptr_grow (&argv_obstack
, "make");
1959 obstack_ptr_grow (&argv_obstack
, "-f");
1960 obstack_ptr_grow (&argv_obstack
, makefile
);
1963 snprintf (jobs
, 31, "-j%ld",
1964 auto_parallel
? nthreads_var
: parallel
);
1965 obstack_ptr_grow (&argv_obstack
, jobs
);
1967 obstack_ptr_grow (&argv_obstack
, "all");
1968 obstack_ptr_grow (&argv_obstack
, NULL
);
1969 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1971 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1972 NULL
, NULL
, PEX_SEARCH
, false);
1973 do_wait (new_argv
[0], pex
);
1974 freeargv (make_argv
);
1975 maybe_unlink (makefile
);
1977 for (i
= 0; i
< nr
; ++i
)
1978 maybe_unlink (input_names
[i
]);
1980 for (i
= 0; i
< nr
; ++i
)
1982 fputs (output_names
[i
], stdout
);
1983 putc ('\n', stdout
);
1984 free (input_names
[i
]);
1988 for (i
= 0; i
< ltoobj_argc
; ++i
)
1989 if (early_debug_object_names
[i
] != NULL
)
1990 printf ("%s\n", early_debug_object_names
[i
]);
1993 free (ltrans_priorities
);
1994 free (output_names
);
1995 output_names
= NULL
;
1996 free (early_debug_object_names
);
1997 early_debug_object_names
= NULL
;
1999 free (list_option_full
);
2000 obstack_free (&env_obstack
, NULL
);
2005 obstack_free (&argv_obstack
, NULL
);
2012 main (int argc
, char *argv
[])
2016 init_opts_obstack ();
2018 p
= argv
[0] + strlen (argv
[0]);
2019 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
2023 xmalloc_set_program_name (progname
);
2025 gcc_init_libintl ();
2027 diagnostic_initialize (global_dc
, 0);
2029 if (atexit (lto_wrapper_cleanup
) != 0)
2030 fatal_error (input_location
, "%<atexit%> failed");
2032 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
2033 signal (SIGINT
, fatal_signal
);
2035 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
2036 signal (SIGHUP
, fatal_signal
);
2038 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
2039 signal (SIGTERM
, fatal_signal
);
2041 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
2042 signal (SIGPIPE
, fatal_signal
);
2045 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
2046 receive the signal. A different setting is inheritable */
2047 signal (SIGCHLD
, SIG_DFL
);
2050 /* We may be called with all the arguments stored in some file and
2051 passed with @file. Expand them into argv before processing. */
2052 expandargv (&argc
, &argv
);
2054 run_gcc (argc
, argv
);