1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009, 2010 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"
50 /* From lto-streamer.h which we cannot include with -fkeep-inline-functions.
51 ??? Split out a lto-streamer-core.h. */
53 #define LTO_SECTION_NAME_PREFIX ".gnu.lto_"
55 /* End of lto-streamer.h copy. */
57 int debug
; /* true if -save-temps. */
58 int verbose
; /* true if -v. */
61 LTO_MODE_NONE
, /* Not doing LTO. */
62 LTO_MODE_LTO
, /* Normal LTO. */
63 LTO_MODE_WHOPR
/* WHOPR. */
66 /* Current LTO mode. */
67 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
69 static char *ltrans_output_file
;
70 static char *flto_out
;
71 static char *args_name
;
72 static unsigned int nr
;
73 static char **input_names
;
74 static char **output_names
;
75 static char *makefile
;
77 static void maybe_unlink_file (const char *);
79 /* Delete tempfiles. */
82 lto_wrapper_cleanup (void)
84 static bool cleanup_done
= false;
90 /* Setting cleanup_done prevents an infinite loop if one of the
91 calls to maybe_unlink_file fails. */
94 if (ltrans_output_file
)
95 maybe_unlink_file (ltrans_output_file
);
97 maybe_unlink_file (flto_out
);
99 maybe_unlink_file (args_name
);
101 maybe_unlink_file (makefile
);
102 for (i
= 0; i
< nr
; ++i
)
104 maybe_unlink_file (input_names
[i
]);
106 maybe_unlink_file (output_names
[i
]);
111 fatal_signal (int signum
)
113 signal (signum
, SIG_DFL
);
114 lto_wrapper_cleanup ();
115 /* Get the same signal again, this time not handled,
116 so its normal effect occurs. */
117 kill (getpid (), signum
);
120 /* Just die. CMSGID is the error message. */
122 static void __attribute__ ((format (printf
, 1, 2)))
123 fatal (const char * cmsgid
, ...)
127 va_start (ap
, cmsgid
);
128 fprintf (stderr
, "lto-wrapper: ");
129 vfprintf (stderr
, _(cmsgid
), ap
);
130 fprintf (stderr
, "\n");
133 lto_wrapper_cleanup ();
134 exit (FATAL_EXIT_CODE
);
138 /* Die when sys call fails. CMSGID is the error message. */
140 static void __attribute__ ((format (printf
, 1, 2)))
141 fatal_perror (const char *cmsgid
, ...)
146 va_start (ap
, cmsgid
);
147 fprintf (stderr
, "lto-wrapper: ");
148 vfprintf (stderr
, _(cmsgid
), ap
);
149 fprintf (stderr
, ": %s\n", xstrerror (e
));
152 lto_wrapper_cleanup ();
153 exit (FATAL_EXIT_CODE
);
157 /* Execute a program, and wait for the reply. ARGV are the arguments. The
158 last one must be NULL. */
160 static struct pex_obj
*
161 collect_execute (char **argv
)
172 for (p_argv
= argv
; (str
= *p_argv
) != (char *) 0; p_argv
++)
173 fprintf (stderr
, " %s", str
);
175 fprintf (stderr
, "\n");
181 pex
= pex_init (0, "lto-wrapper", NULL
);
183 fatal_perror ("pex_init failed");
185 /* Do not use PEX_LAST here, we use our stdout for communicating with
186 collect2 or the linker-plugin. Any output from the sub-process
187 will confuse that. */
188 errmsg
= pex_run (pex
, PEX_SEARCH
, argv
[0], argv
, NULL
,
195 fatal_perror (errmsg
);
205 /* Wait for a process to finish, and exit if a nonzero status is found.
206 PROG is the program name. PEX is the process we should wait for. */
209 collect_wait (const char *prog
, struct pex_obj
*pex
)
213 if (!pex_get_status (pex
, 1, &status
))
214 fatal_perror ("can't get program status");
219 if (WIFSIGNALED (status
))
221 int sig
= WTERMSIG (status
);
222 if (WCOREDUMP (status
))
223 fatal ("%s terminated with signal %d [%s], core dumped",
224 prog
, sig
, strsignal (sig
));
226 fatal ("%s terminated with signal %d [%s]",
227 prog
, sig
, strsignal (sig
));
230 if (WIFEXITED (status
))
231 fatal ("%s returned %d exit status", prog
, WEXITSTATUS (status
));
238 /* Unlink a temporary LTRANS file unless requested otherwise. */
241 maybe_unlink_file (const char *file
)
245 if (unlink_if_ordinary (file
)
247 fatal_perror ("deleting LTRANS file %s", file
);
250 fprintf (stderr
, "[Leaving LTRANS %s]\n", file
);
254 /* Execute program ARGV[0] with arguments ARGV. Wait for it to finish. */
257 fork_execute (char **argv
)
265 args_name
= make_temp_file (".args");
266 at_args
= concat ("@", args_name
, NULL
);
267 args
= fopen (args_name
, "w");
269 fatal ("failed to open %s", args_name
);
271 status
= writeargv (&argv
[1], args
);
274 fatal ("could not write to temporary file %s", args_name
);
278 new_argv
[0] = argv
[0];
279 new_argv
[1] = at_args
;
282 pex
= collect_execute (new_argv
);
283 collect_wait (new_argv
[0], pex
);
285 maybe_unlink_file (args_name
);
290 /* Template of LTRANS dumpbase suffix. */
291 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
293 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
294 environment according to LANG_MASK. */
297 get_options_from_collect_gcc_options (const char *collect_gcc
,
298 const char *collect_gcc_options
,
299 unsigned int lang_mask
,
300 struct cl_decoded_option
**decoded_options
,
301 unsigned int *decoded_options_count
)
303 struct obstack argv_obstack
;
308 argv_storage
= xstrdup (collect_gcc_options
);
309 obstack_init (&argv_obstack
);
310 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
312 for (j
= 0, k
= 0; argv_storage
[j
] != '\0'; ++j
)
314 if (argv_storage
[j
] == '\'')
316 obstack_ptr_grow (&argv_obstack
, &argv_storage
[k
]);
320 if (argv_storage
[j
] == '\0')
321 fatal ("malformed COLLECT_GCC_OPTIONS");
322 else if (strncmp (&argv_storage
[j
], "'\\''", 4) == 0)
324 argv_storage
[k
++] = '\'';
327 else if (argv_storage
[j
] == '\'')
330 argv_storage
[k
++] = argv_storage
[j
++];
333 argv_storage
[k
++] = '\0';
337 obstack_ptr_grow (&argv_obstack
, NULL
);
338 argc
= obstack_object_size (&argv_obstack
) / sizeof (void *) - 1;
339 argv
= XOBFINISH (&argv_obstack
, const char **);
341 decode_cmdline_options_to_array (argc
, (const char **)argv
,
343 decoded_options
, decoded_options_count
);
344 obstack_free (&argv_obstack
, NULL
);
347 /* Append OPTION to the options array DECODED_OPTIONS with size
348 DECODED_OPTIONS_COUNT. */
351 append_option (struct cl_decoded_option
**decoded_options
,
352 unsigned int *decoded_options_count
,
353 struct cl_decoded_option
*option
)
355 ++*decoded_options_count
;
357 = (struct cl_decoded_option
*)
358 xrealloc (*decoded_options
,
359 (*decoded_options_count
360 * sizeof (struct cl_decoded_option
)));
361 memcpy (&(*decoded_options
)[*decoded_options_count
- 1], option
,
362 sizeof (struct cl_decoded_option
));
365 /* Try to merge and complain about options FDECODED_OPTIONS when applied
366 ontop of DECODED_OPTIONS. */
369 merge_and_complain (struct cl_decoded_option
**decoded_options
,
370 unsigned int *decoded_options_count
,
371 struct cl_decoded_option
*fdecoded_options
,
372 unsigned int fdecoded_options_count
)
376 /* ??? Merge options from files. Most cases can be
377 handled by either unioning or intersecting
378 (for example -fwrapv is a case for unioning,
379 -ffast-math is for intersection). Most complaints
380 about real conflicts between different options can
381 be deferred to the compiler proper. Options that
382 we can neither safely handle by intersection nor
383 unioning would need to be complained about here.
384 Ideally we'd have a flag in the opt files that
385 tells whether to union or intersect or reject.
386 In absence of that it's unclear what a good default is.
387 It's also difficult to get positional handling correct. */
389 /* The following does what the old LTO option code did,
390 union all target and a selected set of common options. */
391 for (i
= 0; i
< fdecoded_options_count
; ++i
)
393 struct cl_decoded_option
*foption
= &fdecoded_options
[i
];
394 switch (foption
->opt_index
)
397 if (!(cl_options
[foption
->opt_index
].flags
& CL_TARGET
))
405 case OPT_fexceptions
:
407 /* Do what the old LTO code did - collect exactly one option
408 setting per OPT code, we pick the first we encounter.
409 ??? This doesn't make too much sense, but when it doesn't
410 then we should complain. */
411 for (j
= 0; j
< *decoded_options_count
; ++j
)
412 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
414 if (j
== *decoded_options_count
)
415 append_option (decoded_options
, decoded_options_count
, foption
);
418 case OPT_freg_struct_return
:
419 case OPT_fpcc_struct_return
:
420 for (j
= 0; j
< *decoded_options_count
; ++j
)
421 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
423 if (j
== *decoded_options_count
)
424 fatal ("Option %s not used consistently in all LTO input files",
425 foption
->orig_option_with_args_text
);
431 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
434 run_gcc (unsigned argc
, char *argv
[])
437 const char **new_argv
;
438 const char **argv_ptr
;
439 char *list_option_full
= NULL
;
440 const char *linker_output
= NULL
;
441 const char *collect_gcc
, *collect_gcc_options
;
444 bool no_partition
= false;
445 struct cl_decoded_option
*fdecoded_options
= NULL
;
446 unsigned int fdecoded_options_count
= 0;
447 struct cl_decoded_option
*decoded_options
;
448 unsigned int decoded_options_count
;
449 struct obstack argv_obstack
;
452 /* Get the driver and options. */
453 collect_gcc
= getenv ("COLLECT_GCC");
455 fatal ("environment variable COLLECT_GCC must be set");
456 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
457 if (!collect_gcc_options
)
458 fatal ("environment variable COLLECT_GCC_OPTIONS must be set");
459 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
462 &decoded_options_count
);
464 /* Look at saved options in the IL files. */
465 for (i
= 1; i
< argc
; ++i
)
472 off_t file_offset
= 0, offset
, length
;
474 simple_object_read
*sobj
;
476 struct cl_decoded_option
*f2decoded_options
;
477 unsigned int f2decoded_options_count
;
478 char *filename
= argv
[i
];
479 if ((p
= strrchr (argv
[i
], '@'))
481 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
482 && strlen (p
) == (unsigned int) consumed
)
484 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
485 memcpy (filename
, argv
[i
], p
- argv
[i
]);
486 filename
[p
- argv
[i
]] = '\0';
487 file_offset
= (off_t
) loffset
;
489 fd
= open (argv
[i
], O_RDONLY
);
492 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
499 if (!simple_object_find_section (sobj
, LTO_SECTION_NAME_PREFIX
"." "opts",
500 &offset
, &length
, &errmsg
, &err
))
502 simple_object_release_read (sobj
);
506 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
507 data
= (char *)xmalloc (length
);
508 read (fd
, data
, length
);
512 get_options_from_collect_gcc_options (collect_gcc
,
515 &f2decoded_options_count
);
516 if (!fdecoded_options
)
518 fdecoded_options
= f2decoded_options
;
519 fdecoded_options_count
= f2decoded_options_count
;
522 merge_and_complain (&fdecoded_options
,
523 &fdecoded_options_count
,
524 f2decoded_options
, f2decoded_options_count
);
526 fopts
+= strlen (fopts
) + 1;
528 while (fopts
- data
< length
);
531 simple_object_release_read (sobj
);
535 /* Initalize the common arguments for the driver. */
536 obstack_init (&argv_obstack
);
537 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
538 obstack_ptr_grow (&argv_obstack
, "-xlto");
539 obstack_ptr_grow (&argv_obstack
, "-c");
541 /* Append compiler driver arguments as far as they were merged. */
542 for (j
= 1; j
< fdecoded_options_count
; ++j
)
544 struct cl_decoded_option
*option
= &fdecoded_options
[j
];
546 /* File options have been properly filtered by lto-opts.c. */
547 switch (option
->opt_index
)
549 /* Drop arguments that we want to take from the link line. */
552 case OPT_flto_partition_none
:
553 case OPT_flto_partition_1to1
:
554 case OPT_flto_partition_balanced
:
561 /* For now do what the original LTO option code was doing - pass
562 on any CL_TARGET flag and a few selected others. */
563 switch (option
->opt_index
)
569 case OPT_fexceptions
:
571 case OPT_freg_struct_return
:
572 case OPT_fpcc_struct_return
:
576 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
580 /* Pass the option on. */
581 for (i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
582 obstack_ptr_grow (&argv_obstack
, option
->canonical_option
[i
]);
585 /* Append linker driver arguments. Compiler options from the linker
586 driver arguments will override / merge with those from the compiler. */
587 for (j
= 1; j
< decoded_options_count
; ++j
)
589 struct cl_decoded_option
*option
= &decoded_options
[j
];
591 /* Do not pass on frontend specific flags not suitable for lto. */
592 if (!(cl_options
[option
->opt_index
].flags
593 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
596 switch (option
->opt_index
)
599 linker_output
= option
->arg
;
600 /* We generate new intermediate output, drop this arg. */
611 case OPT_flto_partition_none
:
616 if (strcmp (option
->arg
, "jobserver") == 0)
623 parallel
= atoi (option
->arg
);
630 lto_mode
= LTO_MODE_WHOPR
;
631 /* We've handled these LTO options, do not pass them on. */
634 case OPT_freg_struct_return
:
635 case OPT_fpcc_struct_return
:
636 /* Ignore these, they are determined by the input files.
637 ??? We fail to diagnose a possible mismatch here. */
644 /* Pass the option on. */
645 for (i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
646 obstack_ptr_grow (&argv_obstack
, option
->canonical_option
[i
]);
651 lto_mode
= LTO_MODE_LTO
;
658 char *output_dir
, *base
, *name
;
659 bool bit_bucket
= strcmp (linker_output
, HOST_BIT_BUCKET
) == 0;
661 output_dir
= xstrdup (linker_output
);
663 for (name
= base
; *name
; name
++)
664 if (IS_DIR_SEPARATOR (*name
))
668 linker_output
= &linker_output
[base
- output_dir
];
669 if (*output_dir
== '\0')
671 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
672 output_dir
= current_dir
;
676 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
677 obstack_ptr_grow (&argv_obstack
, output_dir
);
680 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
683 /* Remember at which point we can scrub args to re-use the commons. */
684 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
686 if (lto_mode
== LTO_MODE_LTO
)
688 flto_out
= make_temp_file (".lto.o");
690 obstack_ptr_grow (&argv_obstack
, linker_output
);
691 obstack_ptr_grow (&argv_obstack
, "-o");
692 obstack_ptr_grow (&argv_obstack
, flto_out
);
696 const char *list_option
= "-fltrans-output-list=";
697 size_t list_option_len
= strlen (list_option
);
702 char *dumpbase
= (char *) xmalloc (strlen (linker_output
)
703 + sizeof (".wpa") + 1);
704 strcpy (dumpbase
, linker_output
);
705 strcat (dumpbase
, ".wpa");
706 obstack_ptr_grow (&argv_obstack
, dumpbase
);
709 if (linker_output
&& debug
)
711 ltrans_output_file
= (char *) xmalloc (strlen (linker_output
)
712 + sizeof (".ltrans.out") + 1);
713 strcpy (ltrans_output_file
, linker_output
);
714 strcat (ltrans_output_file
, ".ltrans.out");
717 ltrans_output_file
= make_temp_file (".ltrans.out");
718 list_option_full
= (char *) xmalloc (sizeof (char) *
719 (strlen (ltrans_output_file
) + list_option_len
+ 1));
720 tmp
= list_option_full
;
722 obstack_ptr_grow (&argv_obstack
, tmp
);
723 strcpy (tmp
, list_option
);
724 tmp
+= list_option_len
;
725 strcpy (tmp
, ltrans_output_file
);
727 obstack_ptr_grow (&argv_obstack
, "-fwpa");
730 /* Append the input objects and possible preceeding arguments. */
731 for (i
= 1; i
< argc
; ++i
)
732 obstack_ptr_grow (&argv_obstack
, argv
[i
]);
733 obstack_ptr_grow (&argv_obstack
, NULL
);
735 new_argv
= XOBFINISH (&argv_obstack
, const char **);
736 argv_ptr
= &new_argv
[new_head_argc
];
737 fork_execute (CONST_CAST (char **, new_argv
));
739 if (lto_mode
== LTO_MODE_LTO
)
741 printf("%s\n", flto_out
);
747 FILE *stream
= fopen (ltrans_output_file
, "r");
748 FILE *mstream
= NULL
;
749 struct obstack env_obstack
;
752 fatal_perror ("fopen: %s", ltrans_output_file
);
754 /* Parse the list of LTRANS inputs from the WPA stage. */
755 obstack_init (&env_obstack
);
759 const unsigned piece
= 32;
760 char *output_name
= NULL
;
761 char *buf
, *input_name
= (char *)xmalloc (piece
);
766 if (!fgets (buf
, piece
, stream
))
768 len
= strlen (input_name
);
769 if (input_name
[len
- 1] != '\n')
771 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
772 buf
= input_name
+ len
;
775 input_name
[len
- 1] = '\0';
777 if (input_name
[0] == '*')
778 output_name
= &input_name
[1];
781 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
782 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
783 input_names
[nr
-1] = input_name
;
784 output_names
[nr
-1] = output_name
;
787 maybe_unlink_file (ltrans_output_file
);
788 ltrans_output_file
= NULL
;
792 makefile
= make_temp_file (".mk");
793 mstream
= fopen (makefile
, "w");
796 /* Execute the LTRANS stage for each input file (or prepare a
797 makefile to invoke this in parallel). */
798 for (i
= 0; i
< nr
; ++i
)
801 char *input_name
= input_names
[i
];
802 /* If it's a pass-through file do nothing. */
806 /* Replace the .o suffix with a .ltrans.o suffix and write
807 the resulting name to the LTRANS output list. */
808 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
809 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
810 output_name
= XOBFINISH (&env_obstack
, char *);
812 /* Adjust the dumpbase if the linker output file was seen. */
816 = (char *) xmalloc (strlen (linker_output
)
817 + sizeof(DUMPBASE_SUFFIX
) + 1);
819 strlen (linker_output
) + sizeof(DUMPBASE_SUFFIX
),
820 "%s.ltrans%u", linker_output
, i
);
821 argv_ptr
[0] = dumpbase
;
824 argv_ptr
[1] = "-fltrans";
826 argv_ptr
[3] = output_name
;
827 argv_ptr
[4] = input_name
;
831 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
832 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
833 fprintf (mstream
, " '%s'", new_argv
[j
]);
834 fprintf (mstream
, "\n");
835 /* If we are not preserving the ltrans input files then
836 truncate them as soon as we have processed it. This
837 reduces temporary disk-space usage. */
839 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
841 input_name
, input_name
, input_name
, input_name
);
845 fork_execute (CONST_CAST (char **, new_argv
));
846 maybe_unlink_file (input_name
);
849 output_names
[i
] = output_name
;
856 fprintf (mstream
, "all:");
857 for (i
= 0; i
< nr
; ++i
)
858 fprintf (mstream
, " \\\n\t%s", output_names
[i
]);
859 fprintf (mstream
, "\n");
863 /* Avoid passing --jobserver-fd= and similar flags
864 unless jobserver mode is explicitly enabled. */
865 putenv (xstrdup ("MAKEFLAGS="));
866 putenv (xstrdup ("MFLAGS="));
868 new_argv
[0] = getenv ("MAKE");
870 new_argv
[0] = "make";
872 new_argv
[2] = makefile
;
876 snprintf (jobs
, 31, "-j%d", parallel
);
877 new_argv
[i
++] = jobs
;
879 new_argv
[i
++] = "all";
880 new_argv
[i
++] = NULL
;
881 pex
= collect_execute (CONST_CAST (char **, new_argv
));
882 collect_wait (new_argv
[0], pex
);
883 maybe_unlink_file (makefile
);
885 for (i
= 0; i
< nr
; ++i
)
886 maybe_unlink_file (input_names
[i
]);
888 for (i
= 0; i
< nr
; ++i
)
890 fputs (output_names
[i
], stdout
);
892 free (input_names
[i
]);
897 free (list_option_full
);
898 obstack_free (&env_obstack
, NULL
);
901 obstack_free (&argv_obstack
, NULL
);
908 main (int argc
, char *argv
[])
912 p
= argv
[0] + strlen (argv
[0]);
913 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
917 xmalloc_set_program_name (progname
);
921 diagnostic_initialize (global_dc
, 0);
923 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
924 signal (SIGINT
, fatal_signal
);
926 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
927 signal (SIGHUP
, fatal_signal
);
929 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
930 signal (SIGTERM
, fatal_signal
);
932 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
933 signal (SIGPIPE
, fatal_signal
);
936 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
937 receive the signal. A different setting is inheritable */
938 signal (SIGCHLD
, SIG_DFL
);
941 /* We may be called with all the arguments stored in some file and
942 passed with @file. Expand them into argv before processing. */
943 expandargv (&argc
, &argv
);
945 run_gcc (argc
, argv
);