On 6/16/20 5:10 PM, Marek Polacek wrote:
On Thu, Jun 11, 2020 at 02:31:44PM -0400, Jason Merrill wrote:
On 6/10/20 5:11 PM, Marek Polacek wrote:
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.
Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk/10?
gcc/cp/ChangeLog:
PR c++/95508
* typeck.c (cp_build_array_ref): Call fold_non_dependent_expr instead
of maybe_constant_value.
gcc/testsuite/ChangeLog:
PR c++/95508
* g++.dg/template/conv16.C: New test.
---
gcc/cp/typeck.c | 2 +-
gcc/testsuite/g++.dg/template/conv16.C | 17 +++++++++++++++++
2 files changed, 18 insertions(+), 1 deletion(-)
create mode 100644 gcc/testsuite/g++.dg/template/conv16.C
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index f01ae656254..07144d4c1fc 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -3565,7 +3565,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 = fold_non_dependent_expr (idx, complain);
Hmm, if idx isn't constant this will leave us with non-template trees in the
ARRAY_REF. I think what we want is a function that will fold a
non-dependent expr to a constant or return the argument.
maybe_fold_non_dependent_expr?
Yeah, if IDX was an IMPLICIT_CONV_EXPR, we'd turn it into a CALL_EXPR that
contains no template trees (same result as before r10-7096). We most likely
don't want such trees, we want to keep the IMPLICIT_CONV_EXPR. So like this?
Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk?
-- >8 --
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
* typeck.c (cp_build_array_ref): Call fold_non_dependent_expr instead
of maybe_constant_value.
You need to update your ChangeLog entries. OK with that fixed.
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 c01c42bf886..f766abd3a11 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -7093,6 +7093,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 50d83add458..ee276107928 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -7933,6 +7933,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 f01ae656254..7e84f11579b 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -3565,7 +3565,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;
+};
base-commit: 04afaf4575ff239279cfa34aff17101345451965
