Re: [PATCH][RFC] Re-write LTO option merging

[Richard Guenther <rguenther at suse dot de>]

On Wed, 26 Oct 2011, Richard Guenther wrote:

> 
> This completely rewrites LTO option merging.  At compile (uselessly
> now at WPA?) time we now stream a COLLECT_GCC_OPTIONS like string
> as it comes from argv of the compiler binary.  Those options are
> read in by the LTO driver (lto-wrapper), merged into a single
> set (very simple merge function right now ;)) and given a place to
> complain about incompatible arguments.  The merged set is then
> prepended to the arguments from the linker driver line
> (what we get in COLLECT_GCC_OPTIONS for lto-wrapper), thus the
> linker command-line may override what the compiler command-line(s)
> provided.
> 
> One visible change is that no optimization option on the link line
> no longer means -O0, unless you explicitly specify -O0 at link time.
> 
> There are probably more obscure differences, especially due to the
> very simple merge and complain function ;))  But this is a RFC ...
> 
> If WPA partitioning at any point wants to do something clever with
> a set of incompatible functions it can re-parse the options and
> do that (we then have to arrange for lto-wrapper to let the options
> slip through).
> 
> I'm LTO bootstrapping and testing this simple variant right now
> (I believe we do not excercise funny option combinations right now).
> 
> I'll still implement a very simple merge/complain function.
> Suggestions for that welcome (I'll probably simply compute the
> intersection of options ... in the long run we'd want to annotate
> our options as to whether they should be unioned/intersected).
> 
> Any comments?

Btw, the following is a variant that actually passes LTO bootstrap
without miscompares in the LTO option sections.

Richard.

2011-10-26  Richard Guenther  <rguenther@suse.de>

	* lto-opts.c: Re-implement.
	* lto-streamer.h (lto_register_user_option): Remove.
	(lto_read_file_options): Likewise.
	(lto_reissue_options): Likewise.
	(lto_clear_user_options): Likewise.
	(lto_clear_file_options): Likewise.
	* opts-global.c (post_handling_callback): Remove LTO specific code.
	(decode_options): Likewise.
	* lto-wrapper.c (merge_and_complain): New function.
	(run_gcc): Read all input file options and
	prepend a merged set before the linker driver options.

	lto/
	* lto-lang.c (lto_post_options): Do not read file options.
	* lto.c (lto_read_all_file_options): Remove.
	(lto_init): Call lto_set_in_hooks here.


Index: trunk/gcc/lto-opts.c
===================================================================
*** trunk.orig/gcc/lto-opts.c	2011-10-26 13:46:24.000000000 +0200
--- trunk/gcc/lto-opts.c	2011-10-26 16:26:20.000000000 +0200
***************
*** 1,6 ****
  /* LTO IL options.
  
!    Copyright 2009, 2010, 2011 Free Software Foundation, Inc.
     Contributed by Simon Baldwin <simonb@google.com>
  
  This file is part of GCC.
--- 1,6 ----
  /* LTO IL options.
  
!    Copyright 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
     Contributed by Simon Baldwin <simonb@google.com>
  
  This file is part of GCC.
*************** along with GCC; see the file COPYING3.
*** 33,422 ****
  #include "common/common-target.h"
  #include "diagnostic.h"
  #include "lto-streamer.h"
! 
! /* When a file is initially compiled, the options used when generating
!    the IL are not necessarily the same as those used when linking the
!    objects into the final executable.  In general, most build systems
!    will proceed with something along the lines of:
! 
!    	$ gcc <cc-flags> -flto -c f1.c -o f1.o
! 	$ gcc <cc-flags> -flto -c f2.c -o f2.o
! 	...
! 	$ gcc <cc-flags> -flto -c fN.c -o fN.o
! 
!    And the final link may or may not include the same <cc-flags> used
!    to generate the initial object files:
! 
!    	$ gcc <ld-flags> -flto -o prog f1.o ... fN.o
! 
!    Since we will be generating final code during the link step, some
!    of the flags used during the compile step need to be re-applied
!    during the link step.  For instance, flags in the -m family.
! 
!    The idea is to save a selected set of <cc-flags> in a special
!    section of the initial object files.  This section is then read
!    during linking and the options re-applied.
! 
!    FIXME lto.  Currently the scheme is limited in that only the
!    options saved on the first object file (f1.o) are read back during
!    the link step.  This means that the options used to compile f1.o
!    will be applied to ALL the object files in the final link step.
!    More work needs to be done to implement a merging and validation
!    mechanism, as this will not be enough for all cases.  */
! 
! /* Saved options hold the type of the option (currently CL_TARGET or
!    CL_COMMON), and the code, argument, and value.  */
! 
! typedef struct GTY(()) opt_d
! {
!   unsigned int type;
!   size_t code;
!   char *arg;
!   int value;
! } opt_t;
! 
! DEF_VEC_O (opt_t);
! DEF_VEC_ALLOC_O (opt_t, heap);
! 
! 
! /* Options are held in two vectors, one for those registered by
!    command line handling code, and the other for those read in from
!    any LTO IL input.  */
! static VEC(opt_t, heap) *user_options = NULL;
! static VEC(opt_t, heap) *file_options = NULL;
! 
! /* Iterate FROM in reverse, writing option codes not yet in CODES into *TO.
!    Mark each new option code encountered in CODES.  */
! 
! static void
! reverse_iterate_options (VEC(opt_t, heap) *from, VEC(opt_t, heap) **to,
! 			 bitmap codes)
! {
!   int i;
! 
!   for (i = VEC_length (opt_t, from); i > 0; i--)
!     {
!       const opt_t *const o = VEC_index (opt_t, from, i - 1);
! 
!       if (bitmap_set_bit (codes, o->code))
! 	VEC_safe_push (opt_t, heap, *to, o);
!     }
! }
! 
! /* Concatenate options vectors FIRST and SECOND, rationalize so that only the
!    final of any given option remains, and return the result.  */
! 
! static VEC(opt_t, heap) *
! concatenate_options (VEC(opt_t, heap) *first, VEC(opt_t, heap) *second)
! {
!   VEC(opt_t, heap) *results = NULL;
!   bitmap codes = lto_bitmap_alloc ();
! 
!   reverse_iterate_options (second, &results, codes);
!   reverse_iterate_options (first, &results, codes);
! 
!   lto_bitmap_free (codes);
!   return results;
! }
! 
! /* Clear the options vector in *OPTS_P and set it to NULL.  */
! 
! static void
! clear_options (VEC(opt_t, heap) **opts_p)
! {
!   int i;
!   opt_t *o;
! 
!   FOR_EACH_VEC_ELT (opt_t, *opts_p, i, o)
!     free (o->arg);
! 
!   VEC_free (opt_t, heap, *opts_p);
! }
! 
! /* Write LENGTH bytes from ADDR to STREAM.  */
! 
! static void
! output_data_stream (struct lto_output_stream *stream,
!                     const void *addr, size_t length)
! {
!   lto_output_data_stream (stream, addr, length);
! }
! 
! /* Write string STRING to STREAM.  */
! 
! static void
! output_string_stream (struct lto_output_stream *stream, const char *string)
! {
!   bool flag = false;
! 
!   if (string != NULL)
!     {
!       const size_t length = strlen (string);
! 
!       flag = true;
!       output_data_stream (stream, &flag, sizeof (flag));
!       output_data_stream (stream, &length, sizeof (length));
!       output_data_stream (stream, string, length);
!     }
!   else
!     output_data_stream (stream, &flag, sizeof (flag));
! }
! 
! /* Return a string from IB.  The string is allocated, and the caller is
!    responsible for freeing it.  */
! 
! static char *
! input_string_block (struct lto_input_block *ib)
! {
!   bool flag;
! 
!   lto_input_data_block (ib, &flag, sizeof (flag));
!   if (flag)
!     {
!       size_t length;
!       char *string;
! 
!       lto_input_data_block (ib, &length, sizeof (length));
!       string = (char *) xcalloc (1, length + 1);
!       lto_input_data_block (ib, string, length);
! 
!       return string;
!     }
!   else
!     return NULL;
! }
! 
! /* Return true if this option is one we need to save in LTO output files.
!    At present, we pass along all target options, and common options that
!    involve position independent code.
! 
!    TODO This list of options requires expansion and rationalization.
!    Among others, optimization options may well be appropriate here.  */
! 
! static bool
! register_user_option_p (size_t code, unsigned int type)
! {
!   if (type == CL_TARGET)
!     return true;
!   else if (type == CL_COMMON)
!     {
!       return (code == OPT_fPIC
! 	      || code == OPT_fpic
! 	      || code == OPT_fPIE
! 	      || code == OPT_fpie
! 	      || code == OPT_fcommon
! 	      || code == OPT_fexceptions);
!     }
! 
!   return false;
! }
! 
! /* Note command line option with the given TYPE and CODE, ARG, and VALUE.
!    If relevant to LTO, save it in the user options vector.  */
! 
! void
! lto_register_user_option (size_t code, const char *arg, int value,
! 			  unsigned int type)
! {
!   if (register_user_option_p (code, type))
!     {
!       opt_t o;
! 
!       o.type = type;
!       o.code = code;
!       if (arg != NULL)
! 	{
! 	  o.arg = (char *) xmalloc (strlen (arg) + 1);
! 	  strcpy (o.arg, arg);
! 	}
!       else
! 	o.arg = NULL;
!       o.value = value;
!       VEC_safe_push (opt_t, heap, user_options, &o);
!     }
! }
! 
! /* Empty the saved user options vector.  */
! 
! void
! lto_clear_user_options (void)
! {
!   clear_options (&user_options);
! }
! 
! /* Empty the saved file options vector.  */
! 
! void
! lto_clear_file_options (void)
! {
!   clear_options (&file_options);
! }
! 
! /* Concatenate the user options and any file options read from an LTO IL
!    file, and serialize them to STREAM.  File options precede user options
!    so that the latter override the former when reissued.  */
! 
! static void
! output_options (struct lto_output_stream *stream)
! {
!   VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
!   const size_t length = VEC_length (opt_t, opts);
!   int i;
!   opt_t *o;
! 
!   output_data_stream (stream, &length, sizeof (length));
! 
!   FOR_EACH_VEC_ELT (opt_t, opts, i, o)
!     {
!       output_data_stream (stream, &o->type, sizeof (o->type));
!       output_data_stream (stream, &o->code, sizeof (o->code));
!       output_string_stream (stream, o->arg);
!       output_data_stream (stream, &o->value, sizeof (o->value));
!     }
! 
!   VEC_free (opt_t, heap, opts);
! }
  
  /* Write currently held options to an LTO IL section.  */
  
  void
  lto_write_options (void)
  {
-   char *const section_name = lto_get_section_name (LTO_section_opts, NULL, NULL);
    struct lto_output_stream stream;
!   struct lto_simple_header header;
!   struct lto_output_stream *header_stream;
! 
!   /* Targets and languages can provide defaults for -fexceptions but
!      we only process user options from the command-line.  Until we
!      serialize out a white list of options from the new global state
!      explicitly append important options as user options here.  */
!   if (flag_exceptions)
!     lto_register_user_option (OPT_fexceptions, NULL, 1, CL_COMMON);
! 
!   lto_begin_section (section_name, !flag_wpa);
!   free (section_name);
  
    memset (&stream, 0, sizeof (stream));
-   output_options (&stream);
- 
-   memset (&header, 0, sizeof (header));
-   header.lto_header.major_version = LTO_major_version;
-   header.lto_header.minor_version = LTO_minor_version;
-   header.lto_header.section_type = LTO_section_opts;
- 
-   header.compressed_size = 0;
-   header.main_size = stream.total_size;
- 
-   header_stream = ((struct lto_output_stream *)
- 		   xcalloc (1, sizeof (*header_stream)));
-   lto_output_data_stream (header_stream, &header, sizeof (header));
-   lto_write_stream (header_stream);
-   free (header_stream);
  
!   lto_write_stream (&stream);
!   lto_end_section ();
! }
! 
! /* Unserialize an options vector from IB, and append to file_options.  */
! 
! static void
! input_options (struct lto_input_block *ib)
! {
!   size_t length, i;
! 
!   lto_input_data_block (ib, &length, sizeof (length));
! 
!   for (i = 0; i < length; i++)
      {
!       opt_t o;
! 
!       lto_input_data_block (ib, &o.type, sizeof (o.type));
!       lto_input_data_block (ib, &o.code, sizeof (o.code));
!       o.arg = input_string_block (ib);
!       lto_input_data_block (ib, &o.value, sizeof (o.value));
!       VEC_safe_push (opt_t, heap, file_options, &o);
!     }
! }
! 
! /* Read options from an LTO IL section.  */
! 
! void
! lto_read_file_options (struct lto_file_decl_data *file_data)
! {
!   size_t len, l, skip;
!   const char *data, *p;
!   const struct lto_simple_header *header;
!   int32_t opts_offset;
!   struct lto_input_block ib;
! 
!   data = lto_get_section_data (file_data, LTO_section_opts, NULL, &len);
!   if (!data)
! 	  return;
! 
!   /* Option could be multiple sections merged (through ld -r) 
!      Keep reading all options.  This is ok right now because
!      the options just get mashed together anyways.
!      This will have to be done differently once lto-opts knows
!      how to associate options with different files. */
!   l = len;
!   p = data;
!   do 
!     { 
!       header = (const struct lto_simple_header *) p;
!       opts_offset = sizeof (*header);
! 
!       lto_check_version (header->lto_header.major_version,
! 			 header->lto_header.minor_version);
!       
!       LTO_INIT_INPUT_BLOCK (ib, p + opts_offset, 0, header->main_size);
!       input_options (&ib);
!       
!       skip = header->main_size + opts_offset;
!       l -= skip;
!       p += skip;
!     } 
!   while (l > 0);
! 
!   lto_free_section_data (file_data, LTO_section_opts, 0, data, len);
! }
  
! /* Concatenate the user options and any file options read from an LTO IL
!    file, and reissue them as if all had just been read in from the command
!    line.  As with serialization, file options precede user options.  */
  
! void
! lto_reissue_options (void)
! {
!   VEC(opt_t, heap) *opts = concatenate_options (file_options, user_options);
!   int i;
!   opt_t *o;
  
!   FOR_EACH_VEC_ELT (opt_t, opts, i, o)
!     {
!       void *flag_var = option_flag_var (o->code, &global_options);
  
!       if (flag_var)
! 	set_option (&global_options, &global_options_set,
! 		    o->code, o->value, o->arg,
! 		    DK_UNSPECIFIED, UNKNOWN_LOCATION, global_dc);
  
!       if (o->type == CL_TARGET)
  	{
! 	  struct cl_decoded_option decoded;
! 	  generate_option (o->code, o->arg, o->value, CL_TARGET, &decoded);
! 	  targetm_common.handle_option (&global_options, &global_options_set,
! 					&decoded, UNKNOWN_LOCATION);
  	}
-       else if (o->type == CL_COMMON)
- 	gcc_assert (flag_var);
-       else
- 	gcc_unreachable ();
      }
  
!   /* Flag_shlib is usually set by finish_options, but we are issuing flag_pic
!      too late.  */
!   if (flag_pic && !flag_pie)
!     flag_shlib = 1;
!   VEC_free (opt_t, heap, opts);
  }
--- 33,116 ----
  #include "common/common-target.h"
  #include "diagnostic.h"
  #include "lto-streamer.h"
! #include "toplev.h"
  
  /* Write currently held options to an LTO IL section.  */
  
  void
  lto_write_options (void)
  {
    struct lto_output_stream stream;
!   char *section_name;
!   struct obstack temporary_obstack;
!   unsigned int i, j;
!   char *args;
  
+   section_name = lto_get_section_name (LTO_section_opts, NULL, NULL);
+   lto_begin_section (section_name, false);
    memset (&stream, 0, sizeof (stream));
  
!   obstack_init (&temporary_obstack);
!   for (i = 1; i < save_decoded_options_count; ++i)
      {
!       struct cl_decoded_option *option = &save_decoded_options[i];
!       const char *q, *p;
  
!       /* Skip frontend and driver specific options here.  */
!       if (!(cl_options[option->opt_index].flags & (CL_COMMON|CL_TARGET)))
! 	continue;
! 
!       /* Drop arguments created from the gcc driver that will be rejected
! 	 when passed on.  */
!       if (cl_options[option->opt_index].cl_reject_driver)
! 	continue;
  
!       /* Skip explicitly some common options that we do not need.  */
!       switch (option->opt_index)
! 	{
! 	case OPT_o:
! 	case OPT_dumpbase:
! 	case OPT_SPECIAL_input_file:
! 	  continue;
  
! 	default:
! 	  break;
! 	}
  
!       if (i != 1)
! 	obstack_grow (&temporary_obstack, " ", 1);
!       obstack_grow (&temporary_obstack, "'", 1);
!       q = option->canonical_option[0];
!       while ((p = strchr (q, '\'')))
! 	{
! 	  obstack_grow (&temporary_obstack, q, p - q);
! 	  obstack_grow (&temporary_obstack, "'\\''", 4);
! 	  q = ++p;
! 	}
!       obstack_grow (&temporary_obstack, q, strlen (q));
!       obstack_grow (&temporary_obstack, "'", 1);
  
!       for (j = 1; j < option->canonical_option_num_elements; ++j)
  	{
! 	  obstack_grow (&temporary_obstack, " '", 2);
! 	  q = option->canonical_option[j];
! 	  while ((p = strchr (q, '\'')))
! 	    {
! 	      obstack_grow (&temporary_obstack, q, p - q);
! 	      obstack_grow (&temporary_obstack, "'\\''", 4);
! 	      q = ++p;
! 	    }
! 	  obstack_grow (&temporary_obstack, q, strlen (q));
! 	  obstack_grow (&temporary_obstack, "'", 1);
  	}
      }
+   obstack_grow (&temporary_obstack, "\0", 1);
+   args = XOBFINISH (&temporary_obstack, char *);
+   lto_output_data_stream (&stream, args, strlen (args) + 1);
  
!   lto_write_stream (&stream);
!   lto_end_section ();
! 
!   obstack_free (&temporary_obstack, NULL);
!   free (section_name);
  }
Index: trunk/gcc/lto-streamer.h
===================================================================
*** trunk.orig/gcc/lto-streamer.h	2011-10-26 13:46:24.000000000 +0200
--- trunk/gcc/lto-streamer.h	2011-10-26 14:35:45.000000000 +0200
*************** extern GTY(()) VEC(tree,gc) *lto_global_
*** 882,893 ****
  
  
  /* In lto-opts.c.  */
- extern void lto_register_user_option (size_t, const char *, int, unsigned int);
- extern void lto_read_file_options (struct lto_file_decl_data *);
  extern void lto_write_options (void);
- extern void lto_reissue_options (void);
- void lto_clear_user_options (void);
- void lto_clear_file_options (void);
  
  
  /* In lto-wpa-fixup.c  */
--- 882,888 ----
Index: trunk/gcc/lto/lto-lang.c
===================================================================
*** trunk.orig/gcc/lto/lto-lang.c	2011-10-26 13:46:24.000000000 +0200
--- trunk/gcc/lto/lto-lang.c	2011-10-26 13:48:42.000000000 +0200
*************** lto_post_options (const char **pfilename
*** 692,699 ****
       support.  */
    flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
  
-   lto_read_all_file_options ();
- 
    /* Initialize the compiler back end.  */
    return false;
  }
--- 692,697 ----
Index: trunk/gcc/lto/lto.c
===================================================================
*** trunk.orig/gcc/lto/lto.c	2011-10-26 13:46:24.000000000 +0200
--- trunk/gcc/lto/lto.c	2011-10-26 13:48:42.000000000 +0200
*************** lto_fixup_decls (struct lto_file_decl_da
*** 2494,2553 ****
      }
  }
  
- /* Read the options saved from each file in the command line.  Called
-    from lang_hooks.post_options which is called by process_options
-    right before all the options are used to initialize the compiler.
-    This assumes that decode_options has already run, so the
-    num_in_fnames and in_fnames are properly set.
- 
-    Note that this assumes that all the files had been compiled with
-    the same options, which is not a good assumption.  In general,
-    options ought to be read from all the files in the set and merged.
-    However, it is still unclear what the merge rules should be.  */
- 
- void
- lto_read_all_file_options (void)
- {
-   size_t i;
- 
-   /* Clear any file options currently saved.  */
-   lto_clear_file_options ();
- 
-   /* Set the hooks to read ELF sections.  */
-   lto_set_in_hooks (NULL, get_section_data, free_section_data);
-   if (!quiet_flag)
-     fprintf (stderr, "Reading command line options:");
- 
-   for (i = 0; i < num_in_fnames; i++)
-     {
-       struct lto_file_decl_data *file_data;
-       lto_file *file = lto_obj_file_open (in_fnames[i], false);
-       if (!file)
- 	break;
-       if (!quiet_flag)
- 	{
- 	  fprintf (stderr, " %s", in_fnames[i]);
- 	  fflush (stderr);
- 	}
- 
-       file_data = XCNEW (struct lto_file_decl_data);
-       file_data->file_name = file->filename;
-       file_data->section_hash_table = lto_obj_build_section_table (file, NULL);
- 
-       lto_read_file_options (file_data);
- 
-       lto_obj_file_close (file);
-       htab_delete (file_data->section_hash_table);
-       free (file_data);
-     }
- 
-   if (!quiet_flag)
-     fprintf (stderr, "\n");
- 
-   /* Apply globally the options read from all the files.  */
-   lto_reissue_options ();
- }
- 
  static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data;
  
  /* Turn file datas for sub files into a single array, so that they look
--- 2494,2499 ----
*************** lto_init (void)
*** 2921,2926 ****
--- 2867,2873 ----
    lto_process_name ();
    lto_streamer_hooks_init ();
    lto_reader_init ();
+   lto_set_in_hooks (NULL, get_section_data, free_section_data);
    memset (&lto_stats, 0, sizeof (lto_stats));
    bitmap_obstack_initialize (NULL);
    gimple_register_cfg_hooks ();
Index: trunk/gcc/opts-global.c
===================================================================
*** trunk.orig/gcc/opts-global.c	2011-10-26 13:46:24.000000000 +0200
--- trunk/gcc/opts-global.c	2011-10-26 13:48:42.000000000 +0200
*************** static void
*** 167,176 ****
  post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
  			unsigned int mask ATTRIBUTE_UNUSED)
  {
- #ifdef ENABLE_LTO
-   lto_register_user_option (decoded->opt_index, decoded->arg,
- 			    decoded->value, mask);
- #endif
  }
  
  /* Handle a front-end option; arguments and return value as for
--- 167,172 ----
*************** decode_options (struct gcc_options *opts
*** 314,324 ****
  				decoded_options, decoded_options_count,
  				loc, lang_mask, &handlers, dc);
  
- #ifdef ENABLE_LTO
-   /* Clear any options currently held for LTO.  */
-   lto_clear_user_options ();
- #endif
- 
    read_cmdline_options (opts, opts_set,
  			decoded_options, decoded_options_count,
  			loc, lang_mask,
--- 310,315 ----
Index: trunk/gcc/lto-wrapper.c
===================================================================
*** trunk.orig/gcc/lto-wrapper.c	2011-10-26 13:48:17.000000000 +0200
--- trunk/gcc/lto-wrapper.c	2011-10-26 16:43:04.000000000 +0200
*************** along with GCC; see the file COPYING3.
*** 45,50 ****
--- 45,58 ----
  #include "obstack.h"
  #include "opts.h"
  #include "options.h"
+ #include "simple-object.h"
+ 
+ /* From lto-streamer.h which we cannot include with -fkeep-inline-functions.
+    ???  Split out a lto-streamer-core.h.  */
+ 
+ #define LTO_SECTION_NAME_PREFIX         ".gnu.lto_"
+ 
+ /* End of lto-streamer.h copy.  */
  
  int debug;				/* true if -save-temps.  */
  int verbose;				/* true if -v.  */
*************** get_options_from_collect_gcc_options (co
*** 327,332 ****
--- 335,383 ----
    free (argv);
  }
  
+ /* Try to merge and complain about options FDECODED_OPTIONS when applied
+    ontop of DECODED_OPTIONS.  */
+ 
+ static void
+ merge_and_complain (struct cl_decoded_option **decoded_options,
+ 		    unsigned int *decoded_options_count,
+ 		    struct cl_decoded_option *fdecoded_options,
+ 		    unsigned int fdecoded_options_count)
+ {
+   unsigned int i;
+ 
+   /* ???  Merge options from files.  Most cases can be
+      handled by either unioning or intersecting
+      (for example -fwrapv is a case for unioning,
+      -ffast-math is for intersection).  Most complaints
+      about real conflicts between different options can
+      be deferred to the compiler proper.  Options that
+      we can neither safely handle by intersection nor
+      unioning would need to be complained about here.
+      Ideally we'd have a flag in the opt files that
+      tells whether to union or intersect or reject.
+      In absence of that it's unclear what a good default is.
+      It's also difficult to get positional handling correct.  */
+   /* ???  For now the easiest thing would be to warn about
+      mismatches.  */
+ 
+   if (*decoded_options_count != fdecoded_options_count)
+     {
+       /* ???  Warn?  */
+       return;
+     }
+   for (i = 0; i < *decoded_options_count; ++i)
+     {
+       struct cl_decoded_option *option = &(*decoded_options)[i];
+       struct cl_decoded_option *foption = &fdecoded_options[i];
+       if (strcmp (option->orig_option_with_args_text,
+ 		  foption->orig_option_with_args_text) != 0)
+ 	{
+ 	  /* ???  Warn?  */
+ 	  return;
+ 	}
+     }
+ }
  
  /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
  
*************** run_gcc (unsigned argc, char *argv[])
*** 342,347 ****
--- 393,400 ----
    int parallel = 0;
    int jobserver = 0;
    bool no_partition = false;
+   struct cl_decoded_option *fdecoded_options = NULL;
+   unsigned int fdecoded_options_count = 0;
    struct cl_decoded_option *decoded_options;
    unsigned int decoded_options_count;
  
*************** run_gcc (unsigned argc, char *argv[])
*** 357,369 ****
  					&decoded_options,
  					&decoded_options_count);
  
    /* Initalize the common arguments for the driver.  */
!   new_argv = (const char **) xmalloc ((15 + decoded_options_count + argc)
  				      * sizeof (char *));
    argv_ptr = new_argv;
    *argv_ptr++ = collect_gcc;
    *argv_ptr++ = "-xlto";
    *argv_ptr++ = "-c";
    for (j = 1; j < decoded_options_count; ++j)
      {
        struct cl_decoded_option *option = &decoded_options[j];
--- 410,529 ----
  					&decoded_options,
  					&decoded_options_count);
  
+   /* Look at saved options in the IL files.  */
+   for (i = 1; i < argc; ++i)
+     {
+       char *data, *p;
+       char *fopts;
+       int fd;
+       const char *errmsg;
+       int err;
+       off_t file_offset = 0, offset, length;
+       long loffset;
+       simple_object_read *sobj;
+       int consumed;
+       struct cl_decoded_option *f2decoded_options;
+       unsigned int f2decoded_options_count;
+       char *filename = argv[i];
+       if ((p = strrchr (argv[i], '@'))
+ 	  && p != argv[i] 
+ 	  && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
+ 	  && strlen (p) == (unsigned int) consumed)
+ 	{
+ 	  filename = XNEWVEC (char, p - argv[i] + 1);
+ 	  memcpy (filename, argv[i], p - argv[i]);
+ 	  filename[p - argv[i]] = '\0';
+ 	  file_offset = (off_t) loffset;
+ 	}
+       fd = open (argv[i], O_RDONLY);
+       if (fd == -1)
+ 	continue;
+       sobj = simple_object_start_read (fd, file_offset, NULL, &errmsg, &err);
+       if (!sobj)
+ 	{
+ 	  close (fd);
+ 	  continue;
+ 	}
+       if (!simple_object_find_section (sobj, LTO_SECTION_NAME_PREFIX "." "opts",
+ 				       &offset, &length, &errmsg, &err))
+ 	{
+ 	  simple_object_release_read (sobj);
+ 	  close (fd);
+ 	  continue;
+ 	}
+       lseek (fd, file_offset + offset, SEEK_SET);
+       data = (char *)xmalloc (length);
+       read (fd, data, length);
+       fopts = data;
+       do
+ 	{
+ 	  get_options_from_collect_gcc_options (collect_gcc,
+ 						fopts, CL_LANG_ALL,
+ 						&f2decoded_options,
+ 						&f2decoded_options_count);
+ 	  if (!fdecoded_options)
+ 	    {
+ 	      fdecoded_options = f2decoded_options;
+ 	      fdecoded_options_count = f2decoded_options_count;
+ 	    }
+ 	  else
+ 	    merge_and_complain (&fdecoded_options,
+ 				&fdecoded_options_count,
+ 				f2decoded_options, f2decoded_options_count);
+ 
+ 	  fopts += strlen (fopts) + 1;
+ 	}
+       while (fopts - data < length);
+ 
+       free (data);
+       simple_object_release_read (sobj);
+       close (fd);
+     }
+ 
    /* Initalize the common arguments for the driver.  */
!   new_argv = (const char **) xmalloc ((15
! 				       + fdecoded_options_count
! 				       + decoded_options_count + argc)
  				      * sizeof (char *));
    argv_ptr = new_argv;
    *argv_ptr++ = collect_gcc;
    *argv_ptr++ = "-xlto";
    *argv_ptr++ = "-c";
+ 
+   /* Append compiler driver arguments as far as they were merged.  */
+   for (j = 1; j < fdecoded_options_count; ++j)
+     {
+       struct cl_decoded_option *option = &fdecoded_options[j];
+ 
+       /* Do not pass on frontend or driver specific flags.  */
+       if (!(cl_options[option->opt_index].flags & (CL_COMMON|CL_TARGET)))
+ 	continue;
+ 
+       /* Drop arguments created from the gcc driver that will be rejected
+ 	 when passed on.  */
+       if (cl_options[option->opt_index].cl_reject_driver)
+ 	continue;
+ 
+       switch (option->opt_index)
+ 	{
+ 	/* Drop arguments that we want to take from the link line.  */
+ 	case OPT_flto_:
+ 	case OPT_flto:
+ 	case OPT_flto_partition_none:
+ 	case OPT_flto_partition_1to1:
+ 	case OPT_flto_partition_balanced:
+ 	  continue;
+ 
+ 	default:
+ 	  break;
+ 	}
+ 
+       /* Pass the option on.  */
+       *argv_ptr++ = option->orig_option_with_args_text;
+     }
+ 
+   /* Append linker driver arguments.  Compiler options from the linker
+      driver arguments will override / merge with those from the compiler.  */
    for (j = 1; j < decoded_options_count; ++j)
      {
        struct cl_decoded_option *option = &decoded_options[j];