https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104568
--- Comment #8 from CVS Commits <cvs-commit at gcc dot gnu.org> --- The releases/gcc-11 branch has been updated by Jakub Jelinek <ja...@gcc.gnu.org>: https://gcc.gnu.org/g:18f5bc87bc2eef70991b9c93d1265a7d0ebed58b commit r11-9730-g18f5bc87bc2eef70991b9c93d1265a7d0ebed58b Author: Jakub Jelinek <ja...@redhat.com> Date: Fri Mar 18 18:49:23 2022 +0100 c++: Fix up constexpr evaluation of new with zero sized types [PR104568] The new expression constant expression evaluation right now tries to deduce how many elts the array it uses for the heap or heap [] vars should have (or how many elts should its trailing array have if it has cookie at the start). As new is lowered at that point to (some_type *) ::operator new (size) or so, it computes it by subtracting cookie size if any from size, then divides the result by sizeof (some_type). This works fine for most types, except when sizeof (some_type) is 0, then we divide by zero; size is then equal to cookie_size (or if there is no cookie, to 0). The following patch special cases those cases so that we don't divide by zero and also recover the original outer_nelts from the expression by forcing the size not to be folded in that case but be explicit 0 * outer_nelts or cookie_size + 0 * outer_nelts. Note, we have further issues, we accept-invalid various cases, for both zero sized elt_type and even non-zero sized elts, we aren't able to diagnose out of bounds POINTER_PLUS_EXPR like: constexpr bool foo () { auto p = new int[2]; auto q1 = &p[0]; auto q2 = &p[1]; auto q3 = &p[2]; auto q4 = &p[3]; delete[] p; return true; } constexpr bool a = foo (); That doesn't look like a regression so I think we should resolve that for GCC 13, but there are 2 problems. Figure out why cxx_fold_pointer_plus_expression doesn't deal with the &heap [] etc. cases, and for the zero sized arrays, I think we really need to preserve whether user wrote an array ref or pointer addition, because in the &p[3] case if sizeof(p[0]) == 0 we know that if it has 2 elements it is out of bounds, while if we see p p+ 0 the information if it was p + 2 or p + 3 in the source is lost. clang++ seems to handle it fine even in the zero sized cases or with new expressions. 2022-03-18 Jakub Jelinek <ja...@redhat.com> PR c++/104568 * init.c (build_new_constexpr_heap_type): Remove FULL_SIZE argument and its handling, instead add ITYPE2 argument. Only support COOKIE_SIZE != NULL. (build_new_1): If size is 0, change it to 0 * outer_nelts if outer_nelts is non-NULL. Pass type rather than elt_type to maybe_wrap_new_for_constexpr. * constexpr.c (build_new_constexpr_heap_type): New function. (cxx_eval_constant_expression) <case CONVERT_EXPR>: If elt_size is zero sized type, try to recover outer_nelts from the size argument to operator new/new[] and pass that as arg_size to build_new_constexpr_heap_type. Pass ctx, non_constant_p and overflow_p to that call too. * g++.dg/cpp2a/constexpr-new22.C: New test. (cherry picked from commit 0a0c2c3f06227d46b5e9542dfdd4e0fd2d67d894)
