1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2020 Free Software Foundation, Inc.
4 Factored out of collect2 by Rafael Espindola <espindola@google.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* This program is passed a gcc, a list of gcc arguments and a list of
24 object files containing IL. It scans the argument list to check if
25 we are in whopr mode or not modifies the arguments and needed and
26 prints a list of output files on stdout.
30 $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto
32 The above will print something like
35 If WHOPR is used instead, more than one file might be produced
36 ./ccXj2DTk.lto.ltrans.o
37 ./ccCJuXGv.lto.ltrans.o
42 #include "coretypes.h"
44 #include "diagnostic.h"
48 #include "simple-object.h"
49 #include "lto-section-names.h"
50 #include "collect-utils.h"
52 /* Environment variable, used for passing the names of offload targets from GCC
53 driver to lto-wrapper. */
54 #define OFFLOAD_TARGET_NAMES_ENV "OFFLOAD_TARGET_NAMES"
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_warn_removed
:
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
:
269 /* Do what the old LTO code did - collect exactly one option
270 setting per OPT code, we pick the first we encounter.
271 ??? This doesn't make too much sense, but when it doesn't
272 then we should complain. */
273 for (j
= 0; j
< *decoded_options_count
; ++j
)
274 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
276 if (j
== *decoded_options_count
)
277 append_option (decoded_options
, decoded_options_count
, foption
);
280 /* Figure out what PIC/PIE level wins and merge the results. */
283 pic_option
= foption
;
287 pie_option
= foption
;
292 /* For selected options we can merge conservatively. */
293 for (j
= 0; j
< *decoded_options_count
; ++j
)
294 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
296 if (j
== *decoded_options_count
)
297 append_option (decoded_options
, decoded_options_count
, foption
);
298 /* -fopenmp > -fno-openmp,
299 -fopenacc > -fno-openacc */
300 else if (foption
->value
> (*decoded_options
)[j
].value
)
301 (*decoded_options
)[j
] = *foption
;
304 case OPT_fopenacc_dim_
:
305 /* Append or check identical. */
306 for (j
= 0; j
< *decoded_options_count
; ++j
)
307 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
309 if (j
== *decoded_options_count
)
310 append_option (decoded_options
, decoded_options_count
, foption
);
311 else if (strcmp ((*decoded_options
)[j
].arg
, foption
->arg
))
312 fatal_error (input_location
,
313 "option %s with different values",
314 foption
->orig_option_with_args_text
);
321 for (j
= 0; j
< *decoded_options_count
; ++j
)
322 if ((*decoded_options
)[j
].opt_index
== OPT_O
323 || (*decoded_options
)[j
].opt_index
== OPT_Ofast
324 || (*decoded_options
)[j
].opt_index
== OPT_Og
325 || (*decoded_options
)[j
].opt_index
== OPT_Os
)
327 if (j
== *decoded_options_count
)
328 append_option (decoded_options
, decoded_options_count
, foption
);
329 else if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
330 && foption
->opt_index
!= OPT_O
)
331 /* Exact same options get merged. */
335 /* For mismatched option kinds preserve the optimization
336 level only, thus merge it as -On. This also handles
337 merging of same optimization level -On. */
339 switch (foption
->opt_index
)
342 if (foption
->arg
[0] == '\0')
343 level
= MAX (level
, 1);
345 level
= MAX (level
, atoi (foption
->arg
));
348 level
= MAX (level
, 3);
351 level
= MAX (level
, 1);
354 level
= MAX (level
, 2);
359 switch ((*decoded_options
)[j
].opt_index
)
362 if ((*decoded_options
)[j
].arg
[0] == '\0')
363 level
= MAX (level
, 1);
365 level
= MAX (level
, atoi ((*decoded_options
)[j
].arg
));
368 level
= MAX (level
, 3);
371 level
= MAX (level
, 1);
374 level
= MAX (level
, 2);
379 (*decoded_options
)[j
].opt_index
= OPT_O
;
381 tem
= xasprintf ("-O%d", level
);
382 (*decoded_options
)[j
].arg
= &tem
[2];
383 (*decoded_options
)[j
].canonical_option
[0] = tem
;
384 (*decoded_options
)[j
].value
= 1;
389 case OPT_foffload_abi_
:
390 for (j
= 0; j
< *decoded_options_count
; ++j
)
391 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
393 if (j
== *decoded_options_count
)
394 append_option (decoded_options
, decoded_options_count
, foption
);
395 else if (foption
->value
!= (*decoded_options
)[j
].value
)
396 fatal_error (input_location
,
397 "option %s not used consistently in all LTO input"
398 " files", foption
->orig_option_with_args_text
);
403 append_option (decoded_options
, decoded_options_count
, foption
);
408 /* Merge PIC options:
409 -fPIC + -fpic = -fpic
410 -fPIC + -fno-pic = -fno-pic
411 -fpic/-fPIC + nothing = nothing.
412 It is a common mistake to mix few -fPIC compiled objects into otherwise
413 non-PIC code. We do not want to build everything with PIC then.
415 Similarly we merge PIE options, however in addition we keep
416 -fPIC + -fPIE = -fPIE
417 -fpic + -fPIE = -fpie
418 -fPIC/-fpic + -fpie = -fpie
420 It would be good to warn on mismatches, but it is bit hard to do as
421 we do not know what nothing translates to. */
423 for (unsigned int j
= 0; j
< *decoded_options_count
;)
424 if ((*decoded_options
)[j
].opt_index
== OPT_fPIC
425 || (*decoded_options
)[j
].opt_index
== OPT_fpic
)
427 /* -fno-pic in one unit implies -fno-pic everywhere. */
428 if ((*decoded_options
)[j
].value
== 0)
430 /* If we have no pic option or merge in -fno-pic, we still may turn
431 existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */
432 else if ((pic_option
&& pic_option
->value
== 0)
437 bool big
= (*decoded_options
)[j
].opt_index
== OPT_fPIC
438 && pie_option
->opt_index
== OPT_fPIE
;
439 (*decoded_options
)[j
].opt_index
= big
? OPT_fPIE
: OPT_fpie
;
440 if (pie_option
->value
)
441 (*decoded_options
)[j
].canonical_option
[0]
442 = big
? "-fPIE" : "-fpie";
444 (*decoded_options
)[j
].canonical_option
[0] = "-fno-pie";
445 (*decoded_options
)[j
].value
= pie_option
->value
;
450 (*decoded_options
)[j
] = *pic_option
;
453 /* We do not know if target defaults to pic or not, so just remove
454 option if it is missing in one unit but enabled in other. */
456 remove_option (decoded_options
, j
, decoded_options_count
);
458 else if (pic_option
->opt_index
== OPT_fpic
459 && (*decoded_options
)[j
].opt_index
== OPT_fPIC
)
461 (*decoded_options
)[j
] = *pic_option
;
467 else if ((*decoded_options
)[j
].opt_index
== OPT_fPIE
468 || (*decoded_options
)[j
].opt_index
== OPT_fpie
)
470 /* -fno-pie in one unit implies -fno-pie everywhere. */
471 if ((*decoded_options
)[j
].value
== 0)
473 /* If we have no pie option or merge in -fno-pie, we still preserve
474 PIE/pie if pic/PIC is present. */
475 else if ((pie_option
&& pie_option
->value
== 0)
478 /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */
481 if (pic_option
->opt_index
== OPT_fpic
482 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
484 (*decoded_options
)[j
].opt_index
= OPT_fpie
;
485 (*decoded_options
)[j
].canonical_option
[0]
486 = pic_option
->value
? "-fpie" : "-fno-pie";
488 else if (!pic_option
->value
)
489 (*decoded_options
)[j
].canonical_option
[0] = "-fno-pie";
490 (*decoded_options
)[j
].value
= pic_option
->value
;
495 (*decoded_options
)[j
] = *pie_option
;
498 /* Because we always append pic/PIE options this code path should
499 not happen unless the LTO object was built by old lto1 which
500 did not contain that logic yet. */
502 remove_option (decoded_options
, j
, decoded_options_count
);
504 else if (pie_option
->opt_index
== OPT_fpie
505 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
507 (*decoded_options
)[j
] = *pie_option
;
517 /* Auxiliary function that frees elements of PTR and PTR itself.
518 N is number of elements to be freed. If PTR is NULL, nothing is freed.
519 If an element is NULL, subsequent elements are not freed. */
522 free_array_of_ptrs (void **ptr
, unsigned n
)
526 for (unsigned i
= 0; i
< n
; i
++)
536 /* Parse STR, saving found tokens into PVALUES and return their number.
537 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
538 append it to every token we find. */
541 parse_env_var (const char *str
, char ***pvalues
, const char *append
)
543 const char *curval
, *nextval
;
547 curval
= strchr (str
, ':');
551 curval
= strchr (curval
+ 1, ':');
554 values
= (char**) xmalloc (num
* sizeof (char*));
556 nextval
= strchr (curval
, ':');
558 nextval
= strchr (curval
, '\0');
560 int append_len
= append
? strlen (append
) : 0;
561 for (i
= 0; i
< num
; i
++)
563 int l
= nextval
- curval
;
564 values
[i
] = (char*) xmalloc (l
+ 1 + append_len
);
565 memcpy (values
[i
], curval
, l
);
568 strcat (values
[i
], append
);
569 curval
= nextval
+ 1;
570 nextval
= strchr (curval
, ':');
572 nextval
= strchr (curval
, '\0');
578 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
581 append_compiler_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
584 /* Append compiler driver arguments as far as they were merged. */
585 for (unsigned int j
= 1; j
< count
; ++j
)
587 struct cl_decoded_option
*option
= &opts
[j
];
589 /* File options have been properly filtered by lto-opts.c. */
590 switch (option
->opt_index
)
592 /* Drop arguments that we want to take from the link line. */
595 case OPT_flto_partition_
:
602 /* For now do what the original LTO option code was doing - pass
603 on any CL_TARGET flag and a few selected others. */
604 switch (option
->opt_index
)
606 case OPT_fdiagnostics_show_caret
:
607 case OPT_fdiagnostics_show_labels
:
608 case OPT_fdiagnostics_show_line_numbers
:
609 case OPT_fdiagnostics_show_option
:
610 case OPT_fdiagnostics_show_location_
:
611 case OPT_fshow_column
:
620 case OPT_fopenacc_dim_
:
621 case OPT_foffload_abi_
:
630 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
634 /* Pass the option on. */
635 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
636 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
640 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
643 append_diag_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
646 /* Append compiler driver arguments as far as they were merged. */
647 for (unsigned int j
= 1; j
< count
; ++j
)
649 struct cl_decoded_option
*option
= &opts
[j
];
651 switch (option
->opt_index
)
653 case OPT_fdiagnostics_color_
:
654 case OPT_fdiagnostics_format_
:
655 case OPT_fdiagnostics_show_caret
:
656 case OPT_fdiagnostics_show_labels
:
657 case OPT_fdiagnostics_show_line_numbers
:
658 case OPT_fdiagnostics_show_option
:
659 case OPT_fdiagnostics_show_location_
:
660 case OPT_fshow_column
:
666 /* Pass the option on. */
667 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
668 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
673 /* Append linker options OPTS to ARGV_OBSTACK. */
676 append_linker_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
679 /* Append linker driver arguments. Compiler options from the linker
680 driver arguments will override / merge with those from the compiler. */
681 for (unsigned int j
= 1; j
< count
; ++j
)
683 struct cl_decoded_option
*option
= &opts
[j
];
685 /* Do not pass on frontend specific flags not suitable for lto. */
686 if (!(cl_options
[option
->opt_index
].flags
687 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
690 switch (option
->opt_index
)
695 /* We've handled these LTO options, do not pass them on. */
700 /* Ignore -fno-XXX form of these options, as otherwise
701 corresponding builtins will not be enabled. */
702 if (option
->value
== 0)
710 /* Pass the option on. */
711 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
712 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
716 /* Extract options for TARGET offload compiler from OPTIONS and append
717 them to ARGV_OBSTACK. */
720 append_offload_options (obstack
*argv_obstack
, const char *target
,
721 struct cl_decoded_option
*options
,
722 unsigned int options_count
)
724 for (unsigned i
= 0; i
< options_count
; i
++)
726 const char *cur
, *next
, *opts
;
729 struct cl_decoded_option
*option
= &options
[i
];
731 if (option
->opt_index
!= OPT_foffload_
)
734 /* If option argument starts with '-' then no target is specified. That
735 means offload options are specified for all targets, so we need to
737 if (option
->arg
[0] == '-')
741 opts
= strchr (option
->arg
, '=');
742 /* If there are offload targets specified, but no actual options,
743 there is nothing to do here. */
751 next
= strchr (cur
, ',');
754 next
= (next
> opts
) ? opts
: next
;
756 /* Are we looking for this offload target? */
757 if (strlen (target
) == (size_t) (next
- cur
)
758 && strncmp (target
, cur
, next
- cur
) == 0)
761 /* Skip the comma or equal sign. */
771 argv
= buildargv (opts
);
772 for (argc
= 0; argv
[argc
]; argc
++)
773 obstack_ptr_grow (argv_obstack
, argv
[argc
]);
777 /* Check whether NAME can be accessed in MODE. This is like access,
778 except that it never considers directories to be executable. */
781 access_check (const char *name
, int mode
)
787 if (stat (name
, &st
) < 0
788 || S_ISDIR (st
.st_mode
))
792 return access (name
, mode
);
795 /* Prepare a target image for offload TARGET, using mkoffload tool from
796 COMPILER_PATH. Return the name of the resultant object file. */
799 compile_offload_image (const char *target
, const char *compiler_path
,
800 unsigned in_argc
, char *in_argv
[],
801 struct cl_decoded_option
*compiler_opts
,
802 unsigned int compiler_opt_count
,
803 struct cl_decoded_option
*linker_opts
,
804 unsigned int linker_opt_count
)
806 char *filename
= NULL
;
809 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target
));
810 strcpy (suffix
, "/accel/");
811 strcat (suffix
, target
);
812 strcat (suffix
, "/mkoffload");
815 unsigned n_paths
= parse_env_var (compiler_path
, &paths
, suffix
);
817 const char *compiler
= NULL
;
818 for (unsigned i
= 0; i
< n_paths
; i
++)
819 if (access_check (paths
[i
], X_OK
) == 0)
826 fatal_error (input_location
,
827 "could not find %s in %s (consider using %<-B%>)",
828 suffix
+ 1, compiler_path
);
830 /* Generate temporary output file name. */
831 filename
= make_temp_file (".target.o");
833 struct obstack argv_obstack
;
834 obstack_init (&argv_obstack
);
835 obstack_ptr_grow (&argv_obstack
, compiler
);
837 obstack_ptr_grow (&argv_obstack
, "-save-temps");
839 obstack_ptr_grow (&argv_obstack
, "-v");
840 obstack_ptr_grow (&argv_obstack
, "-o");
841 obstack_ptr_grow (&argv_obstack
, filename
);
843 /* Append names of input object files. */
844 for (unsigned i
= 0; i
< in_argc
; i
++)
845 obstack_ptr_grow (&argv_obstack
, in_argv
[i
]);
847 /* Append options from offload_lto sections. */
848 append_compiler_options (&argv_obstack
, compiler_opts
,
850 append_diag_options (&argv_obstack
, linker_opts
, linker_opt_count
);
852 /* Append options specified by -foffload last. In case of conflicting
853 options we expect offload compiler to choose the latest. */
854 append_offload_options (&argv_obstack
, target
, compiler_opts
,
856 append_offload_options (&argv_obstack
, target
, linker_opts
,
859 obstack_ptr_grow (&argv_obstack
, NULL
);
860 argv
= XOBFINISH (&argv_obstack
, char **);
861 fork_execute (argv
[0], argv
, true);
862 obstack_free (&argv_obstack
, NULL
);
864 free_array_of_ptrs ((void **) paths
, n_paths
);
869 /* The main routine dealing with offloading.
870 The routine builds a target image for each offload target. IN_ARGC and
871 IN_ARGV specify options and input object files. As all of them could contain
872 target sections, we pass them all to target compilers. */
875 compile_images_for_offload_targets (unsigned in_argc
, char *in_argv
[],
876 struct cl_decoded_option
*compiler_opts
,
877 unsigned int compiler_opt_count
,
878 struct cl_decoded_option
*linker_opts
,
879 unsigned int linker_opt_count
)
882 const char *target_names
= getenv (OFFLOAD_TARGET_NAMES_ENV
);
885 unsigned num_targets
= parse_env_var (target_names
, &names
, NULL
);
887 int next_name_entry
= 0;
888 const char *compiler_path
= getenv ("COMPILER_PATH");
892 /* Prepare an image for each target and save the name of the resultant object
893 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
894 offload_names
= XCNEWVEC (char *, num_targets
+ 1);
895 for (unsigned i
= 0; i
< num_targets
; i
++)
897 /* HSA does not use LTO-like streaming and a different compiler, skip
899 if (strcmp (names
[i
], "hsa") == 0)
902 offload_names
[next_name_entry
]
903 = compile_offload_image (names
[i
], compiler_path
, in_argc
, in_argv
,
904 compiler_opts
, compiler_opt_count
,
905 linker_opts
, linker_opt_count
);
906 if (!offload_names
[next_name_entry
])
907 fatal_error (input_location
,
908 "problem with building target image for %s", names
[i
]);
913 free_array_of_ptrs ((void **) names
, num_targets
);
916 /* Copy a file from SRC to DEST. */
919 copy_file (const char *dest
, const char *src
)
921 FILE *d
= fopen (dest
, "wb");
922 FILE *s
= fopen (src
, "rb");
926 size_t len
= fread (buffer
, 1, 512, s
);
928 fatal_error (input_location
, "reading input file");
931 fwrite (buffer
, 1, len
, d
);
933 fatal_error (input_location
, "writing output file");
940 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
941 the copy to the linker. */
944 find_crtoffloadtable (void)
947 const char *library_path
= getenv ("LIBRARY_PATH");
950 unsigned n_paths
= parse_env_var (library_path
, &paths
, "/crtoffloadtable.o");
953 for (i
= 0; i
< n_paths
; i
++)
954 if (access_check (paths
[i
], R_OK
) == 0)
956 /* The linker will delete the filename we give it, so make a copy. */
957 char *crtoffloadtable
= make_temp_file (".crtoffloadtable.o");
958 copy_file (crtoffloadtable
, paths
[i
]);
959 printf ("%s\n", crtoffloadtable
);
960 XDELETEVEC (crtoffloadtable
);
964 fatal_error (input_location
,
965 "installation error, cannot find %<crtoffloadtable.o%>");
967 free_array_of_ptrs ((void **) paths
, n_paths
);
970 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
971 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
972 and OPT_COUNT. Return true if we found a matchingn section, false
973 otherwise. COLLECT_GCC holds the value of the environment variable with
977 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
978 struct cl_decoded_option
**opts
,
979 unsigned int *opt_count
, const char *collect_gcc
)
981 off_t offset
, length
;
986 struct cl_decoded_option
*fdecoded_options
= *opts
;
987 unsigned int fdecoded_options_count
= *opt_count
;
989 simple_object_read
*sobj
;
990 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
995 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
996 strcpy (secname
, prefix
);
997 strcat (secname
, ".opts");
998 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
1001 simple_object_release_read (sobj
);
1005 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
1006 data
= (char *)xmalloc (length
);
1007 read (fd
, data
, length
);
1011 struct cl_decoded_option
*f2decoded_options
;
1012 unsigned int f2decoded_options_count
;
1013 get_options_from_collect_gcc_options (collect_gcc
, fopts
,
1015 &f2decoded_options_count
);
1016 if (!fdecoded_options
)
1018 fdecoded_options
= f2decoded_options
;
1019 fdecoded_options_count
= f2decoded_options_count
;
1022 merge_and_complain (&fdecoded_options
,
1023 &fdecoded_options_count
,
1024 f2decoded_options
, f2decoded_options_count
);
1026 fopts
+= strlen (fopts
) + 1;
1028 while (fopts
- data
< length
);
1031 simple_object_release_read (sobj
);
1032 *opts
= fdecoded_options
;
1033 *opt_count
= fdecoded_options_count
;
1037 /* Copy early debug info sections from INFILE to a new file whose name
1038 is returned. Return NULL on error. */
1041 debug_objcopy (const char *infile
, bool rename
)
1048 const char *orig_infile
= infile
;
1052 if ((p
= strrchr (infile
, '@'))
1054 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1055 && strlen (p
) == (unsigned int) consumed
)
1057 char *fname
= xstrdup (infile
);
1058 fname
[p
- infile
] = '\0';
1060 inoff
= (off_t
) loffset
;
1062 int infd
= open (infile
, O_RDONLY
| O_BINARY
);
1065 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
1072 if (simple_object_find_section (inobj
, ".gnu.debuglto_.debug_info",
1073 &off
, &len
, &errmsg
, &err
) != 1)
1076 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1078 simple_object_release_read (inobj
);
1085 outfile
= (char *) xmalloc (strlen (orig_infile
)
1086 + sizeof (".debug.temp.o") + 1);
1087 strcpy (outfile
, orig_infile
);
1088 strcat (outfile
, ".debug.temp.o");
1091 outfile
= make_temp_file (".debug.temp.o");
1092 errmsg
= simple_object_copy_lto_debug_sections (inobj
, outfile
, &err
, rename
);
1095 unlink_if_ordinary (outfile
);
1096 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1099 simple_object_release_read (inobj
);
1105 /* Helper for qsort: compare priorities for parallel compilation. */
1108 cmp_priority (const void *a
, const void *b
)
1110 return *((const int *)b
)-*((const int *)a
);
1113 /* Number of CPUs that can be used for parallel LTRANS phase. */
1115 static unsigned long nthreads_var
= 0;
1117 #ifdef HAVE_PTHREAD_AFFINITY_NP
1118 unsigned long cpuset_size
;
1119 static unsigned long get_cpuset_size
;
1123 static cpuset_popcount (unsigned long cpusetsize
, cpu_set_t
*cpusetp
)
1126 /* glibc 2.7 and above provide a macro for this. */
1127 return CPU_COUNT_S (cpusetsize
, cpusetp
);
1130 if (cpusetsize
== sizeof (cpu_set_t
))
1131 /* glibc 2.6 and above provide a macro for this. */
1132 return CPU_COUNT (cpusetp
);
1135 unsigned long ret
= 0;
1136 STATIC_ASSERT (sizeof (cpusetp
->__bits
[0]) == sizeof (unsigned long int));
1137 for (i
= 0; i
< cpusetsize
/ sizeof (cpusetp
->__bits
[0]); i
++)
1139 unsigned long int mask
= cpusetp
->__bits
[i
];
1142 ret
+= __builtin_popcountl (mask
);
1149 /* At startup, determine the default number of threads. It would seem
1150 this should be related to the number of cpus online. */
1153 init_num_threads (void)
1155 #ifdef HAVE_PTHREAD_AFFINITY_NP
1156 #if defined (_SC_NPROCESSORS_CONF) && defined (CPU_ALLOC_SIZE)
1157 cpuset_size
= sysconf (_SC_NPROCESSORS_CONF
);
1158 cpuset_size
= CPU_ALLOC_SIZE (cpuset_size
);
1160 cpuset_size
= sizeof (cpu_set_t
);
1163 cpusetp
= (cpu_set_t
*) xmalloc (gomp_cpuset_size
);
1166 int ret
= pthread_getaffinity_np (pthread_self (), gomp_cpuset_size
,
1170 /* Count only the CPUs this process can use. */
1171 nthreads_var
= cpuset_popcount (cpuset_size
, cpusetp
);
1172 if (nthreads_var
== 0)
1174 get_cpuset_size
= cpuset_size
;
1175 #ifdef CPU_ALLOC_SIZE
1177 for (i
= cpuset_size
* 8; i
; i
--)
1178 if (CPU_ISSET_S (i
- 1, cpuset_size
, cpusetp
))
1180 cpuset_size
= CPU_ALLOC_SIZE (i
);
1186 #ifdef CPU_ALLOC_SIZE
1187 if (cpuset_size
< sizeof (cpu_set_t
))
1188 cpuset_size
= sizeof (cpu_set_t
);
1190 cpuset_size
= cpuset_size
* 2;
1191 if (cpuset_size
< 8 * sizeof (cpu_set_t
))
1193 = (cpu_set_t
*) realloc (cpusetp
, cpuset_size
);
1196 /* Avoid fatal if too large memory allocation would be
1197 requested, e.g. kernel returning EINVAL all the time. */
1198 void *p
= realloc (cpusetp
, cpuset_size
);
1201 cpusetp
= (cpu_set_t
*) p
;
1213 #ifdef _SC_NPROCESSORS_ONLN
1214 nthreads_var
= sysconf (_SC_NPROCESSORS_ONLN
);
1218 /* FIXME: once using -std=c11, we can use std::thread::hardware_concurrency. */
1220 /* Return true when a jobserver is running and can accept a job. */
1223 jobserver_active_p (void)
1225 const char *makeflags
= getenv ("MAKEFLAGS");
1226 if (makeflags
== NULL
)
1229 const char *needle
= "--jobserver-auth=";
1230 const char *n
= strstr (makeflags
, needle
);
1237 return (sscanf (n
+ strlen (needle
), "%d,%d", &rfd
, &wfd
) == 2
1240 && is_valid_fd (rfd
)
1241 && is_valid_fd (wfd
));
1244 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1247 run_gcc (unsigned argc
, char *argv
[])
1250 const char **new_argv
;
1251 const char **argv_ptr
;
1252 char *list_option_full
= NULL
;
1253 const char *linker_output
= NULL
;
1254 const char *collect_gcc
, *collect_gcc_options
;
1257 int auto_parallel
= 0;
1258 bool no_partition
= false;
1259 struct cl_decoded_option
*fdecoded_options
= NULL
;
1260 struct cl_decoded_option
*offload_fdecoded_options
= NULL
;
1261 unsigned int fdecoded_options_count
= 0;
1262 unsigned int offload_fdecoded_options_count
= 0;
1263 struct cl_decoded_option
*decoded_options
;
1264 unsigned int decoded_options_count
;
1265 struct obstack argv_obstack
;
1267 bool have_lto
= false;
1268 bool have_offload
= false;
1269 unsigned lto_argc
= 0, ltoobj_argc
= 0;
1270 char **lto_argv
, **ltoobj_argv
;
1271 bool linker_output_rel
= false;
1272 bool skip_debug
= false;
1273 unsigned n_debugobj
;
1275 /* Get the driver and options. */
1276 collect_gcc
= getenv ("COLLECT_GCC");
1278 fatal_error (input_location
,
1279 "environment variable %<COLLECT_GCC%> must be set");
1280 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1281 if (!collect_gcc_options
)
1282 fatal_error (input_location
,
1283 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1284 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
1286 &decoded_options_count
);
1288 /* Allocate array for input object files with LTO IL,
1289 and for possible preceding arguments. */
1290 lto_argv
= XNEWVEC (char *, argc
);
1291 ltoobj_argv
= XNEWVEC (char *, argc
);
1293 /* Look at saved options in the IL files. */
1294 for (i
= 1; i
< argc
; ++i
)
1298 off_t file_offset
= 0;
1301 char *filename
= argv
[i
];
1303 if (strncmp (argv
[i
], "-foffload-objects=",
1304 sizeof ("-foffload-objects=") - 1) == 0)
1306 have_offload
= true;
1307 offload_objects_file_name
1308 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1312 if ((p
= strrchr (argv
[i
], '@'))
1314 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1315 && strlen (p
) == (unsigned int) consumed
)
1317 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1318 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1319 filename
[p
- argv
[i
]] = '\0';
1320 file_offset
= (off_t
) loffset
;
1322 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1323 /* Linker plugin passes -fresolution and -flinker-output options.
1324 -flinker-output is passed only when user did not specify one and thus
1325 we do not need to worry about duplicities with the option handling
1329 lto_argv
[lto_argc
++] = argv
[i
];
1330 if (strcmp (argv
[i
], "-flinker-output=rel") == 0)
1331 linker_output_rel
= true;
1335 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1336 &fdecoded_options
, &fdecoded_options_count
,
1340 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1345 /* Initalize the common arguments for the driver. */
1346 obstack_init (&argv_obstack
);
1347 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1348 obstack_ptr_grow (&argv_obstack
, "-xlto");
1349 obstack_ptr_grow (&argv_obstack
, "-c");
1351 append_compiler_options (&argv_obstack
, fdecoded_options
,
1352 fdecoded_options_count
);
1353 append_linker_options (&argv_obstack
, decoded_options
, decoded_options_count
);
1355 /* Scan linker driver arguments for things that are of relevance to us. */
1356 for (j
= 1; j
< decoded_options_count
; ++j
)
1358 struct cl_decoded_option
*option
= &decoded_options
[j
];
1359 switch (option
->opt_index
)
1362 linker_output
= option
->arg
;
1365 case OPT_save_temps
:
1373 case OPT_flto_partition_
:
1374 if (strcmp (option
->arg
, "none") == 0)
1375 no_partition
= true;
1379 if (strcmp (option
->arg
, "jobserver") == 0)
1384 else if (strcmp (option
->arg
, "auto") == 0)
1391 parallel
= atoi (option
->arg
);
1398 lto_mode
= LTO_MODE_WHOPR
;
1401 case OPT_flinker_output_
:
1402 linker_output_rel
= !strcmp (option
->arg
, "rel");
1406 /* Recognize -g0. */
1407 skip_debug
= option
->arg
&& !strcmp (option
->arg
, "0");
1415 /* Output lto-wrapper invocation command. */
1418 for (i
= 0; i
< argc
; ++i
)
1420 fputs (argv
[i
], stderr
);
1421 fputc (' ', stderr
);
1423 fputc ('\n', stderr
);
1426 if (linker_output_rel
)
1427 no_partition
= true;
1431 lto_mode
= LTO_MODE_LTO
;
1436 else if (!jobserver
&& jobserver_active_p ())
1444 char *output_dir
, *base
, *name
;
1445 bool bit_bucket
= strcmp (linker_output
, HOST_BIT_BUCKET
) == 0;
1447 output_dir
= xstrdup (linker_output
);
1449 for (name
= base
; *name
; name
++)
1450 if (IS_DIR_SEPARATOR (*name
))
1454 linker_output
= &linker_output
[base
- output_dir
];
1455 if (*output_dir
== '\0')
1457 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1458 output_dir
= current_dir
;
1462 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1463 obstack_ptr_grow (&argv_obstack
, output_dir
);
1466 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1469 /* Remember at which point we can scrub args to re-use the commons. */
1470 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1474 unsigned i
, num_offload_files
;
1475 char **offload_argv
;
1478 f
= fopen (offload_objects_file_name
, "r");
1480 fatal_error (input_location
, "cannot open %s: %m",
1481 offload_objects_file_name
);
1482 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1483 fatal_error (input_location
, "cannot read %s: %m",
1484 offload_objects_file_name
);
1485 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1487 /* Read names of object files with offload. */
1488 for (i
= 0; i
< num_offload_files
; i
++)
1490 const unsigned piece
= 32;
1491 char *buf
, *filename
= XNEWVEC (char, piece
);
1496 if (!fgets (buf
, piece
, f
))
1498 len
= strlen (filename
);
1499 if (filename
[len
- 1] != '\n')
1501 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1502 buf
= filename
+ len
;
1505 filename
[len
- 1] = '\0';
1506 offload_argv
[i
] = filename
;
1509 if (offload_argv
[num_offload_files
- 1] == NULL
)
1510 fatal_error (input_location
, "invalid format of %s",
1511 offload_objects_file_name
);
1512 maybe_unlink (offload_objects_file_name
);
1513 offload_objects_file_name
= NULL
;
1515 /* Look at saved offload options in files. */
1516 for (i
= 0; i
< num_offload_files
; i
++)
1521 off_t file_offset
= 0;
1522 char *filename
= offload_argv
[i
];
1524 if ((p
= strrchr (offload_argv
[i
], '@'))
1525 && p
!= offload_argv
[i
]
1526 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1527 && strlen (p
) == (unsigned int) consumed
)
1529 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1530 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1531 filename
[p
- offload_argv
[i
]] = '\0';
1532 file_offset
= (off_t
) loffset
;
1534 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1536 fatal_error (input_location
, "cannot open %s: %m", filename
);
1537 if (!find_and_merge_options (fd
, file_offset
,
1538 OFFLOAD_SECTION_NAME_PREFIX
,
1539 &offload_fdecoded_options
,
1540 &offload_fdecoded_options_count
,
1542 fatal_error (input_location
, "cannot read %s: %m", filename
);
1544 if (filename
!= offload_argv
[i
])
1545 XDELETEVEC (filename
);
1548 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1549 offload_fdecoded_options
,
1550 offload_fdecoded_options_count
,
1552 decoded_options_count
);
1554 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1558 find_crtoffloadtable ();
1559 for (i
= 0; offload_names
[i
]; i
++)
1560 printf ("%s\n", offload_names
[i
]);
1561 free_array_of_ptrs ((void **) offload_names
, i
);
1565 /* If object files contain offload sections, but do not contain LTO sections,
1566 then there is no need to perform a link-time recompilation, i.e.
1567 lto-wrapper is used only for a compilation of offload images. */
1568 if (have_offload
&& !have_lto
)
1571 if (lto_mode
== LTO_MODE_LTO
)
1575 obstack_ptr_grow (&argv_obstack
, linker_output
);
1576 flto_out
= (char *) xmalloc (strlen (linker_output
)
1577 + sizeof (".lto.o") + 1);
1578 strcpy (flto_out
, linker_output
);
1579 strcat (flto_out
, ".lto.o");
1582 flto_out
= make_temp_file (".lto.o");
1583 obstack_ptr_grow (&argv_obstack
, "-o");
1584 obstack_ptr_grow (&argv_obstack
, flto_out
);
1588 const char *list_option
= "-fltrans-output-list=";
1589 size_t list_option_len
= strlen (list_option
);
1594 char *dumpbase
= (char *) xmalloc (strlen (linker_output
)
1595 + sizeof (".wpa") + 1);
1596 strcpy (dumpbase
, linker_output
);
1597 strcat (dumpbase
, ".wpa");
1598 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1601 if (linker_output
&& save_temps
)
1603 ltrans_output_file
= (char *) xmalloc (strlen (linker_output
)
1604 + sizeof (".ltrans.out") + 1);
1605 strcpy (ltrans_output_file
, linker_output
);
1606 strcat (ltrans_output_file
, ".ltrans.out");
1610 char *prefix
= NULL
;
1613 prefix
= (char *) xmalloc (strlen (linker_output
) + 2);
1614 strcpy (prefix
, linker_output
);
1615 strcat (prefix
, ".");
1618 ltrans_output_file
= make_temp_file_with_prefix (prefix
,
1622 list_option_full
= (char *) xmalloc (sizeof (char) *
1623 (strlen (ltrans_output_file
) + list_option_len
+ 1));
1624 tmp
= list_option_full
;
1626 obstack_ptr_grow (&argv_obstack
, tmp
);
1627 strcpy (tmp
, list_option
);
1628 tmp
+= list_option_len
;
1629 strcpy (tmp
, ltrans_output_file
);
1634 fprintf (stderr
, "Using make jobserver\n");
1635 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1637 else if (auto_parallel
)
1640 init_num_threads ();
1642 fprintf (stderr
, "LTO parallelism level set to %ld\n",
1644 sprintf (buf
, "-fwpa=%ld", nthreads_var
);
1645 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1647 else if (parallel
> 1)
1650 sprintf (buf
, "-fwpa=%i", parallel
);
1651 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1654 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1657 /* Append input arguments. */
1658 for (i
= 0; i
< lto_argc
; ++i
)
1659 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1660 /* Append the input objects. */
1661 for (i
= 0; i
< ltoobj_argc
; ++i
)
1662 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1663 obstack_ptr_grow (&argv_obstack
, NULL
);
1665 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1666 argv_ptr
= &new_argv
[new_head_argc
];
1667 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true);
1669 /* Copy the early generated debug info from the objects to temporary
1670 files and append those to the partial link commandline. */
1672 early_debug_object_names
= NULL
;
1675 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1676 num_deb_objs
= ltoobj_argc
;
1677 for (i
= 0; i
< ltoobj_argc
; ++i
)
1680 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1682 early_debug_object_names
[i
] = tem
;
1688 if (lto_mode
== LTO_MODE_LTO
)
1690 printf ("%s\n", flto_out
);
1693 for (i
= 0; i
< ltoobj_argc
; ++i
)
1694 if (early_debug_object_names
[i
] != NULL
)
1695 printf ("%s\n", early_debug_object_names
[i
]);
1697 /* These now belong to collect2. */
1700 free (early_debug_object_names
);
1701 early_debug_object_names
= NULL
;
1705 FILE *stream
= fopen (ltrans_output_file
, "r");
1706 FILE *mstream
= NULL
;
1707 struct obstack env_obstack
;
1711 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1713 /* Parse the list of LTRANS inputs from the WPA stage. */
1714 obstack_init (&env_obstack
);
1718 const unsigned piece
= 32;
1719 char *output_name
= NULL
;
1720 char *buf
, *input_name
= (char *)xmalloc (piece
);
1724 if (fscanf (stream
, "%i\n", &priority
) != 1)
1727 fatal_error (input_location
,
1728 "corrupted ltrans output file %s",
1729 ltrans_output_file
);
1733 if (!fgets (buf
, piece
, stream
))
1735 len
= strlen (input_name
);
1736 if (input_name
[len
- 1] != '\n')
1738 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1739 buf
= input_name
+ len
;
1742 input_name
[len
- 1] = '\0';
1744 if (input_name
[0] == '*')
1745 output_name
= &input_name
[1];
1749 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1750 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1751 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1752 ltrans_priorities
[(nr
-1)*2] = priority
;
1753 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1754 input_names
[nr
-1] = input_name
;
1755 output_names
[nr
-1] = output_name
;
1758 maybe_unlink (ltrans_output_file
);
1759 ltrans_output_file
= NULL
;
1763 makefile
= make_temp_file (".mk");
1764 mstream
= fopen (makefile
, "w");
1765 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1768 /* Execute the LTRANS stage for each input file (or prepare a
1769 makefile to invoke this in parallel). */
1770 for (i
= 0; i
< nr
; ++i
)
1773 char *input_name
= input_names
[i
];
1774 /* If it's a pass-through file do nothing. */
1775 if (output_names
[i
])
1778 /* Replace the .o suffix with a .ltrans.o suffix and write
1779 the resulting name to the LTRANS output list. */
1780 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1781 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1782 output_name
= XOBFINISH (&env_obstack
, char *);
1784 /* Adjust the dumpbase if the linker output file was seen. */
1788 = (char *) xmalloc (strlen (linker_output
)
1789 + sizeof (DUMPBASE_SUFFIX
) + 1);
1791 strlen (linker_output
) + sizeof (DUMPBASE_SUFFIX
),
1792 "%s.ltrans%u", linker_output
, i
);
1793 argv_ptr
[0] = dumpbase
;
1796 argv_ptr
[1] = "-fltrans";
1798 argv_ptr
[3] = output_name
;
1799 argv_ptr
[4] = input_name
;
1803 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1804 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1805 fprintf (mstream
, " '%s'", new_argv
[j
]);
1806 fprintf (mstream
, "\n");
1807 /* If we are not preserving the ltrans input files then
1808 truncate them as soon as we have processed it. This
1809 reduces temporary disk-space usage. */
1811 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1812 "&& mv %s.tem %s\n",
1813 input_name
, input_name
, input_name
, input_name
);
1817 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1819 maybe_unlink (input_name
);
1822 output_names
[i
] = output_name
;
1826 struct pex_obj
*pex
;
1832 for (i
= 0; i
< nr
; ++i
)
1834 int j
= ltrans_priorities
[i
*2 + 1];
1835 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1837 fprintf (mstream
, "\n");
1841 /* Avoid passing --jobserver-fd= and similar flags
1842 unless jobserver mode is explicitly enabled. */
1843 putenv (xstrdup ("MAKEFLAGS="));
1844 putenv (xstrdup ("MFLAGS="));
1846 new_argv
[0] = getenv ("MAKE");
1848 new_argv
[0] = "make";
1850 new_argv
[2] = makefile
;
1854 snprintf (jobs
, 31, "-j%ld",
1855 auto_parallel
? nthreads_var
: parallel
);
1856 new_argv
[i
++] = jobs
;
1858 new_argv
[i
++] = "all";
1859 new_argv
[i
++] = NULL
;
1860 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1861 NULL
, NULL
, PEX_SEARCH
, false);
1862 do_wait (new_argv
[0], pex
);
1863 maybe_unlink (makefile
);
1865 for (i
= 0; i
< nr
; ++i
)
1866 maybe_unlink (input_names
[i
]);
1868 for (i
= 0; i
< nr
; ++i
)
1870 fputs (output_names
[i
], stdout
);
1871 putc ('\n', stdout
);
1872 free (input_names
[i
]);
1876 for (i
= 0; i
< ltoobj_argc
; ++i
)
1877 if (early_debug_object_names
[i
] != NULL
)
1878 printf ("%s\n", early_debug_object_names
[i
]);
1881 free (ltrans_priorities
);
1882 free (output_names
);
1883 output_names
= NULL
;
1884 free (early_debug_object_names
);
1885 early_debug_object_names
= NULL
;
1887 free (list_option_full
);
1888 obstack_free (&env_obstack
, NULL
);
1893 obstack_free (&argv_obstack
, NULL
);
1900 main (int argc
, char *argv
[])
1904 init_opts_obstack ();
1906 p
= argv
[0] + strlen (argv
[0]);
1907 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
1911 xmalloc_set_program_name (progname
);
1913 gcc_init_libintl ();
1915 diagnostic_initialize (global_dc
, 0);
1917 if (atexit (lto_wrapper_cleanup
) != 0)
1918 fatal_error (input_location
, "%<atexit%> failed");
1920 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1921 signal (SIGINT
, fatal_signal
);
1923 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1924 signal (SIGHUP
, fatal_signal
);
1926 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
1927 signal (SIGTERM
, fatal_signal
);
1929 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
1930 signal (SIGPIPE
, fatal_signal
);
1933 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1934 receive the signal. A different setting is inheritable */
1935 signal (SIGCHLD
, SIG_DFL
);
1938 /* We may be called with all the arguments stored in some file and
1939 passed with @file. Expand them into argv before processing. */
1940 expandargv (&argc
, &argv
);
1942 run_gcc (argc
, argv
);