This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] Canonicalize argument handling with lto-wrapper, fixup dumpfile regression


This fixes PR44143 again (ltrans dumps were in /tmp again with odd
names).  On the way it unifies xgcc argument processing to use
COLLECT_GCC_OPTIONS as we do everywhere else in gcc.  This makes
it no longer necessary to pass those to lto-wrapper again,
deleting all the -plugin-args specs processing (and on the way
also support -Wxxx).

Bootstrapped and tested on x86_64-unknown-linux-gnu, I verified
with and without -fuse-linker-plugin that the behavior is sane
and as wanted.

Ok for trunk?

Thanks,
Richard.

2010-05-18  Richard Guenther  <rguenther@suse.de>

	PR lto/44143
	* lto-wrapper.c (verbose): New variable.  Initialize from -v.
	(debug): Initialize from -save-temps.
	(collect_execute): Print command-line when verbose.
	(run_gcc): Always use COLLECT_GCC_OPTIONS.  Use fork_execute
	for ltrans invocation.  Produce -dumpbase flag again.
	(process_args): Remove.
	(main): Simplify.
	* collect2.c (maybe_run_lto_and_relink): Only pass object
	files to lto-wrapper.
	* gcc.c (LINK_COMMAND_SPEC): Likewise.

Index: gcc/lto-wrapper.c
===================================================================
*** gcc/lto-wrapper.c	(revision 159476)
--- gcc/lto-wrapper.c	(working copy)
*************** along with GCC; see the file COPYING3.
*** 45,56 ****
  #include "libiberty.h"
  #include "obstack.h"
  
! int debug;				/* true if -debug */
  
  enum lto_mode_d {
!   LTO_MODE_NONE,			/* Not doing LTO. */
!   LTO_MODE_LTO,				/* Normal LTO. */
!   LTO_MODE_WHOPR			/* WHOPR. */
  };
  
  /* Current LTO mode.  */
--- 45,57 ----
  #include "libiberty.h"
  #include "obstack.h"
  
! int debug;				/* true if -save-temps.  */
! int verbose;				/* true if -v.  */
  
  enum lto_mode_d {
!   LTO_MODE_NONE,			/* Not doing LTO.  */
!   LTO_MODE_LTO,				/* Normal LTO.  */
!   LTO_MODE_WHOPR			/* WHOPR.  */
  };
  
  /* Current LTO mode.  */
*************** collect_execute (char **argv)
*** 129,135 ****
    const char *errmsg;
    int err;
  
!   if (debug)
      {
        char **p_argv;
        const char *str;
--- 130,136 ----
    const char *errmsg;
    int err;
  
!   if (verbose)
      {
        char **p_argv;
        const char *str;
*************** fork_execute (char **argv)
*** 255,281 ****
  static void
  run_gcc (unsigned argc, char *argv[])
  {
!   unsigned i;
!   unsigned new_argc = argc;
    const char **new_argv;
    const char **argv_ptr;
    char *list_option_full = NULL;
  
!   new_argc += 12;
!   new_argv = (const char **) xcalloc (sizeof (char *), new_argc);
  
    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");
!       *argv_ptr++ = "-o";
!       *argv_ptr++ = flto_out;
      }
    else if (lto_mode == LTO_MODE_WHOPR)
      {
--- 256,373 ----
  static void
  run_gcc (unsigned argc, char *argv[])
  {
!   unsigned i, j;
    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;
+ 
+   /* 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 (strcmp (option, "-fwhopr") == 0)
+ 	  lto_mode = LTO_MODE_WHOPR;
+ 	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';
+ 
+       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--;
+ 
    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";
      }
    else if (lto_mode == LTO_MODE_WHOPR)
      {
*************** run_gcc (unsigned argc, char *argv[])
*** 283,362 ****
        size_t list_option_len = strlen (list_option);
        char *tmp;
  
        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++ = tmp;
        strcpy (tmp, list_option);
        tmp += list_option_len;
        strcpy (tmp, ltrans_output_file);
  
!       *argv_ptr++ = "-fwpa";
      }
    else
      fatal ("invalid LTO mode");
  
!   /* 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);
--- 375,412 ----
        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;
        strcpy (tmp, list_option);
        tmp += list_option_len;
        strcpy (tmp, ltrans_output_file);
  
!       argv_ptr[2] = "-fwpa";
!       argv_ptr[3] = "-combine";
      }
    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;
  
    fork_execute (CONST_CAST (char **, new_argv));
  
    if (lto_mode == LTO_MODE_LTO)
      {
        printf("%s\n", flto_out);
*************** run_gcc (unsigned argc, char *argv[])
*** 366,450 ****
    else if (lto_mode == LTO_MODE_WHOPR)
      {
        FILE *stream = fopen (ltrans_output_file, "r");
!       const char *collect_gcc_options, *collect_gcc;
!       struct obstack env_obstack;
!       bool seen_dumpbase = false;
!       bool seen_o = false;
!       char *dumpbase_suffix = NULL;
!       unsigned j;
  
        if (!stream)
  	fatal_perror ("fopen: %s", ltrans_output_file);
  
!       /* 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 (seen_o)
! 	      {
! 		seen_o = false;
! 		continue;
! 	      }
! 
! 	    /* If we see -o, skip it and its argument.  */
! 	    if (strncmp (option, "-o", 2) == 0)
! 	      {
! 		seen_o = true;
! 		continue;
! 	      }
! 
! 	    /* 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 (;;)
  	{
--- 416,427 ----
    else if (lto_mode == LTO_MODE_WHOPR)
      {
        FILE *stream = fopen (ltrans_output_file, "r");
!       int nr = 0;
  
        if (!stream)
  	fatal_perror ("fopen: %s", ltrans_output_file);
  
!       argv_ptr[1] = "-fltrans";
  
        for (;;)
  	{
*************** cont:
*** 473,483 ****
  	    }
  	  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.  */
  
--- 450,455 ----
*************** cont:
*** 488,531 ****
  	      obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
  	      output_name = XOBFINISH (&env_obstack, char *);
  
! 	      argv_ptr[0] = "-o";
! 	      argv_ptr[1] = output_name;
! 	      argv_ptr[2] = input_name;
! 	      argv_ptr[3] = NULL;
! 
! 	      /* Append a sequence number to -dumpbase for LTRANS.  */
! 	      if (dumpbase_suffix)
! 		snprintf (dumpbase_suffix, sizeof (DUMPBASE_SUFFIX) - 7,
! 			  "%lu", (unsigned long) i);
! 
! 	      /* 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)
  		{
! 		  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);
  		}
  
! 	      pex_free (pex);
  
  	      maybe_unlink_file (input_name);
  	    }
--- 460,482 ----
  	      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%d", linker_output, nr++);
! 		  argv_ptr[0] = dumpbase;
  		}
  
! 	      argv_ptr[2] = "-o";
! 	      argv_ptr[3] = output_name;
! 	      argv_ptr[4] = input_name;
! 	      argv_ptr[5] = NULL;
! 
! 	      fork_execute (CONST_CAST (char **, new_argv));
  
  	      maybe_unlink_file (input_name);
  	    }
*************** cont:
*** 536,573 ****
        fclose (stream);
        maybe_unlink_file (ltrans_output_file);
        free (list_option_full);
-       obstack_free (&env_obstack, NULL);
      }
    else
      fatal ("invalid LTO mode");
- }
- 
  
! /* 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;
  }
  
  
--- 487,497 ----
        fclose (stream);
        maybe_unlink_file (ltrans_output_file);
        free (list_option_full);
      }
    else
      fatal ("invalid LTO mode");
  
!   obstack_free (&env_obstack, NULL);
  }
  
  
*************** process_args (int argc, char *argv[], ch
*** 576,593 ****
  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);
!   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;
  }
--- 500,511 ----
  int
  main (int argc, char *argv[])
  {
    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);
  
    return 0;
  }
Index: gcc/collect2.c
===================================================================
*** gcc/collect2.c	(revision 159476)
--- gcc/collect2.c	(working copy)
*************** maybe_run_lto_and_relink (char **lto_ld_
*** 940,949 ****
  
    if (lto_objects.first)
      {
-       const char *opts;
        char **lto_c_argv;
        const char **lto_c_ptr;
-       const char *cp;
        const char **p, **q, **r;
        const char **lto_o_ptr;
        struct lto_object *list;
--- 940,947 ----
*************** maybe_run_lto_and_relink (char **lto_ld_
*** 954,1005 ****
        if (!lto_wrapper)
  	fatal ("COLLECT_LTO_WRAPPER must be set.");
  
        /* There is at least one object file containing LTO info,
           so we need to run the LTO back end and relink.  */
  
-       /* Get compiler options passed down from the parent `gcc' command.
-          These must be passed to the LTO back end.  */
-       opts = getenv ("COLLECT_GCC_OPTIONS");
- 
-       /* Increment the argument count by the number of inherited options.
-          Some arguments may be filtered out later.  Again, an upper bound
-          suffices.  */
- 
-       cp = opts;
- 
-       while (cp && *cp)
-         {
-           extract_string (&cp);
-           num_lto_c_args++;
-         }
-       obstack_free (&temporary_obstack, temporary_firstobj);
- 
-       if (debug)
- 	num_lto_c_args++;
- 
-       /* Increment the argument count by the number of initial
- 	 arguments added below.  */
-       num_lto_c_args += 9;
- 
        lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
        lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
  
        *lto_c_ptr++ = lto_wrapper;
-       *lto_c_ptr++ = c_file_name;
- 
-       cp = opts;
- 
-       while (cp && *cp)
-         {
-           const char *s = extract_string (&cp);
- 
- 	  /* Pass the option or argument to the wrapper.  */
- 	  *lto_c_ptr++ = xstrdup (s);
-         }
-       obstack_free (&temporary_obstack, temporary_firstobj);
- 
-       if (debug)
- 	*lto_c_ptr++ = xstrdup ("-debug");
  
        /* Add LTO objects to the wrapper command line.  */
        for (list = lto_objects.first; list; list = list->next)
--- 952,966 ----
        if (!lto_wrapper)
  	fatal ("COLLECT_LTO_WRAPPER must be set.");
  
+       num_lto_c_args++;
+ 
        /* There is at least one object file containing LTO info,
           so we need to run the LTO back end and relink.  */
  
        lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
        lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv);
  
        *lto_c_ptr++ = lto_wrapper;
  
        /* Add LTO objects to the wrapper command line.  */
        for (list = lto_objects.first; list; list = list->next)
Index: gcc/gcc.c
===================================================================
*** gcc/gcc.c	(revision 159476)
--- gcc/gcc.c	(working copy)
*************** proper position among the other output f
*** 781,795 ****
      %{fuse-linker-plugin: \
      -plugin %(linker_plugin_file) \
      -plugin-opt=%(lto_wrapper) \
-     -plugin-opt=%(lto_gcc) \
      -plugin-opt=-fresolution=%u.res \
      %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)}	\
      %{static:-plugin-opt=-pass-through=-lc}	\
-     %{O*:-plugin-opt=-O%*} \
-     %{w:-plugin-opt=-w} \
-     %{f*:-plugin-opt=-f%*} \
-     %{m*:-plugin-opt=-m%*} \
-     %{v:-plugin-opt=-v} \
      } \
      %{flto} %{fwhopr} %l " LINK_PIE_SPEC \
     "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
--- 781,789 ----


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]