c++: const_cast of null pointer in constant expr [PR99176]

Here we reject

  constexpr const int *p = nullptr;
  constexpr int *q = const_cast<int*>(p);

with "conversion of 'const int*' null pointer to 'int*' is not a
constant expression", which seems bogus.  This code has been rejected
since r238909 which added the can_convert check when converting a null
pointer.  I'm not finding any standard rule that this check was supposed
to enforce.  The original discussion was here
<https://gcc.gnu.org/legacy-ml/gcc-patches/2016-06/msg01447.html>
and here
<https://gcc.gnu.org/legacy-ml/gcc-patches/2016-07/msg00280.html>.

Since can_convert never assumes a C-style cast, it rejects casting
away constness as in the test above and in:

  constexpr int *q = (int *)(const int *) nullptr;

Removing the check only breaks constexpr-nullptr-2.C by not giving any
diagnostic for line 229:

  constexpr B *pb2 = static_cast<B*>(pa0);  // { dg-error "not a constant expression" }

but the cast seems to be valid: we do [expr.static.cast]/7, and
[expr.const] only says that a reinterpreter_cast and converting from
void* is invalid in constexpr.  The can_convert check rejected convering
from void *, but only when converting from a null pointer, so it's not
good enough.  So I've added a check to catch conversions from cv void*.
I realize it's not a great time to be adding additional checking, but
removing the can_convert check would then technically be a regression.

Let's limit the new check to only trigger for integer_zerop and then remove
it in GCC 12.

gcc/cp/ChangeLog:

	DR 1312
	PR c++/99176
	* constexpr.c (is_std_construct_at): New overload.
	(is_std_allocator_allocate): New overload.
	(cxx_eval_call_expression): Use the new overloads.
	(cxx_eval_constant_expression): Reject casting
	from void * as per DR 1312.  Don't check can_convert.

gcc/testsuite/ChangeLog:

	DR 1312
	PR c++/99176
	* g++.dg/cpp0x/constexpr-nullptr-2.C: Adjust dg-error.
	* g++.dg/cpp0x/constexpr-cast2.C: New test.
	* g++.dg/cpp0x/constexpr-cast3.C: New test.

diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index 377fe32..cd0a68e 100644 (file)
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -1837,6 +1837,16 @@ is_std_construct_at (tree fndecl)
   return name && id_equal (name, "construct_at");
 }
 
+/* Overload for the above taking constexpr_call*.  */
+
+static inline bool
+is_std_construct_at (const constexpr_call *call)
+{
+  return (call
+         && call->fundef
+         && is_std_construct_at (call->fundef->decl));
+}
+
 /* Return true if FNDECL is std::allocator<T>::{,de}allocate.  */
 
 static inline bool
@@ -1859,6 +1869,16 @@ is_std_allocator_allocate (tree fndecl)
   return decl_in_std_namespace_p (decl);
 }
 
+/* Overload for the above taking constexpr_call*.  */
+
+static inline bool
+is_std_allocator_allocate (const constexpr_call *call)
+{
+  return (call
+         && call->fundef
+         && is_std_allocator_allocate (call->fundef->decl));
+}
+
 /* Return true if FNDECL is __dynamic_cast.  */
 
 static inline bool
@@ -2313,9 +2333,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
       if (TREE_CODE (t) == CALL_EXPR
          && cxx_replaceable_global_alloc_fn (fun)
          && (CALL_FROM_NEW_OR_DELETE_P (t)
-             || (ctx->call
-                 && ctx->call->fundef
-                 && is_std_allocator_allocate (ctx->call->fundef->decl))))
+             || is_std_allocator_allocate (ctx->call)))
        {
          const int nargs = call_expr_nargs (t);
          tree arg0 = NULL_TREE;
@@ -2423,9 +2441,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
         argument.  */
       if (TREE_CODE (t) == CALL_EXPR
          && cxx_placement_new_fn (fun)
-         && ctx->call
-         && ctx->call->fundef
-         && is_std_construct_at (ctx->call->fundef->decl))
+         && is_std_construct_at (ctx->call))
        {
          const int nargs = call_expr_nargs (t);
          tree arg1 = NULL_TREE;
@@ -6653,6 +6669,36 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
            return t;
          }
 
+       /* [expr.const]: a conversion from type cv void* to a pointer-to-object
+          type cannot be part of a core constant expression as a resolution to
+          DR 1312.  */
+       if (integer_zerop (op) /* FIXME: Remove in GCC 12.  */
+           && TYPE_PTROB_P (type)
+           && TYPE_PTR_P (TREE_TYPE (op))
+           && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (op)))
+           /* Inside a call to std::construct_at or to
+              std::allocator<T>::{,de}allocate, we permit casting from void*
+              because that is compiler-generated code.  */
+           && !is_std_construct_at (ctx->call)
+           && !is_std_allocator_allocate (ctx->call))
+         {
+           /* Likewise, don't error when casting from void* when OP is
+              &heap uninit and similar.  */
+           tree sop = tree_strip_nop_conversions (op);
+           if (TREE_CODE (sop) == ADDR_EXPR
+               && VAR_P (TREE_OPERAND (sop, 0))
+               && DECL_ARTIFICIAL (TREE_OPERAND (sop, 0)))
+             /* OK */;
+           else
+             {
+               if (!ctx->quiet)
+                 error_at (loc, "cast from %qT is not allowed",
+                           TREE_TYPE (op));
+               *non_constant_p = true;
+               return t;
+             }
+         }
+
        if (TREE_CODE (op) == PTRMEM_CST && !TYPE_PTRMEM_P (type))
          op = cplus_expand_constant (op);
 
@@ -6671,26 +6717,10 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
                if (TYPE_REF_P (type))
                  {
                    if (!ctx->quiet)
-                     error_at (loc,
-                               "dereferencing a null pointer");
+                     error_at (loc, "dereferencing a null pointer");
                    *non_constant_p = true;
                    return t;
                  }
-               else if (TYPE_PTR_P (TREE_TYPE (op)))
-                 {
-                   tree from = TREE_TYPE (op);
-
-                   if (!can_convert (type, from, tf_none))
-                     {
-                       if (!ctx->quiet)
-                         error_at (loc,
-                                   "conversion of %qT null pointer to %qT "
-                                   "is not a constant expression",
-                                   from, type);
-                       *non_constant_p = true;
-                       return t;
-                     }
-                 }
              }
            else
              {

diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-cast2.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-cast2.C
new file mode 100644 (file)
index 0000000..7c37f6a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-cast2.C
@@ -0,0 +1,16 @@
+// DR 1312 - Simulated reinterpret_cast in constant expressions.
+// PR c++/99176
+// { dg-do compile { target c++11 } }
+
+static int i;
+constexpr void *vp0 = nullptr;
+constexpr void *vpi = &i;
+constexpr int *p1 = (int *) vp0; // { dg-error "cast from .void\\*. is not allowed" }
+constexpr int *p2 = (int *) vpi; // { dg-error "cast from .void\\*. is not allowed" "integer_zerop" { xfail *-*-* } }
+constexpr int *p3 = static_cast<int *>(vp0); // { dg-error "cast from .void\\*. is not allowed" }
+constexpr int *p4 = static_cast<int *>(vpi); // { dg-error "cast from .void\\*. is not allowed" "integer_zerop" { xfail *-*-* } }
+constexpr void *p5 = vp0;
+constexpr void *p6 = vpi;
+
+constexpr int *pi = &i;
+constexpr bool b = ((int *)(void *) pi == pi); // { dg-error "cast from .void\\*. is not allowed" "integer_zerop" { xfail *-*-* } }

diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-cast3.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-cast3.C
new file mode 100644 (file)
index 0000000..a330a99
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-cast3.C
@@ -0,0 +1,14 @@
+// PR c++/99176
+// { dg-do compile { target c++11 } }
+
+constexpr const int *p = nullptr;
+constexpr int *q1 = const_cast<int*>(p);
+constexpr int *q2 = (int *)(const int *) nullptr;
+
+struct B { };
+struct D : B { };
+constexpr B *q3 = static_cast<B*>(nullptr);
+constexpr D *pd = nullptr;
+constexpr B *pb = nullptr;
+constexpr B *q4 = static_cast<B*>(pd);
+constexpr D *q5 = static_cast<D*>(pb);

diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-nullptr-2.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-nullptr-2.C
index afb4b37..92f3bbd 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-nullptr-2.C
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-nullptr-2.C
@@ -163,7 +163,7 @@ constexpr const void *pv2 = pv0;
 constexpr void *pv3 = pv2;      // { dg-error "invalid conversion|not a constant expression" }
 constexpr const void *pv4 = pv2;
 
-constexpr X *px4 = pv0;         // { dg-error "invalid conversion|not a constant expression" }
+constexpr X *px4 = pv0;         // { dg-error "cast from|invalid conversion|not a constant expression" }
 
 }
 
@@ -226,7 +226,7 @@ constexpr A *pa3 = pd0;                // { dg-error "ambiguous base" }
 constexpr A *pa4 = static_cast<A*>(pd0);  // { dg-error "ambiguous base" }
 
 constexpr B *pb1 = pa0;                   // { dg-error "invalid conversion|not a constant expression" }
-constexpr B *pb2 = static_cast<B*>(pa0);  // { dg-error "not a constant expression" }
+constexpr B *pb2 = static_cast<B*>(pa0);
 
 constexpr C *pc1 = pa0;                   // { dg-error "invalid conversion|not a constant expression" }
 constexpr D *pd1 = pa0;                   // { dg-error "ambiguous base|invalid conversion" }