OSDN Git Service

2010-05-07 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / lto-wrapper.c
index 3dbd96b..c9a37d9 100644 (file)
@@ -45,13 +45,12 @@ along with GCC; see the file COPYING3.  If not see
 #include "libiberty.h"
 #include "obstack.h"
 
-int debug;                             /* true if -save-temps.  */
-int verbose;                           /* true if -v.  */
+int debug;                             /* true if -debug */
 
 enum lto_mode_d {
-  LTO_MODE_NONE,                       /* Not doing LTO.  */
-  LTO_MODE_LTO,                                /* Normal LTO.  */
-  LTO_MODE_WHOPR                       /* WHOPR.  */
+  LTO_MODE_NONE,                       /* Not doing LTO. */
+  LTO_MODE_LTO,                                /* Normal LTO. */
+  LTO_MODE_WHOPR                       /* WHOPR. */
 };
 
 /* Current LTO mode.  */
@@ -130,7 +129,7 @@ collect_execute (char **argv)
   const char *errmsg;
   int err;
 
-  if (verbose)
+  if (debug)
     {
       char **p_argv;
       const char *str;
@@ -148,10 +147,7 @@ collect_execute (char **argv)
   if (pex == NULL)
     fatal_perror ("pex_init failed");
 
-  /* Do not use PEX_LAST here, we use our stdout for communicating with
-     collect2 or the linker-plugin.  Any output from the sub-process
-     will confuse that.  */
-  errmsg = pex_run (pex, PEX_SEARCH, argv[0], argv, NULL,
+  errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0], argv, NULL,
                    NULL, &err);
   if (errmsg != NULL)
     {
@@ -259,127 +255,27 @@ fork_execute (char **argv)
 static void
 run_gcc (unsigned argc, char *argv[])
 {
-  unsigned i, j;
+  unsigned i;
+  unsigned new_argc = argc;
   const char **new_argv;
   const char **argv_ptr;
   char *list_option_full = NULL;
-  const char *linker_output = NULL;
-  const char *collect_gcc_options, *collect_gcc;
-  struct obstack env_obstack;
-  bool seen_o = false;
-  int parallel = 0;
-
-  /* Get the driver and options.  */
-  collect_gcc = getenv ("COLLECT_GCC");
-  if (!collect_gcc)
-    fatal ("environment variable COLLECT_GCC must be set");
-
-  /* Set the CFLAGS environment variable.  */
-  collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
-  if (!collect_gcc_options)
-    fatal ("environment variable COLLECT_GCC_OPTIONS must be set");
-
-  /* Count arguments.  */
-  i = 0;
-  for (j = 0; collect_gcc_options[j] != '\0'; ++j)
-    if (collect_gcc_options[j] == '\'')
-      ++i;
-
-  if (i % 2 != 0)
-    fatal ("malformed COLLECT_GCC_OPTIONS");
-
-  /* Initalize the common arguments for the driver.  */
-  new_argv = (const char **) xmalloc ((15 + i / 2 + argc) * sizeof (char *));
-  argv_ptr = new_argv;
-  *argv_ptr++ = collect_gcc;
-  *argv_ptr++ = "-xlto";
-  *argv_ptr++ = "-c";
-  for (j = 0; collect_gcc_options[j] != '\0'; ++j)
-    if (collect_gcc_options[j] == '\'')
-      {
-       char *option;
-
-       ++j;
-       i = j;
-       while (collect_gcc_options[j] != '\'')
-         ++j;
-
-       obstack_init (&env_obstack);
-       obstack_grow (&env_obstack, &collect_gcc_options[i], j - i);
-       obstack_1grow (&env_obstack, 0);
-       option = XOBFINISH (&env_obstack, char *);
-       if (seen_o)
-         {
-           linker_output = option;
-           seen_o = false;
-           continue;
-         }
-
-       /* If we see -o, skip it and skip and record its argument.  */
-       if (option[0] == '-' && option[1] == 'o')
-         {
-           if (option[2] == '\0')
-             seen_o = true;
-           else
-             linker_output = &option[2];
-           continue;
-         }
-
-       if (strcmp (option, "-save-temps") == 0)
-         debug = 1;
-       if (strcmp (option, "-v") == 0)
-         verbose = 1;
-
-       /* We've handled these LTO options, do not pass them on.  */
-       if (strcmp (option, "-flto") == 0)
-         lto_mode = LTO_MODE_LTO;
-       else if (strncmp (option, "-fwhopr", 7) == 0)
-         {
-           lto_mode = LTO_MODE_WHOPR;
-           if (option[7] == '=')
-             {
-               parallel = atoi (option+8);
-               if (parallel <= 1)
-                 parallel = 0;
-             }
-         }
-       else
-         *argv_ptr++ = option;
-      }
-
-  if (linker_output)
-    {
-      char *output_dir, *base, *name;
 
-      output_dir = xstrdup (linker_output);
-      base = output_dir;
-      for (name = base; *name; name++)
-       if (IS_DIR_SEPARATOR (*name))
-         base = name + 1;
-      *base = '\0';
+  new_argc += 12;
+  new_argv = (const char **) xcalloc (sizeof (char *), new_argc);
 
-      linker_output = &linker_output[base - output_dir];
-      if (*output_dir == '\0')
-       {
-         static char current_dir[] = { '.', DIR_SEPARATOR, '\0' };
-         output_dir = current_dir;
-       }
-      *argv_ptr++ = "-dumpdir";
-      *argv_ptr++ = output_dir;
-
-      *argv_ptr++ = "-dumpbase";
-    }
-  else
-    argv_ptr--;
+  argv_ptr = new_argv;
 
+  *argv_ptr++ = argv[0];
+  *argv_ptr++ = "-combine";
+  *argv_ptr++ = "-x";
+  *argv_ptr++ = "lto";
+  *argv_ptr++ = "-c";
   if (lto_mode == LTO_MODE_LTO)
     {
       flto_out = make_temp_file (".lto.o");
-      if (linker_output)
-       argv_ptr[0] = linker_output;
-      argv_ptr[1] = "-o";
-      argv_ptr[2] = flto_out;
-      argv_ptr[3] = "-combine";
+      *argv_ptr++ = "-o";
+      *argv_ptr++ = flto_out;
     }
   else if (lto_mode == LTO_MODE_WHOPR)
     {
@@ -387,38 +283,80 @@ run_gcc (unsigned argc, char *argv[])
       size_t list_option_len = strlen (list_option);
       char *tmp;
 
-      if (linker_output)
-       {
-         char *dumpbase = (char *) xmalloc (strlen (linker_output)
-                                            + sizeof(".wpa") + 1);
-         strcpy (dumpbase, linker_output);
-         strcat (dumpbase, ".wpa");
-         argv_ptr[0] = dumpbase;
-       }
-
       ltrans_output_file = make_temp_file (".ltrans.out");
       list_option_full = (char *) xmalloc (sizeof (char) *
                         (strlen (ltrans_output_file) + list_option_len + 1));
       tmp = list_option_full;
 
-      argv_ptr[1] = tmp;
+      *argv_ptr++ = tmp;
       strcpy (tmp, list_option);
       tmp += list_option_len;
       strcpy (tmp, ltrans_output_file);
 
-      argv_ptr[2] = "-fwpa";
-      argv_ptr[3] = "-combine";
+      *argv_ptr++ = "-fwpa";
     }
   else
     fatal ("invalid LTO mode");
 
-  /* Append the input objects and possible preceeding arguments.  */
-  for (i = 1; i < argc; ++i)
-    argv_ptr[3 + i] = argv[i];
-  argv_ptr[3 + i] = NULL;
+  /* Add inherited GCC options to the LTO back end command line.
+     Filter out some obviously inappropriate options that will
+     conflict with  the options that we force above.  We pass
+     all of the remaining options on to LTO, and let it complain
+     about any it doesn't like. Note that we invoke LTO via the
+     `gcc' driver, so the usual option processing takes place.
+     Except for `-flto' and `-fwhopr', we should only filter options that
+     are meaningful to `ld', lest an option go silently unclaimed.  */
+  for (i = 1; i < argc; i++)
+    {
+      const char *s = argv[i];
+
+      if (strcmp (s, "-flto") == 0 || strcmp (s, "-fwhopr") == 0)
+       /* We've handled this LTO option, don't pass it on.  */
+       ;
+      else if (*s == '-' && s[1] == 'o')
+       {
+         /* Drop `-o' and its filename argument.  We will use a
+            temporary file for the LTO output.  The `-o' option
+            will be interpreted by the linker.  */
+         if (s[2] == '\0')
+           {
+             char *output_dir, *base, *name;
+
+             i++;
+             output_dir = xstrdup (argv[i]);
+             base = output_dir;
+             for (name = base; *name; name++)
+               if (IS_DIR_SEPARATOR (*name))
+                 base = name + 1;
+             *base = '\0';
+
+             *argv_ptr++ = "-dumpbase";
+             if (*output_dir == '\0')
+               {
+                 static char current_dir[] =
+                   { '.', DIR_SEPARATOR, '\0' };
+                 output_dir = current_dir;
+                 *argv_ptr++ = argv[i];
+               }
+             else
+               *argv_ptr++ = &argv[i][base - output_dir];
+
+             *argv_ptr++ = "-dumpdir";
+             *argv_ptr++ = output_dir;
+           }
+       }
+      else
+       /* Pass the option or argument to LTO.  */
+       *argv_ptr++ = s;
+    }
+
+  *argv_ptr = NULL;
 
   fork_execute (CONST_CAST (char **, new_argv));
 
+  free (new_argv);
+  new_argv = NULL;
+
   if (lto_mode == LTO_MODE_LTO)
     {
       printf("%s\n", flto_out);
@@ -428,22 +366,72 @@ run_gcc (unsigned argc, char *argv[])
   else if (lto_mode == LTO_MODE_WHOPR)
     {
       FILE *stream = fopen (ltrans_output_file, "r");
-      unsigned int nr = 0;
-      char **input_names = NULL;
-      char **output_names = NULL;
-      char *makefile = NULL;
-      FILE *mstream = NULL;
+      const char *collect_gcc_options, *collect_gcc;
+      struct obstack env_obstack;
+      bool seen_dumpbase = false;
+      char *dumpbase_suffix = NULL;
+      unsigned j;
 
       if (!stream)
        fatal_perror ("fopen: %s", ltrans_output_file);
 
-      argv_ptr[1] = "-fltrans";
+      /* Get the driver and options.  */
+      collect_gcc = getenv ("COLLECT_GCC");
+      if (!collect_gcc)
+       fatal ("environment variable COLLECT_GCC must be set");
+
+      /* Set the CFLAGS environment variable.  */
+      collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
+      if (!collect_gcc_options)
+       fatal ("environment variable COLLECT_GCC_OPTIONS must be set");
+
+      /* Count arguments.  */
+      i = 0;
+      for (j = 0; collect_gcc_options[j] != '\0'; ++j)
+       if (collect_gcc_options[j] == '\'')
+         ++i;
+
+      if (i % 2 != 0)
+       fatal ("malformed COLLECT_GCC_OPTIONS");
+
+      /* Initalize the arguments for the LTRANS driver.  */
+      new_argv = (const char **) xmalloc ((8 + i / 2) * sizeof (char *));
+      argv_ptr = new_argv;
+      *argv_ptr++ = collect_gcc;
+      *argv_ptr++ = "-xlto";
+      *argv_ptr++ = "-c";
+      for (j = 0; collect_gcc_options[j] != '\0'; ++j)
+       if (collect_gcc_options[j] == '\'')
+         {
+           char *option;
+
+           ++j;
+           i = j;
+           while (collect_gcc_options[j] != '\'')
+             ++j;
+           obstack_init (&env_obstack);
+           obstack_grow (&env_obstack, &collect_gcc_options[i], j - i);
+           if (seen_dumpbase)
+             obstack_grow (&env_obstack, DUMPBASE_SUFFIX,
+                           sizeof (DUMPBASE_SUFFIX));
+           else
+             obstack_1grow (&env_obstack, 0);
+           option = XOBFINISH (&env_obstack, char *);
+           if (seen_dumpbase)
+             {
+               dumpbase_suffix = option + 7 + j - i;
+               seen_dumpbase = false;
+             }
 
-      if (parallel)
-       {
-         makefile = make_temp_file (".mk");
-         mstream = fopen (makefile, "w");
-       }
+           /* LTRANS does not need -fwhopr.  */
+           if (strncmp (option, "-fwhopr", 7) != 0)
+             {
+               if (strncmp (option, "-dumpbase", 9) == 0)
+                 seen_dumpbase = true;
+               *argv_ptr++ = option;
+             }
+         }
+      *argv_ptr++ = "-fltrans";
 
       for (;;)
        {
@@ -466,9 +454,17 @@ cont:
          input_name[len - 1] = '\0';
 
          if (input_name[0] == '*')
-           output_name = &input_name[1];
+           {
+             continue;
+             output_name = &input_name[1];
+           }
          else
            {
+             struct pex_obj *pex;
+             const char *errmsg;
+             int err;
+             int status;
+
              /* Otherwise, add FILES[I] to lto_execute_ltrans command line
                 and add the resulting file to LTRANS output list.  */
 
@@ -479,76 +475,86 @@ cont:
              obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
              output_name = XOBFINISH (&env_obstack, char *);
 
-             if (linker_output)
-               {
-                 char *dumpbase
-                   = (char *) xmalloc (strlen (linker_output)
-                                       + sizeof(DUMPBASE_SUFFIX) + 1);
-                 snprintf (dumpbase,
-                           strlen (linker_output) + sizeof(DUMPBASE_SUFFIX),
-                           "%s.ltrans%u", linker_output, nr);
-                 argv_ptr[0] = dumpbase;
-               }
+             argv_ptr[0] = "-o";
+             argv_ptr[1] = output_name;
+             argv_ptr[2] = input_name;
+             argv_ptr[3] = NULL;
 
-             argv_ptr[2] = "-o";
-             argv_ptr[3] = output_name;
-             argv_ptr[4] = input_name;
-             argv_ptr[5] = NULL;
+             /* Append a sequence number to -dumpbase for LTRANS.  */
+             if (dumpbase_suffix)
+               snprintf (dumpbase_suffix, sizeof (DUMPBASE_SUFFIX) - 7,
+                         "%lu", (unsigned long) i);
 
-             if (parallel)
+             /* Execute the driver.  */
+             pex = pex_init (0, "lto1", NULL);
+             if (pex == NULL)
+               fatal ("pex_init failed: %s", xstrerror (errno));
+
+             errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, new_argv[0],
+                               CONST_CAST (char **, new_argv),
+                               NULL, NULL, &err);
+             if (errmsg)
+               fatal ("%s: %s", errmsg, xstrerror (err));
+
+             if (!pex_get_status (pex, 1, &status))
+               fatal ("can't get program status: %s", xstrerror (errno));
+
+             if (status)
                {
-                 fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]);
-                 for (i = 1; new_argv[i] != NULL; ++i)
-                   fprintf (mstream, " '%s'", new_argv[i]);
-                 fprintf (mstream, "\n");
+                 if (WIFSIGNALED (status))
+                   {
+                     int sig = WTERMSIG (status);
+                     fatal ("%s terminated with signal %d [%s]%s",
+                            new_argv[0], sig, strsignal (sig),
+                            WCOREDUMP (status) ? ", core dumped" : "");
+                   }
+                 else
+                   fatal ("%s terminated with status %d", new_argv[0], status);
                }
-             else
-               fork_execute (CONST_CAST (char **, new_argv));
+
+             pex_free (pex);
+
+             maybe_unlink_file (input_name);
            }
 
-         nr++;
-         input_names = (char **)xrealloc (input_names, nr * sizeof (char *));
-         output_names = (char **)xrealloc (output_names, nr * sizeof (char *));
-         input_names[nr-1] = input_name;
-         output_names[nr-1] = output_name;
-       }
-      if (parallel)
-       {
-         struct pex_obj *pex;
-         char jobs[32];
-         fprintf (mstream, "all:");
-         for (i = 0; i < nr; ++i)
-           fprintf (mstream, " \\\n\t%s", output_names[i]);
-         fprintf (mstream, "\n");
-         fclose (mstream);
-         new_argv[0] = "make";
-         new_argv[1] = "-f";
-         new_argv[2] = makefile;
-         snprintf (jobs, 31, "-j%d", parallel);
-         new_argv[3] = jobs;
-         new_argv[4] = "all";
-         new_argv[5] = NULL;
-         pex = collect_execute (CONST_CAST (char **, new_argv));
-         collect_wait (new_argv[0], pex);
-         maybe_unlink_file (makefile);
-       }
-      for (i = 0; i < nr; ++i)
-       {
-         fputs (output_names[i], stdout);
+         fputs (output_name, stdout);
          putc ('\n', stdout);
-         maybe_unlink_file (input_names[i]);
-         free (input_names[i]);
        }
-      free (output_names);
-      free (input_names);
       fclose (stream);
       maybe_unlink_file (ltrans_output_file);
       free (list_option_full);
+      obstack_free (&env_obstack, NULL);
     }
   else
     fatal ("invalid LTO mode");
+}
+
 
-  obstack_free (&env_obstack, NULL);
+/* Parse the command line. Copy any unused argument to GCC_ARGV. ARGC is the
+   number of arguments. ARGV contains the arguments. */
+
+static int
+process_args (int argc, char *argv[], char *gcc_argv[])
+{
+  int i;
+  int j = 0;
+
+  for (i = 1; i < argc; i ++)
+    {
+      if (! strcmp (argv[i], "-debug"))
+       debug = 1;
+      else if (! strcmp (argv[i], "-flto"))
+       lto_mode = LTO_MODE_LTO;
+      else if (! strcmp (argv[i], "-fwhopr"))
+       lto_mode = LTO_MODE_WHOPR;
+      else
+       {
+         gcc_argv[j] = argv[i];
+         j++;
+       }
+    }
+
+  return j;
 }
 
 
@@ -557,12 +563,18 @@ cont:
 int
 main (int argc, char *argv[])
 {
+  char **gcc_argv;
+  int gcc_argc;
+
   gcc_init_libintl ();
 
   /* We may be called with all the arguments stored in some file and
      passed with @file.  Expand them into argv before processing.  */
   expandargv (&argc, &argv);
-  run_gcc (argc, argv);
+  gcc_argv = (char **) xcalloc (sizeof (char *), argc);
+  gcc_argc = process_args (argc, argv, gcc_argv);
+  run_gcc (gcc_argc, gcc_argv);
+  free (gcc_argv);
 
   return 0;
 }