1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2022 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"
51 #include "opts-diagnostic.h"
53 /* Environment variable, used for passing the names of offload targets from GCC
54 driver to lto-wrapper. */
55 #define OFFLOAD_TARGET_NAMES_ENV "OFFLOAD_TARGET_NAMES"
56 #define OFFLOAD_TARGET_DEFAULT_ENV "OFFLOAD_TARGET_DEFAULT"
58 /* By default there is no special suffix for target executables. */
59 #ifdef TARGET_EXECUTABLE_SUFFIX
60 #define HAVE_TARGET_EXECUTABLE_SUFFIX
62 #define TARGET_EXECUTABLE_SUFFIX ""
66 LTO_MODE_NONE
, /* Not doing LTO. */
67 LTO_MODE_LTO
, /* Normal LTO. */
68 LTO_MODE_WHOPR
/* WHOPR. */
71 /* Current LTO mode. */
72 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
74 static char *ltrans_output_file
;
75 static char *flto_out
;
76 static unsigned int nr
;
77 static int *ltrans_priorities
;
78 static char **input_names
;
79 static char **output_names
;
80 static char **offload_names
;
81 static char *offload_objects_file_name
;
82 static char *makefile
;
83 static unsigned int num_deb_objs
;
84 static const char **early_debug_object_names
;
85 static bool xassembler_options_error
= false;
87 const char tool_name
[] = "lto-wrapper";
89 /* Delete tempfiles. Called from utils_cleanup. */
96 if (ltrans_output_file
)
97 maybe_unlink (ltrans_output_file
);
99 maybe_unlink (flto_out
);
100 if (offload_objects_file_name
)
101 maybe_unlink (offload_objects_file_name
);
103 maybe_unlink (makefile
);
104 if (early_debug_object_names
)
105 for (i
= 0; i
< num_deb_objs
; ++i
)
106 if (early_debug_object_names
[i
])
107 maybe_unlink (early_debug_object_names
[i
]);
108 for (i
= 0; i
< nr
; ++i
)
110 maybe_unlink (input_names
[i
]);
112 maybe_unlink (output_names
[i
]);
117 lto_wrapper_cleanup (void)
119 utils_cleanup (false);
122 /* Unlink a temporary LTRANS file unless requested otherwise. */
125 maybe_unlink (const char *file
)
129 if (unlink_if_ordinary (file
)
131 fatal_error (input_location
, "deleting LTRANS file %s: %m", file
);
134 fprintf (stderr
, "[Leaving LTRANS %s]\n", file
);
137 /* Template of LTRANS dumpbase suffix. */
138 #define DUMPBASE_SUFFIX "ltrans18446744073709551615"
140 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
143 static vec
<cl_decoded_option
>
144 get_options_from_collect_gcc_options (const char *collect_gcc
,
145 const char *collect_gcc_options
)
147 cl_decoded_option
*decoded_options
;
148 unsigned int decoded_options_count
;
149 struct obstack argv_obstack
;
153 obstack_init (&argv_obstack
);
154 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
156 parse_options_from_collect_gcc_options (collect_gcc_options
,
157 &argv_obstack
, &argc
);
158 argv
= XOBFINISH (&argv_obstack
, const char **);
160 decode_cmdline_options_to_array (argc
, (const char **)argv
, CL_DRIVER
,
161 &decoded_options
, &decoded_options_count
);
162 vec
<cl_decoded_option
> decoded
;
163 decoded
.create (decoded_options_count
);
164 for (unsigned i
= 0; i
< decoded_options_count
; ++i
)
165 decoded
.quick_push (decoded_options
[i
]);
166 free (decoded_options
);
168 obstack_free (&argv_obstack
, NULL
);
173 /* Find option in OPTIONS based on OPT_INDEX, starting at START. -1
174 value is returned if the option is not present. */
177 find_option (vec
<cl_decoded_option
> &options
, size_t opt_index
,
180 for (unsigned i
= start
; i
< options
.length (); ++i
)
181 if (options
[i
].opt_index
== opt_index
)
188 find_option (vec
<cl_decoded_option
> &options
, cl_decoded_option
*option
)
190 return find_option (options
, option
->opt_index
);
193 /* Merge -flto FOPTION into vector of DECODED_OPTIONS. */
196 merge_flto_options (vec
<cl_decoded_option
> &decoded_options
,
197 cl_decoded_option
*foption
)
199 int existing_opt
= find_option (decoded_options
, foption
);
200 if (existing_opt
== -1)
201 decoded_options
.safe_push (*foption
);
204 if (strcmp (foption
->arg
, decoded_options
[existing_opt
].arg
) != 0)
206 /* -flto=auto is preferred. */
207 if (strcmp (decoded_options
[existing_opt
].arg
, "auto") == 0)
209 else if (strcmp (foption
->arg
, "auto") == 0
210 || strcmp (foption
->arg
, "jobserver") == 0)
211 decoded_options
[existing_opt
].arg
= foption
->arg
;
212 else if (strcmp (decoded_options
[existing_opt
].arg
,
215 int n
= atoi (foption
->arg
);
216 int original_n
= atoi (decoded_options
[existing_opt
].arg
);
218 decoded_options
[existing_opt
].arg
= foption
->arg
;
224 /* Try to merge and complain about options FDECODED_OPTIONS when applied
225 ontop of DECODED_OPTIONS. */
228 merge_and_complain (vec
<cl_decoded_option
> &decoded_options
,
229 vec
<cl_decoded_option
> fdecoded_options
,
230 vec
<cl_decoded_option
> decoded_cl_options
)
233 cl_decoded_option
*pic_option
= NULL
;
234 cl_decoded_option
*pie_option
= NULL
;
235 cl_decoded_option
*cf_protection_option
= NULL
;
237 /* ??? Merge options from files. Most cases can be
238 handled by either unioning or intersecting
239 (for example -fwrapv is a case for unioning,
240 -ffast-math is for intersection). Most complaints
241 about real conflicts between different options can
242 be deferred to the compiler proper. Options that
243 we can neither safely handle by intersection nor
244 unioning would need to be complained about here.
245 Ideally we'd have a flag in the opt files that
246 tells whether to union or intersect or reject.
247 In absence of that it's unclear what a good default is.
248 It's also difficult to get positional handling correct. */
250 /* Look for a -fcf-protection option in the link-time options
251 which overrides any -fcf-protection from the lto sections. */
252 for (i
= 0; i
< decoded_cl_options
.length (); ++i
)
254 cl_decoded_option
*foption
= &decoded_cl_options
[i
];
255 if (foption
->opt_index
== OPT_fcf_protection_
)
257 cf_protection_option
= foption
;
261 /* The following does what the old LTO option code did,
262 union all target and a selected set of common options. */
263 for (i
= 0; i
< fdecoded_options
.length (); ++i
)
265 cl_decoded_option
*foption
= &fdecoded_options
[i
];
266 int existing_opt
= find_option (decoded_options
, foption
);
267 switch (foption
->opt_index
)
269 case OPT_SPECIAL_unknown
:
270 case OPT_SPECIAL_ignore
:
271 case OPT_SPECIAL_warn_removed
:
272 case OPT_SPECIAL_program_name
:
273 case OPT_SPECIAL_input_file
:
277 if (!(cl_options
[foption
->opt_index
].flags
& CL_TARGET
))
281 case OPT_fdiagnostics_show_caret
:
282 case OPT_fdiagnostics_show_labels
:
283 case OPT_fdiagnostics_show_line_numbers
:
284 case OPT_fdiagnostics_show_option
:
285 case OPT_fdiagnostics_show_location_
:
286 case OPT_fshow_column
:
290 /* Do what the old LTO code did - collect exactly one option
291 setting per OPT code, we pick the first we encounter.
292 ??? This doesn't make too much sense, but when it doesn't
293 then we should complain. */
294 if (existing_opt
== -1)
295 decoded_options
.safe_push (*foption
);
298 /* Figure out what PIC/PIE level wins and merge the results. */
301 pic_option
= foption
;
305 pie_option
= foption
;
310 /* For selected options we can merge conservatively. */
311 if (existing_opt
== -1)
312 decoded_options
.safe_push (*foption
);
313 /* -fopenmp > -fno-openmp,
314 -fopenacc > -fno-openacc */
315 else if (foption
->value
> decoded_options
[existing_opt
].value
)
316 decoded_options
[existing_opt
] = *foption
;
319 case OPT_fopenacc_dim_
:
320 /* Append or check identical. */
321 if (existing_opt
== -1)
322 decoded_options
.safe_push (*foption
);
323 else if (strcmp (decoded_options
[existing_opt
].arg
, foption
->arg
))
324 fatal_error (input_location
,
325 "option %s with different values",
326 foption
->orig_option_with_args_text
);
329 case OPT_fcf_protection_
:
330 /* Default to link-time option, else append or check identical. */
331 if (!cf_protection_option
332 || cf_protection_option
->value
== CF_CHECK
)
334 if (existing_opt
== -1)
335 decoded_options
.safe_push (*foption
);
336 else if (decoded_options
[existing_opt
].value
!= foption
->value
)
338 if (cf_protection_option
339 && cf_protection_option
->value
== CF_CHECK
)
340 fatal_error (input_location
,
341 "option %qs with mismatching values"
344 decoded_options
[existing_opt
].arg
,
348 /* Merge and update the -fcf-protection option. */
349 decoded_options
[existing_opt
].value
350 &= (foption
->value
& CF_FULL
);
351 switch (decoded_options
[existing_opt
].value
)
354 decoded_options
[existing_opt
].arg
= "none";
357 decoded_options
[existing_opt
].arg
= "branch";
360 decoded_options
[existing_opt
].arg
= "return";
376 for (j
= 0; j
< decoded_options
.length (); ++j
)
377 if (decoded_options
[j
].opt_index
== OPT_O
378 || decoded_options
[j
].opt_index
== OPT_Ofast
379 || decoded_options
[j
].opt_index
== OPT_Og
380 || decoded_options
[j
].opt_index
== OPT_Os
381 || decoded_options
[j
].opt_index
== OPT_Oz
)
386 if (existing_opt
== -1)
387 decoded_options
.safe_push (*foption
);
388 else if (decoded_options
[existing_opt
].opt_index
== foption
->opt_index
389 && foption
->opt_index
!= OPT_O
)
390 /* Exact same options get merged. */
394 /* For mismatched option kinds preserve the optimization
395 level only, thus merge it as -On. This also handles
396 merging of same optimization level -On. */
398 switch (foption
->opt_index
)
401 if (foption
->arg
[0] == '\0')
402 level
= MAX (level
, 1);
404 level
= MAX (level
, atoi (foption
->arg
));
407 level
= MAX (level
, 3);
410 level
= MAX (level
, 1);
414 level
= MAX (level
, 2);
419 switch (decoded_options
[existing_opt
].opt_index
)
422 if (decoded_options
[existing_opt
].arg
[0] == '\0')
423 level
= MAX (level
, 1);
426 atoi (decoded_options
[existing_opt
].arg
));
429 level
= MAX (level
, 3);
432 level
= MAX (level
, 1);
436 level
= MAX (level
, 2);
441 decoded_options
[existing_opt
].opt_index
= OPT_O
;
443 tem
= xasprintf ("-O%d", level
);
444 decoded_options
[existing_opt
].arg
= &tem
[2];
445 decoded_options
[existing_opt
].canonical_option
[0] = tem
;
446 decoded_options
[existing_opt
].value
= 1;
451 case OPT_foffload_abi_
:
452 if (existing_opt
== -1)
453 decoded_options
.safe_push (*foption
);
454 else if (foption
->value
!= decoded_options
[existing_opt
].value
)
455 fatal_error (input_location
,
456 "option %s not used consistently in all LTO input"
457 " files", foption
->orig_option_with_args_text
);
461 case OPT_foffload_options_
:
462 decoded_options
.safe_push (*foption
);
466 merge_flto_options (decoded_options
, foption
);
471 /* Merge PIC options:
472 -fPIC + -fpic = -fpic
473 -fPIC + -fno-pic = -fno-pic
474 -fpic/-fPIC + nothing = nothing.
475 It is a common mistake to mix few -fPIC compiled objects into otherwise
476 non-PIC code. We do not want to build everything with PIC then.
478 Similarly we merge PIE options, however in addition we keep
479 -fPIC + -fPIE = -fPIE
480 -fpic + -fPIE = -fpie
481 -fPIC/-fpic + -fpie = -fpie
483 It would be good to warn on mismatches, but it is bit hard to do as
484 we do not know what nothing translates to. */
486 for (unsigned int j
= 0; j
< decoded_options
.length ();)
487 if (decoded_options
[j
].opt_index
== OPT_fPIC
488 || decoded_options
[j
].opt_index
== OPT_fpic
)
490 /* -fno-pic in one unit implies -fno-pic everywhere. */
491 if (decoded_options
[j
].value
== 0)
493 /* If we have no pic option or merge in -fno-pic, we still may turn
494 existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */
495 else if ((pic_option
&& pic_option
->value
== 0)
500 bool big
= decoded_options
[j
].opt_index
== OPT_fPIC
501 && pie_option
->opt_index
== OPT_fPIE
;
502 decoded_options
[j
].opt_index
= big
? OPT_fPIE
: OPT_fpie
;
503 if (pie_option
->value
)
504 decoded_options
[j
].canonical_option
[0]
505 = big
? "-fPIE" : "-fpie";
507 decoded_options
[j
].canonical_option
[0] = "-fno-pie";
508 decoded_options
[j
].value
= pie_option
->value
;
513 decoded_options
[j
] = *pic_option
;
516 /* We do not know if target defaults to pic or not, so just remove
517 option if it is missing in one unit but enabled in other. */
519 decoded_options
.ordered_remove (j
);
521 else if (pic_option
->opt_index
== OPT_fpic
522 && decoded_options
[j
].opt_index
== OPT_fPIC
)
524 decoded_options
[j
] = *pic_option
;
530 else if (decoded_options
[j
].opt_index
== OPT_fPIE
531 || decoded_options
[j
].opt_index
== OPT_fpie
)
533 /* -fno-pie in one unit implies -fno-pie everywhere. */
534 if (decoded_options
[j
].value
== 0)
536 /* If we have no pie option or merge in -fno-pie, we still preserve
537 PIE/pie if pic/PIC is present. */
538 else if ((pie_option
&& pie_option
->value
== 0)
541 /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */
544 if (pic_option
->opt_index
== OPT_fpic
545 && decoded_options
[j
].opt_index
== OPT_fPIE
)
547 decoded_options
[j
].opt_index
= OPT_fpie
;
548 decoded_options
[j
].canonical_option
[0]
549 = pic_option
->value
? "-fpie" : "-fno-pie";
551 else if (!pic_option
->value
)
552 decoded_options
[j
].canonical_option
[0] = "-fno-pie";
553 decoded_options
[j
].value
= pic_option
->value
;
558 decoded_options
[j
] = *pie_option
;
561 /* Because we always append pic/PIE options this code path should
562 not happen unless the LTO object was built by old lto1 which
563 did not contain that logic yet. */
565 decoded_options
.ordered_remove (j
);
567 else if (pie_option
->opt_index
== OPT_fpie
568 && decoded_options
[j
].opt_index
== OPT_fPIE
)
570 decoded_options
[j
] = *pie_option
;
579 int existing_opt_index
, existing_opt2_index
;
580 if (!xassembler_options_error
)
581 for (existing_opt_index
= existing_opt2_index
= 0; ;
582 existing_opt_index
++, existing_opt2_index
++)
585 = find_option (decoded_options
, OPT_Xassembler
, existing_opt_index
);
587 = find_option (fdecoded_options
, OPT_Xassembler
,
588 existing_opt2_index
);
590 cl_decoded_option
*existing_opt
= NULL
;
591 cl_decoded_option
*existing_opt2
= NULL
;
592 if (existing_opt_index
!= -1)
593 existing_opt
= &decoded_options
[existing_opt_index
];
594 if (existing_opt2_index
!= -1)
595 existing_opt2
= &fdecoded_options
[existing_opt2_index
];
597 if (existing_opt
== NULL
&& existing_opt2
== NULL
)
599 else if (existing_opt
!= NULL
&& existing_opt2
== NULL
)
601 warning (0, "Extra option to %<-Xassembler%>: %s,"
602 " dropping all %<-Xassembler%> and %<-Wa%> options.",
604 xassembler_options_error
= true;
607 else if (existing_opt
== NULL
&& existing_opt2
!= NULL
)
609 warning (0, "Extra option to %<-Xassembler%>: %s,"
610 " dropping all %<-Xassembler%> and %<-Wa%> options.",
612 xassembler_options_error
= true;
615 else if (strcmp (existing_opt
->arg
, existing_opt2
->arg
) != 0)
617 warning (0, "Options to %<-Xassembler%> do not match: %s, %s,"
618 " dropping all %<-Xassembler%> and %<-Wa%> options.",
619 existing_opt
->arg
, existing_opt2
->arg
);
620 xassembler_options_error
= true;
626 /* Auxiliary function that frees elements of PTR and PTR itself.
627 N is number of elements to be freed. If PTR is NULL, nothing is freed.
628 If an element is NULL, subsequent elements are not freed. */
631 free_array_of_ptrs (void **ptr
, unsigned n
)
635 for (unsigned i
= 0; i
< n
; i
++)
645 /* Parse STR, saving found tokens into PVALUES and return their number.
646 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
647 append it to every token we find. */
650 parse_env_var (const char *str
, char ***pvalues
, const char *append
)
652 const char *curval
, *nextval
;
656 curval
= strchr (str
, ':');
660 curval
= strchr (curval
+ 1, ':');
663 values
= (char**) xmalloc (num
* sizeof (char*));
665 nextval
= strchr (curval
, ':');
667 nextval
= strchr (curval
, '\0');
669 int append_len
= append
? strlen (append
) : 0;
670 for (i
= 0; i
< num
; i
++)
672 int l
= nextval
- curval
;
673 values
[i
] = (char*) xmalloc (l
+ 1 + append_len
);
674 memcpy (values
[i
], curval
, l
);
677 strcat (values
[i
], append
);
678 curval
= nextval
+ 1;
679 nextval
= strchr (curval
, ':');
681 nextval
= strchr (curval
, '\0');
687 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
690 append_compiler_options (obstack
*argv_obstack
, vec
<cl_decoded_option
> opts
)
692 /* Append compiler driver arguments as far as they were merged. */
693 for (unsigned int j
= 1; j
< opts
.length (); ++j
)
695 cl_decoded_option
*option
= &opts
[j
];
697 /* File options have been properly filtered by lto-opts.cc. */
698 switch (option
->opt_index
)
700 /* Drop arguments that we want to take from the link line. */
703 case OPT_flto_partition_
:
710 /* For now do what the original LTO option code was doing - pass
711 on any CL_TARGET flag and a few selected others. */
712 switch (option
->opt_index
)
714 case OPT_fdiagnostics_show_caret
:
715 case OPT_fdiagnostics_show_labels
:
716 case OPT_fdiagnostics_show_line_numbers
:
717 case OPT_fdiagnostics_show_option
:
718 case OPT_fdiagnostics_show_location_
:
719 case OPT_fshow_column
:
728 case OPT_fopenacc_dim_
:
729 case OPT_foffload_abi_
:
730 case OPT_fcf_protection_
:
740 /* When we detected a mismatch in assembler options between
741 the input TU's fall back to previous behavior of ignoring them. */
742 if (xassembler_options_error
)
747 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
751 /* Pass the option on. */
752 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
753 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
757 /* Append diag options in OPTS to ARGV_OBSTACK. */
760 append_diag_options (obstack
*argv_obstack
, vec
<cl_decoded_option
> opts
)
762 /* Append compiler driver arguments as far as they were merged. */
763 for (unsigned int j
= 1; j
< opts
.length (); ++j
)
765 cl_decoded_option
*option
= &opts
[j
];
767 switch (option
->opt_index
)
769 case OPT_fdiagnostics_color_
:
770 case OPT_fdiagnostics_format_
:
771 case OPT_fdiagnostics_show_caret
:
772 case OPT_fdiagnostics_show_labels
:
773 case OPT_fdiagnostics_show_line_numbers
:
774 case OPT_fdiagnostics_show_option
:
775 case OPT_fdiagnostics_show_location_
:
776 case OPT_fshow_column
:
782 /* Pass the option on. */
783 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
784 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
789 /* Append linker options OPTS to ARGV_OBSTACK. */
792 append_linker_options (obstack
*argv_obstack
, vec
<cl_decoded_option
> opts
)
794 /* Append linker driver arguments. Compiler options from the linker
795 driver arguments will override / merge with those from the compiler. */
796 for (unsigned int j
= 1; j
< opts
.length (); ++j
)
798 cl_decoded_option
*option
= &opts
[j
];
800 /* Do not pass on frontend specific flags not suitable for lto. */
801 if (!(cl_options
[option
->opt_index
].flags
802 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
805 switch (option
->opt_index
)
810 /* We've handled these LTO options, do not pass them on. */
815 /* Ignore -fno-XXX form of these options, as otherwise
816 corresponding builtins will not be enabled. */
817 if (option
->value
== 0)
825 /* Pass the option on. */
826 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
827 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
831 /* Extract options for TARGET offload compiler from OPTIONS and append
832 them to ARGV_OBSTACK. */
835 append_offload_options (obstack
*argv_obstack
, const char *target
,
836 vec
<cl_decoded_option
> options
)
838 for (unsigned i
= 0; i
< options
.length (); i
++)
840 const char *cur
, *next
, *opts
;
843 cl_decoded_option
*option
= &options
[i
];
845 if (option
->opt_index
!= OPT_foffload_options_
)
848 /* If option argument starts with '-' then no target is specified. That
849 means offload options are specified for all targets, so we need to
851 if (option
->arg
[0] == '-')
855 opts
= strchr (option
->arg
, '=');
861 next
= strchr (cur
, ',');
864 next
= (next
> opts
) ? opts
: next
;
866 /* Are we looking for this offload target? */
867 if (strlen (target
) == (size_t) (next
- cur
)
868 && strncmp (target
, cur
, next
- cur
) == 0)
871 /* Skip the comma or equal sign. */
881 argv
= buildargv (opts
);
882 for (argc
= 0; argv
[argc
]; argc
++)
883 obstack_ptr_grow (argv_obstack
, argv
[argc
]);
887 /* Check whether NAME can be accessed in MODE. This is like access,
888 except that it never considers directories to be executable. */
891 access_check (const char *name
, int mode
)
897 if (stat (name
, &st
) < 0
898 || S_ISDIR (st
.st_mode
))
902 return access (name
, mode
);
905 /* Prepare a target image for offload TARGET, using mkoffload tool from
906 COMPILER_PATH. Return the name of the resultant object file. */
909 compile_offload_image (const char *target
, const char *compiler_path
,
910 unsigned in_argc
, char *in_argv
[],
911 vec
<cl_decoded_option
> compiler_opts
,
912 vec
<cl_decoded_option
> linker_opts
)
914 char *filename
= NULL
;
918 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target
));
919 strcpy (suffix
, "/accel/");
920 strcat (suffix
, target
);
921 strcat (suffix
, "/mkoffload");
924 unsigned n_paths
= parse_env_var (compiler_path
, &paths
, suffix
);
926 const char *compiler
= NULL
;
927 for (unsigned i
= 0; i
< n_paths
; i
++)
928 if (access_check (paths
[i
], X_OK
) == 0)
933 #if OFFLOAD_DEFAULTED
934 if (!compiler
&& getenv (OFFLOAD_TARGET_DEFAULT_ENV
))
936 free_array_of_ptrs ((void **) paths
, n_paths
);
942 fatal_error (input_location
,
943 "could not find %s in %s (consider using %<-B%>)",
944 suffix
+ 1, compiler_path
);
946 dumpbase
= concat (dumppfx
, "x", target
, NULL
);
948 /* Generate temporary output file name. */
950 filename
= concat (dumpbase
, ".o", NULL
);
952 filename
= make_temp_file (".target.o");
954 struct obstack argv_obstack
;
955 obstack_init (&argv_obstack
);
956 obstack_ptr_grow (&argv_obstack
, compiler
);
958 obstack_ptr_grow (&argv_obstack
, "-save-temps");
960 obstack_ptr_grow (&argv_obstack
, "-v");
961 obstack_ptr_grow (&argv_obstack
, "-o");
962 obstack_ptr_grow (&argv_obstack
, filename
);
964 /* Append names of input object files. */
965 for (unsigned i
= 0; i
< in_argc
; i
++)
966 obstack_ptr_grow (&argv_obstack
, in_argv
[i
]);
968 /* Append options from offload_lto sections. */
969 append_compiler_options (&argv_obstack
, compiler_opts
);
970 append_diag_options (&argv_obstack
, linker_opts
);
972 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
973 obstack_ptr_grow (&argv_obstack
, dumpbase
);
975 /* Append options specified by -foffload last. In case of conflicting
976 options we expect offload compiler to choose the latest. */
977 append_offload_options (&argv_obstack
, target
, compiler_opts
);
978 append_offload_options (&argv_obstack
, target
, linker_opts
);
980 obstack_ptr_grow (&argv_obstack
, NULL
);
981 argv
= XOBFINISH (&argv_obstack
, char **);
982 fork_execute (argv
[0], argv
, true, "offload_args");
983 obstack_free (&argv_obstack
, NULL
);
985 free_array_of_ptrs ((void **) paths
, n_paths
);
990 /* The main routine dealing with offloading.
991 The routine builds a target image for each offload target. IN_ARGC and
992 IN_ARGV specify options and input object files. As all of them could contain
993 target sections, we pass them all to target compilers. */
996 compile_images_for_offload_targets (unsigned in_argc
, char *in_argv
[],
997 vec
<cl_decoded_option
> compiler_opts
,
998 vec
<cl_decoded_option
> linker_opts
)
1000 char **names
= NULL
;
1001 const char *target_names
= getenv (OFFLOAD_TARGET_NAMES_ENV
);
1004 unsigned num_targets
= parse_env_var (target_names
, &names
, NULL
);
1005 int next_name_entry
= 0;
1007 const char *compiler_path
= getenv ("COMPILER_PATH");
1011 /* Prepare an image for each target and save the name of the resultant object
1012 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
1013 offload_names
= XCNEWVEC (char *, num_targets
+ 1);
1014 for (unsigned i
= 0; i
< num_targets
; i
++)
1016 offload_names
[next_name_entry
]
1017 = compile_offload_image (names
[i
], compiler_path
, in_argc
, in_argv
,
1018 compiler_opts
, linker_opts
);
1019 if (!offload_names
[next_name_entry
])
1020 #if OFFLOAD_DEFAULTED
1023 fatal_error (input_location
,
1024 "problem with building target image for %s", names
[i
]);
1029 #if OFFLOAD_DEFAULTED
1030 if (next_name_entry
== 0)
1032 free (offload_names
);
1033 offload_names
= NULL
;
1038 free_array_of_ptrs ((void **) names
, num_targets
);
1041 /* Copy a file from SRC to DEST. */
1044 copy_file (const char *dest
, const char *src
)
1046 FILE *d
= fopen (dest
, "wb");
1047 FILE *s
= fopen (src
, "rb");
1051 size_t len
= fread (buffer
, 1, 512, s
);
1052 if (ferror (s
) != 0)
1053 fatal_error (input_location
, "reading input file");
1056 fwrite (buffer
, 1, len
, d
);
1057 if (ferror (d
) != 0)
1058 fatal_error (input_location
, "writing output file");
1065 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
1066 the copy to the linker. */
1069 find_crtoffloadtable (int save_temps
, const char *dumppfx
)
1071 char **paths
= NULL
;
1072 const char *library_path
= getenv ("LIBRARY_PATH");
1075 unsigned n_paths
= parse_env_var (library_path
, &paths
, "/crtoffloadtable.o");
1078 for (i
= 0; i
< n_paths
; i
++)
1079 if (access_check (paths
[i
], R_OK
) == 0)
1081 /* The linker will delete the filename we give it, so make a copy. */
1082 char *crtoffloadtable
;
1084 crtoffloadtable
= make_temp_file (".crtoffloadtable.o");
1086 crtoffloadtable
= concat (dumppfx
, "crtoffloadtable.o", NULL
);
1087 copy_file (crtoffloadtable
, paths
[i
]);
1088 printf ("%s\n", crtoffloadtable
);
1089 XDELETEVEC (crtoffloadtable
);
1093 fatal_error (input_location
,
1094 "installation error, cannot find %<crtoffloadtable.o%>");
1096 free_array_of_ptrs ((void **) paths
, n_paths
);
1099 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
1100 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS.
1101 Return true if we found a matching section, false
1102 otherwise. COLLECT_GCC holds the value of the environment variable with
1106 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
1107 vec
<cl_decoded_option
> decoded_cl_options
, bool first
,
1108 vec
<cl_decoded_option
> *opts
, const char *collect_gcc
)
1110 off_t offset
, length
;
1115 vec
<cl_decoded_option
> fdecoded_options
;
1118 fdecoded_options
= *opts
;
1120 simple_object_read
*sobj
;
1121 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
1126 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
1127 strcpy (secname
, prefix
);
1128 strcat (secname
, ".opts");
1129 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
1132 simple_object_release_read (sobj
);
1136 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
1137 data
= (char *)xmalloc (length
);
1138 read (fd
, data
, length
);
1142 vec
<cl_decoded_option
> f2decoded_options
1143 = get_options_from_collect_gcc_options (collect_gcc
, fopts
);
1146 fdecoded_options
= f2decoded_options
;
1150 merge_and_complain (fdecoded_options
, f2decoded_options
,
1151 decoded_cl_options
);
1153 fopts
+= strlen (fopts
) + 1;
1155 while (fopts
- data
< length
);
1158 simple_object_release_read (sobj
);
1159 *opts
= fdecoded_options
;
1163 /* Copy early debug info sections from INFILE to a new file whose name
1164 is returned. Return NULL on error. */
1167 debug_objcopy (const char *infile
, bool rename
)
1174 const char *orig_infile
= infile
;
1178 if ((p
= strrchr (infile
, '@'))
1180 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1181 && strlen (p
) == (unsigned int) consumed
)
1183 char *fname
= xstrdup (infile
);
1184 fname
[p
- infile
] = '\0';
1186 inoff
= (off_t
) loffset
;
1188 int infd
= open (infile
, O_RDONLY
| O_BINARY
);
1191 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
1198 if (simple_object_find_section (inobj
, ".gnu.debuglto_.debug_info",
1199 &off
, &len
, &errmsg
, &err
) != 1)
1202 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1204 simple_object_release_read (inobj
);
1210 outfile
= concat (orig_infile
, ".debug.temp.o", NULL
);
1212 outfile
= make_temp_file (".debug.temp.o");
1213 errmsg
= simple_object_copy_lto_debug_sections (inobj
, outfile
, &err
, rename
);
1216 unlink_if_ordinary (outfile
);
1217 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1220 simple_object_release_read (inobj
);
1226 /* Helper for qsort: compare priorities for parallel compilation. */
1229 cmp_priority (const void *a
, const void *b
)
1231 return *((const int *)b
)-*((const int *)a
);
1234 /* Number of CPUs that can be used for parallel LTRANS phase. */
1236 static unsigned long nthreads_var
= 0;
1238 #ifdef HAVE_PTHREAD_AFFINITY_NP
1239 unsigned long cpuset_size
;
1240 static unsigned long get_cpuset_size
;
1244 static cpuset_popcount (unsigned long cpusetsize
, cpu_set_t
*cpusetp
)
1247 /* glibc 2.7 and above provide a macro for this. */
1248 return CPU_COUNT_S (cpusetsize
, cpusetp
);
1251 if (cpusetsize
== sizeof (cpu_set_t
))
1252 /* glibc 2.6 and above provide a macro for this. */
1253 return CPU_COUNT (cpusetp
);
1256 unsigned long ret
= 0;
1257 STATIC_ASSERT (sizeof (cpusetp
->__bits
[0]) == sizeof (unsigned long int));
1258 for (i
= 0; i
< cpusetsize
/ sizeof (cpusetp
->__bits
[0]); i
++)
1260 unsigned long int mask
= cpusetp
->__bits
[i
];
1263 ret
+= __builtin_popcountl (mask
);
1270 /* At startup, determine the default number of threads. It would seem
1271 this should be related to the number of cpus online. */
1274 init_num_threads (void)
1276 #ifdef HAVE_PTHREAD_AFFINITY_NP
1277 #if defined (_SC_NPROCESSORS_CONF) && defined (CPU_ALLOC_SIZE)
1278 cpuset_size
= sysconf (_SC_NPROCESSORS_CONF
);
1279 cpuset_size
= CPU_ALLOC_SIZE (cpuset_size
);
1281 cpuset_size
= sizeof (cpu_set_t
);
1284 cpusetp
= (cpu_set_t
*) xmalloc (gomp_cpuset_size
);
1287 int ret
= pthread_getaffinity_np (pthread_self (), gomp_cpuset_size
,
1291 /* Count only the CPUs this process can use. */
1292 nthreads_var
= cpuset_popcount (cpuset_size
, cpusetp
);
1293 if (nthreads_var
== 0)
1295 get_cpuset_size
= cpuset_size
;
1296 #ifdef CPU_ALLOC_SIZE
1298 for (i
= cpuset_size
* 8; i
; i
--)
1299 if (CPU_ISSET_S (i
- 1, cpuset_size
, cpusetp
))
1301 cpuset_size
= CPU_ALLOC_SIZE (i
);
1307 #ifdef CPU_ALLOC_SIZE
1308 if (cpuset_size
< sizeof (cpu_set_t
))
1309 cpuset_size
= sizeof (cpu_set_t
);
1311 cpuset_size
= cpuset_size
* 2;
1312 if (cpuset_size
< 8 * sizeof (cpu_set_t
))
1314 = (cpu_set_t
*) realloc (cpusetp
, cpuset_size
);
1317 /* Avoid fatal if too large memory allocation would be
1318 requested, e.g. kernel returning EINVAL all the time. */
1319 void *p
= realloc (cpusetp
, cpuset_size
);
1322 cpusetp
= (cpu_set_t
*) p
;
1334 #ifdef _SC_NPROCESSORS_ONLN
1335 nthreads_var
= sysconf (_SC_NPROCESSORS_ONLN
);
1339 /* Test and return reason why a jobserver cannot be detected. */
1342 jobserver_active_p (void)
1344 #define JS_PREFIX "jobserver is not available: "
1345 #define JS_NEEDLE "--jobserver-auth="
1347 const char *makeflags
= getenv ("MAKEFLAGS");
1348 if (makeflags
== NULL
)
1349 return JS_PREFIX
"%<MAKEFLAGS%> environment variable is unset";
1351 const char *n
= strstr (makeflags
, JS_NEEDLE
);
1353 return JS_PREFIX
"%<" JS_NEEDLE
"%> is not present in %<MAKEFLAGS%>";
1358 if (sscanf (n
+ strlen (JS_NEEDLE
), "%d,%d", &rfd
, &wfd
) == 2
1361 && is_valid_fd (rfd
)
1362 && is_valid_fd (wfd
))
1365 return JS_PREFIX
"cannot access %<" JS_NEEDLE
"%> file descriptors";
1368 /* Print link to -flto documentation with a hint message. */
1371 print_lto_docs_link ()
1373 bool print_url
= global_dc
->printer
->url_format
!= URL_FORMAT_NONE
;
1374 const char *url
= global_dc
->get_option_url (global_dc
, OPT_flto
);
1377 pp
.url_format
= URL_FORMAT_DEFAULT
;
1378 pp_string (&pp
, "see the ");
1380 pp_begin_url (&pp
, url
);
1381 pp_string (&pp
, "%<-flto%> option documentation");
1384 pp_string (&pp
, " for more information");
1385 inform (UNKNOWN_LOCATION
, pp_formatted_text (&pp
));
1388 /* Test that a make command is present and working, return true if so. */
1393 const char *make
= "make";
1394 char **make_argv
= buildargv (getenv ("MAKE"));
1396 make
= make_argv
[0];
1397 const char *make_args
[] = {make
, "--version", NULL
};
1399 int exit_status
= 0;
1402 = pex_one (PEX_SEARCH
, make_args
[0], CONST_CAST (char **, make_args
),
1403 "make", NULL
, NULL
, &exit_status
, &err
);
1404 freeargv (make_argv
);
1405 return errmsg
== NULL
&& exit_status
== 0 && err
== 0;
1408 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1411 run_gcc (unsigned argc
, char *argv
[])
1414 const char **new_argv
;
1415 const char **argv_ptr
;
1416 char *list_option_full
= NULL
;
1417 const char *linker_output
= NULL
;
1418 const char *collect_gcc
;
1419 char *collect_gcc_options
;
1422 bool jobserver_requested
= false;
1423 int auto_parallel
= 0;
1424 bool no_partition
= false;
1425 const char *jobserver_error
= NULL
;
1426 bool fdecoded_options_first
= true;
1427 vec
<cl_decoded_option
> fdecoded_options
;
1428 fdecoded_options
.create (16);
1429 bool offload_fdecoded_options_first
= true;
1430 vec
<cl_decoded_option
> offload_fdecoded_options
= vNULL
;
1431 struct obstack argv_obstack
;
1433 bool have_lto
= false;
1434 bool have_offload
= false;
1435 unsigned lto_argc
= 0, ltoobj_argc
= 0;
1436 char **lto_argv
, **ltoobj_argv
;
1437 bool linker_output_rel
= false;
1438 bool skip_debug
= false;
1439 const char *incoming_dumppfx
= dumppfx
= NULL
;
1440 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1442 /* Get the driver and options. */
1443 collect_gcc
= getenv ("COLLECT_GCC");
1445 fatal_error (input_location
,
1446 "environment variable %<COLLECT_GCC%> must be set");
1447 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1448 if (!collect_gcc_options
)
1449 fatal_error (input_location
,
1450 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1452 char *collect_as_options
= getenv ("COLLECT_AS_OPTIONS");
1454 /* Prepend -Xassembler to each option, and append the string
1455 to collect_gcc_options. */
1456 if (collect_as_options
)
1458 obstack temporary_obstack
;
1459 obstack_init (&temporary_obstack
);
1461 prepend_xassembler_to_collect_as_options (collect_as_options
,
1462 &temporary_obstack
);
1463 obstack_1grow (&temporary_obstack
, '\0');
1465 char *xassembler_opts_string
1466 = XOBFINISH (&temporary_obstack
, char *);
1467 collect_gcc_options
= concat (collect_gcc_options
, xassembler_opts_string
,
1471 vec
<cl_decoded_option
> decoded_options
1472 = get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
);
1474 /* Allocate array for input object files with LTO IL,
1475 and for possible preceding arguments. */
1476 lto_argv
= XNEWVEC (char *, argc
);
1477 ltoobj_argv
= XNEWVEC (char *, argc
);
1479 /* Look at saved options in the IL files. */
1480 for (i
= 1; i
< argc
; ++i
)
1484 off_t file_offset
= 0;
1487 char *filename
= argv
[i
];
1489 if (startswith (argv
[i
], "-foffload-objects="))
1491 have_offload
= true;
1492 offload_objects_file_name
1493 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1497 if ((p
= strrchr (argv
[i
], '@'))
1499 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1500 && strlen (p
) == (unsigned int) consumed
)
1502 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1503 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1504 filename
[p
- argv
[i
]] = '\0';
1505 file_offset
= (off_t
) loffset
;
1507 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1508 /* Linker plugin passes -fresolution and -flinker-output options.
1509 -flinker-output is passed only when user did not specify one and thus
1510 we do not need to worry about duplicities with the option handling
1514 lto_argv
[lto_argc
++] = argv
[i
];
1515 if (strcmp (argv
[i
], "-flinker-output=rel") == 0)
1516 linker_output_rel
= true;
1520 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1521 decoded_options
, fdecoded_options_first
,
1526 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1527 fdecoded_options_first
= false;
1532 /* Initalize the common arguments for the driver. */
1533 obstack_init (&argv_obstack
);
1534 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1535 obstack_ptr_grow (&argv_obstack
, "-xlto");
1536 obstack_ptr_grow (&argv_obstack
, "-c");
1538 append_compiler_options (&argv_obstack
, fdecoded_options
);
1539 append_linker_options (&argv_obstack
, decoded_options
);
1541 /* Scan linker driver arguments for things that are of relevance to us. */
1542 for (j
= 1; j
< decoded_options
.length (); ++j
)
1544 cl_decoded_option
*option
= &decoded_options
[j
];
1545 switch (option
->opt_index
)
1548 linker_output
= option
->arg
;
1551 /* We don't have to distinguish between -save-temps=* and
1552 -save-temps, -dumpdir already carries that
1554 case OPT_save_temps_
:
1555 case OPT_save_temps
:
1563 case OPT_flto_partition_
:
1564 if (strcmp (option
->arg
, "none") == 0)
1565 no_partition
= true;
1569 /* Merge linker -flto= option with what we have in IL files. */
1570 merge_flto_options (fdecoded_options
, option
);
1571 if (strcmp (option
->arg
, "jobserver") == 0)
1572 jobserver_requested
= true;
1575 case OPT_flinker_output_
:
1576 linker_output_rel
= !strcmp (option
->arg
, "rel");
1580 /* Recognize -g0. */
1581 skip_debug
= option
->arg
&& !strcmp (option
->arg
, "0");
1585 incoming_dumppfx
= dumppfx
= option
->arg
;
1588 case OPT_fdiagnostics_urls_
:
1589 diagnostic_urls_init (global_dc
, option
->value
);
1592 case OPT_fdiagnostics_color_
:
1593 diagnostic_color_init (global_dc
, option
->value
);
1601 /* Process LTO-related options on merged options. */
1602 for (j
= 1; j
< fdecoded_options
.length (); ++j
)
1604 cl_decoded_option
*option
= &fdecoded_options
[j
];
1605 switch (option
->opt_index
)
1608 if (strcmp (option
->arg
, "jobserver") == 0)
1613 else if (strcmp (option
->arg
, "auto") == 0)
1620 parallel
= atoi (option
->arg
);
1627 lto_mode
= LTO_MODE_WHOPR
;
1632 /* Output lto-wrapper invocation command. */
1635 for (i
= 0; i
< argc
; ++i
)
1637 fputs (argv
[i
], stderr
);
1638 fputc (' ', stderr
);
1640 fputc ('\n', stderr
);
1643 if (linker_output_rel
)
1644 no_partition
= true;
1648 lto_mode
= LTO_MODE_LTO
;
1650 jobserver_requested
= false;
1656 jobserver_error
= jobserver_active_p ();
1657 if (jobserver
&& jobserver_error
!= NULL
)
1659 /* Fall back to auto parallelism. */
1663 else if (!jobserver
&& jobserver_error
== NULL
)
1670 /* We need make working for a parallel execution. */
1671 if (parallel
&& !make_exists ())
1677 || strcmp (linker_output
, HOST_BIT_BUCKET
) == 0)
1681 const char *obase
= lbasename (linker_output
), *temp
;
1683 /* Strip the executable extension. */
1684 size_t blen
= strlen (obase
), xlen
;
1685 if ((temp
= strrchr (obase
+ 1, '.'))
1686 && (xlen
= strlen (temp
))
1687 && (strcmp (temp
, ".exe") == 0
1688 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
1689 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
1691 || strcmp (obase
, "a.out") == 0))
1692 dumppfx
= xstrndup (linker_output
,
1693 obase
- linker_output
+ blen
- xlen
+ 1);
1695 dumppfx
= concat (linker_output
, ".", NULL
);
1699 /* If there's no directory component in the dumppfx, add one, so
1700 that, when it is used as -dumpbase, it overrides any occurrence
1701 of -dumpdir that might have been passed in. */
1702 if (!dumppfx
|| lbasename (dumppfx
) == dumppfx
)
1703 dumppfx
= concat (current_dir
, dumppfx
, NULL
);
1705 /* Make sure some -dumpdir is passed, so as to get predictable
1706 -dumpbase overriding semantics. If we got an incoming -dumpdir
1707 argument, we'll pass it on, so don't bother with another one
1709 if (!incoming_dumppfx
)
1711 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1712 obstack_ptr_grow (&argv_obstack
, "");
1714 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1716 /* Remember at which point we can scrub args to re-use the commons. */
1717 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1721 unsigned i
, num_offload_files
;
1722 char **offload_argv
;
1725 f
= fopen (offload_objects_file_name
, "r");
1727 fatal_error (input_location
, "cannot open %s: %m",
1728 offload_objects_file_name
);
1729 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1730 fatal_error (input_location
, "cannot read %s: %m",
1731 offload_objects_file_name
);
1732 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1734 /* Read names of object files with offload. */
1735 for (i
= 0; i
< num_offload_files
; i
++)
1737 const unsigned piece
= 32;
1738 char *buf
, *filename
= XNEWVEC (char, piece
);
1743 if (!fgets (buf
, piece
, f
))
1745 len
= strlen (filename
);
1746 if (filename
[len
- 1] != '\n')
1748 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1749 buf
= filename
+ len
;
1752 filename
[len
- 1] = '\0';
1753 offload_argv
[i
] = filename
;
1756 if (offload_argv
[num_offload_files
- 1] == NULL
)
1757 fatal_error (input_location
, "invalid format of %s",
1758 offload_objects_file_name
);
1759 maybe_unlink (offload_objects_file_name
);
1760 offload_objects_file_name
= NULL
;
1762 /* Look at saved offload options in files. */
1763 for (i
= 0; i
< num_offload_files
; i
++)
1768 off_t file_offset
= 0;
1769 char *filename
= offload_argv
[i
];
1771 if ((p
= strrchr (offload_argv
[i
], '@'))
1772 && p
!= offload_argv
[i
]
1773 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1774 && strlen (p
) == (unsigned int) consumed
)
1776 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1777 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1778 filename
[p
- offload_argv
[i
]] = '\0';
1779 file_offset
= (off_t
) loffset
;
1781 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1783 fatal_error (input_location
, "cannot open %s: %m", filename
);
1784 if (!find_and_merge_options (fd
, file_offset
,
1785 OFFLOAD_SECTION_NAME_PREFIX
,
1787 offload_fdecoded_options_first
,
1788 &offload_fdecoded_options
,
1790 fatal_error (input_location
, "cannot read %s: %m", filename
);
1791 offload_fdecoded_options_first
= false;
1793 if (filename
!= offload_argv
[i
])
1794 XDELETEVEC (filename
);
1797 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1798 offload_fdecoded_options
, decoded_options
);
1800 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1804 find_crtoffloadtable (save_temps
, dumppfx
);
1805 for (i
= 0; offload_names
[i
]; i
++)
1806 printf ("%s\n", offload_names
[i
]);
1807 free_array_of_ptrs ((void **) offload_names
, i
);
1811 /* If object files contain offload sections, but do not contain LTO sections,
1812 then there is no need to perform a link-time recompilation, i.e.
1813 lto-wrapper is used only for a compilation of offload images. */
1814 if (have_offload
&& !have_lto
)
1817 if (lto_mode
== LTO_MODE_LTO
)
1819 /* -dumpbase argument for LTO. */
1820 flto_out
= concat (dumppfx
, "lto.o", NULL
);
1821 obstack_ptr_grow (&argv_obstack
, flto_out
);
1824 flto_out
= make_temp_file (".lto.o");
1825 obstack_ptr_grow (&argv_obstack
, "-o");
1826 obstack_ptr_grow (&argv_obstack
, flto_out
);
1830 const char *list_option
= "-fltrans-output-list=";
1832 /* -dumpbase argument for WPA. */
1833 char *dumpbase
= concat (dumppfx
, "wpa", NULL
);
1834 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1837 ltrans_output_file
= concat (dumppfx
, "ltrans.out", NULL
);
1839 ltrans_output_file
= make_temp_file (".ltrans.out");
1840 list_option_full
= concat (list_option
, ltrans_output_file
, NULL
);
1841 obstack_ptr_grow (&argv_obstack
, list_option_full
);
1846 fprintf (stderr
, "Using make jobserver\n");
1847 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1849 else if (auto_parallel
)
1852 init_num_threads ();
1853 if (nthreads_var
== 0)
1856 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1858 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1859 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1861 else if (parallel
> 1)
1864 sprintf (buf
, "-fwpa=%i", parallel
);
1865 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1868 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1871 /* Append input arguments. */
1872 for (i
= 0; i
< lto_argc
; ++i
)
1873 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1874 /* Append the input objects. */
1875 for (i
= 0; i
< ltoobj_argc
; ++i
)
1876 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1877 obstack_ptr_grow (&argv_obstack
, NULL
);
1879 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1880 argv_ptr
= &new_argv
[new_head_argc
];
1881 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true,
1884 /* Copy the early generated debug info from the objects to temporary
1885 files and append those to the partial link commandline. */
1886 early_debug_object_names
= NULL
;
1889 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1890 num_deb_objs
= ltoobj_argc
;
1891 for (i
= 0; i
< ltoobj_argc
; ++i
)
1894 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1895 early_debug_object_names
[i
] = tem
;
1899 if (lto_mode
== LTO_MODE_LTO
)
1901 printf ("%s\n", flto_out
);
1904 for (i
= 0; i
< ltoobj_argc
; ++i
)
1905 if (early_debug_object_names
[i
] != NULL
)
1906 printf ("%s\n", early_debug_object_names
[i
]);
1908 /* These now belong to collect2. */
1911 free (early_debug_object_names
);
1912 early_debug_object_names
= NULL
;
1916 FILE *stream
= fopen (ltrans_output_file
, "r");
1917 FILE *mstream
= NULL
;
1918 struct obstack env_obstack
;
1922 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1924 /* Parse the list of LTRANS inputs from the WPA stage. */
1925 obstack_init (&env_obstack
);
1929 const unsigned piece
= 32;
1930 char *output_name
= NULL
;
1931 char *buf
, *input_name
= (char *)xmalloc (piece
);
1935 if (fscanf (stream
, "%i\n", &priority
) != 1)
1938 fatal_error (input_location
,
1939 "corrupted ltrans output file %s",
1940 ltrans_output_file
);
1944 if (!fgets (buf
, piece
, stream
))
1946 len
= strlen (input_name
);
1947 if (input_name
[len
- 1] != '\n')
1949 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1950 buf
= input_name
+ len
;
1953 input_name
[len
- 1] = '\0';
1955 if (input_name
[0] == '*')
1956 output_name
= &input_name
[1];
1960 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1961 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1962 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1963 ltrans_priorities
[(nr
-1)*2] = priority
;
1964 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1965 input_names
[nr
-1] = input_name
;
1966 output_names
[nr
-1] = output_name
;
1969 maybe_unlink (ltrans_output_file
);
1970 ltrans_output_file
= NULL
;
1974 if (jobserver_requested
&& jobserver_error
!= NULL
)
1976 warning (0, jobserver_error
);
1977 print_lto_docs_link ();
1979 else if (parallel
== 0)
1981 warning (0, "using serial compilation of %d LTRANS jobs", nr
);
1982 print_lto_docs_link ();
1988 makefile
= make_temp_file (".mk");
1989 mstream
= fopen (makefile
, "w");
1990 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1993 /* Execute the LTRANS stage for each input file (or prepare a
1994 makefile to invoke this in parallel). */
1995 for (i
= 0; i
< nr
; ++i
)
1998 char *input_name
= input_names
[i
];
1999 /* If it's a pass-through file do nothing. */
2000 if (output_names
[i
])
2003 /* Replace the .o suffix with a .ltrans.o suffix and write
2004 the resulting name to the LTRANS output list. */
2005 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
2006 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
2007 output_name
= XOBFINISH (&env_obstack
, char *);
2009 /* Adjust the dumpbase if the linker output file was seen. */
2010 int dumpbase_len
= (strlen (dumppfx
)
2011 + sizeof (DUMPBASE_SUFFIX
)
2012 + sizeof (".ltrans"));
2013 char *dumpbase
= (char *) xmalloc (dumpbase_len
+ 1);
2014 snprintf (dumpbase
, dumpbase_len
, "%sltrans%u.ltrans", dumppfx
, i
);
2015 argv_ptr
[0] = dumpbase
;
2017 argv_ptr
[1] = "-fltrans";
2019 argv_ptr
[3] = output_name
;
2020 argv_ptr
[4] = input_name
;
2024 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
2025 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
2026 fprintf (mstream
, " '%s'", new_argv
[j
]);
2027 fprintf (mstream
, "\n");
2028 /* If we are not preserving the ltrans input files then
2029 truncate them as soon as we have processed it. This
2030 reduces temporary disk-space usage. */
2032 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
2033 "&& mv %s.tem %s\n",
2034 input_name
, input_name
, input_name
, input_name
);
2038 char argsuffix
[sizeof (DUMPBASE_SUFFIX
)
2039 + sizeof (".ltrans_args") + 1];
2041 snprintf (argsuffix
,
2042 sizeof (DUMPBASE_SUFFIX
) + sizeof (".ltrans_args"),
2043 "ltrans%u.ltrans_args", i
);
2044 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
2045 true, save_temps
? argsuffix
: NULL
);
2046 maybe_unlink (input_name
);
2049 output_names
[i
] = output_name
;
2053 struct pex_obj
*pex
;
2059 for (i
= 0; i
< nr
; ++i
)
2061 int j
= ltrans_priorities
[i
*2 + 1];
2062 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
2064 fprintf (mstream
, "\n");
2068 /* Avoid passing --jobserver-fd= and similar flags
2069 unless jobserver mode is explicitly enabled. */
2070 putenv (xstrdup ("MAKEFLAGS="));
2071 putenv (xstrdup ("MFLAGS="));
2074 char **make_argv
= buildargv (getenv ("MAKE"));
2077 for (unsigned argc
= 0; make_argv
[argc
]; argc
++)
2078 obstack_ptr_grow (&argv_obstack
, make_argv
[argc
]);
2081 obstack_ptr_grow (&argv_obstack
, "make");
2083 obstack_ptr_grow (&argv_obstack
, "-f");
2084 obstack_ptr_grow (&argv_obstack
, makefile
);
2087 snprintf (jobs
, 31, "-j%ld",
2088 auto_parallel
? nthreads_var
: parallel
);
2089 obstack_ptr_grow (&argv_obstack
, jobs
);
2091 obstack_ptr_grow (&argv_obstack
, "all");
2092 obstack_ptr_grow (&argv_obstack
, NULL
);
2093 new_argv
= XOBFINISH (&argv_obstack
, const char **);
2095 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
2096 NULL
, NULL
, PEX_SEARCH
, false, NULL
);
2097 do_wait (new_argv
[0], pex
);
2098 freeargv (make_argv
);
2099 maybe_unlink (makefile
);
2101 for (i
= 0; i
< nr
; ++i
)
2102 maybe_unlink (input_names
[i
]);
2104 for (i
= 0; i
< nr
; ++i
)
2106 fputs (output_names
[i
], stdout
);
2107 putc ('\n', stdout
);
2108 free (input_names
[i
]);
2112 for (i
= 0; i
< ltoobj_argc
; ++i
)
2113 if (early_debug_object_names
[i
] != NULL
)
2114 printf ("%s\n", early_debug_object_names
[i
]);
2117 free (ltrans_priorities
);
2118 free (output_names
);
2119 output_names
= NULL
;
2120 free (early_debug_object_names
);
2121 early_debug_object_names
= NULL
;
2123 free (list_option_full
);
2124 obstack_free (&env_obstack
, NULL
);
2129 obstack_free (&argv_obstack
, NULL
);
2136 main (int argc
, char *argv
[])
2140 init_opts_obstack ();
2142 p
= argv
[0] + strlen (argv
[0]);
2143 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
2147 xmalloc_set_program_name (progname
);
2149 gcc_init_libintl ();
2151 diagnostic_initialize (global_dc
, 0);
2152 diagnostic_color_init (global_dc
);
2153 diagnostic_urls_init (global_dc
);
2154 global_dc
->get_option_url
= get_option_url
;
2156 if (atexit (lto_wrapper_cleanup
) != 0)
2157 fatal_error (input_location
, "%<atexit%> failed");
2161 /* We may be called with all the arguments stored in some file and
2162 passed with @file. Expand them into argv before processing. */
2163 expandargv (&argc
, &argv
);
2165 run_gcc (argc
, argv
);