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)
1378 else if (strcmp (option
->arg
, "auto") == 0)
1385 parallel
= atoi (option
->arg
);
1392 lto_mode
= LTO_MODE_WHOPR
;
1395 case OPT_flinker_output_
:
1396 linker_output_rel
= !strcmp (option
->arg
, "rel");
1405 /* Output lto-wrapper invocation command. */
1408 for (i
= 0; i
< argc
; ++i
)
1410 fputs (argv
[i
], stderr
);
1411 fputc (' ', stderr
);
1413 fputc ('\n', stderr
);
1416 if (linker_output_rel
)
1417 no_partition
= true;
1421 lto_mode
= LTO_MODE_LTO
;
1426 else if (!jobserver
)
1427 jobserver
= jobserver_active_p ();
1431 char *output_dir
, *base
, *name
;
1432 bool bit_bucket
= strcmp (linker_output
, HOST_BIT_BUCKET
) == 0;
1434 output_dir
= xstrdup (linker_output
);
1436 for (name
= base
; *name
; name
++)
1437 if (IS_DIR_SEPARATOR (*name
))
1441 linker_output
= &linker_output
[base
- output_dir
];
1442 if (*output_dir
== '\0')
1444 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1445 output_dir
= current_dir
;
1449 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1450 obstack_ptr_grow (&argv_obstack
, output_dir
);
1453 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1456 /* Remember at which point we can scrub args to re-use the commons. */
1457 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1461 unsigned i
, num_offload_files
;
1462 char **offload_argv
;
1465 f
= fopen (offload_objects_file_name
, "r");
1467 fatal_error (input_location
, "cannot open %s: %m",
1468 offload_objects_file_name
);
1469 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1470 fatal_error (input_location
, "cannot read %s: %m",
1471 offload_objects_file_name
);
1472 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1474 /* Read names of object files with offload. */
1475 for (i
= 0; i
< num_offload_files
; i
++)
1477 const unsigned piece
= 32;
1478 char *buf
, *filename
= XNEWVEC (char, piece
);
1483 if (!fgets (buf
, piece
, f
))
1485 len
= strlen (filename
);
1486 if (filename
[len
- 1] != '\n')
1488 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1489 buf
= filename
+ len
;
1492 filename
[len
- 1] = '\0';
1493 offload_argv
[i
] = filename
;
1496 if (offload_argv
[num_offload_files
- 1] == NULL
)
1497 fatal_error (input_location
, "invalid format of %s",
1498 offload_objects_file_name
);
1499 maybe_unlink (offload_objects_file_name
);
1500 offload_objects_file_name
= NULL
;
1502 /* Look at saved offload options in files. */
1503 for (i
= 0; i
< num_offload_files
; i
++)
1508 off_t file_offset
= 0;
1509 char *filename
= offload_argv
[i
];
1511 if ((p
= strrchr (offload_argv
[i
], '@'))
1512 && p
!= offload_argv
[i
]
1513 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1514 && strlen (p
) == (unsigned int) consumed
)
1516 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1517 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1518 filename
[p
- offload_argv
[i
]] = '\0';
1519 file_offset
= (off_t
) loffset
;
1521 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1523 fatal_error (input_location
, "cannot open %s: %m", filename
);
1524 if (!find_and_merge_options (fd
, file_offset
,
1525 OFFLOAD_SECTION_NAME_PREFIX
,
1526 &offload_fdecoded_options
,
1527 &offload_fdecoded_options_count
,
1529 fatal_error (input_location
, "cannot read %s: %m", filename
);
1531 if (filename
!= offload_argv
[i
])
1532 XDELETEVEC (filename
);
1535 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1536 offload_fdecoded_options
,
1537 offload_fdecoded_options_count
,
1539 decoded_options_count
);
1541 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1545 find_crtoffloadtable ();
1546 for (i
= 0; offload_names
[i
]; i
++)
1547 printf ("%s\n", offload_names
[i
]);
1548 free_array_of_ptrs ((void **) offload_names
, i
);
1552 /* If object files contain offload sections, but do not contain LTO sections,
1553 then there is no need to perform a link-time recompilation, i.e.
1554 lto-wrapper is used only for a compilation of offload images. */
1555 if (have_offload
&& !have_lto
)
1558 if (lto_mode
== LTO_MODE_LTO
)
1562 obstack_ptr_grow (&argv_obstack
, linker_output
);
1563 flto_out
= (char *) xmalloc (strlen (linker_output
)
1564 + sizeof (".lto.o") + 1);
1565 strcpy (flto_out
, linker_output
);
1566 strcat (flto_out
, ".lto.o");
1569 flto_out
= make_temp_file (".lto.o");
1570 obstack_ptr_grow (&argv_obstack
, "-o");
1571 obstack_ptr_grow (&argv_obstack
, flto_out
);
1575 const char *list_option
= "-fltrans-output-list=";
1576 size_t list_option_len
= strlen (list_option
);
1581 char *dumpbase
= (char *) xmalloc (strlen (linker_output
)
1582 + sizeof (".wpa") + 1);
1583 strcpy (dumpbase
, linker_output
);
1584 strcat (dumpbase
, ".wpa");
1585 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1588 if (linker_output
&& save_temps
)
1590 ltrans_output_file
= (char *) xmalloc (strlen (linker_output
)
1591 + sizeof (".ltrans.out") + 1);
1592 strcpy (ltrans_output_file
, linker_output
);
1593 strcat (ltrans_output_file
, ".ltrans.out");
1597 char *prefix
= NULL
;
1600 prefix
= (char *) xmalloc (strlen (linker_output
) + 2);
1601 strcpy (prefix
, linker_output
);
1602 strcat (prefix
, ".");
1605 ltrans_output_file
= make_temp_file_with_prefix (prefix
,
1609 list_option_full
= (char *) xmalloc (sizeof (char) *
1610 (strlen (ltrans_output_file
) + list_option_len
+ 1));
1611 tmp
= list_option_full
;
1613 obstack_ptr_grow (&argv_obstack
, tmp
);
1614 strcpy (tmp
, list_option
);
1615 tmp
+= list_option_len
;
1616 strcpy (tmp
, ltrans_output_file
);
1621 fprintf (stderr
, "Using make jobserver\n");
1622 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1624 else if (auto_parallel
)
1627 init_num_threads ();
1629 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1631 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1632 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1634 else if (parallel
> 1)
1637 sprintf (buf
, "-fwpa=%i", parallel
);
1638 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1641 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1644 /* Append input arguments. */
1645 for (i
= 0; i
< lto_argc
; ++i
)
1646 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1647 /* Append the input objects. */
1648 for (i
= 0; i
< ltoobj_argc
; ++i
)
1649 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1650 obstack_ptr_grow (&argv_obstack
, NULL
);
1652 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1653 argv_ptr
= &new_argv
[new_head_argc
];
1654 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true);
1656 /* Copy the early generated debug info from the objects to temporary
1657 files and append those to the partial link commandline. */
1659 early_debug_object_names
= NULL
;
1662 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1663 num_deb_objs
= ltoobj_argc
;
1664 for (i
= 0; i
< ltoobj_argc
; ++i
)
1667 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1669 early_debug_object_names
[i
] = tem
;
1675 if (lto_mode
== LTO_MODE_LTO
)
1677 printf ("%s\n", flto_out
);
1680 for (i
= 0; i
< ltoobj_argc
; ++i
)
1681 if (early_debug_object_names
[i
] != NULL
)
1682 printf ("%s\n", early_debug_object_names
[i
]);
1684 /* These now belong to collect2. */
1687 free (early_debug_object_names
);
1688 early_debug_object_names
= NULL
;
1692 FILE *stream
= fopen (ltrans_output_file
, "r");
1693 FILE *mstream
= NULL
;
1694 struct obstack env_obstack
;
1698 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1700 /* Parse the list of LTRANS inputs from the WPA stage. */
1701 obstack_init (&env_obstack
);
1705 const unsigned piece
= 32;
1706 char *output_name
= NULL
;
1707 char *buf
, *input_name
= (char *)xmalloc (piece
);
1711 if (fscanf (stream
, "%i\n", &priority
) != 1)
1714 fatal_error (input_location
,
1715 "corrupted ltrans output file %s",
1716 ltrans_output_file
);
1720 if (!fgets (buf
, piece
, stream
))
1722 len
= strlen (input_name
);
1723 if (input_name
[len
- 1] != '\n')
1725 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1726 buf
= input_name
+ len
;
1729 input_name
[len
- 1] = '\0';
1731 if (input_name
[0] == '*')
1732 output_name
= &input_name
[1];
1736 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1737 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1738 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1739 ltrans_priorities
[(nr
-1)*2] = priority
;
1740 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1741 input_names
[nr
-1] = input_name
;
1742 output_names
[nr
-1] = output_name
;
1745 maybe_unlink (ltrans_output_file
);
1746 ltrans_output_file
= NULL
;
1750 makefile
= make_temp_file (".mk");
1751 mstream
= fopen (makefile
, "w");
1752 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1755 /* Execute the LTRANS stage for each input file (or prepare a
1756 makefile to invoke this in parallel). */
1757 for (i
= 0; i
< nr
; ++i
)
1760 char *input_name
= input_names
[i
];
1761 /* If it's a pass-through file do nothing. */
1762 if (output_names
[i
])
1765 /* Replace the .o suffix with a .ltrans.o suffix and write
1766 the resulting name to the LTRANS output list. */
1767 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1768 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1769 output_name
= XOBFINISH (&env_obstack
, char *);
1771 /* Adjust the dumpbase if the linker output file was seen. */
1775 = (char *) xmalloc (strlen (linker_output
)
1776 + sizeof (DUMPBASE_SUFFIX
) + 1);
1778 strlen (linker_output
) + sizeof (DUMPBASE_SUFFIX
),
1779 "%s.ltrans%u", linker_output
, i
);
1780 argv_ptr
[0] = dumpbase
;
1783 argv_ptr
[1] = "-fltrans";
1785 argv_ptr
[3] = output_name
;
1786 argv_ptr
[4] = input_name
;
1790 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1791 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1792 fprintf (mstream
, " '%s'", new_argv
[j
]);
1793 fprintf (mstream
, "\n");
1794 /* If we are not preserving the ltrans input files then
1795 truncate them as soon as we have processed it. This
1796 reduces temporary disk-space usage. */
1798 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1799 "&& mv %s.tem %s\n",
1800 input_name
, input_name
, input_name
, input_name
);
1804 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1806 maybe_unlink (input_name
);
1809 output_names
[i
] = output_name
;
1813 struct pex_obj
*pex
;
1819 for (i
= 0; i
< nr
; ++i
)
1821 int j
= ltrans_priorities
[i
*2 + 1];
1822 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1824 fprintf (mstream
, "\n");
1828 /* Avoid passing --jobserver-fd= and similar flags
1829 unless jobserver mode is explicitly enabled. */
1830 putenv (xstrdup ("MAKEFLAGS="));
1831 putenv (xstrdup ("MFLAGS="));
1833 new_argv
[0] = getenv ("MAKE");
1835 new_argv
[0] = "make";
1837 new_argv
[2] = makefile
;
1841 snprintf (jobs
, 31, "-j%ld",
1842 auto_parallel
? nthreads_var
: parallel
);
1843 new_argv
[i
++] = jobs
;
1845 new_argv
[i
++] = "all";
1846 new_argv
[i
++] = NULL
;
1847 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1848 NULL
, NULL
, PEX_SEARCH
, false);
1849 do_wait (new_argv
[0], pex
);
1850 maybe_unlink (makefile
);
1852 for (i
= 0; i
< nr
; ++i
)
1853 maybe_unlink (input_names
[i
]);
1855 for (i
= 0; i
< nr
; ++i
)
1857 fputs (output_names
[i
], stdout
);
1858 putc ('\n', stdout
);
1859 free (input_names
[i
]);
1863 for (i
= 0; i
< ltoobj_argc
; ++i
)
1864 if (early_debug_object_names
[i
] != NULL
)
1865 printf ("%s\n", early_debug_object_names
[i
]);
1868 free (ltrans_priorities
);
1869 free (output_names
);
1870 output_names
= NULL
;
1871 free (early_debug_object_names
);
1872 early_debug_object_names
= NULL
;
1874 free (list_option_full
);
1875 obstack_free (&env_obstack
, NULL
);
1880 obstack_free (&argv_obstack
, NULL
);
1887 main (int argc
, char *argv
[])
1891 init_opts_obstack ();
1893 p
= argv
[0] + strlen (argv
[0]);
1894 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
1898 xmalloc_set_program_name (progname
);
1900 gcc_init_libintl ();
1902 diagnostic_initialize (global_dc
, 0);
1904 if (atexit (lto_wrapper_cleanup
) != 0)
1905 fatal_error (input_location
, "%<atexit%> failed");
1907 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1908 signal (SIGINT
, fatal_signal
);
1910 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1911 signal (SIGHUP
, fatal_signal
);
1913 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
1914 signal (SIGTERM
, fatal_signal
);
1916 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
1917 signal (SIGPIPE
, fatal_signal
);
1920 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1921 receive the signal. A different setting is inheritable */
1922 signal (SIGCHLD
, SIG_DFL
);
1925 /* We may be called with all the arguments stored in some file and
1926 passed with @file. Expand them into argv before processing. */
1927 expandargv (&argc
, &argv
);
1929 run_gcc (argc
, argv
);