[Bug c++/104568] [10 Regression] ICE [c++20] caused by option "-std=c++20 -Wall" when operand of operator new has size equal to 0

["cvs-commit at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104568

--- Comment #10 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-10 branch has been updated by Jakub Jelinek
<jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:d7b94c407a2720955927d501c5a67821c010aeed

commit r10-10696-gd7b94c407a2720955927d501c5a67821c010aeed
Author: Jakub Jelinek <jakub@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  <jakub@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)