[gcc r15-1688] libstdc++: Enable more debug assertions during constant evaluation [PR111250]

[Jonathan Wakely]

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

commit r15-1688-gcfc9fa3bdddc1af59b7854937b99516067fd8c63
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Tue Jun 18 20:57:13 2024 +0100

    libstdc++: Enable more debug assertions during constant evaluation [PR111250]
    
    Some of our debug assertions expand to nothing unless
    _GLIBCXX_ASSERTIONS is defined, which means they are not checked during
    constant evaluation. By making them unconditionally expand to a
    __glibcxx_assert expression they will be checked during constant
    evaluation. This allows us to diagnose more instances of undefined
    behaviour at compile-time, such as accessing a vector past-the-end.
    
    libstdc++-v3/ChangeLog:
    
            PR libstdc++/111250
            * include/debug/assertions.h (__glibcxx_requires_non_empty_range)
            (__glibcxx_requires_nonempty, __glibcxx_requires_subscript):
            Define to __glibcxx_assert expressions or to debug mode
            __glibcxx_check_xxx expressions.
            * testsuite/23_containers/array/element_access/constexpr_c++17.cc:
            Add checks for out-of-bounds accesses in constant expressions.
            * testsuite/23_containers/vector/element_access/constexpr.cc:
            Likewise.

Diff:
---
 libstdc++-v3/include/debug/assertions.h            | 14 ++++---
 .../array/element_access/constexpr_c++17.cc        | 44 ++++++++++++++++++++++
 .../vector/element_access/constexpr.cc             | 24 ++++++++++--
 3 files changed, 72 insertions(+), 10 deletions(-)

diff --git a/libstdc++-v3/include/debug/assertions.h b/libstdc++-v3/include/debug/assertions.h
index fff1ae8def0..20441e33897 100644
--- a/libstdc++-v3/include/debug/assertions.h
+++ b/libstdc++-v3/include/debug/assertions.h
@@ -31,12 +31,7 @@
 
 #include <bits/c++config.h>
 
-#ifndef _GLIBCXX_ASSERTIONS
-# define __glibcxx_requires_non_empty_range(_First,_Last)
-# define __glibcxx_requires_nonempty()
-# define __glibcxx_requires_subscript(_N)
-#else
-
+#ifndef _GLIBCXX_DEBUG
 // Verify that [_First, _Last) forms a non-empty iterator range.
 # define __glibcxx_requires_non_empty_range(_First,_Last)	\
   __glibcxx_assert(_First != _Last)
@@ -45,6 +40,13 @@
 // Verify that the container is nonempty
 # define __glibcxx_requires_nonempty()		\
   __glibcxx_assert(!this->empty())
+#else // Use the more verbose Debug Mode checks.
+# define __glibcxx_requires_non_empty_range(_First,_Last) \
+  __glibcxx_check_non_empty_range(_First,_Last)
+# define __glibcxx_requires_nonempty() \
+  __glibcxx_check_nonempty()
+# define __glibcxx_requires_subscript(_N) \
+  __glibcxx_check_subscript(_N)
 #endif
 
 #if defined _GLIBCXX_DEBUG && _GLIBCXX_HOSTED
diff --git a/libstdc++-v3/testsuite/23_containers/array/element_access/constexpr_c++17.cc b/libstdc++-v3/testsuite/23_containers/array/element_access/constexpr_c++17.cc
index a14ad487b42..19ab1cc1f8e 100644
--- a/libstdc++-v3/testsuite/23_containers/array/element_access/constexpr_c++17.cc
+++ b/libstdc++-v3/testsuite/23_containers/array/element_access/constexpr_c++17.cc
@@ -66,3 +66,47 @@ constexpr bool test_zero()
 }
 
 static_assert( test_zero() );
+
+#ifdef __cpp_concepts
+template<typename T = int>
+  constexpr std::false_type
+  access_empty() { return {}; }
+
+template<typename T = int>
+  requires (std::bool_constant<&std::array<T, 0>{}.at(0) != nullptr>::value)
+  constexpr std::true_type
+  access_empty() { return {}; }
+
+template<typename T = int>
+  requires (std::bool_constant<&std::array<T, 0>{}[0] != nullptr>::value)
+  constexpr std::true_type
+  access_empty() { return {}; }
+
+template<typename T = int>
+  requires (std::bool_constant<&std::array<T, 0>{}.front() != nullptr>::value)
+  constexpr std::true_type
+  access_empty() { return {}; }
+
+template<typename T = int>
+  requires (std::bool_constant<&std::array<T, 0>{}.back() != nullptr>::value)
+  constexpr std::true_type
+  access_empty() { return {}; }
+
+static_assert( ! access_empty() );
+
+template<typename T = int>
+  constexpr std::false_type
+  access_past_the_end() { return {}; }
+
+template<typename T = int>
+  requires (std::bool_constant<std::array<T, 1>{}.at(0) != nullptr>::value)
+  constexpr std::true_type
+  access_past_the_end() { return {}; }
+
+template<typename T = int>
+  requires (std::bool_constant<&std::array<T, 1>{}[1] != nullptr>::value)
+  constexpr std::true_type
+  access_past_the_end() { return {}; }
+
+static_assert( ! access_past_the_end() );
+#endif
diff --git a/libstdc++-v3/testsuite/23_containers/vector/element_access/constexpr.cc b/libstdc++-v3/testsuite/23_containers/vector/element_access/constexpr.cc
index 19c91d28cd6..358ded47ad9 100644
--- a/libstdc++-v3/testsuite/23_containers/vector/element_access/constexpr.cc
+++ b/libstdc++-v3/testsuite/23_containers/vector/element_access/constexpr.cc
@@ -85,23 +85,39 @@ template<typename T = int>
   access_empty() { return {}; }
 
 template<typename T = int>
-  requires (std::bool_constant<(std::vector<T>().at(0), true)>::value)
+  requires (std::bool_constant<&std::vector<T>().at(0) != nullptr>::value)
   constexpr std::true_type
   access_empty() { return {}; }
 
 template<typename T = int>
-  requires (std::bool_constant<(std::vector<T>()[0], true)>::value)
+  requires (std::bool_constant<&std::vector<T>()[0] != nullptr>::value)
   constexpr std::true_type
   access_empty() { return {}; }
 
 template<typename T = int>
-  requires (std::bool_constant<(std::vector<T>().front(), true)>::value)
+  requires (std::bool_constant<&std::vector<T>().front() != nullptr>::value)
   constexpr std::true_type
   access_empty() { return {}; }
 
 template<typename T = int>
-  requires (std::bool_constant<(std::vector<T>().back(), true)>::value)
+  requires (std::bool_constant<&std::vector<T>().back() != nullptr>::value)
   constexpr std::true_type
   access_empty() { return {}; }
 
 static_assert( ! access_empty() );
+
+template<typename T = int>
+  constexpr std::false_type
+  access_past_the_end() { return {}; }
+
+template<typename T = int>
+  requires (std::bool_constant<&std::vector<T>(3).at(3) != nullptr>::value)
+  constexpr std::true_type
+  access_past_the_end() { return {}; }
+
+template<typename T = int>
+  requires (std::bool_constant<&std::vector<T>(3)[3] != nullptr>::value)
+  constexpr std::true_type
+  access_past_the_end() { return {}; }
+
+static_assert( ! access_past_the_end() );