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