gcc/lto-wrapper.c

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