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