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 }