1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2019 Free Software Foundation, Inc.
4 Factored out of collect2 by Rafael Espindola <espindola@google.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* This program is passed a gcc, a list of gcc arguments and a list of
24 object files containing IL. It scans the argument list to check if
25 we are in whopr mode or not modifies the arguments and needed and
26 prints a list of output files on stdout.
30 $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto
32 The above will print something like
35 If WHOPR is used instead, more than one file might be produced
36 ./ccXj2DTk.lto.ltrans.o
37 ./ccCJuXGv.lto.ltrans.o
42 #include "coretypes.h"
44 #include "diagnostic.h"
48 #include "simple-object.h"
49 #include "lto-section-names.h"
50 #include "collect-utils.h"
52 /* Environment variable, used for passing the names of offload targets from GCC
53 driver to lto-wrapper. */
54 #define OFFLOAD_TARGET_NAMES_ENV "OFFLOAD_TARGET_NAMES"
57 LTO_MODE_NONE
, /* Not doing LTO. */
58 LTO_MODE_LTO
, /* Normal LTO. */
59 LTO_MODE_WHOPR
/* WHOPR. */
62 /* Current LTO mode. */
63 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
65 static char *ltrans_output_file
;
66 static char *flto_out
;
67 static unsigned int nr
;
68 static int *ltrans_priorities
;
69 static char **input_names
;
70 static char **output_names
;
71 static char **offload_names
;
72 static char *offload_objects_file_name
;
73 static char *makefile
;
74 static unsigned int num_deb_objs
;
75 static const char **early_debug_object_names
;
77 const char tool_name
[] = "lto-wrapper";
79 /* Delete tempfiles. Called from utils_cleanup. */
86 if (ltrans_output_file
)
87 maybe_unlink (ltrans_output_file
);
89 maybe_unlink (flto_out
);
90 if (offload_objects_file_name
)
91 maybe_unlink (offload_objects_file_name
);
93 maybe_unlink (makefile
);
94 if (early_debug_object_names
)
95 for (i
= 0; i
< num_deb_objs
; ++i
)
96 if (early_debug_object_names
[i
])
97 maybe_unlink (early_debug_object_names
[i
]);
98 for (i
= 0; i
< nr
; ++i
)
100 maybe_unlink (input_names
[i
]);
102 maybe_unlink (output_names
[i
]);
107 lto_wrapper_cleanup (void)
109 utils_cleanup (false);
112 /* Unlink a temporary LTRANS file unless requested otherwise. */
115 maybe_unlink (const char *file
)
119 if (unlink_if_ordinary (file
)
121 fatal_error (input_location
, "deleting LTRANS file %s: %m", file
);
124 fprintf (stderr
, "[Leaving LTRANS %s]\n", file
);
127 /* Template of LTRANS dumpbase suffix. */
128 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
130 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
134 get_options_from_collect_gcc_options (const char *collect_gcc
,
135 const char *collect_gcc_options
,
136 struct cl_decoded_option
**decoded_options
,
137 unsigned int *decoded_options_count
)
139 struct obstack argv_obstack
;
144 argv_storage
= xstrdup (collect_gcc_options
);
145 obstack_init (&argv_obstack
);
146 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
148 for (j
= 0, k
= 0; argv_storage
[j
] != '\0'; ++j
)
150 if (argv_storage
[j
] == '\'')
152 obstack_ptr_grow (&argv_obstack
, &argv_storage
[k
]);
156 if (argv_storage
[j
] == '\0')
157 fatal_error (input_location
,
158 "malformed %<COLLECT_GCC_OPTIONS%>");
159 else if (strncmp (&argv_storage
[j
], "'\\''", 4) == 0)
161 argv_storage
[k
++] = '\'';
164 else if (argv_storage
[j
] == '\'')
167 argv_storage
[k
++] = argv_storage
[j
++];
170 argv_storage
[k
++] = '\0';
174 obstack_ptr_grow (&argv_obstack
, NULL
);
175 argc
= obstack_object_size (&argv_obstack
) / sizeof (void *) - 1;
176 argv
= XOBFINISH (&argv_obstack
, const char **);
178 decode_cmdline_options_to_array (argc
, (const char **)argv
, CL_DRIVER
,
179 decoded_options
, decoded_options_count
);
180 obstack_free (&argv_obstack
, NULL
);
183 /* Append OPTION to the options array DECODED_OPTIONS with size
184 DECODED_OPTIONS_COUNT. */
187 append_option (struct cl_decoded_option
**decoded_options
,
188 unsigned int *decoded_options_count
,
189 struct cl_decoded_option
*option
)
191 ++*decoded_options_count
;
193 = (struct cl_decoded_option
*)
194 xrealloc (*decoded_options
,
195 (*decoded_options_count
196 * sizeof (struct cl_decoded_option
)));
197 memcpy (&(*decoded_options
)[*decoded_options_count
- 1], option
,
198 sizeof (struct cl_decoded_option
));
201 /* Remove option number INDEX from DECODED_OPTIONS, update
202 DECODED_OPTIONS_COUNT. */
205 remove_option (struct cl_decoded_option
**decoded_options
,
206 int index
, unsigned int *decoded_options_count
)
208 --*decoded_options_count
;
209 memmove (&(*decoded_options
)[index
+ 1],
210 &(*decoded_options
)[index
],
211 sizeof (struct cl_decoded_option
)
212 * (*decoded_options_count
- index
));
215 /* Try to merge and complain about options FDECODED_OPTIONS when applied
216 ontop of DECODED_OPTIONS. */
219 merge_and_complain (struct cl_decoded_option
**decoded_options
,
220 unsigned int *decoded_options_count
,
221 struct cl_decoded_option
*fdecoded_options
,
222 unsigned int fdecoded_options_count
)
225 struct cl_decoded_option
*pic_option
= NULL
;
226 struct cl_decoded_option
*pie_option
= NULL
;
228 /* ??? Merge options from files. Most cases can be
229 handled by either unioning or intersecting
230 (for example -fwrapv is a case for unioning,
231 -ffast-math is for intersection). Most complaints
232 about real conflicts between different options can
233 be deferred to the compiler proper. Options that
234 we can neither safely handle by intersection nor
235 unioning would need to be complained about here.
236 Ideally we'd have a flag in the opt files that
237 tells whether to union or intersect or reject.
238 In absence of that it's unclear what a good default is.
239 It's also difficult to get positional handling correct. */
241 /* The following does what the old LTO option code did,
242 union all target and a selected set of common options. */
243 for (i
= 0; i
< fdecoded_options_count
; ++i
)
245 struct cl_decoded_option
*foption
= &fdecoded_options
[i
];
246 switch (foption
->opt_index
)
248 case OPT_SPECIAL_unknown
:
249 case OPT_SPECIAL_ignore
:
250 case OPT_SPECIAL_deprecated
:
251 case OPT_SPECIAL_program_name
:
252 case OPT_SPECIAL_input_file
:
256 if (!(cl_options
[foption
->opt_index
].flags
& CL_TARGET
))
260 case OPT_fdiagnostics_show_caret
:
261 case OPT_fdiagnostics_show_labels
:
262 case OPT_fdiagnostics_show_line_numbers
:
263 case OPT_fdiagnostics_show_option
:
264 case OPT_fdiagnostics_show_location_
:
265 case OPT_fshow_column
:
268 /* Do what the old LTO code did - collect exactly one option
269 setting per OPT code, we pick the first we encounter.
270 ??? This doesn't make too much sense, but when it doesn't
271 then we should complain. */
272 for (j
= 0; j
< *decoded_options_count
; ++j
)
273 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
275 if (j
== *decoded_options_count
)
276 append_option (decoded_options
, decoded_options_count
, foption
);
279 /* Figure out what PIC/PIE level wins and merge the results. */
282 pic_option
= foption
;
286 pie_option
= foption
;
291 /* For selected options we can merge conservatively. */
292 for (j
= 0; j
< *decoded_options_count
; ++j
)
293 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
295 if (j
== *decoded_options_count
)
296 append_option (decoded_options
, decoded_options_count
, foption
);
297 /* -fopenmp > -fno-openmp,
298 -fopenacc > -fno-openacc */
299 else if (foption
->value
> (*decoded_options
)[j
].value
)
300 (*decoded_options
)[j
] = *foption
;
303 case OPT_fopenacc_dim_
:
304 /* Append or check identical. */
305 for (j
= 0; j
< *decoded_options_count
; ++j
)
306 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
308 if (j
== *decoded_options_count
)
309 append_option (decoded_options
, decoded_options_count
, foption
);
310 else if (strcmp ((*decoded_options
)[j
].arg
, foption
->arg
))
311 fatal_error (input_location
,
312 "option %s with different values",
313 foption
->orig_option_with_args_text
);
320 for (j
= 0; j
< *decoded_options_count
; ++j
)
321 if ((*decoded_options
)[j
].opt_index
== OPT_O
322 || (*decoded_options
)[j
].opt_index
== OPT_Ofast
323 || (*decoded_options
)[j
].opt_index
== OPT_Og
324 || (*decoded_options
)[j
].opt_index
== OPT_Os
)
326 if (j
== *decoded_options_count
)
327 append_option (decoded_options
, decoded_options_count
, foption
);
328 else if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
329 && foption
->opt_index
!= OPT_O
)
330 /* Exact same options get merged. */
334 /* For mismatched option kinds preserve the optimization
335 level only, thus merge it as -On. This also handles
336 merging of same optimization level -On. */
338 switch (foption
->opt_index
)
341 if (foption
->arg
[0] == '\0')
342 level
= MAX (level
, 1);
344 level
= MAX (level
, atoi (foption
->arg
));
347 level
= MAX (level
, 3);
350 level
= MAX (level
, 1);
353 level
= MAX (level
, 2);
358 switch ((*decoded_options
)[j
].opt_index
)
361 if ((*decoded_options
)[j
].arg
[0] == '\0')
362 level
= MAX (level
, 1);
364 level
= MAX (level
, atoi ((*decoded_options
)[j
].arg
));
367 level
= MAX (level
, 3);
370 level
= MAX (level
, 1);
373 level
= MAX (level
, 2);
378 (*decoded_options
)[j
].opt_index
= OPT_O
;
380 tem
= xasprintf ("-O%d", level
);
381 (*decoded_options
)[j
].arg
= &tem
[2];
382 (*decoded_options
)[j
].canonical_option
[0] = tem
;
383 (*decoded_options
)[j
].value
= 1;
388 case OPT_foffload_abi_
:
389 for (j
= 0; j
< *decoded_options_count
; ++j
)
390 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
392 if (j
== *decoded_options_count
)
393 append_option (decoded_options
, decoded_options_count
, foption
);
394 else if (foption
->value
!= (*decoded_options
)[j
].value
)
395 fatal_error (input_location
,
396 "option %s not used consistently in all LTO input"
397 " files", foption
->orig_option_with_args_text
);
402 append_option (decoded_options
, decoded_options_count
, foption
);
407 /* Merge PIC options:
408 -fPIC + -fpic = -fpic
409 -fPIC + -fno-pic = -fno-pic
410 -fpic/-fPIC + nothin = nothing.
411 It is a common mistake to mix few -fPIC compiled objects into otherwise
412 non-PIC code. We do not want to build everything with PIC then.
414 Similarly we merge PIE options, however in addition we keep
415 -fPIC + -fPIE = -fPIE
416 -fpic + -fPIE = -fpie
417 -fPIC/-fpic + -fpie = -fpie
419 It would be good to warn on mismatches, but it is bit hard to do as
420 we do not know what nothing translates to. */
422 for (unsigned int j
= 0; j
< *decoded_options_count
;)
423 if ((*decoded_options
)[j
].opt_index
== OPT_fPIC
424 || (*decoded_options
)[j
].opt_index
== OPT_fpic
)
426 /* -fno-pic in one unit implies -fno-pic everywhere. */
427 if ((*decoded_options
)[j
].value
== 0)
429 /* If we have no pic option or merge in -fno-pic, we still may turn
430 existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */
431 else if ((pic_option
&& pic_option
->value
== 0)
436 bool big
= (*decoded_options
)[j
].opt_index
== OPT_fPIC
437 && pie_option
->opt_index
== OPT_fPIE
;
438 (*decoded_options
)[j
].opt_index
= big
? OPT_fPIE
: OPT_fpie
;
439 if (pie_option
->value
)
440 (*decoded_options
)[j
].canonical_option
[0] = big
? "-fPIE" : "-fpie";
442 (*decoded_options
)[j
].canonical_option
[0] = big
? "-fno-pie" : "-fno-pie";
443 (*decoded_options
)[j
].value
= pie_option
->value
;
448 (*decoded_options
)[j
] = *pic_option
;
451 /* We do not know if target defaults to pic or not, so just remove
452 option if it is missing in one unit but enabled in other. */
454 remove_option (decoded_options
, j
, decoded_options_count
);
456 else if (pic_option
->opt_index
== OPT_fpic
457 && (*decoded_options
)[j
].opt_index
== OPT_fPIC
)
459 (*decoded_options
)[j
] = *pic_option
;
465 else if ((*decoded_options
)[j
].opt_index
== OPT_fPIE
466 || (*decoded_options
)[j
].opt_index
== OPT_fpie
)
468 /* -fno-pie in one unit implies -fno-pie everywhere. */
469 if ((*decoded_options
)[j
].value
== 0)
471 /* If we have no pie option or merge in -fno-pie, we still preserve
472 PIE/pie if pic/PIC is present. */
473 else if ((pie_option
&& pie_option
->value
== 0)
476 /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */
479 if (pic_option
->opt_index
== OPT_fpic
480 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
482 (*decoded_options
)[j
].opt_index
= OPT_fpie
;
483 (*decoded_options
)[j
].canonical_option
[0]
484 = pic_option
->value
? "-fpie" : "-fno-pie";
486 else if (!pic_option
->value
)
487 (*decoded_options
)[j
].canonical_option
[0] = "-fno-pie";
488 (*decoded_options
)[j
].value
= pic_option
->value
;
493 (*decoded_options
)[j
] = *pie_option
;
496 /* Because we always append pic/PIE options this code path should
497 not happen unless the LTO object was built by old lto1 which
498 did not contain that logic yet. */
500 remove_option (decoded_options
, j
, decoded_options_count
);
502 else if (pie_option
->opt_index
== OPT_fpie
503 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
505 (*decoded_options
)[j
] = *pie_option
;
515 /* Auxiliary function that frees elements of PTR and PTR itself.
516 N is number of elements to be freed. If PTR is NULL, nothing is freed.
517 If an element is NULL, subsequent elements are not freed. */
520 free_array_of_ptrs (void **ptr
, unsigned n
)
524 for (unsigned i
= 0; i
< n
; i
++)
534 /* Parse STR, saving found tokens into PVALUES and return their number.
535 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
536 append it to every token we find. */
539 parse_env_var (const char *str
, char ***pvalues
, const char *append
)
541 const char *curval
, *nextval
;
545 curval
= strchr (str
, ':');
549 curval
= strchr (curval
+ 1, ':');
552 values
= (char**) xmalloc (num
* sizeof (char*));
554 nextval
= strchr (curval
, ':');
556 nextval
= strchr (curval
, '\0');
558 int append_len
= append
? strlen (append
) : 0;
559 for (i
= 0; i
< num
; i
++)
561 int l
= nextval
- curval
;
562 values
[i
] = (char*) xmalloc (l
+ 1 + append_len
);
563 memcpy (values
[i
], curval
, l
);
566 strcat (values
[i
], append
);
567 curval
= nextval
+ 1;
568 nextval
= strchr (curval
, ':');
570 nextval
= strchr (curval
, '\0');
576 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
579 append_compiler_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
582 /* Append compiler driver arguments as far as they were merged. */
583 for (unsigned int j
= 1; j
< count
; ++j
)
585 struct cl_decoded_option
*option
= &opts
[j
];
587 /* File options have been properly filtered by lto-opts.c. */
588 switch (option
->opt_index
)
590 /* Drop arguments that we want to take from the link line. */
593 case OPT_flto_partition_
:
600 /* For now do what the original LTO option code was doing - pass
601 on any CL_TARGET flag and a few selected others. */
602 switch (option
->opt_index
)
604 case OPT_fdiagnostics_show_caret
:
605 case OPT_fdiagnostics_show_labels
:
606 case OPT_fdiagnostics_show_line_numbers
:
607 case OPT_fdiagnostics_show_option
:
608 case OPT_fdiagnostics_show_location_
:
609 case OPT_fshow_column
:
618 case OPT_fopenacc_dim_
:
619 case OPT_foffload_abi_
:
627 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
631 /* Pass the option on. */
632 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
633 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
637 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
640 append_diag_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
643 /* Append compiler driver arguments as far as they were merged. */
644 for (unsigned int j
= 1; j
< count
; ++j
)
646 struct cl_decoded_option
*option
= &opts
[j
];
648 switch (option
->opt_index
)
650 case OPT_fdiagnostics_color_
:
651 case OPT_fdiagnostics_format_
:
652 case OPT_fdiagnostics_show_caret
:
653 case OPT_fdiagnostics_show_labels
:
654 case OPT_fdiagnostics_show_line_numbers
:
655 case OPT_fdiagnostics_show_option
:
656 case OPT_fdiagnostics_show_location_
:
657 case OPT_fshow_column
:
663 /* Pass the option on. */
664 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
665 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
670 /* Append linker options OPTS to ARGV_OBSTACK. */
673 append_linker_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
676 /* Append linker driver arguments. Compiler options from the linker
677 driver arguments will override / merge with those from the compiler. */
678 for (unsigned int j
= 1; j
< count
; ++j
)
680 struct cl_decoded_option
*option
= &opts
[j
];
682 /* Do not pass on frontend specific flags not suitable for lto. */
683 if (!(cl_options
[option
->opt_index
].flags
684 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
687 switch (option
->opt_index
)
692 /* We've handled these LTO options, do not pass them on. */
697 /* Ignore -fno-XXX form of these options, as otherwise
698 corresponding builtins will not be enabled. */
699 if (option
->value
== 0)
707 /* Pass the option on. */
708 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
709 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
713 /* Extract options for TARGET offload compiler from OPTIONS and append
714 them to ARGV_OBSTACK. */
717 append_offload_options (obstack
*argv_obstack
, const char *target
,
718 struct cl_decoded_option
*options
,
719 unsigned int options_count
)
721 for (unsigned i
= 0; i
< options_count
; i
++)
723 const char *cur
, *next
, *opts
;
726 struct cl_decoded_option
*option
= &options
[i
];
728 if (option
->opt_index
!= OPT_foffload_
)
731 /* If option argument starts with '-' then no target is specified. That
732 means offload options are specified for all targets, so we need to
734 if (option
->arg
[0] == '-')
738 opts
= strchr (option
->arg
, '=');
739 /* If there are offload targets specified, but no actual options,
740 there is nothing to do here. */
748 next
= strchr (cur
, ',');
751 next
= (next
> opts
) ? opts
: next
;
753 /* Are we looking for this offload target? */
754 if (strlen (target
) == (size_t) (next
- cur
)
755 && strncmp (target
, cur
, next
- cur
) == 0)
758 /* Skip the comma or equal sign. */
768 argv
= buildargv (opts
);
769 for (argc
= 0; argv
[argc
]; argc
++)
770 obstack_ptr_grow (argv_obstack
, argv
[argc
]);
774 /* Check whether NAME can be accessed in MODE. This is like access,
775 except that it never considers directories to be executable. */
778 access_check (const char *name
, int mode
)
784 if (stat (name
, &st
) < 0
785 || S_ISDIR (st
.st_mode
))
789 return access (name
, mode
);
792 /* Prepare a target image for offload TARGET, using mkoffload tool from
793 COMPILER_PATH. Return the name of the resultant object file. */
796 compile_offload_image (const char *target
, const char *compiler_path
,
797 unsigned in_argc
, char *in_argv
[],
798 struct cl_decoded_option
*compiler_opts
,
799 unsigned int compiler_opt_count
,
800 struct cl_decoded_option
*linker_opts
,
801 unsigned int linker_opt_count
)
803 char *filename
= NULL
;
806 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target
));
807 strcpy (suffix
, "/accel/");
808 strcat (suffix
, target
);
809 strcat (suffix
, "/mkoffload");
812 unsigned n_paths
= parse_env_var (compiler_path
, &paths
, suffix
);
814 const char *compiler
= NULL
;
815 for (unsigned i
= 0; i
< n_paths
; i
++)
816 if (access_check (paths
[i
], X_OK
) == 0)
823 fatal_error (input_location
,
824 "could not find %s in %s (consider using %<-B%>)",
825 suffix
+ 1, compiler_path
);
827 /* Generate temporary output file name. */
828 filename
= make_temp_file (".target.o");
830 struct obstack argv_obstack
;
831 obstack_init (&argv_obstack
);
832 obstack_ptr_grow (&argv_obstack
, compiler
);
834 obstack_ptr_grow (&argv_obstack
, "-save-temps");
836 obstack_ptr_grow (&argv_obstack
, "-v");
837 obstack_ptr_grow (&argv_obstack
, "-o");
838 obstack_ptr_grow (&argv_obstack
, filename
);
840 /* Append names of input object files. */
841 for (unsigned i
= 0; i
< in_argc
; i
++)
842 obstack_ptr_grow (&argv_obstack
, in_argv
[i
]);
844 /* Append options from offload_lto sections. */
845 append_compiler_options (&argv_obstack
, compiler_opts
,
847 append_diag_options (&argv_obstack
, linker_opts
, linker_opt_count
);
849 /* Append options specified by -foffload last. In case of conflicting
850 options we expect offload compiler to choose the latest. */
851 append_offload_options (&argv_obstack
, target
, compiler_opts
,
853 append_offload_options (&argv_obstack
, target
, linker_opts
,
856 obstack_ptr_grow (&argv_obstack
, NULL
);
857 argv
= XOBFINISH (&argv_obstack
, char **);
858 fork_execute (argv
[0], argv
, true);
859 obstack_free (&argv_obstack
, NULL
);
861 free_array_of_ptrs ((void **) paths
, n_paths
);
866 /* The main routine dealing with offloading.
867 The routine builds a target image for each offload target. IN_ARGC and
868 IN_ARGV specify options and input object files. As all of them could contain
869 target sections, we pass them all to target compilers. */
872 compile_images_for_offload_targets (unsigned in_argc
, char *in_argv
[],
873 struct cl_decoded_option
*compiler_opts
,
874 unsigned int compiler_opt_count
,
875 struct cl_decoded_option
*linker_opts
,
876 unsigned int linker_opt_count
)
879 const char *target_names
= getenv (OFFLOAD_TARGET_NAMES_ENV
);
882 unsigned num_targets
= parse_env_var (target_names
, &names
, NULL
);
884 int next_name_entry
= 0;
885 const char *compiler_path
= getenv ("COMPILER_PATH");
889 /* Prepare an image for each target and save the name of the resultant object
890 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
891 offload_names
= XCNEWVEC (char *, num_targets
+ 1);
892 for (unsigned i
= 0; i
< num_targets
; i
++)
894 /* HSA does not use LTO-like streaming and a different compiler, skip
896 if (strcmp (names
[i
], "hsa") == 0)
899 offload_names
[next_name_entry
]
900 = compile_offload_image (names
[i
], compiler_path
, in_argc
, in_argv
,
901 compiler_opts
, compiler_opt_count
,
902 linker_opts
, linker_opt_count
);
903 if (!offload_names
[next_name_entry
])
904 fatal_error (input_location
,
905 "problem with building target image for %s", names
[i
]);
910 free_array_of_ptrs ((void **) names
, num_targets
);
913 /* Copy a file from SRC to DEST. */
916 copy_file (const char *dest
, const char *src
)
918 FILE *d
= fopen (dest
, "wb");
919 FILE *s
= fopen (src
, "rb");
923 size_t len
= fread (buffer
, 1, 512, s
);
925 fatal_error (input_location
, "reading input file");
928 fwrite (buffer
, 1, len
, d
);
930 fatal_error (input_location
, "writing output file");
937 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
938 the copy to the linker. */
941 find_crtoffloadtable (void)
944 const char *library_path
= getenv ("LIBRARY_PATH");
947 unsigned n_paths
= parse_env_var (library_path
, &paths
, "/crtoffloadtable.o");
950 for (i
= 0; i
< n_paths
; i
++)
951 if (access_check (paths
[i
], R_OK
) == 0)
953 /* The linker will delete the filename we give it, so make a copy. */
954 char *crtoffloadtable
= make_temp_file (".crtoffloadtable.o");
955 copy_file (crtoffloadtable
, paths
[i
]);
956 printf ("%s\n", crtoffloadtable
);
957 XDELETEVEC (crtoffloadtable
);
961 fatal_error (input_location
,
962 "installation error, cannot find %<crtoffloadtable.o%>");
964 free_array_of_ptrs ((void **) paths
, n_paths
);
967 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
968 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
969 and OPT_COUNT. Return true if we found a matchingn section, false
970 otherwise. COLLECT_GCC holds the value of the environment variable with
974 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
975 struct cl_decoded_option
**opts
,
976 unsigned int *opt_count
, const char *collect_gcc
)
978 off_t offset
, length
;
983 struct cl_decoded_option
*fdecoded_options
= *opts
;
984 unsigned int fdecoded_options_count
= *opt_count
;
986 simple_object_read
*sobj
;
987 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
992 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
993 strcpy (secname
, prefix
);
994 strcat (secname
, ".opts");
995 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
998 simple_object_release_read (sobj
);
1002 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
1003 data
= (char *)xmalloc (length
);
1004 read (fd
, data
, length
);
1008 struct cl_decoded_option
*f2decoded_options
;
1009 unsigned int f2decoded_options_count
;
1010 get_options_from_collect_gcc_options (collect_gcc
, fopts
,
1012 &f2decoded_options_count
);
1013 if (!fdecoded_options
)
1015 fdecoded_options
= f2decoded_options
;
1016 fdecoded_options_count
= f2decoded_options_count
;
1019 merge_and_complain (&fdecoded_options
,
1020 &fdecoded_options_count
,
1021 f2decoded_options
, f2decoded_options_count
);
1023 fopts
+= strlen (fopts
) + 1;
1025 while (fopts
- data
< length
);
1028 simple_object_release_read (sobj
);
1029 *opts
= fdecoded_options
;
1030 *opt_count
= fdecoded_options_count
;
1034 /* Copy early debug info sections from INFILE to a new file whose name
1035 is returned. Return NULL on error. */
1038 debug_objcopy (const char *infile
, bool rename
)
1045 const char *orig_infile
= infile
;
1049 if ((p
= strrchr (infile
, '@'))
1051 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1052 && strlen (p
) == (unsigned int) consumed
)
1054 char *fname
= xstrdup (infile
);
1055 fname
[p
- infile
] = '\0';
1057 inoff
= (off_t
) loffset
;
1059 int infd
= open (infile
, O_RDONLY
| O_BINARY
);
1062 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
1069 if (simple_object_find_section (inobj
, ".gnu.debuglto_.debug_info",
1070 &off
, &len
, &errmsg
, &err
) != 1)
1073 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1075 simple_object_release_read (inobj
);
1082 outfile
= (char *) xmalloc (strlen (orig_infile
)
1083 + sizeof (".debug.temp.o") + 1);
1084 strcpy (outfile
, orig_infile
);
1085 strcat (outfile
, ".debug.temp.o");
1088 outfile
= make_temp_file (".debug.temp.o");
1089 errmsg
= simple_object_copy_lto_debug_sections (inobj
, outfile
, &err
, rename
);
1092 unlink_if_ordinary (outfile
);
1093 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1096 simple_object_release_read (inobj
);
1102 /* Helper for qsort: compare priorities for parallel compilation. */
1105 cmp_priority (const void *a
, const void *b
)
1107 return *((const int *)b
)-*((const int *)a
);
1110 /* Number of CPUs that can be used for parallel LTRANS phase. */
1112 static unsigned long nthreads_var
= 0;
1114 #ifdef HAVE_PTHREAD_AFFINITY_NP
1115 unsigned long cpuset_size
;
1116 static unsigned long get_cpuset_size
;
1120 static cpuset_popcount (unsigned long cpusetsize
, cpu_set_t
*cpusetp
)
1123 /* glibc 2.7 and above provide a macro for this. */
1124 return CPU_COUNT_S (cpusetsize
, cpusetp
);
1127 if (cpusetsize
== sizeof (cpu_set_t
))
1128 /* glibc 2.6 and above provide a macro for this. */
1129 return CPU_COUNT (cpusetp
);
1132 unsigned long ret
= 0;
1133 STATIC_ASSERT (sizeof (cpusetp
->__bits
[0]) == sizeof (unsigned long int));
1134 for (i
= 0; i
< cpusetsize
/ sizeof (cpusetp
->__bits
[0]); i
++)
1136 unsigned long int mask
= cpusetp
->__bits
[i
];
1139 ret
+= __builtin_popcountl (mask
);
1146 /* At startup, determine the default number of threads. It would seem
1147 this should be related to the number of cpus online. */
1150 init_num_threads (void)
1152 #ifdef HAVE_PTHREAD_AFFINITY_NP
1153 #if defined (_SC_NPROCESSORS_CONF) && defined (CPU_ALLOC_SIZE)
1154 cpuset_size
= sysconf (_SC_NPROCESSORS_CONF
);
1155 cpuset_size
= CPU_ALLOC_SIZE (cpuset_size
);
1157 cpuset_size
= sizeof (cpu_set_t
);
1160 cpusetp
= (cpu_set_t
*) xmalloc (gomp_cpuset_size
);
1163 int ret
= pthread_getaffinity_np (pthread_self (), gomp_cpuset_size
,
1167 /* Count only the CPUs this process can use. */
1168 nthreads_var
= cpuset_popcount (cpuset_size
, cpusetp
);
1169 if (nthreads_var
== 0)
1171 get_cpuset_size
= cpuset_size
;
1172 #ifdef CPU_ALLOC_SIZE
1174 for (i
= cpuset_size
* 8; i
; i
--)
1175 if (CPU_ISSET_S (i
- 1, cpuset_size
, cpusetp
))
1177 cpuset_size
= CPU_ALLOC_SIZE (i
);
1183 #ifdef CPU_ALLOC_SIZE
1184 if (cpuset_size
< sizeof (cpu_set_t
))
1185 cpuset_size
= sizeof (cpu_set_t
);
1187 cpuset_size
= cpuset_size
* 2;
1188 if (cpuset_size
< 8 * sizeof (cpu_set_t
))
1190 = (cpu_set_t
*) realloc (cpusetp
, cpuset_size
);
1193 /* Avoid fatal if too large memory allocation would be
1194 requested, e.g. kernel returning EINVAL all the time. */
1195 void *p
= realloc (cpusetp
, cpuset_size
);
1198 cpusetp
= (cpu_set_t
*) p
;
1210 #ifdef _SC_NPROCESSORS_ONLN
1211 nthreads_var
= sysconf (_SC_NPROCESSORS_ONLN
);
1215 /* FIXME: once using -std=c11, we can use std::thread::hardware_concurrency. */
1217 /* Return true when a jobserver is running and can accept a job. */
1220 jobserver_active_p (void)
1222 const char *makeflags
= getenv ("MAKEFLAGS");
1223 if (makeflags
== NULL
)
1226 const char *needle
= "--jobserver-auth=";
1227 const char *n
= strstr (makeflags
, needle
);
1234 return (sscanf (n
+ strlen (needle
), "%d,%d", &rfd
, &wfd
) == 2
1237 && is_valid_fd (rfd
)
1238 && is_valid_fd (wfd
));
1241 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1244 run_gcc (unsigned argc
, char *argv
[])
1247 const char **new_argv
;
1248 const char **argv_ptr
;
1249 char *list_option_full
= NULL
;
1250 const char *linker_output
= NULL
;
1251 const char *collect_gcc
, *collect_gcc_options
;
1254 int auto_parallel
= 0;
1255 bool no_partition
= false;
1256 struct cl_decoded_option
*fdecoded_options
= NULL
;
1257 struct cl_decoded_option
*offload_fdecoded_options
= NULL
;
1258 unsigned int fdecoded_options_count
= 0;
1259 unsigned int offload_fdecoded_options_count
= 0;
1260 struct cl_decoded_option
*decoded_options
;
1261 unsigned int decoded_options_count
;
1262 struct obstack argv_obstack
;
1264 bool have_lto
= false;
1265 bool have_offload
= false;
1266 unsigned lto_argc
= 0, ltoobj_argc
= 0;
1267 char **lto_argv
, **ltoobj_argv
;
1268 bool linker_output_rel
= false;
1269 bool skip_debug
= false;
1270 unsigned n_debugobj
;
1272 /* Get the driver and options. */
1273 collect_gcc
= getenv ("COLLECT_GCC");
1275 fatal_error (input_location
,
1276 "environment variable %<COLLECT_GCC%> must be set");
1277 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1278 if (!collect_gcc_options
)
1279 fatal_error (input_location
,
1280 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1281 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
1283 &decoded_options_count
);
1285 /* Allocate array for input object files with LTO IL,
1286 and for possible preceding arguments. */
1287 lto_argv
= XNEWVEC (char *, argc
);
1288 ltoobj_argv
= XNEWVEC (char *, argc
);
1290 /* Look at saved options in the IL files. */
1291 for (i
= 1; i
< argc
; ++i
)
1295 off_t file_offset
= 0;
1298 char *filename
= argv
[i
];
1300 if (strncmp (argv
[i
], "-foffload-objects=",
1301 sizeof ("-foffload-objects=") - 1) == 0)
1303 have_offload
= true;
1304 offload_objects_file_name
1305 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1309 if ((p
= strrchr (argv
[i
], '@'))
1311 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1312 && strlen (p
) == (unsigned int) consumed
)
1314 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1315 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1316 filename
[p
- argv
[i
]] = '\0';
1317 file_offset
= (off_t
) loffset
;
1319 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1320 /* Linker plugin passes -fresolution and -flinker-output options.
1321 -flinker-output is passed only when user did not specify one and thus
1322 we do not need to worry about duplicities with the option handling
1326 lto_argv
[lto_argc
++] = argv
[i
];
1327 if (strcmp (argv
[i
], "-flinker-output=rel") == 0)
1328 linker_output_rel
= true;
1332 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1333 &fdecoded_options
, &fdecoded_options_count
,
1337 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1342 /* Initalize the common arguments for the driver. */
1343 obstack_init (&argv_obstack
);
1344 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1345 obstack_ptr_grow (&argv_obstack
, "-xlto");
1346 obstack_ptr_grow (&argv_obstack
, "-c");
1348 append_compiler_options (&argv_obstack
, fdecoded_options
,
1349 fdecoded_options_count
);
1350 append_linker_options (&argv_obstack
, decoded_options
, decoded_options_count
);
1352 /* Scan linker driver arguments for things that are of relevance to us. */
1353 for (j
= 1; j
< decoded_options_count
; ++j
)
1355 struct cl_decoded_option
*option
= &decoded_options
[j
];
1356 switch (option
->opt_index
)
1359 linker_output
= option
->arg
;
1362 case OPT_save_temps
:
1370 case OPT_flto_partition_
:
1371 if (strcmp (option
->arg
, "none") == 0)
1372 no_partition
= true;
1376 if (strcmp (option
->arg
, "jobserver") == 0)
1381 else if (strcmp (option
->arg
, "auto") == 0)
1388 parallel
= atoi (option
->arg
);
1395 lto_mode
= LTO_MODE_WHOPR
;
1398 case OPT_flinker_output_
:
1399 linker_output_rel
= !strcmp (option
->arg
, "rel");
1408 /* Output lto-wrapper invocation command. */
1411 for (i
= 0; i
< argc
; ++i
)
1413 fputs (argv
[i
], stderr
);
1414 fputc (' ', stderr
);
1416 fputc ('\n', stderr
);
1419 if (linker_output_rel
)
1420 no_partition
= true;
1424 lto_mode
= LTO_MODE_LTO
;
1429 else if (!jobserver
&& jobserver_active_p ())
1437 char *output_dir
, *base
, *name
;
1438 bool bit_bucket
= strcmp (linker_output
, HOST_BIT_BUCKET
) == 0;
1440 output_dir
= xstrdup (linker_output
);
1442 for (name
= base
; *name
; name
++)
1443 if (IS_DIR_SEPARATOR (*name
))
1447 linker_output
= &linker_output
[base
- output_dir
];
1448 if (*output_dir
== '\0')
1450 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1451 output_dir
= current_dir
;
1455 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1456 obstack_ptr_grow (&argv_obstack
, output_dir
);
1459 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1462 /* Remember at which point we can scrub args to re-use the commons. */
1463 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1467 unsigned i
, num_offload_files
;
1468 char **offload_argv
;
1471 f
= fopen (offload_objects_file_name
, "r");
1473 fatal_error (input_location
, "cannot open %s: %m",
1474 offload_objects_file_name
);
1475 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1476 fatal_error (input_location
, "cannot read %s: %m",
1477 offload_objects_file_name
);
1478 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1480 /* Read names of object files with offload. */
1481 for (i
= 0; i
< num_offload_files
; i
++)
1483 const unsigned piece
= 32;
1484 char *buf
, *filename
= XNEWVEC (char, piece
);
1489 if (!fgets (buf
, piece
, f
))
1491 len
= strlen (filename
);
1492 if (filename
[len
- 1] != '\n')
1494 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1495 buf
= filename
+ len
;
1498 filename
[len
- 1] = '\0';
1499 offload_argv
[i
] = filename
;
1502 if (offload_argv
[num_offload_files
- 1] == NULL
)
1503 fatal_error (input_location
, "invalid format of %s",
1504 offload_objects_file_name
);
1505 maybe_unlink (offload_objects_file_name
);
1506 offload_objects_file_name
= NULL
;
1508 /* Look at saved offload options in files. */
1509 for (i
= 0; i
< num_offload_files
; i
++)
1514 off_t file_offset
= 0;
1515 char *filename
= offload_argv
[i
];
1517 if ((p
= strrchr (offload_argv
[i
], '@'))
1518 && p
!= offload_argv
[i
]
1519 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1520 && strlen (p
) == (unsigned int) consumed
)
1522 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1523 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1524 filename
[p
- offload_argv
[i
]] = '\0';
1525 file_offset
= (off_t
) loffset
;
1527 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1529 fatal_error (input_location
, "cannot open %s: %m", filename
);
1530 if (!find_and_merge_options (fd
, file_offset
,
1531 OFFLOAD_SECTION_NAME_PREFIX
,
1532 &offload_fdecoded_options
,
1533 &offload_fdecoded_options_count
,
1535 fatal_error (input_location
, "cannot read %s: %m", filename
);
1537 if (filename
!= offload_argv
[i
])
1538 XDELETEVEC (filename
);
1541 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1542 offload_fdecoded_options
,
1543 offload_fdecoded_options_count
,
1545 decoded_options_count
);
1547 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1551 find_crtoffloadtable ();
1552 for (i
= 0; offload_names
[i
]; i
++)
1553 printf ("%s\n", offload_names
[i
]);
1554 free_array_of_ptrs ((void **) offload_names
, i
);
1558 /* If object files contain offload sections, but do not contain LTO sections,
1559 then there is no need to perform a link-time recompilation, i.e.
1560 lto-wrapper is used only for a compilation of offload images. */
1561 if (have_offload
&& !have_lto
)
1564 if (lto_mode
== LTO_MODE_LTO
)
1568 obstack_ptr_grow (&argv_obstack
, linker_output
);
1569 flto_out
= (char *) xmalloc (strlen (linker_output
)
1570 + sizeof (".lto.o") + 1);
1571 strcpy (flto_out
, linker_output
);
1572 strcat (flto_out
, ".lto.o");
1575 flto_out
= make_temp_file (".lto.o");
1576 obstack_ptr_grow (&argv_obstack
, "-o");
1577 obstack_ptr_grow (&argv_obstack
, flto_out
);
1581 const char *list_option
= "-fltrans-output-list=";
1582 size_t list_option_len
= strlen (list_option
);
1587 char *dumpbase
= (char *) xmalloc (strlen (linker_output
)
1588 + sizeof (".wpa") + 1);
1589 strcpy (dumpbase
, linker_output
);
1590 strcat (dumpbase
, ".wpa");
1591 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1594 if (linker_output
&& save_temps
)
1596 ltrans_output_file
= (char *) xmalloc (strlen (linker_output
)
1597 + sizeof (".ltrans.out") + 1);
1598 strcpy (ltrans_output_file
, linker_output
);
1599 strcat (ltrans_output_file
, ".ltrans.out");
1603 char *prefix
= NULL
;
1606 prefix
= (char *) xmalloc (strlen (linker_output
) + 2);
1607 strcpy (prefix
, linker_output
);
1608 strcat (prefix
, ".");
1611 ltrans_output_file
= make_temp_file_with_prefix (prefix
,
1615 list_option_full
= (char *) xmalloc (sizeof (char) *
1616 (strlen (ltrans_output_file
) + list_option_len
+ 1));
1617 tmp
= list_option_full
;
1619 obstack_ptr_grow (&argv_obstack
, tmp
);
1620 strcpy (tmp
, list_option
);
1621 tmp
+= list_option_len
;
1622 strcpy (tmp
, ltrans_output_file
);
1627 fprintf (stderr
, "Using make jobserver\n");
1628 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1630 else if (auto_parallel
)
1633 init_num_threads ();
1635 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1637 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1638 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1640 else if (parallel
> 1)
1643 sprintf (buf
, "-fwpa=%i", parallel
);
1644 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1647 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1650 /* Append input arguments. */
1651 for (i
= 0; i
< lto_argc
; ++i
)
1652 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1653 /* Append the input objects. */
1654 for (i
= 0; i
< ltoobj_argc
; ++i
)
1655 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1656 obstack_ptr_grow (&argv_obstack
, NULL
);
1658 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1659 argv_ptr
= &new_argv
[new_head_argc
];
1660 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true);
1662 /* Copy the early generated debug info from the objects to temporary
1663 files and append those to the partial link commandline. */
1665 early_debug_object_names
= NULL
;
1668 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1669 num_deb_objs
= ltoobj_argc
;
1670 for (i
= 0; i
< ltoobj_argc
; ++i
)
1673 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1675 early_debug_object_names
[i
] = tem
;
1681 if (lto_mode
== LTO_MODE_LTO
)
1683 printf ("%s\n", flto_out
);
1686 for (i
= 0; i
< ltoobj_argc
; ++i
)
1687 if (early_debug_object_names
[i
] != NULL
)
1688 printf ("%s\n", early_debug_object_names
[i
]);
1690 /* These now belong to collect2. */
1693 free (early_debug_object_names
);
1694 early_debug_object_names
= NULL
;
1698 FILE *stream
= fopen (ltrans_output_file
, "r");
1699 FILE *mstream
= NULL
;
1700 struct obstack env_obstack
;
1704 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1706 /* Parse the list of LTRANS inputs from the WPA stage. */
1707 obstack_init (&env_obstack
);
1711 const unsigned piece
= 32;
1712 char *output_name
= NULL
;
1713 char *buf
, *input_name
= (char *)xmalloc (piece
);
1717 if (fscanf (stream
, "%i\n", &priority
) != 1)
1720 fatal_error (input_location
,
1721 "corrupted ltrans output file %s",
1722 ltrans_output_file
);
1726 if (!fgets (buf
, piece
, stream
))
1728 len
= strlen (input_name
);
1729 if (input_name
[len
- 1] != '\n')
1731 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1732 buf
= input_name
+ len
;
1735 input_name
[len
- 1] = '\0';
1737 if (input_name
[0] == '*')
1738 output_name
= &input_name
[1];
1742 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1743 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1744 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1745 ltrans_priorities
[(nr
-1)*2] = priority
;
1746 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1747 input_names
[nr
-1] = input_name
;
1748 output_names
[nr
-1] = output_name
;
1751 maybe_unlink (ltrans_output_file
);
1752 ltrans_output_file
= NULL
;
1756 makefile
= make_temp_file (".mk");
1757 mstream
= fopen (makefile
, "w");
1758 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1761 /* Execute the LTRANS stage for each input file (or prepare a
1762 makefile to invoke this in parallel). */
1763 for (i
= 0; i
< nr
; ++i
)
1766 char *input_name
= input_names
[i
];
1767 /* If it's a pass-through file do nothing. */
1768 if (output_names
[i
])
1771 /* Replace the .o suffix with a .ltrans.o suffix and write
1772 the resulting name to the LTRANS output list. */
1773 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1774 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1775 output_name
= XOBFINISH (&env_obstack
, char *);
1777 /* Adjust the dumpbase if the linker output file was seen. */
1781 = (char *) xmalloc (strlen (linker_output
)
1782 + sizeof (DUMPBASE_SUFFIX
) + 1);
1784 strlen (linker_output
) + sizeof (DUMPBASE_SUFFIX
),
1785 "%s.ltrans%u", linker_output
, i
);
1786 argv_ptr
[0] = dumpbase
;
1789 argv_ptr
[1] = "-fltrans";
1791 argv_ptr
[3] = output_name
;
1792 argv_ptr
[4] = input_name
;
1796 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1797 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1798 fprintf (mstream
, " '%s'", new_argv
[j
]);
1799 fprintf (mstream
, "\n");
1800 /* If we are not preserving the ltrans input files then
1801 truncate them as soon as we have processed it. This
1802 reduces temporary disk-space usage. */
1804 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1805 "&& mv %s.tem %s\n",
1806 input_name
, input_name
, input_name
, input_name
);
1810 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1812 maybe_unlink (input_name
);
1815 output_names
[i
] = output_name
;
1819 struct pex_obj
*pex
;
1825 for (i
= 0; i
< nr
; ++i
)
1827 int j
= ltrans_priorities
[i
*2 + 1];
1828 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1830 fprintf (mstream
, "\n");
1834 /* Avoid passing --jobserver-fd= and similar flags
1835 unless jobserver mode is explicitly enabled. */
1836 putenv (xstrdup ("MAKEFLAGS="));
1837 putenv (xstrdup ("MFLAGS="));
1839 new_argv
[0] = getenv ("MAKE");
1841 new_argv
[0] = "make";
1843 new_argv
[2] = makefile
;
1847 snprintf (jobs
, 31, "-j%ld",
1848 auto_parallel
? nthreads_var
: parallel
);
1849 new_argv
[i
++] = jobs
;
1851 new_argv
[i
++] = "all";
1852 new_argv
[i
++] = NULL
;
1853 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1854 NULL
, NULL
, PEX_SEARCH
, false);
1855 do_wait (new_argv
[0], pex
);
1856 maybe_unlink (makefile
);
1858 for (i
= 0; i
< nr
; ++i
)
1859 maybe_unlink (input_names
[i
]);
1861 for (i
= 0; i
< nr
; ++i
)
1863 fputs (output_names
[i
], stdout
);
1864 putc ('\n', stdout
);
1865 free (input_names
[i
]);
1869 for (i
= 0; i
< ltoobj_argc
; ++i
)
1870 if (early_debug_object_names
[i
] != NULL
)
1871 printf ("%s\n", early_debug_object_names
[i
]);
1874 free (ltrans_priorities
);
1875 free (output_names
);
1876 output_names
= NULL
;
1877 free (early_debug_object_names
);
1878 early_debug_object_names
= NULL
;
1880 free (list_option_full
);
1881 obstack_free (&env_obstack
, NULL
);
1886 obstack_free (&argv_obstack
, NULL
);
1893 main (int argc
, char *argv
[])
1897 init_opts_obstack ();
1899 p
= argv
[0] + strlen (argv
[0]);
1900 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
1904 xmalloc_set_program_name (progname
);
1906 gcc_init_libintl ();
1908 diagnostic_initialize (global_dc
, 0);
1910 if (atexit (lto_wrapper_cleanup
) != 0)
1911 fatal_error (input_location
, "%<atexit%> failed");
1913 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1914 signal (SIGINT
, fatal_signal
);
1916 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1917 signal (SIGHUP
, fatal_signal
);
1919 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
1920 signal (SIGTERM
, fatal_signal
);
1922 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
1923 signal (SIGPIPE
, fatal_signal
);
1926 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1927 receive the signal. A different setting is inheritable */
1928 signal (SIGCHLD
, SIG_DFL
);
1931 /* We may be called with all the arguments stored in some file and
1932 passed with @file. Expand them into argv before processing. */
1933 expandargv (&argc
, &argv
);
1935 run_gcc (argc
, argv
);