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 unsigned n_debugobj
;
1440 const char *incoming_dumppfx
= dumppfx
= NULL
;
1441 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1443 /* Get the driver and options. */
1444 collect_gcc
= getenv ("COLLECT_GCC");
1446 fatal_error (input_location
,
1447 "environment variable %<COLLECT_GCC%> must be set");
1448 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1449 if (!collect_gcc_options
)
1450 fatal_error (input_location
,
1451 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1453 char *collect_as_options
= getenv ("COLLECT_AS_OPTIONS");
1455 /* Prepend -Xassembler to each option, and append the string
1456 to collect_gcc_options. */
1457 if (collect_as_options
)
1459 obstack temporary_obstack
;
1460 obstack_init (&temporary_obstack
);
1462 prepend_xassembler_to_collect_as_options (collect_as_options
,
1463 &temporary_obstack
);
1464 obstack_1grow (&temporary_obstack
, '\0');
1466 char *xassembler_opts_string
1467 = XOBFINISH (&temporary_obstack
, char *);
1468 collect_gcc_options
= concat (collect_gcc_options
, xassembler_opts_string
,
1472 vec
<cl_decoded_option
> decoded_options
1473 = get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
);
1475 /* Allocate array for input object files with LTO IL,
1476 and for possible preceding arguments. */
1477 lto_argv
= XNEWVEC (char *, argc
);
1478 ltoobj_argv
= XNEWVEC (char *, argc
);
1480 /* Look at saved options in the IL files. */
1481 for (i
= 1; i
< argc
; ++i
)
1485 off_t file_offset
= 0;
1488 char *filename
= argv
[i
];
1490 if (startswith (argv
[i
], "-foffload-objects="))
1492 have_offload
= true;
1493 offload_objects_file_name
1494 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1498 if ((p
= strrchr (argv
[i
], '@'))
1500 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1501 && strlen (p
) == (unsigned int) consumed
)
1503 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1504 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1505 filename
[p
- argv
[i
]] = '\0';
1506 file_offset
= (off_t
) loffset
;
1508 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1509 /* Linker plugin passes -fresolution and -flinker-output options.
1510 -flinker-output is passed only when user did not specify one and thus
1511 we do not need to worry about duplicities with the option handling
1515 lto_argv
[lto_argc
++] = argv
[i
];
1516 if (strcmp (argv
[i
], "-flinker-output=rel") == 0)
1517 linker_output_rel
= true;
1521 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1522 decoded_options
, fdecoded_options_first
,
1527 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1528 fdecoded_options_first
= false;
1533 /* Initalize the common arguments for the driver. */
1534 obstack_init (&argv_obstack
);
1535 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1536 obstack_ptr_grow (&argv_obstack
, "-xlto");
1537 obstack_ptr_grow (&argv_obstack
, "-c");
1539 append_compiler_options (&argv_obstack
, fdecoded_options
);
1540 append_linker_options (&argv_obstack
, decoded_options
);
1542 /* Scan linker driver arguments for things that are of relevance to us. */
1543 for (j
= 1; j
< decoded_options
.length (); ++j
)
1545 cl_decoded_option
*option
= &decoded_options
[j
];
1546 switch (option
->opt_index
)
1549 linker_output
= option
->arg
;
1552 /* We don't have to distinguish between -save-temps=* and
1553 -save-temps, -dumpdir already carries that
1555 case OPT_save_temps_
:
1556 case OPT_save_temps
:
1564 case OPT_flto_partition_
:
1565 if (strcmp (option
->arg
, "none") == 0)
1566 no_partition
= true;
1570 /* Merge linker -flto= option with what we have in IL files. */
1571 merge_flto_options (fdecoded_options
, option
);
1572 if (strcmp (option
->arg
, "jobserver") == 0)
1573 jobserver_requested
= true;
1576 case OPT_flinker_output_
:
1577 linker_output_rel
= !strcmp (option
->arg
, "rel");
1581 /* Recognize -g0. */
1582 skip_debug
= option
->arg
&& !strcmp (option
->arg
, "0");
1586 incoming_dumppfx
= dumppfx
= option
->arg
;
1589 case OPT_fdiagnostics_urls_
:
1590 diagnostic_urls_init (global_dc
, option
->value
);
1593 case OPT_fdiagnostics_color_
:
1594 diagnostic_color_init (global_dc
, option
->value
);
1602 /* Process LTO-related options on merged options. */
1603 for (j
= 1; j
< fdecoded_options
.length (); ++j
)
1605 cl_decoded_option
*option
= &fdecoded_options
[j
];
1606 switch (option
->opt_index
)
1609 if (strcmp (option
->arg
, "jobserver") == 0)
1614 else if (strcmp (option
->arg
, "auto") == 0)
1621 parallel
= atoi (option
->arg
);
1628 lto_mode
= LTO_MODE_WHOPR
;
1633 /* Output lto-wrapper invocation command. */
1636 for (i
= 0; i
< argc
; ++i
)
1638 fputs (argv
[i
], stderr
);
1639 fputc (' ', stderr
);
1641 fputc ('\n', stderr
);
1644 if (linker_output_rel
)
1645 no_partition
= true;
1649 lto_mode
= LTO_MODE_LTO
;
1651 jobserver_requested
= false;
1657 jobserver_error
= jobserver_active_p ();
1658 if (jobserver
&& jobserver_error
!= NULL
)
1660 /* Fall back to auto parallelism. */
1664 else if (!jobserver
&& jobserver_error
== NULL
)
1671 /* We need make working for a parallel execution. */
1672 if (parallel
&& !make_exists ())
1678 || strcmp (linker_output
, HOST_BIT_BUCKET
) == 0)
1682 const char *obase
= lbasename (linker_output
), *temp
;
1684 /* Strip the executable extension. */
1685 size_t blen
= strlen (obase
), xlen
;
1686 if ((temp
= strrchr (obase
+ 1, '.'))
1687 && (xlen
= strlen (temp
))
1688 && (strcmp (temp
, ".exe") == 0
1689 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
1690 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
1692 || strcmp (obase
, "a.out") == 0))
1693 dumppfx
= xstrndup (linker_output
,
1694 obase
- linker_output
+ blen
- xlen
+ 1);
1696 dumppfx
= concat (linker_output
, ".", NULL
);
1700 /* If there's no directory component in the dumppfx, add one, so
1701 that, when it is used as -dumpbase, it overrides any occurrence
1702 of -dumpdir that might have been passed in. */
1703 if (!dumppfx
|| lbasename (dumppfx
) == dumppfx
)
1704 dumppfx
= concat (current_dir
, dumppfx
, NULL
);
1706 /* Make sure some -dumpdir is passed, so as to get predictable
1707 -dumpbase overriding semantics. If we got an incoming -dumpdir
1708 argument, we'll pass it on, so don't bother with another one
1710 if (!incoming_dumppfx
)
1712 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1713 obstack_ptr_grow (&argv_obstack
, "");
1715 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1717 /* Remember at which point we can scrub args to re-use the commons. */
1718 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1722 unsigned i
, num_offload_files
;
1723 char **offload_argv
;
1726 f
= fopen (offload_objects_file_name
, "r");
1728 fatal_error (input_location
, "cannot open %s: %m",
1729 offload_objects_file_name
);
1730 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1731 fatal_error (input_location
, "cannot read %s: %m",
1732 offload_objects_file_name
);
1733 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1735 /* Read names of object files with offload. */
1736 for (i
= 0; i
< num_offload_files
; i
++)
1738 const unsigned piece
= 32;
1739 char *buf
, *filename
= XNEWVEC (char, piece
);
1744 if (!fgets (buf
, piece
, f
))
1746 len
= strlen (filename
);
1747 if (filename
[len
- 1] != '\n')
1749 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1750 buf
= filename
+ len
;
1753 filename
[len
- 1] = '\0';
1754 offload_argv
[i
] = filename
;
1757 if (offload_argv
[num_offload_files
- 1] == NULL
)
1758 fatal_error (input_location
, "invalid format of %s",
1759 offload_objects_file_name
);
1760 maybe_unlink (offload_objects_file_name
);
1761 offload_objects_file_name
= NULL
;
1763 /* Look at saved offload options in files. */
1764 for (i
= 0; i
< num_offload_files
; i
++)
1769 off_t file_offset
= 0;
1770 char *filename
= offload_argv
[i
];
1772 if ((p
= strrchr (offload_argv
[i
], '@'))
1773 && p
!= offload_argv
[i
]
1774 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1775 && strlen (p
) == (unsigned int) consumed
)
1777 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1778 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1779 filename
[p
- offload_argv
[i
]] = '\0';
1780 file_offset
= (off_t
) loffset
;
1782 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1784 fatal_error (input_location
, "cannot open %s: %m", filename
);
1785 if (!find_and_merge_options (fd
, file_offset
,
1786 OFFLOAD_SECTION_NAME_PREFIX
,
1788 offload_fdecoded_options_first
,
1789 &offload_fdecoded_options
,
1791 fatal_error (input_location
, "cannot read %s: %m", filename
);
1792 offload_fdecoded_options_first
= false;
1794 if (filename
!= offload_argv
[i
])
1795 XDELETEVEC (filename
);
1798 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1799 offload_fdecoded_options
, decoded_options
);
1801 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1805 find_crtoffloadtable (save_temps
, dumppfx
);
1806 for (i
= 0; offload_names
[i
]; i
++)
1807 printf ("%s\n", offload_names
[i
]);
1808 free_array_of_ptrs ((void **) offload_names
, i
);
1812 /* If object files contain offload sections, but do not contain LTO sections,
1813 then there is no need to perform a link-time recompilation, i.e.
1814 lto-wrapper is used only for a compilation of offload images. */
1815 if (have_offload
&& !have_lto
)
1818 if (lto_mode
== LTO_MODE_LTO
)
1820 /* -dumpbase argument for LTO. */
1821 flto_out
= concat (dumppfx
, "lto.o", NULL
);
1822 obstack_ptr_grow (&argv_obstack
, flto_out
);
1825 flto_out
= make_temp_file (".lto.o");
1826 obstack_ptr_grow (&argv_obstack
, "-o");
1827 obstack_ptr_grow (&argv_obstack
, flto_out
);
1831 const char *list_option
= "-fltrans-output-list=";
1833 /* -dumpbase argument for WPA. */
1834 char *dumpbase
= concat (dumppfx
, "wpa", NULL
);
1835 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1838 ltrans_output_file
= concat (dumppfx
, "ltrans.out", NULL
);
1840 ltrans_output_file
= make_temp_file (".ltrans.out");
1841 list_option_full
= concat (list_option
, ltrans_output_file
, NULL
);
1842 obstack_ptr_grow (&argv_obstack
, list_option_full
);
1847 fprintf (stderr
, "Using make jobserver\n");
1848 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1850 else if (auto_parallel
)
1853 init_num_threads ();
1854 if (nthreads_var
== 0)
1857 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1859 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1860 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1862 else if (parallel
> 1)
1865 sprintf (buf
, "-fwpa=%i", parallel
);
1866 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1869 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1872 /* Append input arguments. */
1873 for (i
= 0; i
< lto_argc
; ++i
)
1874 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1875 /* Append the input objects. */
1876 for (i
= 0; i
< ltoobj_argc
; ++i
)
1877 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1878 obstack_ptr_grow (&argv_obstack
, NULL
);
1880 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1881 argv_ptr
= &new_argv
[new_head_argc
];
1882 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true,
1885 /* Copy the early generated debug info from the objects to temporary
1886 files and append those to the partial link commandline. */
1888 early_debug_object_names
= NULL
;
1891 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1892 num_deb_objs
= ltoobj_argc
;
1893 for (i
= 0; i
< ltoobj_argc
; ++i
)
1896 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1898 early_debug_object_names
[i
] = tem
;
1904 if (lto_mode
== LTO_MODE_LTO
)
1906 printf ("%s\n", flto_out
);
1909 for (i
= 0; i
< ltoobj_argc
; ++i
)
1910 if (early_debug_object_names
[i
] != NULL
)
1911 printf ("%s\n", early_debug_object_names
[i
]);
1913 /* These now belong to collect2. */
1916 free (early_debug_object_names
);
1917 early_debug_object_names
= NULL
;
1921 FILE *stream
= fopen (ltrans_output_file
, "r");
1922 FILE *mstream
= NULL
;
1923 struct obstack env_obstack
;
1927 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1929 /* Parse the list of LTRANS inputs from the WPA stage. */
1930 obstack_init (&env_obstack
);
1934 const unsigned piece
= 32;
1935 char *output_name
= NULL
;
1936 char *buf
, *input_name
= (char *)xmalloc (piece
);
1940 if (fscanf (stream
, "%i\n", &priority
) != 1)
1943 fatal_error (input_location
,
1944 "corrupted ltrans output file %s",
1945 ltrans_output_file
);
1949 if (!fgets (buf
, piece
, stream
))
1951 len
= strlen (input_name
);
1952 if (input_name
[len
- 1] != '\n')
1954 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1955 buf
= input_name
+ len
;
1958 input_name
[len
- 1] = '\0';
1960 if (input_name
[0] == '*')
1961 output_name
= &input_name
[1];
1965 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1966 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1967 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1968 ltrans_priorities
[(nr
-1)*2] = priority
;
1969 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1970 input_names
[nr
-1] = input_name
;
1971 output_names
[nr
-1] = output_name
;
1974 maybe_unlink (ltrans_output_file
);
1975 ltrans_output_file
= NULL
;
1979 if (jobserver_requested
&& jobserver_error
!= NULL
)
1981 warning (0, jobserver_error
);
1982 print_lto_docs_link ();
1984 else if (parallel
== 0)
1986 warning (0, "using serial compilation of %d LTRANS jobs", nr
);
1987 print_lto_docs_link ();
1993 makefile
= make_temp_file (".mk");
1994 mstream
= fopen (makefile
, "w");
1995 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1998 /* Execute the LTRANS stage for each input file (or prepare a
1999 makefile to invoke this in parallel). */
2000 for (i
= 0; i
< nr
; ++i
)
2003 char *input_name
= input_names
[i
];
2004 /* If it's a pass-through file do nothing. */
2005 if (output_names
[i
])
2008 /* Replace the .o suffix with a .ltrans.o suffix and write
2009 the resulting name to the LTRANS output list. */
2010 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
2011 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
2012 output_name
= XOBFINISH (&env_obstack
, char *);
2014 /* Adjust the dumpbase if the linker output file was seen. */
2015 int dumpbase_len
= (strlen (dumppfx
)
2016 + sizeof (DUMPBASE_SUFFIX
)
2017 + sizeof (".ltrans"));
2018 char *dumpbase
= (char *) xmalloc (dumpbase_len
+ 1);
2019 snprintf (dumpbase
, dumpbase_len
, "%sltrans%u.ltrans", dumppfx
, i
);
2020 argv_ptr
[0] = dumpbase
;
2022 argv_ptr
[1] = "-fltrans";
2024 argv_ptr
[3] = output_name
;
2025 argv_ptr
[4] = input_name
;
2029 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
2030 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
2031 fprintf (mstream
, " '%s'", new_argv
[j
]);
2032 fprintf (mstream
, "\n");
2033 /* If we are not preserving the ltrans input files then
2034 truncate them as soon as we have processed it. This
2035 reduces temporary disk-space usage. */
2037 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
2038 "&& mv %s.tem %s\n",
2039 input_name
, input_name
, input_name
, input_name
);
2043 char argsuffix
[sizeof (DUMPBASE_SUFFIX
)
2044 + sizeof (".ltrans_args") + 1];
2046 snprintf (argsuffix
,
2047 sizeof (DUMPBASE_SUFFIX
) + sizeof (".ltrans_args"),
2048 "ltrans%u.ltrans_args", i
);
2049 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
2050 true, save_temps
? argsuffix
: NULL
);
2051 maybe_unlink (input_name
);
2054 output_names
[i
] = output_name
;
2058 struct pex_obj
*pex
;
2064 for (i
= 0; i
< nr
; ++i
)
2066 int j
= ltrans_priorities
[i
*2 + 1];
2067 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
2069 fprintf (mstream
, "\n");
2073 /* Avoid passing --jobserver-fd= and similar flags
2074 unless jobserver mode is explicitly enabled. */
2075 putenv (xstrdup ("MAKEFLAGS="));
2076 putenv (xstrdup ("MFLAGS="));
2079 char **make_argv
= buildargv (getenv ("MAKE"));
2082 for (unsigned argc
= 0; make_argv
[argc
]; argc
++)
2083 obstack_ptr_grow (&argv_obstack
, make_argv
[argc
]);
2086 obstack_ptr_grow (&argv_obstack
, "make");
2088 obstack_ptr_grow (&argv_obstack
, "-f");
2089 obstack_ptr_grow (&argv_obstack
, makefile
);
2092 snprintf (jobs
, 31, "-j%ld",
2093 auto_parallel
? nthreads_var
: parallel
);
2094 obstack_ptr_grow (&argv_obstack
, jobs
);
2096 obstack_ptr_grow (&argv_obstack
, "all");
2097 obstack_ptr_grow (&argv_obstack
, NULL
);
2098 new_argv
= XOBFINISH (&argv_obstack
, const char **);
2100 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
2101 NULL
, NULL
, PEX_SEARCH
, false, NULL
);
2102 do_wait (new_argv
[0], pex
);
2103 freeargv (make_argv
);
2104 maybe_unlink (makefile
);
2106 for (i
= 0; i
< nr
; ++i
)
2107 maybe_unlink (input_names
[i
]);
2109 for (i
= 0; i
< nr
; ++i
)
2111 fputs (output_names
[i
], stdout
);
2112 putc ('\n', stdout
);
2113 free (input_names
[i
]);
2117 for (i
= 0; i
< ltoobj_argc
; ++i
)
2118 if (early_debug_object_names
[i
] != NULL
)
2119 printf ("%s\n", early_debug_object_names
[i
]);
2122 free (ltrans_priorities
);
2123 free (output_names
);
2124 output_names
= NULL
;
2125 free (early_debug_object_names
);
2126 early_debug_object_names
= NULL
;
2128 free (list_option_full
);
2129 obstack_free (&env_obstack
, NULL
);
2134 obstack_free (&argv_obstack
, NULL
);
2141 main (int argc
, char *argv
[])
2145 init_opts_obstack ();
2147 p
= argv
[0] + strlen (argv
[0]);
2148 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
2152 xmalloc_set_program_name (progname
);
2154 gcc_init_libintl ();
2156 diagnostic_initialize (global_dc
, 0);
2157 diagnostic_color_init (global_dc
);
2158 diagnostic_urls_init (global_dc
);
2159 global_dc
->get_option_url
= get_option_url
;
2161 if (atexit (lto_wrapper_cleanup
) != 0)
2162 fatal_error (input_location
, "%<atexit%> failed");
2166 /* We may be called with all the arguments stored in some file and
2167 passed with @file. Expand them into argv before processing. */
2168 expandargv (&argc
, &argv
);
2170 run_gcc (argc
, argv
);