OSDN Git Service

PR lto/51916
[pf3gnuchains/gcc-fork.git] / gcc / lto-wrapper.c
1 /* Wrapper to call lto.  Used by collect2 and the linker plugin.
2    Copyright (C) 2009, 2010 Free Software Foundation, Inc.
3
4    Factored out of collect2 by Rafael Espindola <espindola@google.com>
5
6 This file is part of GCC.
7
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
11 version.
12
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
16 for more details.
17
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/>.  */
21
22
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.
27
28    Example:
29
30    $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto
31
32    The above will print something like
33    /tmp/ccwbQ8B2.lto.o
34
35    If WHOPR is used instead, more than one file might be produced
36    ./ccXj2DTk.lto.ltrans.o
37    ./ccCJuXGv.lto.ltrans.o
38 */
39
40 #include "config.h"
41 #include "system.h"
42 #include "coretypes.h"
43 #include "intl.h"
44 #include "diagnostic.h"
45 #include "obstack.h"
46 #include "opts.h"
47 #include "options.h"
48 #include "simple-object.h"
49
50 /* From lto-streamer.h which we cannot include with -fkeep-inline-functions.
51    ???  Split out a lto-streamer-core.h.  */
52
53 #define LTO_SECTION_NAME_PREFIX         ".gnu.lto_"
54
55 /* End of lto-streamer.h copy.  */
56
57 int debug;                              /* true if -save-temps.  */
58 int verbose;                            /* true if -v.  */
59
60 enum lto_mode_d {
61   LTO_MODE_NONE,                        /* Not doing LTO.  */
62   LTO_MODE_LTO,                         /* Normal LTO.  */
63   LTO_MODE_WHOPR                        /* WHOPR.  */
64 };
65
66 /* Current LTO mode.  */
67 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
68
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;
76
77 static void maybe_unlink_file (const char *);
78
79  /* Delete tempfiles.  */
80
81 static void
82 lto_wrapper_cleanup (void)
83 {
84   static bool cleanup_done = false;
85   unsigned int i;
86
87   if (cleanup_done)
88     return;
89
90   /* Setting cleanup_done prevents an infinite loop if one of the
91      calls to maybe_unlink_file fails. */
92   cleanup_done = true;
93
94   if (ltrans_output_file)
95     maybe_unlink_file (ltrans_output_file);
96   if (flto_out)
97     maybe_unlink_file (flto_out);
98   if (args_name)
99     maybe_unlink_file (args_name);
100   if (makefile)
101     maybe_unlink_file (makefile);
102   for (i = 0; i < nr; ++i)
103     {
104       maybe_unlink_file (input_names[i]);
105       if (output_names[i])
106         maybe_unlink_file (output_names[i]);
107     }
108 }
109
110 static void
111 fatal_signal (int signum)
112 {
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);
118 }
119
120 /* Just die. CMSGID is the error message. */
121
122 static void __attribute__ ((format (printf, 1, 2)))
123 fatal (const char * cmsgid, ...)
124 {
125   va_list ap;
126
127   va_start (ap, cmsgid);
128   fprintf (stderr, "lto-wrapper: ");
129   vfprintf (stderr, _(cmsgid), ap);
130   fprintf (stderr, "\n");
131   va_end (ap);
132
133   lto_wrapper_cleanup ();
134   exit (FATAL_EXIT_CODE);
135 }
136
137
138 /* Die when sys call fails. CMSGID is the error message.  */
139
140 static void __attribute__ ((format (printf, 1, 2)))
141 fatal_perror (const char *cmsgid, ...)
142 {
143   int e = errno;
144   va_list ap;
145
146   va_start (ap, cmsgid);
147   fprintf (stderr, "lto-wrapper: ");
148   vfprintf (stderr, _(cmsgid), ap);
149   fprintf (stderr, ": %s\n", xstrerror (e));
150   va_end (ap);
151
152   lto_wrapper_cleanup ();
153   exit (FATAL_EXIT_CODE);
154 }
155
156
157 /* Execute a program, and wait for the reply. ARGV are the arguments. The
158    last one must be NULL. */
159
160 static struct pex_obj *
161 collect_execute (char **argv)
162 {
163   struct pex_obj *pex;
164   const char *errmsg;
165   int err;
166
167   if (verbose)
168     {
169       char **p_argv;
170       const char *str;
171
172       for (p_argv = argv; (str = *p_argv) != (char *) 0; p_argv++)
173         fprintf (stderr, " %s", str);
174
175       fprintf (stderr, "\n");
176     }
177
178   fflush (stdout);
179   fflush (stderr);
180
181   pex = pex_init (0, "lto-wrapper", NULL);
182   if (pex == NULL)
183     fatal_perror ("pex_init failed");
184
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,
189                     NULL, &err);
190   if (errmsg != NULL)
191     {
192       if (err != 0)
193         {
194           errno = err;
195           fatal_perror (errmsg);
196         }
197       else
198         fatal (errmsg);
199     }
200
201   return pex;
202 }
203
204
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. */
207
208 static int
209 collect_wait (const char *prog, struct pex_obj *pex)
210 {
211   int status;
212
213   if (!pex_get_status (pex, 1, &status))
214     fatal_perror ("can't get program status");
215   pex_free (pex);
216
217   if (status)
218     {
219       if (WIFSIGNALED (status))
220         {
221           int sig = WTERMSIG (status);
222           if (WCOREDUMP (status))
223             fatal ("%s terminated with signal %d [%s], core dumped",
224                    prog, sig, strsignal (sig));
225           else
226             fatal ("%s terminated with signal %d [%s]",
227                    prog, sig, strsignal (sig));
228         }
229
230       if (WIFEXITED (status))
231         fatal ("%s returned %d exit status", prog, WEXITSTATUS (status));
232     }
233
234   return 0;
235 }
236
237
238 /* Unlink a temporary LTRANS file unless requested otherwise.  */
239
240 static void
241 maybe_unlink_file (const char *file)
242 {
243   if (! debug)
244     {
245       if (unlink_if_ordinary (file)
246           && errno != ENOENT)
247         fatal_perror ("deleting LTRANS file %s", file);
248     }
249   else
250     fprintf (stderr, "[Leaving LTRANS %s]\n", file);
251 }
252
253
254 /* Execute program ARGV[0] with arguments ARGV. Wait for it to finish.  */
255
256 static void
257 fork_execute (char **argv)
258 {
259   struct pex_obj *pex;
260   char *new_argv[3];
261   char *at_args;
262   FILE *args;
263   int status;
264
265   args_name = make_temp_file (".args");
266   at_args = concat ("@", args_name, NULL);
267   args = fopen (args_name, "w");
268   if (args == NULL)
269     fatal ("failed to open %s", args_name);
270
271   status = writeargv (&argv[1], args);
272
273   if (status)
274     fatal ("could not write to temporary file %s",  args_name);
275
276   fclose (args);
277
278   new_argv[0] = argv[0];
279   new_argv[1] = at_args;
280   new_argv[2] = NULL;
281
282   pex = collect_execute (new_argv);
283   collect_wait (new_argv[0], pex);
284
285   maybe_unlink_file (args_name);
286   args_name = NULL;
287   free (at_args);
288 }
289
290 /* Template of LTRANS dumpbase suffix.  */
291 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
292
293 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
294    environment according to LANG_MASK.  */
295
296 static void
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)
302 {
303   struct obstack argv_obstack;
304   char *argv_storage;
305   const char **argv;
306   int j, k, argc;
307
308   argv_storage = xstrdup (collect_gcc_options);
309   obstack_init (&argv_obstack);
310   obstack_ptr_grow (&argv_obstack, collect_gcc);
311
312   for (j = 0, k = 0; argv_storage[j] != '\0'; ++j)
313     {
314       if (argv_storage[j] == '\'')
315         {
316           obstack_ptr_grow (&argv_obstack, &argv_storage[k]);
317           ++j;
318           do
319             {
320               if (argv_storage[j] == '\0')
321                 fatal ("malformed COLLECT_GCC_OPTIONS");
322               else if (strncmp (&argv_storage[j], "'\\''", 4) == 0)
323                 {
324                   argv_storage[k++] = '\'';
325                   j += 4;
326                 }
327               else if (argv_storage[j] == '\'')
328                 break;
329               else
330                 argv_storage[k++] = argv_storage[j++];
331             }
332           while (1);
333           argv_storage[k++] = '\0';
334         }
335     }
336
337   obstack_ptr_grow (&argv_obstack, NULL);
338   argc = obstack_object_size (&argv_obstack) / sizeof (void *) - 1;
339   argv = XOBFINISH (&argv_obstack, const char **);
340
341   decode_cmdline_options_to_array (argc, (const char **)argv,
342                                    lang_mask,
343                                    decoded_options, decoded_options_count);
344   obstack_free (&argv_obstack, NULL);
345 }
346
347 /* Append OPTION to the options array DECODED_OPTIONS with size
348    DECODED_OPTIONS_COUNT.  */
349
350 static void
351 append_option (struct cl_decoded_option **decoded_options,
352                unsigned int *decoded_options_count,
353                struct cl_decoded_option *option)
354 {
355   ++*decoded_options_count;
356   *decoded_options
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));
363 }
364
365 /* Try to merge and complain about options FDECODED_OPTIONS when applied
366    ontop of DECODED_OPTIONS.  */
367
368 static void
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)
373 {
374   unsigned int i, j;
375
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.  */
388
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)
392     {
393       struct cl_decoded_option *foption = &fdecoded_options[i];
394       switch (foption->opt_index)
395         {
396         default:
397           if (!(cl_options[foption->opt_index].flags & CL_TARGET))
398             break;
399
400           /* Fallthru.  */
401         case OPT_fPIC:
402         case OPT_fpic:
403         case OPT_fpie:
404         case OPT_fcommon:
405         case OPT_fexceptions:
406         case OPT_fgnu_tm:
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)
413               break;
414           if (j == *decoded_options_count)
415             append_option (decoded_options, decoded_options_count, foption);
416           break;
417         }
418     }
419 }
420
421 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
422
423 static void
424 run_gcc (unsigned argc, char *argv[])
425 {
426   unsigned i, j;
427   const char **new_argv;
428   const char **argv_ptr;
429   char *list_option_full = NULL;
430   const char *linker_output = NULL;
431   const char *collect_gcc, *collect_gcc_options;
432   int parallel = 0;
433   int jobserver = 0;
434   bool no_partition = false;
435   struct cl_decoded_option *fdecoded_options = NULL;
436   unsigned int fdecoded_options_count = 0;
437   struct cl_decoded_option *decoded_options;
438   unsigned int decoded_options_count;
439   struct obstack argv_obstack;
440   int new_head_argc;
441
442   /* Get the driver and options.  */
443   collect_gcc = getenv ("COLLECT_GCC");
444   if (!collect_gcc)
445     fatal ("environment variable COLLECT_GCC must be set");
446   collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
447   if (!collect_gcc_options)
448     fatal ("environment variable COLLECT_GCC_OPTIONS must be set");
449   get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options,
450                                         CL_LANG_ALL,
451                                         &decoded_options,
452                                         &decoded_options_count);
453
454   /* Look at saved options in the IL files.  */
455   for (i = 1; i < argc; ++i)
456     {
457       char *data, *p;
458       char *fopts;
459       int fd;
460       const char *errmsg;
461       int err;
462       off_t file_offset = 0, offset, length;
463       long loffset;
464       simple_object_read *sobj;
465       int consumed;
466       struct cl_decoded_option *f2decoded_options;
467       unsigned int f2decoded_options_count;
468       char *filename = argv[i];
469       if ((p = strrchr (argv[i], '@'))
470           && p != argv[i] 
471           && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
472           && strlen (p) == (unsigned int) consumed)
473         {
474           filename = XNEWVEC (char, p - argv[i] + 1);
475           memcpy (filename, argv[i], p - argv[i]);
476           filename[p - argv[i]] = '\0';
477           file_offset = (off_t) loffset;
478         }
479       fd = open (argv[i], O_RDONLY);
480       if (fd == -1)
481         continue;
482       sobj = simple_object_start_read (fd, file_offset, "__GNU_LTO", 
483                                        &errmsg, &err);
484       if (!sobj)
485         {
486           close (fd);
487           continue;
488         }
489       if (!simple_object_find_section (sobj, LTO_SECTION_NAME_PREFIX "." "opts",
490                                        &offset, &length, &errmsg, &err))
491         {
492           simple_object_release_read (sobj);
493           close (fd);
494           continue;
495         }
496       lseek (fd, file_offset + offset, SEEK_SET);
497       data = (char *)xmalloc (length);
498       read (fd, data, length);
499       fopts = data;
500       do
501         {
502           get_options_from_collect_gcc_options (collect_gcc,
503                                                 fopts, CL_LANG_ALL,
504                                                 &f2decoded_options,
505                                                 &f2decoded_options_count);
506           if (!fdecoded_options)
507             {
508               fdecoded_options = f2decoded_options;
509               fdecoded_options_count = f2decoded_options_count;
510             }
511           else
512             merge_and_complain (&fdecoded_options,
513                                 &fdecoded_options_count,
514                                 f2decoded_options, f2decoded_options_count);
515
516           fopts += strlen (fopts) + 1;
517         }
518       while (fopts - data < length);
519
520       free (data);
521       simple_object_release_read (sobj);
522       close (fd);
523     }
524
525   /* Initalize the common arguments for the driver.  */
526   obstack_init (&argv_obstack);
527   obstack_ptr_grow (&argv_obstack, collect_gcc);
528   obstack_ptr_grow (&argv_obstack, "-xlto");
529   obstack_ptr_grow (&argv_obstack, "-c");
530
531   /* Append compiler driver arguments as far as they were merged.  */
532   for (j = 1; j < fdecoded_options_count; ++j)
533     {
534       struct cl_decoded_option *option = &fdecoded_options[j];
535
536       /* File options have been properly filtered by lto-opts.c.  */
537       switch (option->opt_index)
538         {
539           /* Drop arguments that we want to take from the link line.  */
540           case OPT_flto_:
541           case OPT_flto:
542           case OPT_flto_partition_none:
543           case OPT_flto_partition_1to1:
544           case OPT_flto_partition_balanced:
545               continue;
546
547           default:
548               break;
549         }
550
551       /* For now do what the original LTO option code was doing - pass
552          on any CL_TARGET flag and a few selected others.  */
553       switch (option->opt_index)
554         {
555         case OPT_fPIC:
556         case OPT_fpic:
557         case OPT_fpie:
558         case OPT_fcommon:
559         case OPT_fexceptions:
560         case OPT_fgnu_tm:
561           break;
562
563         default:
564           if (!(cl_options[option->opt_index].flags & CL_TARGET))
565             continue;
566         }
567
568       /* Pass the option on.  */
569       for (i = 0; i < option->canonical_option_num_elements; ++i)
570         obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
571     }
572
573   /* Append linker driver arguments.  Compiler options from the linker
574      driver arguments will override / merge with those from the compiler.  */
575   for (j = 1; j < decoded_options_count; ++j)
576     {
577       struct cl_decoded_option *option = &decoded_options[j];
578
579       /* Do not pass on frontend specific flags not suitable for lto.  */
580       if (!(cl_options[option->opt_index].flags
581             & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
582         continue;
583
584       switch (option->opt_index)
585         {
586         case OPT_o:
587           linker_output = option->arg;
588           /* We generate new intermediate output, drop this arg.  */
589           continue;
590
591         case OPT_save_temps:
592           debug = 1;
593           break;
594
595         case OPT_v:
596           verbose = 1;
597           break;
598
599         case OPT_flto_partition_none:
600           no_partition = true;
601           break;
602
603         case OPT_flto_:
604           if (strcmp (option->arg, "jobserver") == 0)
605             {
606               jobserver = 1;
607               parallel = 1;
608             }
609           else
610             {
611               parallel = atoi (option->arg);
612               if (parallel <= 1)
613                 parallel = 0;
614             }
615           /* Fallthru.  */
616
617         case OPT_flto:
618           lto_mode = LTO_MODE_WHOPR;
619           /* We've handled these LTO options, do not pass them on.  */
620           continue;
621
622         default:
623           break;
624         }
625
626       /* Pass the option on.  */
627       for (i = 0; i < option->canonical_option_num_elements; ++i)
628         obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
629     }
630
631   if (no_partition)
632     {
633       lto_mode = LTO_MODE_LTO;
634       jobserver = 0;
635       parallel = 0;
636     }
637
638   if (linker_output)
639     {
640       char *output_dir, *base, *name;
641       bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0;
642
643       output_dir = xstrdup (linker_output);
644       base = output_dir;
645       for (name = base; *name; name++)
646         if (IS_DIR_SEPARATOR (*name))
647           base = name + 1;
648       *base = '\0';
649
650       linker_output = &linker_output[base - output_dir];
651       if (*output_dir == '\0')
652         {
653           static char current_dir[] = { '.', DIR_SEPARATOR, '\0' };
654           output_dir = current_dir;
655         }
656       if (!bit_bucket)
657         {
658           obstack_ptr_grow (&argv_obstack, "-dumpdir");
659           obstack_ptr_grow (&argv_obstack, output_dir);
660         }
661
662       obstack_ptr_grow (&argv_obstack, "-dumpbase");
663     }
664
665   /* Remember at which point we can scrub args to re-use the commons.  */
666   new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *);
667
668   if (lto_mode == LTO_MODE_LTO)
669     {
670       flto_out = make_temp_file (".lto.o");
671       if (linker_output)
672         obstack_ptr_grow (&argv_obstack, linker_output);
673       obstack_ptr_grow (&argv_obstack, "-o");
674       obstack_ptr_grow (&argv_obstack, flto_out);
675     }
676   else 
677     {
678       const char *list_option = "-fltrans-output-list=";
679       size_t list_option_len = strlen (list_option);
680       char *tmp;
681
682       if (linker_output)
683         {
684           char *dumpbase = (char *) xmalloc (strlen (linker_output)
685                                              + sizeof (".wpa") + 1);
686           strcpy (dumpbase, linker_output);
687           strcat (dumpbase, ".wpa");
688           obstack_ptr_grow (&argv_obstack, dumpbase);
689         }
690
691       if (linker_output && debug)
692         {
693           ltrans_output_file = (char *) xmalloc (strlen (linker_output)
694                                                  + sizeof (".ltrans.out") + 1);
695           strcpy (ltrans_output_file, linker_output);
696           strcat (ltrans_output_file, ".ltrans.out");
697         }
698       else
699         ltrans_output_file = make_temp_file (".ltrans.out");
700       list_option_full = (char *) xmalloc (sizeof (char) *
701                          (strlen (ltrans_output_file) + list_option_len + 1));
702       tmp = list_option_full;
703
704       obstack_ptr_grow (&argv_obstack, tmp);
705       strcpy (tmp, list_option);
706       tmp += list_option_len;
707       strcpy (tmp, ltrans_output_file);
708
709       obstack_ptr_grow (&argv_obstack, "-fwpa");
710     }
711
712   /* Append the input objects and possible preceeding arguments.  */
713   for (i = 1; i < argc; ++i)
714     obstack_ptr_grow (&argv_obstack, argv[i]);
715   obstack_ptr_grow (&argv_obstack, NULL);
716
717   new_argv = XOBFINISH (&argv_obstack, const char **);
718   argv_ptr = &new_argv[new_head_argc];
719   fork_execute (CONST_CAST (char **, new_argv));
720
721   if (lto_mode == LTO_MODE_LTO)
722     {
723       printf("%s\n", flto_out);
724       free (flto_out);
725       flto_out = NULL;
726     }
727   else
728     {
729       FILE *stream = fopen (ltrans_output_file, "r");
730       FILE *mstream = NULL;
731       struct obstack env_obstack;
732
733       if (!stream)
734         fatal_perror ("fopen: %s", ltrans_output_file);
735
736       /* Parse the list of LTRANS inputs from the WPA stage.  */
737       obstack_init (&env_obstack);
738       nr = 0;
739       for (;;)
740         {
741           const unsigned piece = 32;
742           char *output_name = NULL;
743           char *buf, *input_name = (char *)xmalloc (piece);
744           size_t len;
745
746           buf = input_name;
747 cont:
748           if (!fgets (buf, piece, stream))
749             break;
750           len = strlen (input_name);
751           if (input_name[len - 1] != '\n')
752             {
753               input_name = (char *)xrealloc (input_name, len + piece);
754               buf = input_name + len;
755               goto cont;
756             }
757           input_name[len - 1] = '\0';
758
759           if (input_name[0] == '*')
760             output_name = &input_name[1];
761
762           nr++;
763           input_names = (char **)xrealloc (input_names, nr * sizeof (char *));
764           output_names = (char **)xrealloc (output_names, nr * sizeof (char *));
765           input_names[nr-1] = input_name;
766           output_names[nr-1] = output_name;
767         }
768       fclose (stream);
769       maybe_unlink_file (ltrans_output_file);
770       ltrans_output_file = NULL;
771
772       if (parallel)
773         {
774           makefile = make_temp_file (".mk");
775           mstream = fopen (makefile, "w");
776         }
777
778       /* Execute the LTRANS stage for each input file (or prepare a
779          makefile to invoke this in parallel).  */
780       for (i = 0; i < nr; ++i)
781         {
782           char *output_name;
783           char *input_name = input_names[i];
784           /* If it's a pass-through file do nothing.  */
785           if (output_names[i])
786             continue;
787
788           /* Replace the .o suffix with a .ltrans.o suffix and write
789              the resulting name to the LTRANS output list.  */
790           obstack_grow (&env_obstack, input_name, strlen (input_name) - 2);
791           obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
792           output_name = XOBFINISH (&env_obstack, char *);
793
794           /* Adjust the dumpbase if the linker output file was seen.  */
795           if (linker_output)
796             {
797               char *dumpbase
798                   = (char *) xmalloc (strlen (linker_output)
799                                       + sizeof(DUMPBASE_SUFFIX) + 1);
800               snprintf (dumpbase,
801                         strlen (linker_output) + sizeof(DUMPBASE_SUFFIX),
802                         "%s.ltrans%u", linker_output, i);
803               argv_ptr[0] = dumpbase;
804             }
805
806           argv_ptr[1] = "-fltrans";
807           argv_ptr[2] = "-o";
808           argv_ptr[3] = output_name;
809           argv_ptr[4] = input_name;
810           argv_ptr[5] = NULL;
811           if (parallel)
812             {
813               fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]);
814               for (j = 1; new_argv[j] != NULL; ++j)
815                 fprintf (mstream, " '%s'", new_argv[j]);
816               fprintf (mstream, "\n");
817               /* If we are not preserving the ltrans input files then
818                  truncate them as soon as we have processed it.  This
819                  reduces temporary disk-space usage.  */
820               if (! debug)
821                 fprintf (mstream, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
822                          "&& mv %s.tem %s\n",
823                          input_name, input_name, input_name, input_name); 
824             }
825           else
826             {
827               fork_execute (CONST_CAST (char **, new_argv));
828               maybe_unlink_file (input_name);
829             }
830
831           output_names[i] = output_name;
832         }
833       if (parallel)
834         {
835           struct pex_obj *pex;
836           char jobs[32];
837
838           fprintf (mstream, "all:");
839           for (i = 0; i < nr; ++i)
840             fprintf (mstream, " \\\n\t%s", output_names[i]);
841           fprintf (mstream, "\n");
842           fclose (mstream);
843           if (!jobserver)
844             {
845               /* Avoid passing --jobserver-fd= and similar flags 
846                  unless jobserver mode is explicitly enabled.  */
847               putenv (xstrdup ("MAKEFLAGS="));
848               putenv (xstrdup ("MFLAGS="));
849             }
850           new_argv[0] = getenv ("MAKE");
851           if (!new_argv[0])
852             new_argv[0] = "make";
853           new_argv[1] = "-f";
854           new_argv[2] = makefile;
855           i = 3;
856           if (!jobserver)
857             {
858               snprintf (jobs, 31, "-j%d", parallel);
859               new_argv[i++] = jobs;
860             }
861           new_argv[i++] = "all";
862           new_argv[i++] = NULL;
863           pex = collect_execute (CONST_CAST (char **, new_argv));
864           collect_wait (new_argv[0], pex);
865           maybe_unlink_file (makefile);
866           makefile = NULL;
867           for (i = 0; i < nr; ++i)
868             maybe_unlink_file (input_names[i]);
869         }
870       for (i = 0; i < nr; ++i)
871         {
872           fputs (output_names[i], stdout);
873           putc ('\n', stdout);
874           free (input_names[i]);
875         }
876       nr = 0;
877       free (output_names);
878       free (input_names);
879       free (list_option_full);
880       obstack_free (&env_obstack, NULL);
881     }
882
883   obstack_free (&argv_obstack, NULL);
884 }
885
886
887 /* Entry point.  */
888
889 int
890 main (int argc, char *argv[])
891 {
892   const char *p;
893
894   p = argv[0] + strlen (argv[0]);
895   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
896     --p;
897   progname = p;
898
899   xmalloc_set_program_name (progname);
900
901   gcc_init_libintl ();
902
903   diagnostic_initialize (global_dc, 0);
904
905   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
906     signal (SIGINT, fatal_signal);
907 #ifdef SIGHUP
908   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
909     signal (SIGHUP, fatal_signal);
910 #endif
911   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
912     signal (SIGTERM, fatal_signal);
913 #ifdef SIGPIPE
914   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
915     signal (SIGPIPE, fatal_signal);
916 #endif
917 #ifdef SIGCHLD
918   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
919      receive the signal.  A different setting is inheritable */
920   signal (SIGCHLD, SIG_DFL);
921 #endif
922
923   /* We may be called with all the arguments stored in some file and
924      passed with @file.  Expand them into argv before processing.  */
925   expandargv (&argc, &argv);
926
927   run_gcc (argc, argv);
928
929   return 0;
930 }