From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2153) id D04DA3858C60; Sun, 21 Apr 2024 04:09:03 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org D04DA3858C60 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1713672543; bh=ZQ8O8hNHIMlBOKgkc197coukvipIWWd5pCooJpePFss=; h=From:To:Subject:Date:From; b=V0yC87K5qkE3mY5XkfRk/AAQN1ZxBOqWMoM3zx3FJUCHBa1wa0yQN3HPcwVV8t99G cAQAiC9zvQDpqODgOtf+0lE+ifpsHFp6FYvGeCB+6FZhmyXSL7i98Q0UeINpAjAdVv O9UDem083NR2E2KpCtrrnKHQYZ/sCRZO/rjsNf2A= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jakub Jelinek To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-8629] c++: Fix up maybe_warn_for_constant_evaluated calls [PR114580] X-Act-Checkin: gcc X-Git-Author: Jakub Jelinek X-Git-Refname: refs/heads/releases/gcc-13 X-Git-Oldrev: 38af0d59043da4cc07cd62c17da599e43668e3be X-Git-Newrev: ae3b6dea0445f9650cf1a684527efac06497f1b4 Message-Id: <20240421040903.D04DA3858C60@sourceware.org> Date: Sun, 21 Apr 2024 04:09:03 +0000 (GMT) List-Id: https://gcc.gnu.org/g:ae3b6dea0445f9650cf1a684527efac06497f1b4 commit r13-8629-gae3b6dea0445f9650cf1a684527efac06497f1b4 Author: Jakub Jelinek Date: Tue Apr 9 09:31:42 2024 +0200 c++: Fix up maybe_warn_for_constant_evaluated calls [PR114580] When looking at maybe_warn_for_constant_evaluated for the trivial infinite loops patch, I've noticed that it can emit weird diagnostics for if constexpr in templates, first warn that std::is_constant_evaluted() always evaluates to false (because the function template is not constexpr) and then during instantiation warn that std::is_constant_evaluted() always evaluates to true (because it is used in if constexpr condition). Now, only the latter is actually true, even when the if constexpr is in a non-constexpr function, it will still always evaluate to true. So, the following patch fixes it to call maybe_warn_for_constant_evaluated always with IF_STMT_CONSTEXPR_P (if_stmt) as the second argument rather than true if it is if constexpr with non-dependent condition etc. 2024-04-09 Jakub Jelinek PR c++/114580 * semantics.cc (finish_if_stmt_cond): Call maybe_warn_for_constant_evaluated with IF_STMT_CONSTEXPR_P (if_stmt) as the second argument, rather than true/false depending on if it is if constexpr with non-dependent constant expression with bool type. * g++.dg/cpp2a/is-constant-evaluated15.C: New test. (cherry picked from commit cfed80b9e4f562c99679739548df9369117dd791) Diff: --- gcc/cp/semantics.cc | 10 +++----- .../g++.dg/cpp2a/is-constant-evaluated15.C | 28 ++++++++++++++++++++++ 2 files changed, 31 insertions(+), 7 deletions(-) diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index ff5252905fe..a9fabf92a2a 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -1046,6 +1046,7 @@ tree finish_if_stmt_cond (tree orig_cond, tree if_stmt) { tree cond = maybe_convert_cond (orig_cond); + maybe_warn_for_constant_evaluated (cond, IF_STMT_CONSTEXPR_P (if_stmt)); if (IF_STMT_CONSTEXPR_P (if_stmt) && !type_dependent_expression_p (cond) && require_constant_expression (cond) @@ -1054,16 +1055,11 @@ finish_if_stmt_cond (tree orig_cond, tree if_stmt) converted to bool. */ && TYPE_MAIN_VARIANT (TREE_TYPE (cond)) == boolean_type_node) { - maybe_warn_for_constant_evaluated (cond, /*constexpr_if=*/true); cond = instantiate_non_dependent_expr (cond); cond = cxx_constant_value (cond); } - else - { - maybe_warn_for_constant_evaluated (cond, /*constexpr_if=*/false); - if (processing_template_decl) - cond = orig_cond; - } + else if (processing_template_decl) + cond = orig_cond; finish_cond (&IF_COND (if_stmt), cond); add_stmt (if_stmt); THEN_CLAUSE (if_stmt) = push_stmt_list (); diff --git a/gcc/testsuite/g++.dg/cpp2a/is-constant-evaluated15.C b/gcc/testsuite/g++.dg/cpp2a/is-constant-evaluated15.C new file mode 100644 index 00000000000..50a3cac6e07 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/is-constant-evaluated15.C @@ -0,0 +1,28 @@ +// PR c++/114580 +// { dg-do compile { target c++17 } } +// { dg-options "-Wtautological-compare" } + +namespace std { + constexpr inline bool + is_constant_evaluated () noexcept + { +#if __cpp_if_consteval >= 202106L + if consteval { return true; } else { return false; } +#else + return __builtin_is_constant_evaluated (); +#endif + } +} + +template +void foo () +{ + if constexpr ((T) std::is_constant_evaluated ()) // { dg-warning "'std::is_constant_evaluated' always evaluates to true in 'if constexpr'" } + ; // { dg-bogus "'std::is_constant_evaluated' always evaluates to false in a non-'constexpr' function" } +} + +void +bar () +{ + foo (); +}