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
  49 int debug;                              /* true if -save-temps.  */
  50 int verbose;                            /* true if -v.  */
  51
  52 enum lto_mode_d {
  53   LTO_MODE_NONE,                        /* Not doing LTO.  */
  54   LTO_MODE_LTO,                         /* Normal LTO.  */
  55   LTO_MODE_WHOPR                        /* WHOPR.  */
  56 };
  57
  58 /* Current LTO mode.  */
  59 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
  60
  61 static char *ltrans_output_file;
  62 static char *flto_out;
  63 static char *args_name;
  64 static unsigned int nr;
  65 static char **input_names;
  66 static char **output_names;
  67 static char *makefile;
  68
  69 static void maybe_unlink_file (const char *);
  70
  71  /* Delete tempfiles.  */
  72
  73 static void
  74 lto_wrapper_cleanup (void)
  75 {
  76   static bool cleanup_done = false;
  77   unsigned int i;
  78
  79   if (cleanup_done)
  80     return;
  81
  82   /* Setting cleanup_done prevents an infinite loop if one of the
  83      calls to maybe_unlink_file fails. */
  84   cleanup_done = true;
  85
  86   if (ltrans_output_file)
  87     maybe_unlink_file (ltrans_output_file);
  88   if (flto_out)
  89     maybe_unlink_file (flto_out);
  90   if (args_name)
  91     maybe_unlink_file (args_name);
  92   if (makefile)
  93     maybe_unlink_file (makefile);
  94   for (i = 0; i < nr; ++i)
  95     {
  96       maybe_unlink_file (input_names[i]);
  97       if (output_names[i])
  98         maybe_unlink_file (output_names[i]);
  99     }
 100 }
 101
 102 static void
 103 fatal_signal (int signum)
 104 {
 105   signal (signum, SIG_DFL);
 106   lto_wrapper_cleanup ();
 107   /* Get the same signal again, this time not handled,
 108      so its normal effect occurs.  */
 109   kill (getpid (), signum);
 110 }
 111
 112 /* Just die. CMSGID is the error message. */
 113
 114 static void __attribute__ ((format (printf, 1, 2)))
 115 fatal (const char * cmsgid, ...)
 116 {
 117   va_list ap;
 118
 119   va_start (ap, cmsgid);
 120   fprintf (stderr, "lto-wrapper: ");
 121   vfprintf (stderr, _(cmsgid), ap);
 122   fprintf (stderr, "\n");
 123   va_end (ap);
 124
 125   lto_wrapper_cleanup ();
 126   exit (FATAL_EXIT_CODE);
 127 }
 128
 129
 130 /* Die when sys call fails. CMSGID is the error message.  */
 131
 132 static void __attribute__ ((format (printf, 1, 2)))
 133 fatal_perror (const char *cmsgid, ...)
 134 {
 135   int e = errno;
 136   va_list ap;
 137
 138   va_start (ap, cmsgid);
 139   fprintf (stderr, "lto-wrapper: ");
 140   vfprintf (stderr, _(cmsgid), ap);
 141   fprintf (stderr, ": %s\n", xstrerror (e));
 142   va_end (ap);
 143
 144   lto_wrapper_cleanup ();
 145   exit (FATAL_EXIT_CODE);
 146 }
 147
 148
 149 /* Execute a program, and wait for the reply. ARGV are the arguments. The
 150    last one must be NULL. */
 151
 152 static struct pex_obj *
 153 collect_execute (char **argv)
 154 {
 155   struct pex_obj *pex;
 156   const char *errmsg;
 157   int err;
 158
 159   if (verbose)
 160     {
 161       char **p_argv;
 162       const char *str;
 163
 164       for (p_argv = argv; (str = *p_argv) != (char *) 0; p_argv++)
 165         fprintf (stderr, " %s", str);
 166
 167       fprintf (stderr, "\n");
 168     }
 169
 170   fflush (stdout);
 171   fflush (stderr);
 172
 173   pex = pex_init (0, "lto-wrapper", NULL);
 174   if (pex == NULL)
 175     fatal_perror ("pex_init failed");
 176
 177   /* Do not use PEX_LAST here, we use our stdout for communicating with
 178      collect2 or the linker-plugin.  Any output from the sub-process
 179      will confuse that.  */
 180   errmsg = pex_run (pex, PEX_SEARCH, argv[0], argv, NULL,
 181                     NULL, &err);
 182   if (errmsg != NULL)
 183     {
 184       if (err != 0)
 185         {
 186           errno = err;
 187           fatal_perror (errmsg);
 188         }
 189       else
 190         fatal (errmsg);
 191     }
 192
 193   return pex;
 194 }
 195
 196
 197 /* Wait for a process to finish, and exit if a nonzero status is found.
 198    PROG is the program name. PEX is the process we should wait for. */
 199
 200 static int
 201 collect_wait (const char *prog, struct pex_obj *pex)
 202 {
 203   int status;
 204
 205   if (!pex_get_status (pex, 1, &status))
 206     fatal_perror ("can't get program status");
 207   pex_free (pex);
 208
 209   if (status)
 210     {
 211       if (WIFSIGNALED (status))
 212         {
 213           int sig = WTERMSIG (status);
 214           if (WCOREDUMP (status))
 215             fatal ("%s terminated with signal %d [%s], core dumped",
 216                    prog, sig, strsignal (sig));
 217           else
 218             fatal ("%s terminated with signal %d [%s]",
 219                    prog, sig, strsignal (sig));
 220         }
 221
 222       if (WIFEXITED (status))
 223         fatal ("%s returned %d exit status", prog, WEXITSTATUS (status));
 224     }
 225
 226   return 0;
 227 }
 228
 229
 230 /* Unlink a temporary LTRANS file unless requested otherwise.  */
 231
 232 static void
 233 maybe_unlink_file (const char *file)
 234 {
 235   if (! debug)
 236     {
 237       if (unlink_if_ordinary (file)
 238           && errno != ENOENT)
 239         fatal_perror ("deleting LTRANS file %s", file);
 240     }
 241   else
 242     fprintf (stderr, "[Leaving LTRANS %s]\n", file);
 243 }
 244
 245
 246 /* Execute program ARGV[0] with arguments ARGV. Wait for it to finish.  */
 247
 248 static void
 249 fork_execute (char **argv)
 250 {
 251   struct pex_obj *pex;
 252   char *new_argv[3];
 253   char *at_args;
 254   FILE *args;
 255   int status;
 256
 257   args_name = make_temp_file (".args");
 258   at_args = concat ("@", args_name, NULL);
 259   args = fopen (args_name, "w");
 260   if (args == NULL)
 261     fatal ("failed to open %s", args_name);
 262
 263   status = writeargv (&argv[1], args);
 264
 265   if (status)
 266     fatal ("could not write to temporary file %s",  args_name);
 267
 268   fclose (args);
 269
 270   new_argv[0] = argv[0];
 271   new_argv[1] = at_args;
 272   new_argv[2] = NULL;
 273
 274   pex = collect_execute (new_argv);
 275   collect_wait (new_argv[0], pex);
 276
 277   maybe_unlink_file (args_name);
 278   args_name = NULL;
 279   free (at_args);
 280 }
 281
 282 /* Template of LTRANS dumpbase suffix.  */
 283 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
 284
 285 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
 286    environment according to LANG_MASK.  */
 287
 288 static void
 289 get_options_from_collect_gcc_options (const char *collect_gcc,
 290                                       const char *collect_gcc_options,
 291                                       unsigned int lang_mask,
 292                                       struct cl_decoded_option **decoded_options,
 293                                       unsigned int *decoded_options_count)
 294 {
 295   char *argv_storage;
 296   const char **argv;
 297   int i, j, argc;
 298
 299   /* Count arguments, account for the program name.  */
 300   argc = 2;
 301   for (j = 0; collect_gcc_options[j] != '\0'; ++j)
 302     if (collect_gcc_options[j] == '\'')
 303       ++argc;
 304   if (argc % 2 != 0)
 305     fatal ("malformed COLLECT_GCC_OPTIONS");
 306
 307   /* Copy the options to a argv-like array.  */
 308   argc /= 2;
 309   argv = (const char **) xmalloc ((argc + 2) * sizeof (char *));
 310   argv[0] = collect_gcc;
 311   argv_storage = xstrdup (collect_gcc_options);
 312   for (i = 1, j = 0; argv_storage[j] != '\0'; ++j)
 313     {
 314       if (argv_storage[j] == '\'')
 315         {
 316           argv[i++] = &argv_storage[++j];
 317           while (argv_storage[j] != '\'')
 318             ++j;
 319           argv_storage[j] = '\0';
 320         }
 321     }
 322   argv[i] = NULL;
 323
 324   decode_cmdline_options_to_array (argc, (const char **)argv,
 325                                    lang_mask,
 326                                    decoded_options, decoded_options_count);
 327   free (argv);
 328 }
 329
 330
 331 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
 332
 333 static void
 334 run_gcc (unsigned argc, char *argv[])
 335 {
 336   unsigned i, j;
 337   const char **new_argv;
 338   const char **argv_ptr;
 339   char *list_option_full = NULL;
 340   const char *linker_output = NULL;
 341   const char *collect_gcc, *collect_gcc_options;
 342   int parallel = 0;
 343   int jobserver = 0;
 344   bool no_partition = false;
 345   struct cl_decoded_option *decoded_options;
 346   unsigned int decoded_options_count;
 347   struct obstack argv_obstack;
 348   int new_head_argc;
 349
 350   /* Get the driver and options.  */
 351   collect_gcc = getenv ("COLLECT_GCC");
 352   if (!collect_gcc)
 353     fatal ("environment variable COLLECT_GCC must be set");
 354   collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
 355   if (!collect_gcc_options)
 356     fatal ("environment variable COLLECT_GCC_OPTIONS must be set");
 357   get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options,
 358                                         CL_LANG_ALL,
 359                                         &decoded_options,
 360                                         &decoded_options_count);
 361
 362   /* Initalize the common arguments for the driver.  */
 363   obstack_init (&argv_obstack);
 364   obstack_ptr_grow (&argv_obstack, collect_gcc);
 365   obstack_ptr_grow (&argv_obstack, "-xlto");
 366   obstack_ptr_grow (&argv_obstack, "-c");
 367   for (j = 1; j < decoded_options_count; ++j)
 368     {
 369       struct cl_decoded_option *option = &decoded_options[j];
 370
 371       /* Do not pass on frontend specific flags not suitable for lto.  */
 372       if (!(cl_options[option->opt_index].flags
 373             & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
 374         continue;
 375
 376       switch (option->opt_index)
 377         {
 378         case OPT_o:
 379           linker_output = option->arg;
 380           /* We generate new intermediate output, drop this arg.  */
 381           continue;
 382
 383         case OPT_save_temps:
 384           debug = 1;
 385           break;
 386
 387         case OPT_v:
 388           verbose = 1;
 389           break;
 390
 391         case OPT_flto_partition_none:
 392           no_partition = true;
 393           break;
 394
 395         case OPT_flto_:
 396           if (strcmp (option->arg, "jobserver") == 0)
 397             {
 398               jobserver = 1;
 399               parallel = 1;
 400             }
 401           else
 402             {
 403               parallel = atoi (option->arg);
 404               if (parallel <= 1)
 405                 parallel = 0;
 406             }
 407           /* Fallthru.  */
 408
 409         case OPT_flto:
 410           lto_mode = LTO_MODE_WHOPR;
 411           /* We've handled these LTO options, do not pass them on.  */
 412           continue;
 413
 414         default:
 415           break;
 416         }
 417
 418       /* Pass the option on.  */
 419       for (i = 0; i < option->canonical_option_num_elements; ++i)
 420         obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
 421     }
 422
 423   if (no_partition)
 424     {
 425       lto_mode = LTO_MODE_LTO;
 426       jobserver = 0;
 427       parallel = 0;
 428     }
 429
 430   if (linker_output)
 431     {
 432       char *output_dir, *base, *name;
 433       bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0;
 434
 435       output_dir = xstrdup (linker_output);
 436       base = output_dir;
 437       for (name = base; *name; name++)
 438         if (IS_DIR_SEPARATOR (*name))
 439           base = name + 1;
 440       *base = '\0';
 441
 442       linker_output = &linker_output[base - output_dir];
 443       if (*output_dir == '\0')
 444         {
 445           static char current_dir[] = { '.', DIR_SEPARATOR, '\0' };
 446           output_dir = current_dir;
 447         }
 448       if (!bit_bucket)
 449         {
 450           obstack_ptr_grow (&argv_obstack, "-dumpdir");
 451           obstack_ptr_grow (&argv_obstack, output_dir);
 452         }
 453
 454       obstack_ptr_grow (&argv_obstack, "-dumpbase");
 455     }
 456
 457   /* Remember at which point we can scrub args to re-use the commons.  */
 458   new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *);
 459
 460   if (lto_mode == LTO_MODE_LTO)
 461     {
 462       flto_out = make_temp_file (".lto.o");
 463       if (linker_output)
 464         obstack_ptr_grow (&argv_obstack, linker_output);
 465       obstack_ptr_grow (&argv_obstack, "-o");
 466       obstack_ptr_grow (&argv_obstack, flto_out);
 467     }
 468   else
 469     {
 470       const char *list_option = "-fltrans-output-list=";
 471       size_t list_option_len = strlen (list_option);
 472       char *tmp;
 473
 474       if (linker_output)
 475         {
 476           char *dumpbase = (char *) xmalloc (strlen (linker_output)
 477                                              + sizeof (".wpa") + 1);
 478           strcpy (dumpbase, linker_output);
 479           strcat (dumpbase, ".wpa");
 480           obstack_ptr_grow (&argv_obstack, dumpbase);
 481         }
 482
 483       if (linker_output && debug)
 484         {
 485           ltrans_output_file = (char *) xmalloc (strlen (linker_output)
 486                                                  + sizeof (".ltrans.out") + 1);
 487           strcpy (ltrans_output_file, linker_output);
 488           strcat (ltrans_output_file, ".ltrans.out");
 489         }
 490       else
 491         ltrans_output_file = make_temp_file (".ltrans.out");
 492       list_option_full = (char *) xmalloc (sizeof (char) *
 493                          (strlen (ltrans_output_file) + list_option_len + 1));
 494       tmp = list_option_full;
 495
 496       obstack_ptr_grow (&argv_obstack, tmp);
 497       strcpy (tmp, list_option);
 498       tmp += list_option_len;
 499       strcpy (tmp, ltrans_output_file);
 500
 501       obstack_ptr_grow (&argv_obstack, "-fwpa");
 502     }
 503
 504   /* Append the input objects and possible preceeding arguments.  */
 505   for (i = 1; i < argc; ++i)
 506     obstack_ptr_grow (&argv_obstack, argv[i]);
 507   obstack_ptr_grow (&argv_obstack, NULL);
 508
 509   new_argv = XOBFINISH (&argv_obstack, const char **);
 510   argv_ptr = &new_argv[new_head_argc];
 511   fork_execute (CONST_CAST (char **, new_argv));
 512
 513   if (lto_mode == LTO_MODE_LTO)
 514     {
 515       printf("%s\n", flto_out);
 516       free (flto_out);
 517       flto_out = NULL;
 518     }
 519   else
 520     {
 521       FILE *stream = fopen (ltrans_output_file, "r");
 522       FILE *mstream = NULL;
 523       struct obstack env_obstack;
 524
 525       if (!stream)
 526         fatal_perror ("fopen: %s", ltrans_output_file);
 527
 528       /* Parse the list of LTRANS inputs from the WPA stage.  */
 529       obstack_init (&env_obstack);
 530       nr = 0;
 531       for (;;)
 532         {
 533           const unsigned piece = 32;
 534           char *output_name = NULL;
 535           char *buf, *input_name = (char *)xmalloc (piece);
 536           size_t len;
 537
 538           buf = input_name;
 539 cont:
 540           if (!fgets (buf, piece, stream))
 541             break;
 542           len = strlen (input_name);
 543           if (input_name[len - 1] != '\n')
 544             {
 545               input_name = (char *)xrealloc (input_name, len + piece);
 546               buf = input_name + len;
 547               goto cont;
 548             }
 549           input_name[len - 1] = '\0';
 550
 551           if (input_name[0] == '*')
 552             output_name = &input_name[1];
 553
 554           nr++;
 555           input_names = (char **)xrealloc (input_names, nr * sizeof (char *));
 556           output_names = (char **)xrealloc (output_names, nr * sizeof (char *));
 557           input_names[nr-1] = input_name;
 558           output_names[nr-1] = output_name;
 559         }
 560       fclose (stream);
 561       maybe_unlink_file (ltrans_output_file);
 562       ltrans_output_file = NULL;
 563
 564       if (parallel)
 565         {
 566           makefile = make_temp_file (".mk");
 567           mstream = fopen (makefile, "w");
 568         }
 569
 570       /* Execute the LTRANS stage for each input file (or prepare a
 571          makefile to invoke this in parallel).  */
 572       for (i = 0; i < nr; ++i)
 573         {
 574           char *output_name;
 575           char *input_name = input_names[i];
 576           /* If it's a pass-through file do nothing.  */
 577           if (output_names[i])
 578             continue;
 579
 580           /* Replace the .o suffix with a .ltrans.o suffix and write
 581              the resulting name to the LTRANS output list.  */
 582           obstack_grow (&env_obstack, input_name, strlen (input_name) - 2);
 583           obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
 584           output_name = XOBFINISH (&env_obstack, char *);
 585
 586           /* Adjust the dumpbase if the linker output file was seen.  */
 587           if (linker_output)
 588             {
 589               char *dumpbase
 590                   = (char *) xmalloc (strlen (linker_output)
 591                                       + sizeof(DUMPBASE_SUFFIX) + 1);
 592               snprintf (dumpbase,
 593                         strlen (linker_output) + sizeof(DUMPBASE_SUFFIX),
 594                         "%s.ltrans%u", linker_output, i);
 595               argv_ptr[0] = dumpbase;
 596             }
 597
 598           argv_ptr[1] = "-fltrans";
 599           argv_ptr[2] = "-o";
 600           argv_ptr[3] = output_name;
 601           argv_ptr[4] = input_name;
 602           argv_ptr[5] = NULL;
 603           if (parallel)
 604             {
 605               fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]);
 606               for (j = 1; new_argv[j] != NULL; ++j)
 607                 fprintf (mstream, " '%s'", new_argv[j]);
 608               fprintf (mstream, "\n");
 609             }
 610           else
 611             fork_execute (CONST_CAST (char **, new_argv));
 612
 613           output_names[i] = output_name;
 614         }
 615       if (parallel)
 616         {
 617           struct pex_obj *pex;
 618           char jobs[32];
 619
 620           fprintf (mstream, "all:");
 621           for (i = 0; i < nr; ++i)
 622             fprintf (mstream, " \\\n\t%s", output_names[i]);
 623           fprintf (mstream, "\n");
 624           fclose (mstream);
 625           if (!jobserver)
 626             {
 627               /* Avoid passing --jobserver-fd= and similar flags
 628                  unless jobserver mode is explicitly enabled.  */
 629               putenv (xstrdup ("MAKEFLAGS="));
 630               putenv (xstrdup ("MFLAGS="));
 631             }
 632           new_argv[0] = getenv ("MAKE");
 633           if (!new_argv[0])
 634             new_argv[0] = "make";
 635           new_argv[1] = "-f";
 636           new_argv[2] = makefile;
 637           i = 3;
 638           if (!jobserver)
 639             {
 640               snprintf (jobs, 31, "-j%d", parallel);
 641               new_argv[i++] = jobs;
 642             }
 643           new_argv[i++] = "all";
 644           new_argv[i++] = NULL;
 645           pex = collect_execute (CONST_CAST (char **, new_argv));
 646           collect_wait (new_argv[0], pex);
 647           maybe_unlink_file (makefile);
 648           makefile = NULL;
 649         }
 650       for (i = 0; i < nr; ++i)
 651         {
 652           fputs (output_names[i], stdout);
 653           putc ('\n', stdout);
 654           maybe_unlink_file (input_names[i]);
 655           free (input_names[i]);
 656         }
 657       nr = 0;
 658       free (output_names);
 659       free (input_names);
 660       free (list_option_full);
 661       obstack_free (&env_obstack, NULL);
 662     }
 663
 664   obstack_free (&argv_obstack, NULL);
 665 }
 666
 667
 668 /* Entry point.  */
 669
 670 int
 671 main (int argc, char *argv[])
 672 {
 673   const char *p;
 674
 675   p = argv[0] + strlen (argv[0]);
 676   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
 677     --p;
 678   progname = p;
 679
 680   xmalloc_set_program_name (progname);
 681
 682   gcc_init_libintl ();
 683
 684   diagnostic_initialize (global_dc, 0);
 685
 686   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
 687     signal (SIGINT, fatal_signal);
 688 #ifdef SIGHUP
 689   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
 690     signal (SIGHUP, fatal_signal);
 691 #endif
 692   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
 693     signal (SIGTERM, fatal_signal);
 694 #ifdef SIGPIPE
 695   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
 696     signal (SIGPIPE, fatal_signal);
 697 #endif
 698 #ifdef SIGCHLD
 699   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
 700      receive the signal.  A different setting is inheritable */
 701   signal (SIGCHLD, SIG_DFL);
 702 #endif
 703
 704   /* We may be called with all the arguments stored in some file and
 705      passed with @file.  Expand them into argv before processing.  */
 706   expandargv (&argc, &argv);
 707
 708   run_gcc (argc, argv);
 709
 710   return 0;
 711 }