1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2018 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 char *debug_obj
;
76 const char tool_name
[] = "lto-wrapper";
78 /* Delete tempfiles. Called from utils_cleanup. */
85 if (ltrans_output_file
)
86 maybe_unlink (ltrans_output_file
);
88 maybe_unlink (flto_out
);
89 if (offload_objects_file_name
)
90 maybe_unlink (offload_objects_file_name
);
92 maybe_unlink (makefile
);
94 maybe_unlink (debug_obj
);
95 for (i
= 0; i
< nr
; ++i
)
97 maybe_unlink (input_names
[i
]);
99 maybe_unlink (output_names
[i
]);
104 lto_wrapper_cleanup (void)
106 utils_cleanup (false);
109 /* Unlink a temporary LTRANS file unless requested otherwise. */
112 maybe_unlink (const char *file
)
116 if (unlink_if_ordinary (file
)
118 fatal_error (input_location
, "deleting LTRANS file %s: %m", file
);
121 fprintf (stderr
, "[Leaving LTRANS %s]\n", file
);
124 /* Template of LTRANS dumpbase suffix. */
125 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
127 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
128 environment according to LANG_MASK. */
131 get_options_from_collect_gcc_options (const char *collect_gcc
,
132 const char *collect_gcc_options
,
133 unsigned int lang_mask
,
134 struct cl_decoded_option
**decoded_options
,
135 unsigned int *decoded_options_count
)
137 struct obstack argv_obstack
;
142 argv_storage
= xstrdup (collect_gcc_options
);
143 obstack_init (&argv_obstack
);
144 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
146 for (j
= 0, k
= 0; argv_storage
[j
] != '\0'; ++j
)
148 if (argv_storage
[j
] == '\'')
150 obstack_ptr_grow (&argv_obstack
, &argv_storage
[k
]);
154 if (argv_storage
[j
] == '\0')
155 fatal_error (input_location
, "malformed COLLECT_GCC_OPTIONS");
156 else if (strncmp (&argv_storage
[j
], "'\\''", 4) == 0)
158 argv_storage
[k
++] = '\'';
161 else if (argv_storage
[j
] == '\'')
164 argv_storage
[k
++] = argv_storage
[j
++];
167 argv_storage
[k
++] = '\0';
171 obstack_ptr_grow (&argv_obstack
, NULL
);
172 argc
= obstack_object_size (&argv_obstack
) / sizeof (void *) - 1;
173 argv
= XOBFINISH (&argv_obstack
, const char **);
175 decode_cmdline_options_to_array (argc
, (const char **)argv
,
177 decoded_options
, decoded_options_count
);
178 obstack_free (&argv_obstack
, NULL
);
181 /* Append OPTION to the options array DECODED_OPTIONS with size
182 DECODED_OPTIONS_COUNT. */
185 append_option (struct cl_decoded_option
**decoded_options
,
186 unsigned int *decoded_options_count
,
187 struct cl_decoded_option
*option
)
189 ++*decoded_options_count
;
191 = (struct cl_decoded_option
*)
192 xrealloc (*decoded_options
,
193 (*decoded_options_count
194 * sizeof (struct cl_decoded_option
)));
195 memcpy (&(*decoded_options
)[*decoded_options_count
- 1], option
,
196 sizeof (struct cl_decoded_option
));
199 /* Remove option number INDEX from DECODED_OPTIONS, update
200 DECODED_OPTIONS_COUNT. */
203 remove_option (struct cl_decoded_option
**decoded_options
,
204 int index
, unsigned int *decoded_options_count
)
206 --*decoded_options_count
;
207 memmove (&(*decoded_options
)[index
+ 1],
208 &(*decoded_options
)[index
],
209 sizeof (struct cl_decoded_option
)
210 * (*decoded_options_count
- index
));
213 /* Try to merge and complain about options FDECODED_OPTIONS when applied
214 ontop of DECODED_OPTIONS. */
217 merge_and_complain (struct cl_decoded_option
**decoded_options
,
218 unsigned int *decoded_options_count
,
219 struct cl_decoded_option
*fdecoded_options
,
220 unsigned int fdecoded_options_count
)
223 struct cl_decoded_option
*pic_option
= NULL
;
224 struct cl_decoded_option
*pie_option
= NULL
;
226 /* ??? Merge options from files. Most cases can be
227 handled by either unioning or intersecting
228 (for example -fwrapv is a case for unioning,
229 -ffast-math is for intersection). Most complaints
230 about real conflicts between different options can
231 be deferred to the compiler proper. Options that
232 we can neither safely handle by intersection nor
233 unioning would need to be complained about here.
234 Ideally we'd have a flag in the opt files that
235 tells whether to union or intersect or reject.
236 In absence of that it's unclear what a good default is.
237 It's also difficult to get positional handling correct. */
239 /* The following does what the old LTO option code did,
240 union all target and a selected set of common options. */
241 for (i
= 0; i
< fdecoded_options_count
; ++i
)
243 struct cl_decoded_option
*foption
= &fdecoded_options
[i
];
244 switch (foption
->opt_index
)
246 case OPT_SPECIAL_unknown
:
247 case OPT_SPECIAL_ignore
:
248 case OPT_SPECIAL_program_name
:
249 case OPT_SPECIAL_input_file
:
253 if (!(cl_options
[foption
->opt_index
].flags
& CL_TARGET
))
257 case OPT_fdiagnostics_show_caret
:
258 case OPT_fdiagnostics_show_option
:
259 case OPT_fdiagnostics_show_location_
:
260 case OPT_fshow_column
:
263 /* Do what the old LTO code did - collect exactly one option
264 setting per OPT code, we pick the first we encounter.
265 ??? This doesn't make too much sense, but when it doesn't
266 then we should complain. */
267 for (j
= 0; j
< *decoded_options_count
; ++j
)
268 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
270 if (j
== *decoded_options_count
)
271 append_option (decoded_options
, decoded_options_count
, foption
);
274 /* Figure out what PIC/PIE level wins and merge the results. */
277 pic_option
= foption
;
281 pie_option
= foption
;
286 case OPT_fcheck_pointer_bounds
:
287 /* For selected options we can merge conservatively. */
288 for (j
= 0; j
< *decoded_options_count
; ++j
)
289 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
291 if (j
== *decoded_options_count
)
292 append_option (decoded_options
, decoded_options_count
, foption
);
293 /* -fopenmp > -fno-openmp,
294 -fopenacc > -fno-openacc,
295 -fcheck_pointer_bounds > -fcheck_pointer_bounds */
296 else if (foption
->value
> (*decoded_options
)[j
].value
)
297 (*decoded_options
)[j
] = *foption
;
300 case OPT_fopenacc_dim_
:
301 /* Append or check identical. */
302 for (j
= 0; j
< *decoded_options_count
; ++j
)
303 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
305 if (j
== *decoded_options_count
)
306 append_option (decoded_options
, decoded_options_count
, foption
);
307 else if (strcmp ((*decoded_options
)[j
].arg
, foption
->arg
))
308 fatal_error (input_location
,
309 "Option %s with different values",
310 foption
->orig_option_with_args_text
);
317 for (j
= 0; j
< *decoded_options_count
; ++j
)
318 if ((*decoded_options
)[j
].opt_index
== OPT_O
319 || (*decoded_options
)[j
].opt_index
== OPT_Ofast
320 || (*decoded_options
)[j
].opt_index
== OPT_Og
321 || (*decoded_options
)[j
].opt_index
== OPT_Os
)
323 if (j
== *decoded_options_count
)
324 append_option (decoded_options
, decoded_options_count
, foption
);
325 else if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
326 && foption
->opt_index
!= OPT_O
)
327 /* Exact same options get merged. */
331 /* For mismatched option kinds preserve the optimization
332 level only, thus merge it as -On. This also handles
333 merging of same optimization level -On. */
335 switch (foption
->opt_index
)
338 if (foption
->arg
[0] == '\0')
339 level
= MAX (level
, 1);
341 level
= MAX (level
, atoi (foption
->arg
));
344 level
= MAX (level
, 3);
347 level
= MAX (level
, 1);
350 level
= MAX (level
, 2);
355 switch ((*decoded_options
)[j
].opt_index
)
358 if ((*decoded_options
)[j
].arg
[0] == '\0')
359 level
= MAX (level
, 1);
361 level
= MAX (level
, atoi ((*decoded_options
)[j
].arg
));
364 level
= MAX (level
, 3);
367 level
= MAX (level
, 1);
370 level
= MAX (level
, 2);
375 (*decoded_options
)[j
].opt_index
= OPT_O
;
377 tem
= xasprintf ("-O%d", level
);
378 (*decoded_options
)[j
].arg
= &tem
[2];
379 (*decoded_options
)[j
].canonical_option
[0] = tem
;
380 (*decoded_options
)[j
].value
= 1;
385 case OPT_foffload_abi_
:
386 for (j
= 0; j
< *decoded_options_count
; ++j
)
387 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
389 if (j
== *decoded_options_count
)
390 append_option (decoded_options
, decoded_options_count
, foption
);
391 else if (foption
->value
!= (*decoded_options
)[j
].value
)
392 fatal_error (input_location
,
393 "Option %s not used consistently in all LTO input"
394 " files", foption
->orig_option_with_args_text
);
399 append_option (decoded_options
, decoded_options_count
, foption
);
404 /* Merge PIC options:
405 -fPIC + -fpic = -fpic
406 -fPIC + -fno-pic = -fno-pic
407 -fpic/-fPIC + nothin = nothing.
408 It is a common mistake to mix few -fPIC compiled objects into otherwise
409 non-PIC code. We do not want to build everything with PIC then.
411 It would be good to warn on mismatches, but it is bit hard to do as
412 we do not know what nothing translates to. */
414 for (unsigned int j
= 0; j
< *decoded_options_count
;)
415 if ((*decoded_options
)[j
].opt_index
== OPT_fPIC
416 || (*decoded_options
)[j
].opt_index
== OPT_fpic
)
419 || (pic_option
->value
> 0) != ((*decoded_options
)[j
].value
> 0))
420 remove_option (decoded_options
, j
, decoded_options_count
);
421 else if (pic_option
->opt_index
== OPT_fPIC
422 && (*decoded_options
)[j
].opt_index
== OPT_fpic
)
424 (*decoded_options
)[j
] = *pic_option
;
430 else if ((*decoded_options
)[j
].opt_index
== OPT_fPIE
431 || (*decoded_options
)[j
].opt_index
== OPT_fpie
)
434 || pie_option
->value
!= (*decoded_options
)[j
].value
)
435 remove_option (decoded_options
, j
, decoded_options_count
);
436 else if (pie_option
->opt_index
== OPT_fPIE
437 && (*decoded_options
)[j
].opt_index
== OPT_fpie
)
439 (*decoded_options
)[j
] = *pie_option
;
449 /* Auxiliary function that frees elements of PTR and PTR itself.
450 N is number of elements to be freed. If PTR is NULL, nothing is freed.
451 If an element is NULL, subsequent elements are not freed. */
454 free_array_of_ptrs (void **ptr
, unsigned n
)
458 for (unsigned i
= 0; i
< n
; i
++)
468 /* Parse STR, saving found tokens into PVALUES and return their number.
469 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
470 append it to every token we find. */
473 parse_env_var (const char *str
, char ***pvalues
, const char *append
)
475 const char *curval
, *nextval
;
479 curval
= strchr (str
, ':');
483 curval
= strchr (curval
+ 1, ':');
486 values
= (char**) xmalloc (num
* sizeof (char*));
488 nextval
= strchr (curval
, ':');
490 nextval
= strchr (curval
, '\0');
492 int append_len
= append
? strlen (append
) : 0;
493 for (i
= 0; i
< num
; i
++)
495 int l
= nextval
- curval
;
496 values
[i
] = (char*) xmalloc (l
+ 1 + append_len
);
497 memcpy (values
[i
], curval
, l
);
500 strcat (values
[i
], append
);
501 curval
= nextval
+ 1;
502 nextval
= strchr (curval
, ':');
504 nextval
= strchr (curval
, '\0');
510 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
513 append_compiler_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
516 /* Append compiler driver arguments as far as they were merged. */
517 for (unsigned int j
= 1; j
< count
; ++j
)
519 struct cl_decoded_option
*option
= &opts
[j
];
521 /* File options have been properly filtered by lto-opts.c. */
522 switch (option
->opt_index
)
524 /* Drop arguments that we want to take from the link line. */
527 case OPT_flto_partition_
:
534 /* For now do what the original LTO option code was doing - pass
535 on any CL_TARGET flag and a few selected others. */
536 switch (option
->opt_index
)
538 case OPT_fdiagnostics_show_caret
:
539 case OPT_fdiagnostics_show_option
:
540 case OPT_fdiagnostics_show_location_
:
541 case OPT_fshow_column
:
550 case OPT_fopenacc_dim_
:
551 case OPT_foffload_abi_
:
556 case OPT_fcheck_pointer_bounds
:
560 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
564 /* Pass the option on. */
565 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
566 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
570 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
573 append_diag_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
576 /* Append compiler driver arguments as far as they were merged. */
577 for (unsigned int j
= 1; j
< count
; ++j
)
579 struct cl_decoded_option
*option
= &opts
[j
];
581 switch (option
->opt_index
)
583 case OPT_fdiagnostics_color_
:
584 case OPT_fdiagnostics_show_caret
:
585 case OPT_fdiagnostics_show_option
:
586 case OPT_fdiagnostics_show_location_
:
587 case OPT_fshow_column
:
593 /* Pass the option on. */
594 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
595 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
600 /* Append linker options OPTS to ARGV_OBSTACK. */
603 append_linker_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
606 /* Append linker driver arguments. Compiler options from the linker
607 driver arguments will override / merge with those from the compiler. */
608 for (unsigned int j
= 1; j
< count
; ++j
)
610 struct cl_decoded_option
*option
= &opts
[j
];
612 /* Do not pass on frontend specific flags not suitable for lto. */
613 if (!(cl_options
[option
->opt_index
].flags
614 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
617 switch (option
->opt_index
)
622 /* We've handled these LTO options, do not pass them on. */
627 /* Ignore -fno-XXX form of these options, as otherwise
628 corresponding builtins will not be enabled. */
629 if (option
->value
== 0)
637 /* Pass the option on. */
638 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
639 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
643 /* Extract options for TARGET offload compiler from OPTIONS and append
644 them to ARGV_OBSTACK. */
647 append_offload_options (obstack
*argv_obstack
, const char *target
,
648 struct cl_decoded_option
*options
,
649 unsigned int options_count
)
651 for (unsigned i
= 0; i
< options_count
; i
++)
653 const char *cur
, *next
, *opts
;
656 struct cl_decoded_option
*option
= &options
[i
];
658 if (option
->opt_index
!= OPT_foffload_
)
661 /* If option argument starts with '-' then no target is specified. That
662 means offload options are specified for all targets, so we need to
664 if (option
->arg
[0] == '-')
668 opts
= strchr (option
->arg
, '=');
669 /* If there are offload targets specified, but no actual options,
670 there is nothing to do here. */
678 next
= strchr (cur
, ',');
681 next
= (next
> opts
) ? opts
: next
;
683 /* Are we looking for this offload target? */
684 if (strlen (target
) == (size_t) (next
- cur
)
685 && strncmp (target
, cur
, next
- cur
) == 0)
688 /* Skip the comma or equal sign. */
698 argv
= buildargv (opts
);
699 for (argc
= 0; argv
[argc
]; argc
++)
700 obstack_ptr_grow (argv_obstack
, argv
[argc
]);
704 /* Check whether NAME can be accessed in MODE. This is like access,
705 except that it never considers directories to be executable. */
708 access_check (const char *name
, int mode
)
714 if (stat (name
, &st
) < 0
715 || S_ISDIR (st
.st_mode
))
719 return access (name
, mode
);
722 /* Prepare a target image for offload TARGET, using mkoffload tool from
723 COMPILER_PATH. Return the name of the resultant object file. */
726 compile_offload_image (const char *target
, const char *compiler_path
,
727 unsigned in_argc
, char *in_argv
[],
728 struct cl_decoded_option
*compiler_opts
,
729 unsigned int compiler_opt_count
,
730 struct cl_decoded_option
*linker_opts
,
731 unsigned int linker_opt_count
)
733 char *filename
= NULL
;
736 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target
));
737 strcpy (suffix
, "/accel/");
738 strcat (suffix
, target
);
739 strcat (suffix
, "/mkoffload");
742 unsigned n_paths
= parse_env_var (compiler_path
, &paths
, suffix
);
744 const char *compiler
= NULL
;
745 for (unsigned i
= 0; i
< n_paths
; i
++)
746 if (access_check (paths
[i
], X_OK
) == 0)
753 fatal_error (input_location
,
754 "could not find %s in %s (consider using '-B')\n", suffix
+ 1,
757 /* Generate temporary output file name. */
758 filename
= make_temp_file (".target.o");
760 struct obstack argv_obstack
;
761 obstack_init (&argv_obstack
);
762 obstack_ptr_grow (&argv_obstack
, compiler
);
764 obstack_ptr_grow (&argv_obstack
, "-save-temps");
766 obstack_ptr_grow (&argv_obstack
, "-v");
767 obstack_ptr_grow (&argv_obstack
, "-o");
768 obstack_ptr_grow (&argv_obstack
, filename
);
770 /* Append names of input object files. */
771 for (unsigned i
= 0; i
< in_argc
; i
++)
772 obstack_ptr_grow (&argv_obstack
, in_argv
[i
]);
774 /* Append options from offload_lto sections. */
775 append_compiler_options (&argv_obstack
, compiler_opts
,
777 append_diag_options (&argv_obstack
, linker_opts
, linker_opt_count
);
779 /* Append options specified by -foffload last. In case of conflicting
780 options we expect offload compiler to choose the latest. */
781 append_offload_options (&argv_obstack
, target
, compiler_opts
,
783 append_offload_options (&argv_obstack
, target
, linker_opts
,
786 obstack_ptr_grow (&argv_obstack
, NULL
);
787 argv
= XOBFINISH (&argv_obstack
, char **);
788 fork_execute (argv
[0], argv
, true);
789 obstack_free (&argv_obstack
, NULL
);
791 free_array_of_ptrs ((void **) paths
, n_paths
);
796 /* The main routine dealing with offloading.
797 The routine builds a target image for each offload target. IN_ARGC and
798 IN_ARGV specify options and input object files. As all of them could contain
799 target sections, we pass them all to target compilers. */
802 compile_images_for_offload_targets (unsigned in_argc
, char *in_argv
[],
803 struct cl_decoded_option
*compiler_opts
,
804 unsigned int compiler_opt_count
,
805 struct cl_decoded_option
*linker_opts
,
806 unsigned int linker_opt_count
)
809 const char *target_names
= getenv (OFFLOAD_TARGET_NAMES_ENV
);
812 unsigned num_targets
= parse_env_var (target_names
, &names
, NULL
);
814 int next_name_entry
= 0;
815 const char *compiler_path
= getenv ("COMPILER_PATH");
819 /* Prepare an image for each target and save the name of the resultant object
820 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
821 offload_names
= XCNEWVEC (char *, num_targets
+ 1);
822 for (unsigned i
= 0; i
< num_targets
; i
++)
824 /* HSA does not use LTO-like streaming and a different compiler, skip
826 if (strcmp (names
[i
], "hsa") == 0)
829 offload_names
[next_name_entry
]
830 = compile_offload_image (names
[i
], compiler_path
, in_argc
, in_argv
,
831 compiler_opts
, compiler_opt_count
,
832 linker_opts
, linker_opt_count
);
833 if (!offload_names
[next_name_entry
])
834 fatal_error (input_location
,
835 "problem with building target image for %s\n", names
[i
]);
840 free_array_of_ptrs ((void **) names
, num_targets
);
843 /* Copy a file from SRC to DEST. */
846 copy_file (const char *dest
, const char *src
)
848 FILE *d
= fopen (dest
, "wb");
849 FILE *s
= fopen (src
, "rb");
853 size_t len
= fread (buffer
, 1, 512, s
);
855 fatal_error (input_location
, "reading input file");
858 fwrite (buffer
, 1, len
, d
);
860 fatal_error (input_location
, "writing output file");
867 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
868 the copy to the linker. */
871 find_crtoffloadtable (void)
874 const char *library_path
= getenv ("LIBRARY_PATH");
877 unsigned n_paths
= parse_env_var (library_path
, &paths
, "/crtoffloadtable.o");
880 for (i
= 0; i
< n_paths
; i
++)
881 if (access_check (paths
[i
], R_OK
) == 0)
883 /* The linker will delete the filename we give it, so make a copy. */
884 char *crtoffloadtable
= make_temp_file (".crtoffloadtable.o");
885 copy_file (crtoffloadtable
, paths
[i
]);
886 printf ("%s\n", crtoffloadtable
);
887 XDELETEVEC (crtoffloadtable
);
891 fatal_error (input_location
,
892 "installation error, can't find crtoffloadtable.o");
894 free_array_of_ptrs ((void **) paths
, n_paths
);
897 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
898 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
899 and OPT_COUNT. Return true if we found a matchingn section, false
900 otherwise. COLLECT_GCC holds the value of the environment variable with
904 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
905 struct cl_decoded_option
**opts
,
906 unsigned int *opt_count
, const char *collect_gcc
)
908 off_t offset
, length
;
913 struct cl_decoded_option
*fdecoded_options
= *opts
;
914 unsigned int fdecoded_options_count
= *opt_count
;
916 simple_object_read
*sobj
;
917 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
922 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
923 strcpy (secname
, prefix
);
924 strcat (secname
, ".opts");
925 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
928 simple_object_release_read (sobj
);
932 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
933 data
= (char *)xmalloc (length
);
934 read (fd
, data
, length
);
938 struct cl_decoded_option
*f2decoded_options
;
939 unsigned int f2decoded_options_count
;
940 get_options_from_collect_gcc_options (collect_gcc
,
943 &f2decoded_options_count
);
944 if (!fdecoded_options
)
946 fdecoded_options
= f2decoded_options
;
947 fdecoded_options_count
= f2decoded_options_count
;
950 merge_and_complain (&fdecoded_options
,
951 &fdecoded_options_count
,
952 f2decoded_options
, f2decoded_options_count
);
954 fopts
+= strlen (fopts
) + 1;
956 while (fopts
- data
< length
);
959 simple_object_release_read (sobj
);
960 *opts
= fdecoded_options
;
961 *opt_count
= fdecoded_options_count
;
965 /* Copy early debug info sections from INFILE to a new file whose name
966 is returned. Return NULL on error. */
969 debug_objcopy (const char *infile
)
979 if ((p
= strrchr (infile
, '@'))
981 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
982 && strlen (p
) == (unsigned int) consumed
)
984 char *fname
= xstrdup (infile
);
985 fname
[p
- infile
] = '\0';
987 inoff
= (off_t
) loffset
;
989 int infd
= open (infile
, O_RDONLY
| O_BINARY
);
992 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
999 if (simple_object_find_section (inobj
, ".gnu.debuglto_.debug_info",
1000 &off
, &len
, &errmsg
, &err
) != 1)
1003 fatal_error (0, "%s: %s\n", errmsg
, xstrerror (err
));
1005 simple_object_release_read (inobj
);
1010 outfile
= make_temp_file ("debugobjtem");
1011 errmsg
= simple_object_copy_lto_debug_sections (inobj
, outfile
, &err
);
1014 unlink_if_ordinary (outfile
);
1015 fatal_error (0, "%s: %s\n", errmsg
, xstrerror (err
));
1018 simple_object_release_read (inobj
);
1024 /* Helper for qsort: compare priorities for parallel compilation. */
1027 cmp_priority (const void *a
, const void *b
)
1029 return *((const int *)b
)-*((const int *)a
);
1033 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1036 run_gcc (unsigned argc
, char *argv
[])
1039 const char **new_argv
;
1040 const char **argv_ptr
;
1041 char *list_option_full
= NULL
;
1042 const char *linker_output
= NULL
;
1043 const char *collect_gcc
, *collect_gcc_options
;
1046 bool no_partition
= false;
1047 struct cl_decoded_option
*fdecoded_options
= NULL
;
1048 struct cl_decoded_option
*offload_fdecoded_options
= NULL
;
1049 unsigned int fdecoded_options_count
= 0;
1050 unsigned int offload_fdecoded_options_count
= 0;
1051 struct cl_decoded_option
*decoded_options
;
1052 unsigned int decoded_options_count
;
1053 struct obstack argv_obstack
;
1055 bool have_lto
= false;
1056 bool have_offload
= false;
1057 unsigned lto_argc
= 0, ltoobj_argc
= 0;
1058 char **lto_argv
, **ltoobj_argv
;
1059 bool skip_debug
= false;
1060 unsigned n_debugobj
;
1062 /* Get the driver and options. */
1063 collect_gcc
= getenv ("COLLECT_GCC");
1065 fatal_error (input_location
,
1066 "environment variable COLLECT_GCC must be set");
1067 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1068 if (!collect_gcc_options
)
1069 fatal_error (input_location
,
1070 "environment variable COLLECT_GCC_OPTIONS must be set");
1071 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
1074 &decoded_options_count
);
1076 /* Allocate array for input object files with LTO IL,
1077 and for possible preceding arguments. */
1078 lto_argv
= XNEWVEC (char *, argc
);
1079 ltoobj_argv
= XNEWVEC (char *, argc
);
1081 /* Look at saved options in the IL files. */
1082 for (i
= 1; i
< argc
; ++i
)
1086 off_t file_offset
= 0;
1089 char *filename
= argv
[i
];
1091 if (strncmp (argv
[i
], "-foffload-objects=",
1092 sizeof ("-foffload-objects=") - 1) == 0)
1094 have_offload
= true;
1095 offload_objects_file_name
1096 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1100 if ((p
= strrchr (argv
[i
], '@'))
1102 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1103 && strlen (p
) == (unsigned int) consumed
)
1105 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1106 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1107 filename
[p
- argv
[i
]] = '\0';
1108 file_offset
= (off_t
) loffset
;
1110 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1113 lto_argv
[lto_argc
++] = argv
[i
];
1117 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1118 &fdecoded_options
, &fdecoded_options_count
,
1122 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1127 /* Initalize the common arguments for the driver. */
1128 obstack_init (&argv_obstack
);
1129 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1130 obstack_ptr_grow (&argv_obstack
, "-xlto");
1131 obstack_ptr_grow (&argv_obstack
, "-c");
1133 append_compiler_options (&argv_obstack
, fdecoded_options
,
1134 fdecoded_options_count
);
1135 append_linker_options (&argv_obstack
, decoded_options
, decoded_options_count
);
1137 /* Scan linker driver arguments for things that are of relevance to us. */
1138 for (j
= 1; j
< decoded_options_count
; ++j
)
1140 struct cl_decoded_option
*option
= &decoded_options
[j
];
1141 switch (option
->opt_index
)
1144 linker_output
= option
->arg
;
1147 case OPT_save_temps
:
1155 case OPT_flto_partition_
:
1156 if (strcmp (option
->arg
, "none") == 0)
1157 no_partition
= true;
1161 if (strcmp (option
->arg
, "jobserver") == 0)
1168 parallel
= atoi (option
->arg
);
1175 lto_mode
= LTO_MODE_WHOPR
;
1183 /* Output lto-wrapper invocation command. */
1186 for (i
= 0; i
< argc
; ++i
)
1188 fputs (argv
[i
], stderr
);
1189 fputc (' ', stderr
);
1191 fputc ('\n', stderr
);
1196 lto_mode
= LTO_MODE_LTO
;
1203 char *output_dir
, *base
, *name
;
1204 bool bit_bucket
= strcmp (linker_output
, HOST_BIT_BUCKET
) == 0;
1206 output_dir
= xstrdup (linker_output
);
1208 for (name
= base
; *name
; name
++)
1209 if (IS_DIR_SEPARATOR (*name
))
1213 linker_output
= &linker_output
[base
- output_dir
];
1214 if (*output_dir
== '\0')
1216 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1217 output_dir
= current_dir
;
1221 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1222 obstack_ptr_grow (&argv_obstack
, output_dir
);
1225 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1228 /* Remember at which point we can scrub args to re-use the commons. */
1229 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1233 unsigned i
, num_offload_files
;
1234 char **offload_argv
;
1237 f
= fopen (offload_objects_file_name
, "r");
1239 fatal_error (input_location
, "cannot open %s: %m",
1240 offload_objects_file_name
);
1241 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1242 fatal_error (input_location
, "cannot read %s: %m",
1243 offload_objects_file_name
);
1244 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1246 /* Read names of object files with offload. */
1247 for (i
= 0; i
< num_offload_files
; i
++)
1249 const unsigned piece
= 32;
1250 char *buf
, *filename
= XNEWVEC (char, piece
);
1255 if (!fgets (buf
, piece
, f
))
1257 len
= strlen (filename
);
1258 if (filename
[len
- 1] != '\n')
1260 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1261 buf
= filename
+ len
;
1264 filename
[len
- 1] = '\0';
1265 offload_argv
[i
] = filename
;
1268 if (offload_argv
[num_offload_files
- 1] == NULL
)
1269 fatal_error (input_location
, "invalid format of %s",
1270 offload_objects_file_name
);
1271 maybe_unlink (offload_objects_file_name
);
1272 offload_objects_file_name
= NULL
;
1274 /* Look at saved offload options in files. */
1275 for (i
= 0; i
< num_offload_files
; i
++)
1280 off_t file_offset
= 0;
1281 char *filename
= offload_argv
[i
];
1283 if ((p
= strrchr (offload_argv
[i
], '@'))
1284 && p
!= offload_argv
[i
]
1285 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1286 && strlen (p
) == (unsigned int) consumed
)
1288 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1289 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1290 filename
[p
- offload_argv
[i
]] = '\0';
1291 file_offset
= (off_t
) loffset
;
1293 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1295 fatal_error (input_location
, "cannot open %s: %m", filename
);
1296 if (!find_and_merge_options (fd
, file_offset
,
1297 OFFLOAD_SECTION_NAME_PREFIX
,
1298 &offload_fdecoded_options
,
1299 &offload_fdecoded_options_count
,
1301 fatal_error (input_location
, "cannot read %s: %m", filename
);
1303 if (filename
!= offload_argv
[i
])
1304 XDELETEVEC (filename
);
1307 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1308 offload_fdecoded_options
,
1309 offload_fdecoded_options_count
,
1311 decoded_options_count
);
1313 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1317 find_crtoffloadtable ();
1318 for (i
= 0; offload_names
[i
]; i
++)
1319 printf ("%s\n", offload_names
[i
]);
1320 free_array_of_ptrs ((void **) offload_names
, i
);
1324 /* If object files contain offload sections, but do not contain LTO sections,
1325 then there is no need to perform a link-time recompilation, i.e.
1326 lto-wrapper is used only for a compilation of offload images. */
1327 if (have_offload
&& !have_lto
)
1330 if (lto_mode
== LTO_MODE_LTO
)
1332 flto_out
= make_temp_file (".lto.o");
1334 obstack_ptr_grow (&argv_obstack
, linker_output
);
1335 obstack_ptr_grow (&argv_obstack
, "-o");
1336 obstack_ptr_grow (&argv_obstack
, flto_out
);
1340 const char *list_option
= "-fltrans-output-list=";
1341 size_t list_option_len
= strlen (list_option
);
1346 char *dumpbase
= (char *) xmalloc (strlen (linker_output
)
1347 + sizeof (".wpa") + 1);
1348 strcpy (dumpbase
, linker_output
);
1349 strcat (dumpbase
, ".wpa");
1350 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1353 if (linker_output
&& save_temps
)
1355 ltrans_output_file
= (char *) xmalloc (strlen (linker_output
)
1356 + sizeof (".ltrans.out") + 1);
1357 strcpy (ltrans_output_file
, linker_output
);
1358 strcat (ltrans_output_file
, ".ltrans.out");
1361 ltrans_output_file
= make_temp_file (".ltrans.out");
1362 list_option_full
= (char *) xmalloc (sizeof (char) *
1363 (strlen (ltrans_output_file
) + list_option_len
+ 1));
1364 tmp
= list_option_full
;
1366 obstack_ptr_grow (&argv_obstack
, tmp
);
1367 strcpy (tmp
, list_option
);
1368 tmp
+= list_option_len
;
1369 strcpy (tmp
, ltrans_output_file
);
1372 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1373 else if (parallel
> 1)
1376 sprintf (buf
, "-fwpa=%i", parallel
);
1377 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1380 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1383 /* Append input arguments. */
1384 for (i
= 0; i
< lto_argc
; ++i
)
1385 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1386 /* Append the input objects. */
1387 for (i
= 0; i
< ltoobj_argc
; ++i
)
1388 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1389 obstack_ptr_grow (&argv_obstack
, NULL
);
1391 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1392 argv_ptr
= &new_argv
[new_head_argc
];
1393 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true);
1395 /* Handle early generated debug information. At compile-time
1396 we output early DWARF debug info into .gnu.debuglto_ prefixed
1397 sections. LTRANS object DWARF debug info refers to that.
1398 So we need to transfer the .gnu.debuglto_ sections to the final
1399 link. Ideally the linker plugin interface would allow us to
1400 not claim those sections and instruct the linker to keep
1401 them, renaming them in the process. For now we extract and
1402 rename those sections via a simple-object interface to produce
1403 regular objects containing only the early debug info. We
1404 then partially link those to a single early debug info object
1405 and pass that as additional output back to the linker plugin. */
1407 /* Prepare the partial link to gather the compile-time generated
1408 debug-info into a single input for the final link. */
1409 debug_obj
= make_temp_file ("debugobj");
1410 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1411 for (i
= 1; i
< decoded_options_count
; ++i
)
1413 /* Retain linker choice and -B. */
1414 if (decoded_options
[i
].opt_index
== OPT_B
1415 || decoded_options
[i
].opt_index
== OPT_fuse_ld_bfd
1416 || decoded_options
[i
].opt_index
== OPT_fuse_ld_gold
)
1417 append_linker_options (&argv_obstack
, &decoded_options
[i
-1], 2);
1418 /* Retain all target options, this preserves -m32 for example. */
1419 if (cl_options
[decoded_options
[i
].opt_index
].flags
& CL_TARGET
)
1420 append_linker_options (&argv_obstack
, &decoded_options
[i
-1], 2);
1421 /* Recognize -g0. */
1422 if (decoded_options
[i
].opt_index
== OPT_g
1423 && strcmp (decoded_options
[i
].arg
, "0") == 0)
1426 obstack_ptr_grow (&argv_obstack
, "-r");
1427 obstack_ptr_grow (&argv_obstack
, "-nostdlib");
1428 obstack_ptr_grow (&argv_obstack
, "-o");
1429 obstack_ptr_grow (&argv_obstack
, debug_obj
);
1431 /* Copy the early generated debug info from the objects to temporary
1432 files and append those to the partial link commandline. */
1435 for (i
= 0; i
< ltoobj_argc
; ++i
)
1438 if ((tem
= debug_objcopy (ltoobj_argv
[i
])))
1440 obstack_ptr_grow (&argv_obstack
, tem
);
1445 /* Link them all into a single object. Ideally this would reduce
1446 disk space usage mainly due to .debug_str merging but unfortunately
1447 GNU ld doesn't perform this with -r. */
1450 obstack_ptr_grow (&argv_obstack
, NULL
);
1451 const char **debug_link_argv
= XOBFINISH (&argv_obstack
, const char **);
1452 fork_execute (debug_link_argv
[0],
1453 CONST_CAST (char **, debug_link_argv
), false);
1455 /* And dispose the temporaries. */
1456 for (i
= 0; debug_link_argv
[i
]; ++i
)
1458 for (--i
; i
> 0; --i
)
1460 if (strcmp (debug_link_argv
[i
], debug_obj
) == 0)
1462 maybe_unlink (debug_link_argv
[i
]);
1467 unlink_if_ordinary (debug_obj
);
1473 if (lto_mode
== LTO_MODE_LTO
)
1475 printf ("%s\n", flto_out
);
1478 printf ("%s\n", debug_obj
);
1487 FILE *stream
= fopen (ltrans_output_file
, "r");
1488 FILE *mstream
= NULL
;
1489 struct obstack env_obstack
;
1493 fatal_error (input_location
, "fopen: %s: %m", ltrans_output_file
);
1495 /* Parse the list of LTRANS inputs from the WPA stage. */
1496 obstack_init (&env_obstack
);
1500 const unsigned piece
= 32;
1501 char *output_name
= NULL
;
1502 char *buf
, *input_name
= (char *)xmalloc (piece
);
1506 if (fscanf (stream
, "%i\n", &priority
) != 1)
1509 fatal_error (input_location
,
1510 "Corrupted ltrans output file %s",
1511 ltrans_output_file
);
1515 if (!fgets (buf
, piece
, stream
))
1517 len
= strlen (input_name
);
1518 if (input_name
[len
- 1] != '\n')
1520 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1521 buf
= input_name
+ len
;
1524 input_name
[len
- 1] = '\0';
1526 if (input_name
[0] == '*')
1527 output_name
= &input_name
[1];
1531 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1532 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1533 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1534 ltrans_priorities
[(nr
-1)*2] = priority
;
1535 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1536 input_names
[nr
-1] = input_name
;
1537 output_names
[nr
-1] = output_name
;
1540 maybe_unlink (ltrans_output_file
);
1541 ltrans_output_file
= NULL
;
1545 makefile
= make_temp_file (".mk");
1546 mstream
= fopen (makefile
, "w");
1547 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1550 /* Execute the LTRANS stage for each input file (or prepare a
1551 makefile to invoke this in parallel). */
1552 for (i
= 0; i
< nr
; ++i
)
1555 char *input_name
= input_names
[i
];
1556 /* If it's a pass-through file do nothing. */
1557 if (output_names
[i
])
1560 /* Replace the .o suffix with a .ltrans.o suffix and write
1561 the resulting name to the LTRANS output list. */
1562 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1563 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1564 output_name
= XOBFINISH (&env_obstack
, char *);
1566 /* Adjust the dumpbase if the linker output file was seen. */
1570 = (char *) xmalloc (strlen (linker_output
)
1571 + sizeof (DUMPBASE_SUFFIX
) + 1);
1573 strlen (linker_output
) + sizeof (DUMPBASE_SUFFIX
),
1574 "%s.ltrans%u", linker_output
, i
);
1575 argv_ptr
[0] = dumpbase
;
1578 argv_ptr
[1] = "-fltrans";
1580 argv_ptr
[3] = output_name
;
1581 argv_ptr
[4] = input_name
;
1585 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1586 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1587 fprintf (mstream
, " '%s'", new_argv
[j
]);
1588 fprintf (mstream
, "\n");
1589 /* If we are not preserving the ltrans input files then
1590 truncate them as soon as we have processed it. This
1591 reduces temporary disk-space usage. */
1593 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1594 "&& mv %s.tem %s\n",
1595 input_name
, input_name
, input_name
, input_name
);
1599 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1601 maybe_unlink (input_name
);
1604 output_names
[i
] = output_name
;
1608 struct pex_obj
*pex
;
1611 fprintf (mstream
, "all:");
1612 for (i
= 0; i
< nr
; ++i
)
1614 int j
= ltrans_priorities
[i
*2 + 1];
1615 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1617 fprintf (mstream
, "\n");
1621 /* Avoid passing --jobserver-fd= and similar flags
1622 unless jobserver mode is explicitly enabled. */
1623 putenv (xstrdup ("MAKEFLAGS="));
1624 putenv (xstrdup ("MFLAGS="));
1626 new_argv
[0] = getenv ("MAKE");
1628 new_argv
[0] = "make";
1630 new_argv
[2] = makefile
;
1634 snprintf (jobs
, 31, "-j%d", parallel
);
1635 new_argv
[i
++] = jobs
;
1637 new_argv
[i
++] = "all";
1638 new_argv
[i
++] = NULL
;
1639 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1640 NULL
, NULL
, PEX_SEARCH
, false);
1641 do_wait (new_argv
[0], pex
);
1642 maybe_unlink (makefile
);
1644 for (i
= 0; i
< nr
; ++i
)
1645 maybe_unlink (input_names
[i
]);
1649 printf ("%s\n", debug_obj
);
1653 for (i
= 0; i
< nr
; ++i
)
1655 fputs (output_names
[i
], stdout
);
1656 putc ('\n', stdout
);
1657 free (input_names
[i
]);
1660 free (ltrans_priorities
);
1661 free (output_names
);
1663 free (list_option_full
);
1664 obstack_free (&env_obstack
, NULL
);
1669 obstack_free (&argv_obstack
, NULL
);
1676 main (int argc
, char *argv
[])
1680 init_opts_obstack ();
1682 p
= argv
[0] + strlen (argv
[0]);
1683 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
1687 xmalloc_set_program_name (progname
);
1689 gcc_init_libintl ();
1691 diagnostic_initialize (global_dc
, 0);
1693 if (atexit (lto_wrapper_cleanup
) != 0)
1694 fatal_error (input_location
, "atexit failed");
1696 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1697 signal (SIGINT
, fatal_signal
);
1699 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1700 signal (SIGHUP
, fatal_signal
);
1702 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
1703 signal (SIGTERM
, fatal_signal
);
1705 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
1706 signal (SIGPIPE
, fatal_signal
);
1709 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1710 receive the signal. A different setting is inheritable */
1711 signal (SIGCHLD
, SIG_DFL
);
1714 /* We may be called with all the arguments stored in some file and
1715 passed with @file. Expand them into argv before processing. */
1716 expandargv (&argc
, &argv
);
1718 run_gcc (argc
, argv
);