gcc/lto-wrapper.c

   1 /* Wrapper to call lto.  Used by collect2 and the linker plugin.
   2    Copyright (C) 2009 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 -fwhopr 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 "tm.h"
  44 #include "intl.h"
  45 #include "libiberty.h"
  46
  47 int debug;                              /* true if -debug */
  48
  49 enum lto_mode_d {
  50   LTO_MODE_NONE,                        /* Not doing LTO. */
  51   LTO_MODE_LTO,                         /* Normal LTO. */
  52   LTO_MODE_WHOPR                        /* WHOPR. */
  53 };
  54
  55 /* Current LTO mode.  */
  56 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
  57
  58 static char *ltrans_output_file;
  59 static char *flto_out;
  60 static char *args_name;
  61
  62 static void maybe_unlink_file (const char *);
  63
  64 /* Delete tempfiles and exit function.  */
  65
  66 static void
  67 lto_wrapper_exit (int status)
  68 {
  69   static bool cleanup_done = false;
  70   if (!cleanup_done)
  71     {
  72       /* Setting cleanup_done prevents an infinite loop if one of the
  73          calls to maybe_unlink_file fails. */
  74       cleanup_done = true;
  75
  76       if (ltrans_output_file)
  77         maybe_unlink_file (ltrans_output_file);
  78       if (flto_out)
  79         maybe_unlink_file (flto_out);
  80       if (args_name)
  81         maybe_unlink_file (args_name);
  82     }
  83   exit (status);
  84 }
  85
  86 /* Just die. CMSGID is the error message. */
  87
  88 static void __attribute__ ((format (printf, 1, 2)))
  89 fatal (const char * cmsgid, ...)
  90 {
  91   va_list ap;
  92
  93   va_start (ap, cmsgid);
  94   fprintf (stderr, "lto-wrapper: ");
  95   vfprintf (stderr, _(cmsgid), ap);
  96   fprintf (stderr, "\n");
  97   va_end (ap);
  98
  99   lto_wrapper_exit (FATAL_EXIT_CODE);
 100 }
 101
 102
 103 /* Die when sys call fails. CMSGID is the error message.  */
 104
 105 static void __attribute__ ((format (printf, 1, 2)))
 106 fatal_perror (const char *cmsgid, ...)
 107 {
 108   int e = errno;
 109   va_list ap;
 110
 111   va_start (ap, cmsgid);
 112   fprintf (stderr, "lto-wrapper: ");
 113   vfprintf (stderr, _(cmsgid), ap);
 114   fprintf (stderr, ": %s\n", xstrerror (e));
 115   va_end (ap);
 116
 117   lto_wrapper_exit (FATAL_EXIT_CODE);
 118 }
 119
 120
 121 /* Execute a program, and wait for the reply. ARGV are the arguments. The
 122    last one must be NULL. */
 123
 124 static struct pex_obj *
 125 collect_execute (char **argv)
 126 {
 127   struct pex_obj *pex;
 128   const char *errmsg;
 129   int err;
 130
 131   if (debug)
 132     {
 133       char **p_argv;
 134       const char *str;
 135
 136       for (p_argv = argv; (str = *p_argv) != (char *) 0; p_argv++)
 137         fprintf (stderr, " %s", str);
 138
 139       fprintf (stderr, "\n");
 140     }
 141
 142   fflush (stdout);
 143   fflush (stderr);
 144
 145   pex = pex_init (0, "lto-wrapper", NULL);
 146   if (pex == NULL)
 147     fatal_perror ("pex_init failed");
 148
 149   errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0], argv, NULL,
 150                     NULL, &err);
 151   if (errmsg != NULL)
 152     {
 153       if (err != 0)
 154         {
 155           errno = err;
 156           fatal_perror (errmsg);
 157         }
 158       else
 159         fatal (errmsg);
 160     }
 161
 162   return pex;
 163 }
 164
 165
 166 /* Wait for a process to finish, and exit if a nonzero status is found.
 167    PROG is the program name. PEX is the process we should wait for. */
 168
 169 static int
 170 collect_wait (const char *prog, struct pex_obj *pex)
 171 {
 172   int status;
 173
 174   if (!pex_get_status (pex, 1, &status))
 175     fatal_perror ("can't get program status");
 176   pex_free (pex);
 177
 178   if (status)
 179     {
 180       if (WIFSIGNALED (status))
 181         {
 182           int sig = WTERMSIG (status);
 183           if (WCOREDUMP (status))
 184             fatal ("%s terminated with signal %d [%s], core dumped",
 185                    prog, sig, strsignal (sig));
 186           else
 187             fatal ("%s terminated with signal %d [%s]",
 188                    prog, sig, strsignal (sig));
 189         }
 190
 191       if (WIFEXITED (status))
 192         fatal ("%s returned %d exit status", prog, WEXITSTATUS (status));
 193     }
 194
 195   return 0;
 196 }
 197
 198
 199 /* Unlink a temporary LTRANS file unless requested otherwise.  */
 200
 201 static void
 202 maybe_unlink_file (const char *file)
 203 {
 204   if (! debug)
 205     {
 206       if (unlink_if_ordinary (file))
 207         fatal_perror ("deleting LTRANS file %s", file);
 208     }
 209   else
 210     fprintf (stderr, "[Leaving LTRANS %s]\n", file);
 211 }
 212
 213
 214 /* Execute program ARGV[0] with arguments ARGV. Wait for it to finish.  */
 215
 216 static void
 217 fork_execute (char **argv)
 218 {
 219   struct pex_obj *pex;
 220   char *new_argv[3];
 221   char *at_args;
 222   FILE *args;
 223   int status;
 224
 225   args_name = make_temp_file (".args");
 226   at_args = concat ("@", args_name, NULL);
 227   args = fopen (args_name, "w");
 228   if (args == NULL)
 229     fatal ("failed to open %s", args_name);
 230
 231   status = writeargv (&argv[1], args);
 232
 233   if (status)
 234     fatal ("could not write to temporary file %s",  args_name);
 235
 236   fclose (args);
 237
 238   new_argv[0] = argv[0];
 239   new_argv[1] = at_args;
 240   new_argv[2] = NULL;
 241
 242   pex = collect_execute (new_argv);
 243   collect_wait (new_argv[0], pex);
 244
 245   maybe_unlink_file (args_name);
 246   free (at_args);
 247 }
 248
 249
 250 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
 251
 252 static void
 253 run_gcc (unsigned argc, char *argv[])
 254 {
 255   unsigned i;
 256   unsigned new_argc = argc;
 257   const char **new_argv;
 258   const char **argv_ptr;
 259   char *list_option_full = NULL;
 260
 261   new_argc += 8;
 262   new_argv = (const char **) xcalloc (sizeof (char *), new_argc);
 263
 264   argv_ptr = new_argv;
 265
 266   *argv_ptr++ = argv[0];
 267   *argv_ptr++ = "-combine";
 268   *argv_ptr++ = "-x";
 269   *argv_ptr++ = "lto";
 270   *argv_ptr++ = "-c";
 271   if (lto_mode == LTO_MODE_LTO)
 272     {
 273       flto_out = make_temp_file (".lto.o");
 274       *argv_ptr++ = "-o";
 275       *argv_ptr++ = flto_out;
 276     }
 277   else if (lto_mode == LTO_MODE_WHOPR)
 278     {
 279       const char *list_option = "-fltrans-output-list=";
 280       size_t list_option_len = strlen (list_option);
 281       char *tmp;
 282
 283       ltrans_output_file = make_temp_file (".ltrans.out");
 284       list_option_full = (char *) xmalloc (sizeof (char) *
 285                          (strlen (ltrans_output_file) + list_option_len + 1));
 286       tmp = list_option_full;
 287
 288       *argv_ptr++ = tmp;
 289       strcpy (tmp, list_option);
 290       tmp += list_option_len;
 291       strcpy (tmp, ltrans_output_file);
 292
 293       *argv_ptr++ = "-fwpa";
 294     }
 295   else
 296     fatal ("invalid LTO mode");
 297
 298   /* Add inherited GCC options to the LTO back end command line.
 299      Filter out some obviously inappropriate options that will
 300      conflict with  the options that we force above.  We pass
 301      all of the remaining options on to LTO, and let it complain
 302      about any it doesn't like. Note that we invoke LTO via the
 303      `gcc' driver, so the usual option processing takes place.
 304      Except for `-flto' and `-fwhopr', we should only filter options that
 305      are meaningful to `ld', lest an option go silently unclaimed.  */
 306   for (i = 1; i < argc; i++)
 307     {
 308       const char *s = argv[i];
 309
 310       if (strcmp (s, "-flto") == 0 || strcmp (s, "-fwhopr") == 0)
 311         /* We've handled this LTO option, don't pass it on.  */
 312         ;
 313       else if (*s == '-' && s[1] == 'o')
 314         {
 315           /* Drop `-o' and its filename argument.  We will use a
 316              temporary file for the LTO output.  The `-o' option
 317              will be interpreted by the linker.  */
 318           if (s[2] == '\0')
 319             i++;
 320         }
 321       else
 322         /* Pass the option or argument to LTO.  */
 323         *argv_ptr++ = s;
 324     }
 325
 326   *argv_ptr = NULL;
 327
 328   fork_execute (CONST_CAST (char **, new_argv));
 329   free (new_argv);
 330   new_argv = NULL;
 331
 332   if (lto_mode == LTO_MODE_LTO)
 333     {
 334       printf("%s\n", flto_out);
 335       free (flto_out);
 336       flto_out = NULL;
 337     }
 338   else if (lto_mode == LTO_MODE_WHOPR)
 339     {
 340       FILE *stream = fopen (ltrans_output_file, "r");
 341       int c;
 342
 343       if (!stream)
 344         fatal_perror ("fopen: %s", ltrans_output_file);
 345
 346       while ((c = getc (stream)) != EOF)
 347         putc (c, stdout);
 348       fclose (stream);
 349       maybe_unlink_file (ltrans_output_file);
 350       free (list_option_full);
 351     }
 352   else
 353     fatal ("invalid LTO mode");
 354 }
 355
 356
 357 /* Parse the command line. Copy any unused argument to GCC_ARGV. ARGC is the
 358    number of arguments. ARGV contains the arguments. */
 359
 360 static int
 361 process_args (int argc, char *argv[], char *gcc_argv[])
 362 {
 363   int i;
 364   int j = 0;
 365
 366   for (i = 1; i < argc; i ++)
 367     {
 368       if (! strcmp (argv[i], "-debug"))
 369         debug = 1;
 370       else if (! strcmp (argv[i], "-flto"))
 371         lto_mode = LTO_MODE_LTO;
 372       else if (! strcmp (argv[i], "-fwhopr"))
 373         lto_mode = LTO_MODE_WHOPR;
 374       else
 375         {
 376           gcc_argv[j] = argv[i];
 377           j++;
 378         }
 379     }
 380
 381   return j;
 382 }
 383
 384
 385 /* Entry point.  */
 386
 387 int
 388 main (int argc, char *argv[])
 389 {
 390   char **gcc_argv;
 391   int gcc_argc;
 392
 393   gcc_init_libintl ();
 394
 395   /* We may be called with all the arguments stored in some file and
 396      passed with @file.  Expand them into argv before processing.  */
 397   expandargv (&argc, &argv);
 398   gcc_argv = (char **) xcalloc (sizeof (char *), argc);
 399   gcc_argc = process_args (argc, argv, gcc_argv);
 400   run_gcc (gcc_argc, gcc_argv);
 401   free (gcc_argv);
 402
 403   return 0;
 404 }