From: Alexandre Oliva <aoliva@redhat.com>
To: gcc-patches@gcc.gnu.org
Cc: jason@redhat.com, nathan@acm.org
Subject: [PATCH] [PR85569] skip constexpr target_expr constructor dummy type conversion
Date: Thu, 22 Nov 2018 23:39:00 -0000 [thread overview]
Message-ID: <or1s7csmv8.fsf@lxoliva.fsfla.org> (raw)
The testcase is the work-around testcase for the PR; even that had
started failing. The problem was that, when unqualifying the type of
a TARGET_EXPR, we'd create a variant of the type, then request the
conversion of the TARGET_EXPR_INITIAL to that variant type. Though
the types are different pointer-wise, they're the same_type_p, so the
resulting modified expr compares cp_tree_equal to the original, which
maybe_constant_value flags as an error. There's no reason to
construct an alternate TARGET_EXPR or CONSTRUCTOR just because of an
equivalent type, except for another spot that expected pointer
equality that would no longer be satisfied. Without relaxing the
assert in constexpr_call_hasher::equal, g++.robertl/eb73.C would
trigger an assertion failure.
Regstrapped on i686- and x86_64-linux-gnu. Ok to install?
for gcc/cp/ChangeLog
PR c++/85569
* constexpr.c (adjust_temp_type): Test for type equality with
same_type_p.
for gcc/testsuite
PR c++/85569
* g++.dg/cpp1z/pr85569.C: New.
---
gcc/cp/constexpr.c | 4 +
gcc/testsuite/g++.dg/cpp1z/pr85569.C | 93 ++++++++++++++++++++++++++++++++++
2 files changed, 95 insertions(+), 2 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/cpp1z/pr85569.C
diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index 92fd2b2d9d59..bb5d1301b332 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -1060,7 +1060,7 @@ constexpr_call_hasher::equal (constexpr_call *lhs, constexpr_call *rhs)
{
tree lhs_arg = TREE_VALUE (lhs_bindings);
tree rhs_arg = TREE_VALUE (rhs_bindings);
- gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
+ gcc_assert (same_type_p (TREE_TYPE (lhs_arg), TREE_TYPE (rhs_arg)));
if (!cp_tree_equal (lhs_arg, rhs_arg))
return false;
lhs_bindings = TREE_CHAIN (lhs_bindings);
@@ -1276,7 +1276,7 @@ cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun,
static tree
adjust_temp_type (tree type, tree temp)
{
- if (TREE_TYPE (temp) == type)
+ if (TREE_TYPE (temp) == type || same_type_p (TREE_TYPE (temp), type))
return temp;
/* Avoid wrapping an aggregate value in a NOP_EXPR. */
if (TREE_CODE (temp) == CONSTRUCTOR)
diff --git a/gcc/testsuite/g++.dg/cpp1z/pr85569.C b/gcc/testsuite/g++.dg/cpp1z/pr85569.C
new file mode 100644
index 000000000000..aec543041a0f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/pr85569.C
@@ -0,0 +1,93 @@
+// { dg-do compile { target c++17 } }
+
+#include <utility>
+#include <tuple>
+
+#define LIFT_FWD(x) std::forward<decltype(x)>(x)
+
+template <typename T>
+inline
+constexpr
+auto
+equal(
+ T &&t)
+{
+ return [t = std::forward<T>(t)](const auto& obj)
+ -> decltype(obj == t)
+ {
+ return obj == t;
+ };
+}
+
+template <typename F, typename T>
+struct is_tuple_invocable;
+
+template <typename F, typename ... Ts>
+struct is_tuple_invocable<F, std::tuple<Ts...>>
+{
+ using type = typename std::is_invocable<F, Ts...>::type;
+};
+
+template <typename F>
+inline
+constexpr
+auto
+compose(
+ F&& f
+)
+ noexcept
+-> F
+{
+ return std::forward<F>(f);
+}
+
+namespace detail {
+ template <typename F, typename Tail, typename ... T>
+ inline
+ constexpr
+ auto
+ compose(
+ std::true_type,
+ F&& f,
+ Tail&& tail,
+ T&& ... objs)
+ noexcept(noexcept(f(tail(std::forward<T>(objs)...))))
+ -> decltype(f(tail(std::forward<T>(objs)...)))
+ {
+ return f(tail(std::forward<T>(objs)...));
+ }
+}
+template <typename F, typename ... Fs>
+inline
+constexpr
+auto
+compose(
+ F&& f,
+ Fs&&... fs)
+{
+ return [f = std::forward<F>(f), tail = compose(std::forward<Fs>(fs)...)]
+ (auto&& ... objs)
+ -> decltype(detail::compose(typename std::is_invocable<decltype(compose(std::forward<Fs>(fs)...)), decltype(objs)...>::type{},
+ f,
+ compose(std::forward<Fs>(fs)...),
+ LIFT_FWD(objs)...))
+ {
+ using tail_type = decltype(compose(std::forward<Fs>(fs)...));
+
+#ifndef NOT_VIA_TUPLE
+ using args_type = std::tuple<decltype(objs)...>;
+ constexpr auto unitail = typename is_tuple_invocable<tail_type, args_type>::type{};
+#else
+ constexpr auto unitail = typename std::is_invocable<tail_type, decltype(objs)...>::type{};
+#endif
+
+ return detail::compose(unitail, f, tail, LIFT_FWD(objs)...);
+ };
+}
+
+template <auto N>
+constexpr auto eq = equal(N);
+
+static_assert(compose(eq<3>,
+ std::plus<>{})(1,2),
+ "compose is constexpr");
--
Alexandre Oliva, freedom fighter https://FSFLA.org/blogs/lxo
Be the change, be Free! FSF Latin America board member
GNU Toolchain Engineer Free Software Evangelist
Hay que enGNUrecerse, pero sin perder la terGNUra jamás-GNUChe
next reply other threads:[~2018-11-22 23:39 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2018-11-22 23:39 Alexandre Oliva [this message]
2018-11-27 23:41 ` Jason Merrill
2018-12-05 6:34 ` Alexandre Oliva
2018-12-05 8:45 ` [committed] Add testcase for already fixed PR c++/87897 Jakub Jelinek
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=or1s7csmv8.fsf@lxoliva.fsfla.org \
--to=aoliva@redhat.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=jason@redhat.com \
--cc=nathan@acm.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).