[patch] 35_all_ICE-array-subscript-PR95508.patch

35_all_ICE-array-subscript-PR95508.patch (text/plain), 3.79 KB, created by Sergei Trofimovich (RETIRED) on 2020-06-24 18:07:54 UTC

https://gcc.gnu.org/PR95508
https://bugs.gentoo.org/729434

From 1bab254fd30c2b94a675b9057349fc80946375b1 Mon Sep 17 00:00:00 2001
From: Marek Polacek <[e-mail]>
Date: Wed, 17 Jun 2020 14:38:05 -0400
Subject: [PATCH] c++: ICE with IMPLICIT_CONV_EXPR in array subscript [PR95508]

Since r10-7096 convert_like, when called in a template, creates an
IMPLICIT_CONV_EXPR when we're converting to/from array type.

In this test, we have e[f], and we're converting f (of type class A) to
int, so convert_like in build_new_op_1 created the IMPLICIT_CONV_EXPR
that got into cp_build_array_ref which calls maybe_constant_value.  My
patch above failed to adjust this spot to call fold_non_dependent_expr
instead, which can handle codes like I_C_E in a template.  Fixed by
using a new function maybe_fold_non_dependent_expr, which, if the expr
can't be evaluated to a constant, returns the original expression.

gcc/cp/ChangeLog:

	PR c++/95508
	* constexpr.c (maybe_fold_non_dependent_expr): New.
	* cp-tree.h (maybe_fold_non_dependent_expr): Declare.
	* typeck.c (cp_build_array_ref): Call maybe_fold_non_dependent_expr
	instead of maybe_constant_value.

gcc/testsuite/ChangeLog:

	PR c++/95508
	* g++.dg/template/conv16.C: New test.
---
 gcc/cp/constexpr.c                     | 13 +++++++++++++
 gcc/cp/cp-tree.h                       |  2 ++
 gcc/cp/typeck.c                        |  2 +-
 gcc/testsuite/g++.dg/template/conv16.C | 17 +++++++++++++++++
 4 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 gcc/testsuite/g++.dg/template/conv16.C

diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index 75c4a1f6197..bda8d6a8bef 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -7043,6 +7043,19 @@ fold_non_dependent_expr (tree t,
   return maybe_constant_value (t, object, manifestly_const_eval);
 }
 
+/* Like fold_non_dependent_expr, but if EXPR couldn't be folded to a constant,
+   return the original expression.  */
+
+tree
+maybe_fold_non_dependent_expr (tree expr,
+			       tsubst_flags_t complain/*=tf_warning_or_error*/)
+{
+  tree t = fold_non_dependent_expr (expr, complain);
+  if (t && TREE_CONSTANT (t))
+    return t;
+
+  return expr;
+}
 
 /* Like maybe_constant_init but first fully instantiate the argument.  */
 
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index eab9c29af0a..f220ed9f52a 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -7955,6 +7955,8 @@ extern tree maybe_constant_init			(tree, tree = NULL_TREE, bool = false);
 extern tree fold_non_dependent_expr		(tree,
 						 tsubst_flags_t = tf_warning_or_error,
 						 bool = false, tree = NULL_TREE);
+extern tree maybe_fold_non_dependent_expr	(tree,
+						 tsubst_flags_t = tf_warning_or_error);
 extern tree fold_non_dependent_init		(tree,
 						 tsubst_flags_t = tf_warning_or_error,
 						 bool = false);
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 2fd6dbee468..5f8f8290f0f 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -3553,7 +3553,7 @@ cp_build_array_ref (location_t loc, tree array, tree idx,
 	 pointer arithmetic.)  */
       idx = cp_perform_integral_promotions (idx, complain);
 
-      idx = maybe_constant_value (idx);
+      idx = maybe_fold_non_dependent_expr (idx, complain);
 
       /* An array that is indexed by a non-constant
 	 cannot be stored in a register; we must be able to do
diff --git a/gcc/testsuite/g++.dg/template/conv16.C b/gcc/testsuite/g++.dg/template/conv16.C
new file mode 100644
index 00000000000..c0843efdf9d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/conv16.C
@@ -0,0 +1,17 @@
+// PR c++/95508
+// { dg-do compile }
+
+template <typename>
+struct A;
+template <typename>
+struct B {
+  operator int () { return 0; }
+};
+template <>
+struct A<unsigned> : B<int> {};
+struct D {
+  template <typename>
+  int foo () { return e[f]; }
+  int e[6];
+  A<unsigned> f;
+};
-- 
2.27.0