[PR lto/77458] Avoid ICE in offloading with differing _FloatN, _FloatNx types

Thomas Schwinge thomas@codesourcery.com
Thu Sep 29 13:18:00 GMT 2016


Hi Richard!

On Mon, 19 Sep 2016 13:25:01 +0200, Richard Biener <richard.guenther@gmail.com> wrote:
> On Mon, Sep 19, 2016 at 1:19 PM, Thomas Schwinge
> <thomas@codesourcery.com> wrote:
> > On Mon, 19 Sep 2016 10:18:35 +0200, Richard Biener <richard.guenther@gmail.com> wrote:
> >> On Fri, Sep 16, 2016 at 3:32 PM, Thomas Schwinge
> >> <thomas@codesourcery.com> wrote:
> >> > --- gcc/tree-streamer.c
> >> > +++ gcc/tree-streamer.c
> >> > @@ -278,9 +278,23 @@ record_common_node (struct streamer_tree_cache_d *cache, tree node)
> >> >    streamer_tree_cache_append (cache, node, cache->nodes.length ());
> >> >
> >> >    if (POINTER_TYPE_P (node)
> >> > -      || TREE_CODE (node) == COMPLEX_TYPE
> >> >        || TREE_CODE (node) == ARRAY_TYPE)
> >> >      record_common_node (cache, TREE_TYPE (node));
> >> > +  else if (TREE_CODE (node) == COMPLEX_TYPE)
> >> > +    {
> >> > +      /* Assert that complex types' component types have already been handled
> >> > +        (and we thus don't need to recurse here).  See PR lto/77458.  */
> >> > +[...]

> >> So I very much like to go forward with this kind of change as well

> > [patch]

> Ok with [changes]

Like this?  (I'll then continue to replicate this for other tree codes.)

commit b304f88f7226d93c8e13584a916cc713a989a635
Author: Thomas Schwinge <thomas@codesourcery.com>
Date:   Wed Sep 28 12:36:59 2016 +0200

    [PR lto/77458] Avoid ICE in offloading with differing _FloatN, _FloatNx types
    
    	gcc/
    	PR lto/77458
    	* tree-core.h (enum tree_index): Put the complex types after their
    	component types.
    	* tree-streamer.c (verify_common_node_recorded): New function.
    	(preload_common_nodes) <TREE_CODE (node) == COMPLEX_TYPE>: Use it.
---
 gcc/tree-core.h     | 31 +++++++++++++++++--------------
 gcc/tree-streamer.c | 33 ++++++++++++++++++++++++++++++++-
 2 files changed, 49 insertions(+), 15 deletions(-)

diff --git gcc/tree-core.h gcc/tree-core.h
index 353a625..35b67c9 100644
--- gcc/tree-core.h
+++ gcc/tree-core.h
@@ -553,20 +553,6 @@ enum tree_index {
   TI_BOOLEAN_FALSE,
   TI_BOOLEAN_TRUE,
 
-  TI_COMPLEX_INTEGER_TYPE,
-  TI_COMPLEX_FLOAT_TYPE,
-  TI_COMPLEX_DOUBLE_TYPE,
-  TI_COMPLEX_LONG_DOUBLE_TYPE,
-
-  TI_COMPLEX_FLOAT16_TYPE,
-  TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE,
-  TI_COMPLEX_FLOAT32_TYPE,
-  TI_COMPLEX_FLOAT64_TYPE,
-  TI_COMPLEX_FLOAT128_TYPE,
-  TI_COMPLEX_FLOAT32X_TYPE,
-  TI_COMPLEX_FLOAT64X_TYPE,
-  TI_COMPLEX_FLOAT128X_TYPE,
-
   TI_FLOAT_TYPE,
   TI_DOUBLE_TYPE,
   TI_LONG_DOUBLE_TYPE,
@@ -596,6 +582,23 @@ enum tree_index {
 			     - TI_FLOATN_NX_TYPE_FIRST		\
 			     + 1)
 
+  /* Put the complex types after their component types, so that in (sequential)
+     tree streaming we can assert that their component types have already been
+     handled (see tree-streamer.c:record_common_node).  */
+  TI_COMPLEX_INTEGER_TYPE,
+  TI_COMPLEX_FLOAT_TYPE,
+  TI_COMPLEX_DOUBLE_TYPE,
+  TI_COMPLEX_LONG_DOUBLE_TYPE,
+
+  TI_COMPLEX_FLOAT16_TYPE,
+  TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE,
+  TI_COMPLEX_FLOAT32_TYPE,
+  TI_COMPLEX_FLOAT64_TYPE,
+  TI_COMPLEX_FLOAT128_TYPE,
+  TI_COMPLEX_FLOAT32X_TYPE,
+  TI_COMPLEX_FLOAT64X_TYPE,
+  TI_COMPLEX_FLOAT128X_TYPE,
+
   TI_FLOAT_PTR_TYPE,
   TI_DOUBLE_PTR_TYPE,
   TI_LONG_DOUBLE_PTR_TYPE,
diff --git gcc/tree-streamer.c gcc/tree-streamer.c
index 7ea7096..6ada89a 100644
--- gcc/tree-streamer.c
+++ gcc/tree-streamer.c
@@ -248,6 +248,32 @@ streamer_tree_cache_lookup (struct streamer_tree_cache_d *cache, tree t,
 }
 
 
+/* Verify that NODE is in CACHE.  */
+
+static void
+verify_common_node_recorded (struct streamer_tree_cache_d *cache, tree node)
+{
+  /* Restrict this to flag_checking only because in general violating it is
+     harmless plus we never know what happens on all targets/frontend/flag(!)
+     combinations.  */
+  if (!flag_checking)
+    return;
+
+  bool found = false;
+  if (cache->node_map)
+    gcc_assert (streamer_tree_cache_lookup (cache, node, NULL));
+  else
+    {
+      gcc_assert (cache->nodes.exists ());
+      /* Linear search...  */
+      for (unsigned i = 0; !found && i < cache->nodes.length (); ++i)
+	if (cache->nodes[i] == node)
+	  found = true;
+      gcc_assert (found);
+    }
+}
+
+
 /* Record NODE in CACHE.  */
 
 static void
@@ -278,9 +304,14 @@ record_common_node (struct streamer_tree_cache_d *cache, tree node)
   streamer_tree_cache_append (cache, node, cache->nodes.length ());
 
   if (POINTER_TYPE_P (node)
-      || TREE_CODE (node) == COMPLEX_TYPE
       || TREE_CODE (node) == ARRAY_TYPE)
     record_common_node (cache, TREE_TYPE (node));
+  else if (TREE_CODE (node) == COMPLEX_TYPE)
+    {
+      /* Verify that a complex type's component type (node_type) has been
+	 handled already (and we thus don't need to recurse here).  */
+      verify_common_node_recorded (cache, TREE_TYPE (node));
+    }
   else if (TREE_CODE (node) == RECORD_TYPE)
     {
       /* The FIELD_DECLs of structures should be shared, so that every


Grüße
 Thomas



More information about the Gcc mailing list