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, NULL, &errmsg, &err);
 483       if (!sobj)
 484         {
 485           close (fd);
 486           continue;
 487         }
 488       if (!simple_object_find_section (sobj, LTO_SECTION_NAME_PREFIX "." "opts",
 489                                        &offset, &length, &errmsg, &err))
 490         {
 491           simple_object_release_read (sobj);
 492           close (fd);
 493           continue;
 494         }
 495       lseek (fd, file_offset + offset, SEEK_SET);
 496       data = (char *)xmalloc (length);
 497       read (fd, data, length);
 498       fopts = data;
 499       do
 500         {
 501           get_options_from_collect_gcc_options (collect_gcc,
 502                                                 fopts, CL_LANG_ALL,
 503                                                 &f2decoded_options,
 504                                                 &f2decoded_options_count);
 505           if (!fdecoded_options)
 506             {
 507               fdecoded_options = f2decoded_options;
 508               fdecoded_options_count = f2decoded_options_count;
 509             }
 510           else
 511             merge_and_complain (&fdecoded_options,
 512                                 &fdecoded_options_count,
 513                                 f2decoded_options, f2decoded_options_count);
 514
 515           fopts += strlen (fopts) + 1;
 516         }
 517       while (fopts - data < length);
 518
 519       free (data);
 520       simple_object_release_read (sobj);
 521       close (fd);
 522     }
 523
 524   /* Initalize the common arguments for the driver.  */
 525   obstack_init (&argv_obstack);
 526   obstack_ptr_grow (&argv_obstack, collect_gcc);
 527   obstack_ptr_grow (&argv_obstack, "-xlto");
 528   obstack_ptr_grow (&argv_obstack, "-c");
 529
 530   /* Append compiler driver arguments as far as they were merged.  */
 531   for (j = 1; j < fdecoded_options_count; ++j)
 532     {
 533       struct cl_decoded_option *option = &fdecoded_options[j];
 534
 535       /* File options have been properly filtered by lto-opts.c.  */
 536       switch (option->opt_index)
 537         {
 538           /* Drop arguments that we want to take from the link line.  */
 539           case OPT_flto_:
 540           case OPT_flto:
 541           case OPT_flto_partition_none:
 542           case OPT_flto_partition_1to1:
 543           case OPT_flto_partition_balanced:
 544               continue;
 545
 546           default:
 547               break;
 548         }
 549
 550       /* For now do what the original LTO option code was doing - pass
 551          on any CL_TARGET flag and a few selected others.  */
 552       switch (option->opt_index)
 553         {
 554         case OPT_fPIC:
 555         case OPT_fpic:
 556         case OPT_fpie:
 557         case OPT_fcommon:
 558         case OPT_fexceptions:
 559         case OPT_fgnu_tm:
 560           break;
 561
 562         default:
 563           if (!(cl_options[option->opt_index].flags & CL_TARGET))
 564             continue;
 565         }
 566
 567       /* Pass the option on.  */
 568       for (i = 0; i < option->canonical_option_num_elements; ++i)
 569         obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
 570     }
 571
 572   /* Append linker driver arguments.  Compiler options from the linker
 573      driver arguments will override / merge with those from the compiler.  */
 574   for (j = 1; j < decoded_options_count; ++j)
 575     {
 576       struct cl_decoded_option *option = &decoded_options[j];
 577
 578       /* Do not pass on frontend specific flags not suitable for lto.  */
 579       if (!(cl_options[option->opt_index].flags
 580             & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
 581         continue;
 582
 583       switch (option->opt_index)
 584         {
 585         case OPT_o:
 586           linker_output = option->arg;
 587           /* We generate new intermediate output, drop this arg.  */
 588           continue;
 589
 590         case OPT_save_temps:
 591           debug = 1;
 592           break;
 593
 594         case OPT_v:
 595           verbose = 1;
 596           break;
 597
 598         case OPT_flto_partition_none:
 599           no_partition = true;
 600           break;
 601
 602         case OPT_flto_:
 603           if (strcmp (option->arg, "jobserver") == 0)
 604             {
 605               jobserver = 1;
 606               parallel = 1;
 607             }
 608           else
 609             {
 610               parallel = atoi (option->arg);
 611               if (parallel <= 1)
 612                 parallel = 0;
 613             }
 614           /* Fallthru.  */
 615
 616         case OPT_flto:
 617           lto_mode = LTO_MODE_WHOPR;
 618           /* We've handled these LTO options, do not pass them on.  */
 619           continue;
 620
 621         default:
 622           break;
 623         }
 624
 625       /* Pass the option on.  */
 626       for (i = 0; i < option->canonical_option_num_elements; ++i)
 627         obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
 628     }
 629
 630   if (no_partition)
 631     {
 632       lto_mode = LTO_MODE_LTO;
 633       jobserver = 0;
 634       parallel = 0;
 635     }
 636
 637   if (linker_output)
 638     {
 639       char *output_dir, *base, *name;
 640       bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0;
 641
 642       output_dir = xstrdup (linker_output);
 643       base = output_dir;
 644       for (name = base; *name; name++)
 645         if (IS_DIR_SEPARATOR (*name))
 646           base = name + 1;
 647       *base = '\0';
 648
 649       linker_output = &linker_output[base - output_dir];
 650       if (*output_dir == '\0')
 651         {
 652           static char current_dir[] = { '.', DIR_SEPARATOR, '\0' };
 653           output_dir = current_dir;
 654         }
 655       if (!bit_bucket)
 656         {
 657           obstack_ptr_grow (&argv_obstack, "-dumpdir");
 658           obstack_ptr_grow (&argv_obstack, output_dir);
 659         }
 660
 661       obstack_ptr_grow (&argv_obstack, "-dumpbase");
 662     }
 663
 664   /* Remember at which point we can scrub args to re-use the commons.  */
 665   new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *);
 666
 667   if (lto_mode == LTO_MODE_LTO)
 668     {
 669       flto_out = make_temp_file (".lto.o");
 670       if (linker_output)
 671         obstack_ptr_grow (&argv_obstack, linker_output);
 672       obstack_ptr_grow (&argv_obstack, "-o");
 673       obstack_ptr_grow (&argv_obstack, flto_out);
 674     }
 675   else
 676     {
 677       const char *list_option = "-fltrans-output-list=";
 678       size_t list_option_len = strlen (list_option);
 679       char *tmp;
 680
 681       if (linker_output)
 682         {
 683           char *dumpbase = (char *) xmalloc (strlen (linker_output)
 684                                              + sizeof (".wpa") + 1);
 685           strcpy (dumpbase, linker_output);
 686           strcat (dumpbase, ".wpa");
 687           obstack_ptr_grow (&argv_obstack, dumpbase);
 688         }
 689
 690       if (linker_output && debug)
 691         {
 692           ltrans_output_file = (char *) xmalloc (strlen (linker_output)
 693                                                  + sizeof (".ltrans.out") + 1);
 694           strcpy (ltrans_output_file, linker_output);
 695           strcat (ltrans_output_file, ".ltrans.out");
 696         }
 697       else
 698         ltrans_output_file = make_temp_file (".ltrans.out");
 699       list_option_full = (char *) xmalloc (sizeof (char) *
 700                          (strlen (ltrans_output_file) + list_option_len + 1));
 701       tmp = list_option_full;
 702
 703       obstack_ptr_grow (&argv_obstack, tmp);
 704       strcpy (tmp, list_option);
 705       tmp += list_option_len;
 706       strcpy (tmp, ltrans_output_file);
 707
 708       obstack_ptr_grow (&argv_obstack, "-fwpa");
 709     }
 710
 711   /* Append the input objects and possible preceeding arguments.  */
 712   for (i = 1; i < argc; ++i)
 713     obstack_ptr_grow (&argv_obstack, argv[i]);
 714   obstack_ptr_grow (&argv_obstack, NULL);
 715
 716   new_argv = XOBFINISH (&argv_obstack, const char **);
 717   argv_ptr = &new_argv[new_head_argc];
 718   fork_execute (CONST_CAST (char **, new_argv));
 719
 720   if (lto_mode == LTO_MODE_LTO)
 721     {
 722       printf("%s\n", flto_out);
 723       free (flto_out);
 724       flto_out = NULL;
 725     }
 726   else
 727     {
 728       FILE *stream = fopen (ltrans_output_file, "r");
 729       FILE *mstream = NULL;
 730       struct obstack env_obstack;
 731
 732       if (!stream)
 733         fatal_perror ("fopen: %s", ltrans_output_file);
 734
 735       /* Parse the list of LTRANS inputs from the WPA stage.  */
 736       obstack_init (&env_obstack);
 737       nr = 0;
 738       for (;;)
 739         {
 740           const unsigned piece = 32;
 741           char *output_name = NULL;
 742           char *buf, *input_name = (char *)xmalloc (piece);
 743           size_t len;
 744
 745           buf = input_name;
 746 cont:
 747           if (!fgets (buf, piece, stream))
 748             break;
 749           len = strlen (input_name);
 750           if (input_name[len - 1] != '\n')
 751             {
 752               input_name = (char *)xrealloc (input_name, len + piece);
 753               buf = input_name + len;
 754               goto cont;
 755             }
 756           input_name[len - 1] = '\0';
 757
 758           if (input_name[0] == '*')
 759             output_name = &input_name[1];
 760
 761           nr++;
 762           input_names = (char **)xrealloc (input_names, nr * sizeof (char *));
 763           output_names = (char **)xrealloc (output_names, nr * sizeof (char *));
 764           input_names[nr-1] = input_name;
 765           output_names[nr-1] = output_name;
 766         }
 767       fclose (stream);
 768       maybe_unlink_file (ltrans_output_file);
 769       ltrans_output_file = NULL;
 770
 771       if (parallel)
 772         {
 773           makefile = make_temp_file (".mk");
 774           mstream = fopen (makefile, "w");
 775         }
 776
 777       /* Execute the LTRANS stage for each input file (or prepare a
 778          makefile to invoke this in parallel).  */
 779       for (i = 0; i < nr; ++i)
 780         {
 781           char *output_name;
 782           char *input_name = input_names[i];
 783           /* If it's a pass-through file do nothing.  */
 784           if (output_names[i])
 785             continue;
 786
 787           /* Replace the .o suffix with a .ltrans.o suffix and write
 788              the resulting name to the LTRANS output list.  */
 789           obstack_grow (&env_obstack, input_name, strlen (input_name) - 2);
 790           obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
 791           output_name = XOBFINISH (&env_obstack, char *);
 792
 793           /* Adjust the dumpbase if the linker output file was seen.  */
 794           if (linker_output)
 795             {
 796               char *dumpbase
 797                   = (char *) xmalloc (strlen (linker_output)
 798                                       + sizeof(DUMPBASE_SUFFIX) + 1);
 799               snprintf (dumpbase,
 800                         strlen (linker_output) + sizeof(DUMPBASE_SUFFIX),
 801                         "%s.ltrans%u", linker_output, i);
 802               argv_ptr[0] = dumpbase;
 803             }
 804
 805           argv_ptr[1] = "-fltrans";
 806           argv_ptr[2] = "-o";
 807           argv_ptr[3] = output_name;
 808           argv_ptr[4] = input_name;
 809           argv_ptr[5] = NULL;
 810           if (parallel)
 811             {
 812               fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]);
 813               for (j = 1; new_argv[j] != NULL; ++j)
 814                 fprintf (mstream, " '%s'", new_argv[j]);
 815               fprintf (mstream, "\n");
 816               /* If we are not preserving the ltrans input files then
 817                  truncate them as soon as we have processed it.  This
 818                  reduces temporary disk-space usage.  */
 819               if (! debug)
 820                 fprintf (mstream, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
 821                          "&& mv %s.tem %s\n",
 822                          input_name, input_name, input_name, input_name);
 823             }
 824           else
 825             {
 826               fork_execute (CONST_CAST (char **, new_argv));
 827               maybe_unlink_file (input_name);
 828             }
 829
 830           output_names[i] = output_name;
 831         }
 832       if (parallel)
 833         {
 834           struct pex_obj *pex;
 835           char jobs[32];
 836
 837           fprintf (mstream, "all:");
 838           for (i = 0; i < nr; ++i)
 839             fprintf (mstream, " \\\n\t%s", output_names[i]);
 840           fprintf (mstream, "\n");
 841           fclose (mstream);
 842           if (!jobserver)
 843             {
 844               /* Avoid passing --jobserver-fd= and similar flags
 845                  unless jobserver mode is explicitly enabled.  */
 846               putenv (xstrdup ("MAKEFLAGS="));
 847               putenv (xstrdup ("MFLAGS="));
 848             }
 849           new_argv[0] = getenv ("MAKE");
 850           if (!new_argv[0])
 851             new_argv[0] = "make";
 852           new_argv[1] = "-f";
 853           new_argv[2] = makefile;
 854           i = 3;
 855           if (!jobserver)
 856             {
 857               snprintf (jobs, 31, "-j%d", parallel);
 858               new_argv[i++] = jobs;
 859             }
 860           new_argv[i++] = "all";
 861           new_argv[i++] = NULL;
 862           pex = collect_execute (CONST_CAST (char **, new_argv));
 863           collect_wait (new_argv[0], pex);
 864           maybe_unlink_file (makefile);
 865           makefile = NULL;
 866           for (i = 0; i < nr; ++i)
 867             maybe_unlink_file (input_names[i]);
 868         }
 869       for (i = 0; i < nr; ++i)
 870         {
 871           fputs (output_names[i], stdout);
 872           putc ('\n', stdout);
 873           free (input_names[i]);
 874         }
 875       nr = 0;
 876       free (output_names);
 877       free (input_names);
 878       free (list_option_full);
 879       obstack_free (&env_obstack, NULL);
 880     }
 881
 882   obstack_free (&argv_obstack, NULL);
 883 }
 884
 885
 886 /* Entry point.  */
 887
 888 int
 889 main (int argc, char *argv[])
 890 {
 891   const char *p;
 892
 893   p = argv[0] + strlen (argv[0]);
 894   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
 895     --p;
 896   progname = p;
 897
 898   xmalloc_set_program_name (progname);
 899
 900   gcc_init_libintl ();
 901
 902   diagnostic_initialize (global_dc, 0);
 903
 904   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
 905     signal (SIGINT, fatal_signal);
 906 #ifdef SIGHUP
 907   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
 908     signal (SIGHUP, fatal_signal);
 909 #endif
 910   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
 911     signal (SIGTERM, fatal_signal);
 912 #ifdef SIGPIPE
 913   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
 914     signal (SIGPIPE, fatal_signal);
 915 #endif
 916 #ifdef SIGCHLD
 917   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
 918      receive the signal.  A different setting is inheritable */
 919   signal (SIGCHLD, SIG_DFL);
 920 #endif
 921
 922   /* We may be called with all the arguments stored in some file and
 923      passed with @file.  Expand them into argv before processing.  */
 924   expandargv (&argc, &argv);
 925
 926   run_gcc (argc, argv);
 927
 928   return 0;
 929 }