re PR target/52555 (ICE unrecognizable insn with -ffast-math and __attribute__((optim...

	PR target/52555
	* genopinit.c (raw_optab_handler): Use this_fn_optabs.
	(swap_optab_enable): Same.
	(init_all_optabs): Use argument instead of global.
	* tree.h (struct tree_optimization_option): New field
	target_optabs.
	* expr.h (init_all_optabs): Add argument to prototype.
	(TREE_OPTIMIZATION_OPTABS): New.
	(save_optabs_if_changed): Protoize.
	* optabs.h: Declare this_fn_optabs.
	* optabs.c (save_optabs_if_changed): New.
	Declare this_fn_optabs.
	(init_optabs): Add argument to init_all_optabs() call.
	* function.c (invoke_set_current_function_hook): Handle per
	function optabs.
	* function.h (struct function): New field optabs.
	* config/mips/mips.c (mips_set_mips16_mode): Handle when
	optimization_current_node has changed.
	* target-globals.h (save_target_globals_default_opts): Protoize.
	* target-globals.c (save_target_globals_default_opts): New.
c-family/
	* c-common.c (handle_optimize_attribute): Call
	save_optabs_if_changed.

Co-Authored-By: Jakub Jelinek <jakub@redhat.com>
From-SVN: r196129

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index e8be788a8c738b287d9a9ffc658669e7a9d8a2eb..83a466e9a397c4aadba16d8c732164a61906ff1b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,27 @@
+2013-02-15  Aldy Hernandez  <aldyh@redhat.com>
+           Jakub Jelinek  <jakub@redhat.com>
+
+       PR target/52555
+       * genopinit.c (raw_optab_handler): Use this_fn_optabs.
+       (swap_optab_enable): Same.
+       (init_all_optabs): Use argument instead of global.
+       * tree.h (struct tree_optimization_option): New field
+       target_optabs.
+       * expr.h (init_all_optabs): Add argument to prototype.
+       (TREE_OPTIMIZATION_OPTABS): New.
+       (save_optabs_if_changed): Protoize.
+       * optabs.h: Declare this_fn_optabs.
+       * optabs.c (save_optabs_if_changed): New.
+       Declare this_fn_optabs.
+       (init_optabs): Add argument to init_all_optabs() call.
+       * function.c (invoke_set_current_function_hook): Handle per
+       function optabs.
+       * function.h (struct function): New field optabs.
+       * config/mips/mips.c (mips_set_mips16_mode): Handle when
+       optimization_current_node has changed.
+       * target-globals.h (save_target_globals_default_opts): Protoize.
+       * target-globals.c (save_target_globals_default_opts): New.
+
 2013-02-18  John David Anglin  <dave.anglin@nrc-cnrc.gc.ca>
 
        PR target/56347

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index 40b6e5569560f98f3687a4bb90c89a03d8517265..afa9cd7a39a5cf3462a13d5a0a1fb789c09387a3 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,9 @@
+2013-02-11  Aldy Hernandez  <aldyh@redhat.com>
+
+       PR target/52555
+       * c-common.c (handle_optimize_attribute): Call
+       save_optabs_if_changed.
+
 2013-02-18  Jakub Jelinek  <jakub@redhat.com>
            Steven Bosscher  <steven@gcc.gnu.org>
 

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 1e6afaa77f247f23b908654ca6d8859b122db9d7..a1d47a68045bacbe9944dc26e6e4a2c56eef6e4f 100644 (file)
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -8925,6 +8925,8 @@ handle_optimize_attribute (tree *node, tree name, tree args,
       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
        = build_optimization_node ();
 
+      save_optabs_if_changed (*node);
+
       /* Restore current options.  */
       cl_optimization_restore (&global_options, &cur_opts);
     }

diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c
index b203cdd1ed23866e4c01c5ae62d87e977949b7ce..252e828480e44ec239b053cff83a6af7a1107f4d 100644 (file)
--- a/gcc/config/mips/mips.c
+++ b/gcc/config/mips/mips.c
@@ -16313,7 +16313,7 @@ mips_set_mips16_mode (int mips16_p)
   if (mips16_p)
     {
       if (!mips16_globals)
-       mips16_globals = save_target_globals ();
+       mips16_globals = save_target_globals_default_opts ();
       else
        restore_target_globals (mips16_globals);
     }

diff --git a/gcc/expr.h b/gcc/expr.h
index f5063b47cdd354e96f7814a53ae7af8bc114477d..15fcb471d8d5836d7e2c96e6c4dbbfcdded16b38 100644 (file)
--- a/gcc/expr.h
+++ b/gcc/expr.h
@@ -718,7 +718,7 @@ extern bool split_comparison (enum rtx_code, enum machine_mode,
 /* Call this once to initialize the contents of the optabs
    appropriately for the current target machine.  */
 extern void init_optabs (void);
-extern void init_all_optabs (void);
+extern void init_all_optabs (struct target_optabs *);
 
 /* Call this to initialize an optab function entry.  */
 extern rtx init_one_libfunc (const char *);

diff --git a/gcc/function.c b/gcc/function.c
index 4ce2259ef719ab118bf73d8fea177f1f75d853ef..1b41cf2cb34cc0dee3478873bf8298b8ca1e320c 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -4400,6 +4400,26 @@ invoke_set_current_function_hook (tree fndecl)
        }
 
       targetm.set_current_function (fndecl);
+
+      if (opts == optimization_default_node)
+       this_fn_optabs = this_target_optabs;
+      else
+       {
+         struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
+         if (fn->optabs == NULL)
+           {
+             if (this_target_optabs == &default_target_optabs)
+               fn->optabs = TREE_OPTIMIZATION_OPTABS (opts);
+             else
+               {
+                 fn->optabs = (unsigned char *)
+                   ggc_alloc_atomic (sizeof (struct target_optabs));
+                 init_all_optabs ((struct target_optabs *) fn->optabs);
+               }
+           }
+         this_fn_optabs = fn->optabs ? (struct target_optabs *) fn->optabs
+                                     : this_target_optabs;
+       }
     }
 }
 

diff --git a/gcc/function.h b/gcc/function.h
index 89d71e592dd227e52422dc4249037fac54e6d346..53e28b768c0b061cbbcdcc779eaa070730deb4cf 100644 (file)
--- a/gcc/function.h
+++ b/gcc/function.h
@@ -580,6 +580,9 @@ struct GTY(()) function {
      a string describing the reason for failure.  */
   const char * GTY((skip)) cannot_be_copied_reason;
 
+  /* Optabs for this function.  This is of type `struct target_optabs *'.  */
+  unsigned char *GTY ((atomic)) optabs;
+
   /* Collected bit flags.  */
 
   /* Number of units of general registers that need saving in stdarg

diff --git a/gcc/genopinit.c b/gcc/genopinit.c
index 1bb2f770d2239652918cfca046bb6f74082e8ac3..fb8071765dde413910c817a0ce87d6b8fd1ff927 100644 (file)
--- a/gcc/genopinit.c
+++ b/gcc/genopinit.c
@@ -422,8 +422,8 @@ main (int argc, char **argv)
     fprintf (s_file, "  { %#08x, CODE_FOR_%s },\n", p->sort_num, p->name);
   fprintf (s_file, "};\n\n");
 
-  fprintf (s_file, "void\ninit_all_optabs (void)\n{\n");
-  fprintf (s_file, "  bool *ena = this_target_optabs->pat_enable;\n");
+  fprintf (s_file, "void\ninit_all_optabs (struct target_optabs *optabs)\n{\n");
+  fprintf (s_file, "  bool *ena = optabs->pat_enable;\n");
   for (i = 0; patterns.iterate (i, &p); ++i)
     fprintf (s_file, "  ena[%u] = HAVE_%s;\n", i, p->name);
   fprintf (s_file, "}\n\n");
@@ -456,7 +456,7 @@ main (int argc, char **argv)
           "raw_optab_handler (unsigned scode)\n"
           "{\n"
           "  int i = lookup_handler (scode);\n"
-          "  return (i >= 0 && this_target_optabs->pat_enable[i]\n"
+          "  return (i >= 0 && this_fn_optabs->pat_enable[i]\n"
           "          ? pats[i].icode : CODE_FOR_nothing);\n"
           "}\n\n");
 
@@ -468,8 +468,8 @@ main (int argc, char **argv)
           "  int i = lookup_handler (scode);\n"
           "  if (i >= 0)\n"
           "    {\n"
-          "      bool ret = this_target_optabs->pat_enable[i];\n"
-          "      this_target_optabs->pat_enable[i] = set;\n"
+          "      bool ret = this_fn_optabs->pat_enable[i];\n"
+          "      this_fn_optabs->pat_enable[i] = set;\n"
           "      return ret;\n"
           "    }\n"
           "  else\n"

diff --git a/gcc/optabs.c b/gcc/optabs.c
index c1dacf487a0c55305aaf201cb938304e37179b70..c5778d1928bfc98048504c79a6a6ec239b0c02d5 100644 (file)
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -44,6 +44,7 @@ along with GCC; see the file COPYING3.  If not see
 
 struct target_optabs default_target_optabs;
 struct target_libfuncs default_target_libfuncs;
+struct target_optabs *this_fn_optabs = &default_target_optabs;
 #if SWITCHABLE_TARGET
 struct target_optabs *this_target_optabs = &default_target_optabs;
 struct target_libfuncs *this_target_libfuncs = &default_target_libfuncs;
@@ -6150,7 +6151,7 @@ init_optabs (void)
     libfunc_hash = htab_create_ggc (10, hash_libfunc, eq_libfunc, NULL);
 
   /* Fill in the optabs with the insns we support.  */
-  init_all_optabs ();
+  init_all_optabs (this_fn_optabs);
 
   /* The ffs function operates on `int'.  Fall back on it if we do not
      have a libgcc2 function for that width.  */
@@ -6207,6 +6208,38 @@ init_optabs (void)
   targetm.init_libfuncs ();
 }
 
+/* Recompute the optabs and save them if they have changed.  */
+
+void
+save_optabs_if_changed (tree fndecl)
+{
+  /* ?? If this fails, we should temporarily restore the default
+     target first (set_cfun (NULL) ??), do the rest of this function,
+     and then restore it.  */
+  gcc_assert (this_target_optabs == &default_target_optabs);
+
+  struct target_optabs *tmp_optabs = (struct target_optabs *)
+    ggc_alloc_atomic (sizeof (struct target_optabs));
+  tree optnode = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
+
+  /* Generate a new set of optabs into tmp_optabs.  */
+  init_all_optabs (tmp_optabs);
+
+  /* If the optabs changed, record it.  */
+  if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
+    {
+      if (TREE_OPTIMIZATION_OPTABS (optnode))
+       ggc_free (TREE_OPTIMIZATION_OPTABS (optnode));
+
+      TREE_OPTIMIZATION_OPTABS (optnode) = (unsigned char *) tmp_optabs;
+    }
+  else
+    {
+      TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
+      ggc_free (tmp_optabs);
+    }
+}
+
 /* A helper function for init_sync_libfuncs.  Using the basename BASE,
    install libfuncs into TAB for BASE_N for 1 <= N <= MAX.  */
 

diff --git a/gcc/optabs.h b/gcc/optabs.h
index c08adcf454f84dcf197d0a9ca2aa47449135325b..4de4409342de199bd2cc058ed9c1ad946729b354 100644 (file)
--- a/gcc/optabs.h
+++ b/gcc/optabs.h
@@ -76,6 +76,7 @@ struct target_optabs {
 };
 
 extern struct target_optabs default_target_optabs;
+extern struct target_optabs *this_fn_optabs;
 #if SWITCHABLE_TARGET
 extern struct target_optabs *this_target_optabs;
 #else

diff --git a/gcc/target-globals.c b/gcc/target-globals.c
index 533a8e5837408127624cd86727481d25dde62deb..d72495da26d284a59038a6a8d8bab21cd3ba51f3 100644 (file)
--- a/gcc/target-globals.c
+++ b/gcc/target-globals.c
@@ -91,4 +91,33 @@ save_target_globals (void)
   return g;
 }
 
+/* Like save_target_globals() above, but set *this_target_optabs
+   correctly when a previous function has changed
+   *this_target_optabs.  */
+
+struct target_globals *
+save_target_globals_default_opts ()
+{
+  struct target_globals *globals;
+
+  if (optimization_current_node != optimization_default_node)
+    {
+      tree opts = optimization_current_node;
+      /* Temporarily switch to the default optimization node, so that
+        *this_target_optabs is set to the default, not reflecting
+        whatever a previous function used for the optimize
+        attribute.  */
+      optimization_current_node = optimization_default_node;
+      cl_optimization_restore
+       (&global_options,
+        TREE_OPTIMIZATION (optimization_default_node));
+      globals = save_target_globals ();
+      optimization_current_node = opts;
+      cl_optimization_restore (&global_options,
+                              TREE_OPTIMIZATION (opts));
+      return globals;
+    }
+  return save_target_globals ();
+}
+
 #endif

diff --git a/gcc/target-globals.h b/gcc/target-globals.h
index 110f879cd7bf0f3c3c4b92de61d389cb39aa008d..04eba530abe4ffb81dbb3f4421f42d5b997007c2 100644 (file)
--- a/gcc/target-globals.h
+++ b/gcc/target-globals.h
@@ -60,6 +60,7 @@ struct GTY(()) target_globals {
 extern struct target_globals default_target_globals;
 
 extern struct target_globals *save_target_globals (void);
+extern struct target_globals *save_target_globals_default_opts (void);
 
 static inline void
 restore_target_globals (struct target_globals *g)

diff --git a/gcc/testsuite/gcc.c-torture/compile/pr52555.c b/gcc/testsuite/gcc.c-torture/compile/pr52555.c
new file mode 100644 (file)
index 0000000..7016834
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/pr52555.c
@@ -0,0 +1,10 @@
+/* { dg-options "-ffast-math" } */
+
+float farg;
+unsigned val;
+
+void __attribute__((optimize("O")))
+test()
+{
+  val = __builtin_ceilf(farg);
+}

diff --git a/gcc/tree.h b/gcc/tree.h
index c3c814ca33af5be9dac48bc41f124c50373a9a9d..740d43827127172d9599120eab680001494ca8c2 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -3586,14 +3586,25 @@ struct GTY(()) tree_optimization_option {
 
   /* The optimization options used by the user.  */
   struct cl_optimization opts;
+
+  /* Target optabs for this set of optimization options.  This is of
+     type `struct target_optabs *'.  */
+  unsigned char *GTY ((atomic)) target_optabs;
 };
 
 #define TREE_OPTIMIZATION(NODE) \
   (&OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts)
 
+#define TREE_OPTIMIZATION_OPTABS(NODE) \
+  (OPTIMIZATION_NODE_CHECK (NODE)->optimization.target_optabs)
+
 /* Return a tree node that encapsulates the current optimization options.  */
 extern tree build_optimization_node (void);
 
+/* Save a new set of target_optabs in a TREE_OPTIMIZATION node if the
+   current set of optabs has changed.  */
+extern void save_optabs_if_changed (tree);
+
 /* Target options used by a function.  */
 
 struct GTY(()) tree_target_option {