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
)
1586 warning (0, jobserver_error
);
1590 else if (!jobserver
&& jobserver_error
== NULL
)
1597 /* We need make working for a parallel execution. */
1598 if (parallel
&& !make_exists ())
1604 || strcmp (linker_output
, HOST_BIT_BUCKET
) == 0)
1608 const char *obase
= lbasename (linker_output
), *temp
;
1610 /* Strip the executable extension. */
1611 size_t blen
= strlen (obase
), xlen
;
1612 if ((temp
= strrchr (obase
+ 1, '.'))
1613 && (xlen
= strlen (temp
))
1614 && (strcmp (temp
, ".exe") == 0
1615 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
1616 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
1618 || strcmp (obase
, "a.out") == 0))
1619 dumppfx
= xstrndup (linker_output
,
1620 obase
- linker_output
+ blen
- xlen
+ 1);
1622 dumppfx
= concat (linker_output
, ".", NULL
);
1626 /* If there's no directory component in the dumppfx, add one, so
1627 that, when it is used as -dumpbase, it overrides any occurrence
1628 of -dumpdir that might have been passed in. */
1629 if (!dumppfx
|| lbasename (dumppfx
) == dumppfx
)
1630 dumppfx
= concat (current_dir
, dumppfx
, NULL
);
1632 /* Make sure some -dumpdir is passed, so as to get predictable
1633 -dumpbase overriding semantics. If we got an incoming -dumpdir
1634 argument, we'll pass it on, so don't bother with another one
1636 if (!incoming_dumppfx
)
1638 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1639 obstack_ptr_grow (&argv_obstack
, "");
1641 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1643 /* Remember at which point we can scrub args to re-use the commons. */
1644 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1648 unsigned i
, num_offload_files
;
1649 char **offload_argv
;
1652 f
= fopen (offload_objects_file_name
, "r");
1654 fatal_error (input_location
, "cannot open %s: %m",
1655 offload_objects_file_name
);
1656 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1657 fatal_error (input_location
, "cannot read %s: %m",
1658 offload_objects_file_name
);
1659 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1661 /* Read names of object files with offload. */
1662 for (i
= 0; i
< num_offload_files
; i
++)
1664 const unsigned piece
= 32;
1665 char *buf
, *filename
= XNEWVEC (char, piece
);
1670 if (!fgets (buf
, piece
, f
))
1672 len
= strlen (filename
);
1673 if (filename
[len
- 1] != '\n')
1675 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1676 buf
= filename
+ len
;
1679 filename
[len
- 1] = '\0';
1680 offload_argv
[i
] = filename
;
1683 if (offload_argv
[num_offload_files
- 1] == NULL
)
1684 fatal_error (input_location
, "invalid format of %s",
1685 offload_objects_file_name
);
1686 maybe_unlink (offload_objects_file_name
);
1687 offload_objects_file_name
= NULL
;
1689 /* Look at saved offload options in files. */
1690 for (i
= 0; i
< num_offload_files
; i
++)
1695 off_t file_offset
= 0;
1696 char *filename
= offload_argv
[i
];
1698 if ((p
= strrchr (offload_argv
[i
], '@'))
1699 && p
!= offload_argv
[i
]
1700 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1701 && strlen (p
) == (unsigned int) consumed
)
1703 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1704 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1705 filename
[p
- offload_argv
[i
]] = '\0';
1706 file_offset
= (off_t
) loffset
;
1708 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1710 fatal_error (input_location
, "cannot open %s: %m", filename
);
1711 if (!find_and_merge_options (fd
, file_offset
,
1712 OFFLOAD_SECTION_NAME_PREFIX
,
1713 decoded_options
, decoded_options_count
,
1714 &offload_fdecoded_options
,
1715 &offload_fdecoded_options_count
,
1717 fatal_error (input_location
, "cannot read %s: %m", filename
);
1719 if (filename
!= offload_argv
[i
])
1720 XDELETEVEC (filename
);
1723 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1724 offload_fdecoded_options
,
1725 offload_fdecoded_options_count
,
1727 decoded_options_count
);
1729 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1733 find_crtoffloadtable (save_temps
, dumppfx
);
1734 for (i
= 0; offload_names
[i
]; i
++)
1735 printf ("%s\n", offload_names
[i
]);
1736 free_array_of_ptrs ((void **) offload_names
, i
);
1740 /* If object files contain offload sections, but do not contain LTO sections,
1741 then there is no need to perform a link-time recompilation, i.e.
1742 lto-wrapper is used only for a compilation of offload images. */
1743 if (have_offload
&& !have_lto
)
1746 if (lto_mode
== LTO_MODE_LTO
)
1748 /* -dumpbase argument for LTO. */
1749 flto_out
= concat (dumppfx
, "lto.o", NULL
);
1750 obstack_ptr_grow (&argv_obstack
, flto_out
);
1753 flto_out
= make_temp_file (".lto.o");
1754 obstack_ptr_grow (&argv_obstack
, "-o");
1755 obstack_ptr_grow (&argv_obstack
, flto_out
);
1759 const char *list_option
= "-fltrans-output-list=";
1761 /* -dumpbase argument for WPA. */
1762 char *dumpbase
= concat (dumppfx
, "wpa", NULL
);
1763 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1766 ltrans_output_file
= concat (dumppfx
, "ltrans.out", NULL
);
1768 ltrans_output_file
= make_temp_file (".ltrans.out");
1769 list_option_full
= concat (list_option
, ltrans_output_file
, NULL
);
1770 obstack_ptr_grow (&argv_obstack
, list_option_full
);
1775 fprintf (stderr
, "Using make jobserver\n");
1776 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1778 else if (auto_parallel
)
1781 init_num_threads ();
1783 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1785 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1786 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1788 else if (parallel
> 1)
1791 sprintf (buf
, "-fwpa=%i", parallel
);
1792 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1795 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1798 /* Append input arguments. */
1799 for (i
= 0; i
< lto_argc
; ++i
)
1800 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1801 /* Append the input objects. */
1802 for (i
= 0; i
< ltoobj_argc
; ++i
)
1803 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1804 obstack_ptr_grow (&argv_obstack
, NULL
);
1806 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1807 argv_ptr
= &new_argv
[new_head_argc
];
1808 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true,
1811 /* Copy the early generated debug info from the objects to temporary
1812 files and append those to the partial link commandline. */
1814 early_debug_object_names
= NULL
;
1817 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1818 num_deb_objs
= ltoobj_argc
;
1819 for (i
= 0; i
< ltoobj_argc
; ++i
)
1822 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1824 early_debug_object_names
[i
] = tem
;
1830 if (lto_mode
== LTO_MODE_LTO
)
1832 printf ("%s\n", flto_out
);
1835 for (i
= 0; i
< ltoobj_argc
; ++i
)
1836 if (early_debug_object_names
[i
] != NULL
)
1837 printf ("%s\n", early_debug_object_names
[i
]);
1839 /* These now belong to collect2. */
1842 free (early_debug_object_names
);
1843 early_debug_object_names
= NULL
;
1847 FILE *stream
= fopen (ltrans_output_file
, "r");
1848 FILE *mstream
= NULL
;
1849 struct obstack env_obstack
;
1853 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1855 /* Parse the list of LTRANS inputs from the WPA stage. */
1856 obstack_init (&env_obstack
);
1860 const unsigned piece
= 32;
1861 char *output_name
= NULL
;
1862 char *buf
, *input_name
= (char *)xmalloc (piece
);
1866 if (fscanf (stream
, "%i\n", &priority
) != 1)
1869 fatal_error (input_location
,
1870 "corrupted ltrans output file %s",
1871 ltrans_output_file
);
1875 if (!fgets (buf
, piece
, stream
))
1877 len
= strlen (input_name
);
1878 if (input_name
[len
- 1] != '\n')
1880 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1881 buf
= input_name
+ len
;
1884 input_name
[len
- 1] = '\0';
1886 if (input_name
[0] == '*')
1887 output_name
= &input_name
[1];
1891 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1892 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1893 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1894 ltrans_priorities
[(nr
-1)*2] = priority
;
1895 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1896 input_names
[nr
-1] = input_name
;
1897 output_names
[nr
-1] = output_name
;
1900 maybe_unlink (ltrans_output_file
);
1901 ltrans_output_file
= NULL
;
1905 makefile
= make_temp_file (".mk");
1906 mstream
= fopen (makefile
, "w");
1907 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1910 /* Execute the LTRANS stage for each input file (or prepare a
1911 makefile to invoke this in parallel). */
1912 for (i
= 0; i
< nr
; ++i
)
1915 char *input_name
= input_names
[i
];
1916 /* If it's a pass-through file do nothing. */
1917 if (output_names
[i
])
1920 /* Replace the .o suffix with a .ltrans.o suffix and write
1921 the resulting name to the LTRANS output list. */
1922 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1923 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1924 output_name
= XOBFINISH (&env_obstack
, char *);
1926 /* Adjust the dumpbase if the linker output file was seen. */
1927 int dumpbase_len
= (strlen (dumppfx
) + sizeof (DUMPBASE_SUFFIX
));
1928 char *dumpbase
= (char *) xmalloc (dumpbase_len
+ 1);
1929 snprintf (dumpbase
, dumpbase_len
, "%sltrans%u.ltrans", dumppfx
, i
);
1930 argv_ptr
[0] = dumpbase
;
1932 argv_ptr
[1] = "-fltrans";
1934 argv_ptr
[3] = output_name
;
1935 argv_ptr
[4] = input_name
;
1939 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1940 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1941 fprintf (mstream
, " '%s'", new_argv
[j
]);
1942 fprintf (mstream
, "\n");
1943 /* If we are not preserving the ltrans input files then
1944 truncate them as soon as we have processed it. This
1945 reduces temporary disk-space usage. */
1947 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1948 "&& mv %s.tem %s\n",
1949 input_name
, input_name
, input_name
, input_name
);
1953 char argsuffix
[sizeof (DUMPBASE_SUFFIX
) + 1];
1955 snprintf (argsuffix
, sizeof (DUMPBASE_SUFFIX
),
1956 "ltrans%u.ltrans_args", i
);
1957 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1958 true, save_temps
? argsuffix
: NULL
);
1959 maybe_unlink (input_name
);
1962 output_names
[i
] = output_name
;
1966 struct pex_obj
*pex
;
1972 for (i
= 0; i
< nr
; ++i
)
1974 int j
= ltrans_priorities
[i
*2 + 1];
1975 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1977 fprintf (mstream
, "\n");
1981 /* Avoid passing --jobserver-fd= and similar flags
1982 unless jobserver mode is explicitly enabled. */
1983 putenv (xstrdup ("MAKEFLAGS="));
1984 putenv (xstrdup ("MFLAGS="));
1987 char **make_argv
= buildargv (getenv ("MAKE"));
1990 for (unsigned argc
= 0; make_argv
[argc
]; argc
++)
1991 obstack_ptr_grow (&argv_obstack
, make_argv
[argc
]);
1994 obstack_ptr_grow (&argv_obstack
, "make");
1996 obstack_ptr_grow (&argv_obstack
, "-f");
1997 obstack_ptr_grow (&argv_obstack
, makefile
);
2000 snprintf (jobs
, 31, "-j%ld",
2001 auto_parallel
? nthreads_var
: parallel
);
2002 obstack_ptr_grow (&argv_obstack
, jobs
);
2004 obstack_ptr_grow (&argv_obstack
, "all");
2005 obstack_ptr_grow (&argv_obstack
, NULL
);
2006 new_argv
= XOBFINISH (&argv_obstack
, const char **);
2008 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
2009 NULL
, NULL
, PEX_SEARCH
, false, NULL
);
2010 do_wait (new_argv
[0], pex
);
2011 freeargv (make_argv
);
2012 maybe_unlink (makefile
);
2014 for (i
= 0; i
< nr
; ++i
)
2015 maybe_unlink (input_names
[i
]);
2017 for (i
= 0; i
< nr
; ++i
)
2019 fputs (output_names
[i
], stdout
);
2020 putc ('\n', stdout
);
2021 free (input_names
[i
]);
2025 for (i
= 0; i
< ltoobj_argc
; ++i
)
2026 if (early_debug_object_names
[i
] != NULL
)
2027 printf ("%s\n", early_debug_object_names
[i
]);
2030 free (ltrans_priorities
);
2031 free (output_names
);
2032 output_names
= NULL
;
2033 free (early_debug_object_names
);
2034 early_debug_object_names
= NULL
;
2036 free (list_option_full
);
2037 obstack_free (&env_obstack
, NULL
);
2042 obstack_free (&argv_obstack
, NULL
);
2049 main (int argc
, char *argv
[])
2053 init_opts_obstack ();
2055 p
= argv
[0] + strlen (argv
[0]);
2056 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
2060 xmalloc_set_program_name (progname
);
2062 gcc_init_libintl ();
2064 diagnostic_initialize (global_dc
, 0);
2066 if (atexit (lto_wrapper_cleanup
) != 0)
2067 fatal_error (input_location
, "%<atexit%> failed");
2069 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
2070 signal (SIGINT
, fatal_signal
);
2072 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
2073 signal (SIGHUP
, fatal_signal
);
2075 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
2076 signal (SIGTERM
, fatal_signal
);
2078 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
2079 signal (SIGPIPE
, fatal_signal
);
2082 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
2083 receive the signal. A different setting is inheritable */
2084 signal (SIGCHLD
, SIG_DFL
);
2087 /* We may be called with all the arguments stored in some file and
2088 passed with @file. Expand them into argv before processing. */
2089 expandargv (&argc
, &argv
);
2091 run_gcc (argc
, argv
);