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, "offload_args");
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 (int save_temps
, const char *dumppfx
)
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
;
1044 crtoffloadtable
= make_temp_file (".crtoffloadtable.o");
1046 crtoffloadtable
= concat (dumppfx
, "crtoffloadtable.o", NULL
);
1047 copy_file (crtoffloadtable
, paths
[i
]);
1048 printf ("%s\n", crtoffloadtable
);
1049 XDELETEVEC (crtoffloadtable
);
1053 fatal_error (input_location
,
1054 "installation error, cannot find %<crtoffloadtable.o%>");
1056 free_array_of_ptrs ((void **) paths
, n_paths
);
1059 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
1060 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
1061 and OPT_COUNT. Return true if we found a matching section, false
1062 otherwise. COLLECT_GCC holds the value of the environment variable with
1066 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
1067 struct cl_decoded_option
*decoded_cl_options
,
1068 unsigned int decoded_cl_options_count
,
1069 struct cl_decoded_option
**opts
,
1070 unsigned int *opt_count
, const char *collect_gcc
)
1072 off_t offset
, length
;
1077 struct cl_decoded_option
*fdecoded_options
= *opts
;
1078 unsigned int fdecoded_options_count
= *opt_count
;
1080 simple_object_read
*sobj
;
1081 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
1086 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
1087 strcpy (secname
, prefix
);
1088 strcat (secname
, ".opts");
1089 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
1092 simple_object_release_read (sobj
);
1096 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
1097 data
= (char *)xmalloc (length
);
1098 read (fd
, data
, length
);
1102 struct cl_decoded_option
*f2decoded_options
;
1103 unsigned int f2decoded_options_count
;
1104 get_options_from_collect_gcc_options (collect_gcc
, fopts
,
1106 &f2decoded_options_count
);
1107 if (!fdecoded_options
)
1109 fdecoded_options
= f2decoded_options
;
1110 fdecoded_options_count
= f2decoded_options_count
;
1113 merge_and_complain (&fdecoded_options
,
1114 &fdecoded_options_count
,
1115 f2decoded_options
, f2decoded_options_count
,
1117 decoded_cl_options_count
);
1119 fopts
+= strlen (fopts
) + 1;
1121 while (fopts
- data
< length
);
1124 simple_object_release_read (sobj
);
1125 *opts
= fdecoded_options
;
1126 *opt_count
= fdecoded_options_count
;
1130 /* Copy early debug info sections from INFILE to a new file whose name
1131 is returned. Return NULL on error. */
1134 debug_objcopy (const char *infile
, bool rename
)
1141 const char *orig_infile
= infile
;
1145 if ((p
= strrchr (infile
, '@'))
1147 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1148 && strlen (p
) == (unsigned int) consumed
)
1150 char *fname
= xstrdup (infile
);
1151 fname
[p
- infile
] = '\0';
1153 inoff
= (off_t
) loffset
;
1155 int infd
= open (infile
, O_RDONLY
| O_BINARY
);
1158 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
1165 if (simple_object_find_section (inobj
, ".gnu.debuglto_.debug_info",
1166 &off
, &len
, &errmsg
, &err
) != 1)
1169 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1171 simple_object_release_read (inobj
);
1177 outfile
= concat (orig_infile
, ".debug.temp.o", NULL
);
1179 outfile
= make_temp_file (".debug.temp.o");
1180 errmsg
= simple_object_copy_lto_debug_sections (inobj
, outfile
, &err
, rename
);
1183 unlink_if_ordinary (outfile
);
1184 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1187 simple_object_release_read (inobj
);
1193 /* Helper for qsort: compare priorities for parallel compilation. */
1196 cmp_priority (const void *a
, const void *b
)
1198 return *((const int *)b
)-*((const int *)a
);
1201 /* Number of CPUs that can be used for parallel LTRANS phase. */
1203 static unsigned long nthreads_var
= 0;
1205 #ifdef HAVE_PTHREAD_AFFINITY_NP
1206 unsigned long cpuset_size
;
1207 static unsigned long get_cpuset_size
;
1211 static cpuset_popcount (unsigned long cpusetsize
, cpu_set_t
*cpusetp
)
1214 /* glibc 2.7 and above provide a macro for this. */
1215 return CPU_COUNT_S (cpusetsize
, cpusetp
);
1218 if (cpusetsize
== sizeof (cpu_set_t
))
1219 /* glibc 2.6 and above provide a macro for this. */
1220 return CPU_COUNT (cpusetp
);
1223 unsigned long ret
= 0;
1224 STATIC_ASSERT (sizeof (cpusetp
->__bits
[0]) == sizeof (unsigned long int));
1225 for (i
= 0; i
< cpusetsize
/ sizeof (cpusetp
->__bits
[0]); i
++)
1227 unsigned long int mask
= cpusetp
->__bits
[i
];
1230 ret
+= __builtin_popcountl (mask
);
1237 /* At startup, determine the default number of threads. It would seem
1238 this should be related to the number of cpus online. */
1241 init_num_threads (void)
1243 #ifdef HAVE_PTHREAD_AFFINITY_NP
1244 #if defined (_SC_NPROCESSORS_CONF) && defined (CPU_ALLOC_SIZE)
1245 cpuset_size
= sysconf (_SC_NPROCESSORS_CONF
);
1246 cpuset_size
= CPU_ALLOC_SIZE (cpuset_size
);
1248 cpuset_size
= sizeof (cpu_set_t
);
1251 cpusetp
= (cpu_set_t
*) xmalloc (gomp_cpuset_size
);
1254 int ret
= pthread_getaffinity_np (pthread_self (), gomp_cpuset_size
,
1258 /* Count only the CPUs this process can use. */
1259 nthreads_var
= cpuset_popcount (cpuset_size
, cpusetp
);
1260 if (nthreads_var
== 0)
1262 get_cpuset_size
= cpuset_size
;
1263 #ifdef CPU_ALLOC_SIZE
1265 for (i
= cpuset_size
* 8; i
; i
--)
1266 if (CPU_ISSET_S (i
- 1, cpuset_size
, cpusetp
))
1268 cpuset_size
= CPU_ALLOC_SIZE (i
);
1274 #ifdef CPU_ALLOC_SIZE
1275 if (cpuset_size
< sizeof (cpu_set_t
))
1276 cpuset_size
= sizeof (cpu_set_t
);
1278 cpuset_size
= cpuset_size
* 2;
1279 if (cpuset_size
< 8 * sizeof (cpu_set_t
))
1281 = (cpu_set_t
*) realloc (cpusetp
, cpuset_size
);
1284 /* Avoid fatal if too large memory allocation would be
1285 requested, e.g. kernel returning EINVAL all the time. */
1286 void *p
= realloc (cpusetp
, cpuset_size
);
1289 cpusetp
= (cpu_set_t
*) p
;
1301 #ifdef _SC_NPROCESSORS_ONLN
1302 nthreads_var
= sysconf (_SC_NPROCESSORS_ONLN
);
1306 /* FIXME: once using -std=c++11, we can use std::thread::hardware_concurrency. */
1308 /* Test and return reason why a jobserver cannot be detected. */
1311 jobserver_active_p (void)
1313 #define JS_PREFIX "jobserver is not available: "
1314 #define JS_NEEDLE "--jobserver-auth="
1316 const char *makeflags
= getenv ("MAKEFLAGS");
1317 if (makeflags
== NULL
)
1318 return JS_PREFIX
"%<MAKEFLAGS%> environment variable is unset";
1320 const char *n
= strstr (makeflags
, JS_NEEDLE
);
1322 return JS_PREFIX
"%<" JS_NEEDLE
"%> is not present in %<MAKEFLAGS%>";
1327 if (sscanf (n
+ strlen (JS_NEEDLE
), "%d,%d", &rfd
, &wfd
) == 2
1330 && is_valid_fd (rfd
)
1331 && is_valid_fd (wfd
))
1334 return JS_PREFIX
"cannot access %<" JS_NEEDLE
"%> file descriptors";
1337 /* Test that a make command is present and working, return true if so. */
1342 const char *make
= "make";
1343 char **make_argv
= buildargv (getenv ("MAKE"));
1345 make
= make_argv
[0];
1346 const char *make_args
[] = {make
, "--version", NULL
};
1348 int exit_status
= 0;
1351 = pex_one (PEX_SEARCH
, make_args
[0], CONST_CAST (char **, make_args
),
1352 "make", NULL
, NULL
, &exit_status
, &err
);
1353 freeargv (make_argv
);
1354 return errmsg
== NULL
&& exit_status
== 0 && err
== 0;
1357 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1360 run_gcc (unsigned argc
, char *argv
[])
1363 const char **new_argv
;
1364 const char **argv_ptr
;
1365 char *list_option_full
= NULL
;
1366 const char *linker_output
= NULL
;
1367 const char *collect_gcc
;
1368 char *collect_gcc_options
;
1371 int auto_parallel
= 0;
1372 bool no_partition
= false;
1373 struct cl_decoded_option
*fdecoded_options
= NULL
;
1374 struct cl_decoded_option
*offload_fdecoded_options
= NULL
;
1375 unsigned int fdecoded_options_count
= 0;
1376 unsigned int offload_fdecoded_options_count
= 0;
1377 struct cl_decoded_option
*decoded_options
;
1378 unsigned int decoded_options_count
;
1379 struct obstack argv_obstack
;
1381 bool have_lto
= false;
1382 bool have_offload
= false;
1383 unsigned lto_argc
= 0, ltoobj_argc
= 0;
1384 char **lto_argv
, **ltoobj_argv
;
1385 bool linker_output_rel
= false;
1386 bool skip_debug
= false;
1387 unsigned n_debugobj
;
1388 const char *incoming_dumppfx
= dumppfx
= NULL
;
1389 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1391 /* Get the driver and options. */
1392 collect_gcc
= getenv ("COLLECT_GCC");
1394 fatal_error (input_location
,
1395 "environment variable %<COLLECT_GCC%> must be set");
1396 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1397 if (!collect_gcc_options
)
1398 fatal_error (input_location
,
1399 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1401 char *collect_as_options
= getenv ("COLLECT_AS_OPTIONS");
1403 /* Prepend -Xassembler to each option, and append the string
1404 to collect_gcc_options. */
1405 if (collect_as_options
)
1407 obstack temporary_obstack
;
1408 obstack_init (&temporary_obstack
);
1410 prepend_xassembler_to_collect_as_options (collect_as_options
,
1411 &temporary_obstack
);
1412 obstack_1grow (&temporary_obstack
, '\0');
1414 char *xassembler_opts_string
1415 = XOBFINISH (&temporary_obstack
, char *);
1416 collect_gcc_options
= concat (collect_gcc_options
, xassembler_opts_string
,
1420 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
1422 &decoded_options_count
);
1424 /* Allocate array for input object files with LTO IL,
1425 and for possible preceding arguments. */
1426 lto_argv
= XNEWVEC (char *, argc
);
1427 ltoobj_argv
= XNEWVEC (char *, argc
);
1429 /* Look at saved options in the IL files. */
1430 for (i
= 1; i
< argc
; ++i
)
1434 off_t file_offset
= 0;
1437 char *filename
= argv
[i
];
1439 if (strncmp (argv
[i
], "-foffload-objects=",
1440 sizeof ("-foffload-objects=") - 1) == 0)
1442 have_offload
= true;
1443 offload_objects_file_name
1444 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1448 if ((p
= strrchr (argv
[i
], '@'))
1450 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1451 && strlen (p
) == (unsigned int) consumed
)
1453 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1454 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1455 filename
[p
- argv
[i
]] = '\0';
1456 file_offset
= (off_t
) loffset
;
1458 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1459 /* Linker plugin passes -fresolution and -flinker-output options.
1460 -flinker-output is passed only when user did not specify one and thus
1461 we do not need to worry about duplicities with the option handling
1465 lto_argv
[lto_argc
++] = argv
[i
];
1466 if (strcmp (argv
[i
], "-flinker-output=rel") == 0)
1467 linker_output_rel
= true;
1471 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1472 decoded_options
, decoded_options_count
,
1473 &fdecoded_options
, &fdecoded_options_count
,
1477 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1482 /* Initalize the common arguments for the driver. */
1483 obstack_init (&argv_obstack
);
1484 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1485 obstack_ptr_grow (&argv_obstack
, "-xlto");
1486 obstack_ptr_grow (&argv_obstack
, "-c");
1488 append_compiler_options (&argv_obstack
, fdecoded_options
,
1489 fdecoded_options_count
);
1490 append_linker_options (&argv_obstack
, decoded_options
, decoded_options_count
);
1492 /* Scan linker driver arguments for things that are of relevance to us. */
1493 for (j
= 1; j
< decoded_options_count
; ++j
)
1495 struct cl_decoded_option
*option
= &decoded_options
[j
];
1496 switch (option
->opt_index
)
1499 linker_output
= option
->arg
;
1502 /* We don't have to distinguish between -save-temps=* and
1503 -save-temps, -dumpdir already carries that
1505 case OPT_save_temps_
:
1506 case OPT_save_temps
:
1514 case OPT_flto_partition_
:
1515 if (strcmp (option
->arg
, "none") == 0)
1516 no_partition
= true;
1520 if (strcmp (option
->arg
, "jobserver") == 0)
1525 else if (strcmp (option
->arg
, "auto") == 0)
1532 parallel
= atoi (option
->arg
);
1539 lto_mode
= LTO_MODE_WHOPR
;
1542 case OPT_flinker_output_
:
1543 linker_output_rel
= !strcmp (option
->arg
, "rel");
1547 /* Recognize -g0. */
1548 skip_debug
= option
->arg
&& !strcmp (option
->arg
, "0");
1552 incoming_dumppfx
= dumppfx
= option
->arg
;
1560 /* Output lto-wrapper invocation command. */
1563 for (i
= 0; i
< argc
; ++i
)
1565 fputs (argv
[i
], stderr
);
1566 fputc (' ', stderr
);
1568 fputc ('\n', stderr
);
1571 if (linker_output_rel
)
1572 no_partition
= true;
1576 lto_mode
= LTO_MODE_LTO
;
1583 const char *jobserver_error
= jobserver_active_p ();
1584 if (jobserver
&& jobserver_error
!= NULL
)
1585 warning (0, jobserver_error
);
1586 else if (!jobserver
&& jobserver_error
== NULL
)
1593 /* We need make working for a parallel execution. */
1594 if (parallel
&& !make_exists ())
1600 || strcmp (linker_output
, HOST_BIT_BUCKET
) == 0)
1604 const char *obase
= lbasename (linker_output
), *temp
;
1606 /* Strip the executable extension. */
1607 size_t blen
= strlen (obase
), xlen
;
1608 if ((temp
= strrchr (obase
+ 1, '.'))
1609 && (xlen
= strlen (temp
))
1610 && (strcmp (temp
, ".exe") == 0
1611 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
1612 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
1614 || strcmp (obase
, "a.out") == 0))
1615 dumppfx
= xstrndup (linker_output
,
1616 obase
- linker_output
+ blen
- xlen
+ 1);
1618 dumppfx
= concat (linker_output
, ".", NULL
);
1622 /* If there's no directory component in the dumppfx, add one, so
1623 that, when it is used as -dumpbase, it overrides any occurrence
1624 of -dumpdir that might have been passed in. */
1625 if (!dumppfx
|| lbasename (dumppfx
) == dumppfx
)
1626 dumppfx
= concat (current_dir
, dumppfx
, NULL
);
1628 /* Make sure some -dumpdir is passed, so as to get predictable
1629 -dumpbase overriding semantics. If we got an incoming -dumpdir
1630 argument, we'll pass it on, so don't bother with another one
1632 if (!incoming_dumppfx
)
1634 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1635 obstack_ptr_grow (&argv_obstack
, "");
1637 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1639 /* Remember at which point we can scrub args to re-use the commons. */
1640 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1644 unsigned i
, num_offload_files
;
1645 char **offload_argv
;
1648 f
= fopen (offload_objects_file_name
, "r");
1650 fatal_error (input_location
, "cannot open %s: %m",
1651 offload_objects_file_name
);
1652 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1653 fatal_error (input_location
, "cannot read %s: %m",
1654 offload_objects_file_name
);
1655 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1657 /* Read names of object files with offload. */
1658 for (i
= 0; i
< num_offload_files
; i
++)
1660 const unsigned piece
= 32;
1661 char *buf
, *filename
= XNEWVEC (char, piece
);
1666 if (!fgets (buf
, piece
, f
))
1668 len
= strlen (filename
);
1669 if (filename
[len
- 1] != '\n')
1671 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1672 buf
= filename
+ len
;
1675 filename
[len
- 1] = '\0';
1676 offload_argv
[i
] = filename
;
1679 if (offload_argv
[num_offload_files
- 1] == NULL
)
1680 fatal_error (input_location
, "invalid format of %s",
1681 offload_objects_file_name
);
1682 maybe_unlink (offload_objects_file_name
);
1683 offload_objects_file_name
= NULL
;
1685 /* Look at saved offload options in files. */
1686 for (i
= 0; i
< num_offload_files
; i
++)
1691 off_t file_offset
= 0;
1692 char *filename
= offload_argv
[i
];
1694 if ((p
= strrchr (offload_argv
[i
], '@'))
1695 && p
!= offload_argv
[i
]
1696 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1697 && strlen (p
) == (unsigned int) consumed
)
1699 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1700 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1701 filename
[p
- offload_argv
[i
]] = '\0';
1702 file_offset
= (off_t
) loffset
;
1704 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1706 fatal_error (input_location
, "cannot open %s: %m", filename
);
1707 if (!find_and_merge_options (fd
, file_offset
,
1708 OFFLOAD_SECTION_NAME_PREFIX
,
1709 decoded_options
, decoded_options_count
,
1710 &offload_fdecoded_options
,
1711 &offload_fdecoded_options_count
,
1713 fatal_error (input_location
, "cannot read %s: %m", filename
);
1715 if (filename
!= offload_argv
[i
])
1716 XDELETEVEC (filename
);
1719 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1720 offload_fdecoded_options
,
1721 offload_fdecoded_options_count
,
1723 decoded_options_count
);
1725 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1729 find_crtoffloadtable (save_temps
, dumppfx
);
1730 for (i
= 0; offload_names
[i
]; i
++)
1731 printf ("%s\n", offload_names
[i
]);
1732 free_array_of_ptrs ((void **) offload_names
, i
);
1736 /* If object files contain offload sections, but do not contain LTO sections,
1737 then there is no need to perform a link-time recompilation, i.e.
1738 lto-wrapper is used only for a compilation of offload images. */
1739 if (have_offload
&& !have_lto
)
1742 if (lto_mode
== LTO_MODE_LTO
)
1744 /* -dumpbase argument for LTO. */
1745 flto_out
= concat (dumppfx
, "lto.o", NULL
);
1746 obstack_ptr_grow (&argv_obstack
, flto_out
);
1749 flto_out
= make_temp_file (".lto.o");
1750 obstack_ptr_grow (&argv_obstack
, "-o");
1751 obstack_ptr_grow (&argv_obstack
, flto_out
);
1755 const char *list_option
= "-fltrans-output-list=";
1757 /* -dumpbase argument for WPA. */
1758 char *dumpbase
= concat (dumppfx
, "wpa", NULL
);
1759 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1762 ltrans_output_file
= concat (dumppfx
, "ltrans.out", NULL
);
1764 ltrans_output_file
= make_temp_file (".ltrans.out");
1765 list_option_full
= concat (list_option
, ltrans_output_file
, NULL
);
1766 obstack_ptr_grow (&argv_obstack
, list_option_full
);
1771 fprintf (stderr
, "Using make jobserver\n");
1772 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1774 else if (auto_parallel
)
1777 init_num_threads ();
1779 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1781 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1782 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1784 else if (parallel
> 1)
1787 sprintf (buf
, "-fwpa=%i", parallel
);
1788 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1791 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1794 /* Append input arguments. */
1795 for (i
= 0; i
< lto_argc
; ++i
)
1796 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1797 /* Append the input objects. */
1798 for (i
= 0; i
< ltoobj_argc
; ++i
)
1799 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1800 obstack_ptr_grow (&argv_obstack
, NULL
);
1802 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1803 argv_ptr
= &new_argv
[new_head_argc
];
1804 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true,
1807 /* Copy the early generated debug info from the objects to temporary
1808 files and append those to the partial link commandline. */
1810 early_debug_object_names
= NULL
;
1813 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1814 num_deb_objs
= ltoobj_argc
;
1815 for (i
= 0; i
< ltoobj_argc
; ++i
)
1818 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1820 early_debug_object_names
[i
] = tem
;
1826 if (lto_mode
== LTO_MODE_LTO
)
1828 printf ("%s\n", flto_out
);
1831 for (i
= 0; i
< ltoobj_argc
; ++i
)
1832 if (early_debug_object_names
[i
] != NULL
)
1833 printf ("%s\n", early_debug_object_names
[i
]);
1835 /* These now belong to collect2. */
1838 free (early_debug_object_names
);
1839 early_debug_object_names
= NULL
;
1843 FILE *stream
= fopen (ltrans_output_file
, "r");
1844 FILE *mstream
= NULL
;
1845 struct obstack env_obstack
;
1849 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1851 /* Parse the list of LTRANS inputs from the WPA stage. */
1852 obstack_init (&env_obstack
);
1856 const unsigned piece
= 32;
1857 char *output_name
= NULL
;
1858 char *buf
, *input_name
= (char *)xmalloc (piece
);
1862 if (fscanf (stream
, "%i\n", &priority
) != 1)
1865 fatal_error (input_location
,
1866 "corrupted ltrans output file %s",
1867 ltrans_output_file
);
1871 if (!fgets (buf
, piece
, stream
))
1873 len
= strlen (input_name
);
1874 if (input_name
[len
- 1] != '\n')
1876 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1877 buf
= input_name
+ len
;
1880 input_name
[len
- 1] = '\0';
1882 if (input_name
[0] == '*')
1883 output_name
= &input_name
[1];
1887 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1888 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1889 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1890 ltrans_priorities
[(nr
-1)*2] = priority
;
1891 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1892 input_names
[nr
-1] = input_name
;
1893 output_names
[nr
-1] = output_name
;
1896 maybe_unlink (ltrans_output_file
);
1897 ltrans_output_file
= NULL
;
1901 makefile
= make_temp_file (".mk");
1902 mstream
= fopen (makefile
, "w");
1903 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1906 /* Execute the LTRANS stage for each input file (or prepare a
1907 makefile to invoke this in parallel). */
1908 for (i
= 0; i
< nr
; ++i
)
1911 char *input_name
= input_names
[i
];
1912 /* If it's a pass-through file do nothing. */
1913 if (output_names
[i
])
1916 /* Replace the .o suffix with a .ltrans.o suffix and write
1917 the resulting name to the LTRANS output list. */
1918 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1919 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1920 output_name
= XOBFINISH (&env_obstack
, char *);
1922 /* Adjust the dumpbase if the linker output file was seen. */
1923 int dumpbase_len
= (strlen (dumppfx
) + sizeof (DUMPBASE_SUFFIX
));
1924 char *dumpbase
= (char *) xmalloc (dumpbase_len
+ 1);
1925 snprintf (dumpbase
, dumpbase_len
, "%sltrans%u.ltrans", dumppfx
, i
);
1926 argv_ptr
[0] = dumpbase
;
1928 argv_ptr
[1] = "-fltrans";
1930 argv_ptr
[3] = output_name
;
1931 argv_ptr
[4] = input_name
;
1935 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1936 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1937 fprintf (mstream
, " '%s'", new_argv
[j
]);
1938 fprintf (mstream
, "\n");
1939 /* If we are not preserving the ltrans input files then
1940 truncate them as soon as we have processed it. This
1941 reduces temporary disk-space usage. */
1943 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1944 "&& mv %s.tem %s\n",
1945 input_name
, input_name
, input_name
, input_name
);
1949 char argsuffix
[sizeof (DUMPBASE_SUFFIX
) + 1];
1951 snprintf (argsuffix
, sizeof (DUMPBASE_SUFFIX
),
1952 "ltrans%u.ltrans_args", i
);
1953 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1954 true, save_temps
? argsuffix
: NULL
);
1955 maybe_unlink (input_name
);
1958 output_names
[i
] = output_name
;
1962 struct pex_obj
*pex
;
1968 for (i
= 0; i
< nr
; ++i
)
1970 int j
= ltrans_priorities
[i
*2 + 1];
1971 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1973 fprintf (mstream
, "\n");
1977 /* Avoid passing --jobserver-fd= and similar flags
1978 unless jobserver mode is explicitly enabled. */
1979 putenv (xstrdup ("MAKEFLAGS="));
1980 putenv (xstrdup ("MFLAGS="));
1983 char **make_argv
= buildargv (getenv ("MAKE"));
1986 for (unsigned argc
= 0; make_argv
[argc
]; argc
++)
1987 obstack_ptr_grow (&argv_obstack
, make_argv
[argc
]);
1990 obstack_ptr_grow (&argv_obstack
, "make");
1992 obstack_ptr_grow (&argv_obstack
, "-f");
1993 obstack_ptr_grow (&argv_obstack
, makefile
);
1996 snprintf (jobs
, 31, "-j%ld",
1997 auto_parallel
? nthreads_var
: parallel
);
1998 obstack_ptr_grow (&argv_obstack
, jobs
);
2000 obstack_ptr_grow (&argv_obstack
, "all");
2001 obstack_ptr_grow (&argv_obstack
, NULL
);
2002 new_argv
= XOBFINISH (&argv_obstack
, const char **);
2004 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
2005 NULL
, NULL
, PEX_SEARCH
, false, NULL
);
2006 do_wait (new_argv
[0], pex
);
2007 freeargv (make_argv
);
2008 maybe_unlink (makefile
);
2010 for (i
= 0; i
< nr
; ++i
)
2011 maybe_unlink (input_names
[i
]);
2013 for (i
= 0; i
< nr
; ++i
)
2015 fputs (output_names
[i
], stdout
);
2016 putc ('\n', stdout
);
2017 free (input_names
[i
]);
2021 for (i
= 0; i
< ltoobj_argc
; ++i
)
2022 if (early_debug_object_names
[i
] != NULL
)
2023 printf ("%s\n", early_debug_object_names
[i
]);
2026 free (ltrans_priorities
);
2027 free (output_names
);
2028 output_names
= NULL
;
2029 free (early_debug_object_names
);
2030 early_debug_object_names
= NULL
;
2032 free (list_option_full
);
2033 obstack_free (&env_obstack
, NULL
);
2038 obstack_free (&argv_obstack
, NULL
);
2045 main (int argc
, char *argv
[])
2049 init_opts_obstack ();
2051 p
= argv
[0] + strlen (argv
[0]);
2052 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
2056 xmalloc_set_program_name (progname
);
2058 gcc_init_libintl ();
2060 diagnostic_initialize (global_dc
, 0);
2062 if (atexit (lto_wrapper_cleanup
) != 0)
2063 fatal_error (input_location
, "%<atexit%> failed");
2065 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
2066 signal (SIGINT
, fatal_signal
);
2068 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
2069 signal (SIGHUP
, fatal_signal
);
2071 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
2072 signal (SIGTERM
, fatal_signal
);
2074 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
2075 signal (SIGPIPE
, fatal_signal
);
2078 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
2079 receive the signal. A different setting is inheritable */
2080 signal (SIGCHLD
, SIG_DFL
);
2083 /* We may be called with all the arguments stored in some file and
2084 passed with @file. Expand them into argv before processing. */
2085 expandargv (&argc
, &argv
);
2087 run_gcc (argc
, argv
);