This is the mail archive of the libstdc++@gcc.gnu.org mailing list for the libstdc++ project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[patch] Enable lightweight checks with _GLIBCXX_ASSERTIONS.


This patch adds the "debug mode lite" we've been talking about, by
changing __glibcxx_assert to be activated by _GLIBCXX_ASSERTIONS
instead of _GLIBCXX_DEBUG (and making the latter imply the former).

_GLIBCXX_ASSERTIONS is already used in Parallel Mode for enabling
optional assertions (although some of them are O(n) and so we might
want to change them to use another macro like _GLIBCXX_DEBUG or
_GLIBCXX_PARALLEL_ASSERTIONS instead).

With the change to define __glibcxx_assert() without Debug Mode we can
change most uses of _GLIBCXX_DEBUG_ASSERT to simply __glibcxx_assert,
so that the assertion is done when _GLIBCXX_ASSERTIONS is defined (not
only in Debug Mode).

I haven't added any new assertions yet, this just converts the
lightweight Debug Mode checks, but the next step will be to add
additional assertions to the (normal mode) containers. The google
branches contain several good examples of checks to add.

François, what do you think of this approach?


commit 10af11a95e3a7341f6371801e37ff140e197e634
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Mon Sep 7 14:05:23 2015 +0100

    Enable lightweight checks with _GLIBCXX_ASSERTIONS.
    
    	* doc/xml/manual/using.xml (_GLIBCXX_ASSERTIONS): Document.
    	* doc/html/manual/using_macros.html: Regenerate.
    	* include/bits/c++config: Define _GLIBCXX_ASSERTIONS when
    	_GLIBCXX_DEBUG is defined. Disable std::string extern templates when
    	(_GLIBCXX_EXTERN_TEMPLATE, __glibcxx_assert): Depend on
    	_GLIBCXX_ASSERTIONS instead of _GLIBCXX_DEBUG.
    	* include/debug/debug.h [!_GLIBCXX_DEBUG]: Define
    	__glibcxx_requires_non_empty_range and __glibcxx_requires_nonempty.
    	* include/backward/auto_ptr.h (auto_ptr::operator*,
    	auto_ptr::operator->): Replace _GLIBCXX_DEBUG_ASSERT with
    	__glibcxx_assert.
    	* include/bits/basic_string.h (basic_string::operator[],
    	basic_string::front, basic_string::back, basic_string::pop_back):
    	Likewise.
    	* include/bits/random.h
    	(uniform_int_distribution::param_type::param_type,
    	uniform_real_distribution::param_type::param_type,
    	normal_distribution::param_type::param_type,
    	gamma_distribution::param_type::param_type,
    	bernoulli_distribution::param_type::param_type,
    	binomial_distribution::param_type::param_type,
    	geometric_distribution::param_type::param_type,
    	negative_binomial_distribution::param_type::param_type,
    	poisson_distribution::param_type::param_type,
    	exponential_distribution::param_type::param_type): Likewise.
    	* include/bits/regex.h (match_results::operator[],
    	match_results::prefix, match_results::suffix): Likewise.
    	* include/bits/regex.tcc (format, regex_iterator::operator++):
    	Likewise.
    	* include/bits/regex_automaton.tcc (_StateSeq::_M_clone): Likewise.
    	* include/bits/regex_compiler.tcc (_Compiler::_Compiler,
    	_Compiler::_M_insert_character_class_matcher): Likewise.
    	* include/bits/regex_executor.tcc (_Executor::_M_dfs): Likewise.
    	* include/bits/regex_scanner.tcc (_Scanner::_M_advance,
    	_Scanner::_M_scan_normal): Likewise.
    	* include/bits/shared_ptr_base.h (__shared_ptr::_M_reset,
    	__shared_ptr::operator*): Likewise.
    	* include/bits/stl_iterator_base_funcs.h (__advance): Likewise.
    	* include/bits/unique_ptr.h (unique_ptr::operator*,
    	unique_ptr::operator[]): Likewise.
    	* include/experimental/fs_path.h (path::path(string_type, _Type),
    	path::iterator::operator++, path::iterator::operator--,
    	path::iterator::operator*): Likewise.
    	* include/experimental/string_view (basic_string_view::operator[],
    	basic_string_view::front, basic_string_view::back,
    	basic_string_view::remove_prefix): Likewise.
    	* include/ext/random (beta_distribution::param_type::param_type,
    	normal_mv_distribution::param_type::param_type,
    	rice_distribution::param_type::param_type,
    	pareto_distribution::param_type::param_type,
    	k_distribution::param_type::param_type,
    	arcsine_distribution::param_type::param_type,
    	hoyt_distribution::param_type::param_type,
    	triangular_distribution::param_type::param_type,
    	von_mises_distribution::param_type::param_type,
    	hypergeometric_distribution::param_type::param_type,
    	logistic_distribution::param_type::param_type): Likewise.
    	* include/ext/vstring.h (__versa_string::operator[]): Likewise.
    	* include/std/complex (polar): Likewise.
    	* include/std/mutex [!_GTHREAD_USE_MUTEX_TIMEDLOCK]
    	(timed_mutex::~timed_mutex, timed_mutex::unlock,
    	(recursive_timed_mutex::~timed_mutex, recursive_timed_mutex::unlock):
    	Likewise.
    	* include/std/shared_mutex [!PTHREAD_RWLOCK_INITIALIZER]
    	(__shared_mutex_pthread::__shared_mutex_pthread,
    	__shared_mutex_pthread::~__shared_mutex_pthread): Likewise.
    	(__shared_mutex_pthread::lock, __shared_mutex_pthread::try_lock,
    	__shared_mutex_pthread::unlock, __shared_mutex_pthread::lock_shared,
    	__shared_mutex_pthread::try_lock_shared): Likewise.
    	(__shared_mutex_cv::~__shared_mutex_cv, __shared_mutex_cv::unlock,
    	__shared_mutex_cv::unlock_shared): Likewise.
    	(shared_timed_mutex::try_lock_until,
    	shared_timed_mutex::try_lock_shared_until): Likewise.
    	* include/std/valarray (valarray::valarray(const _Tp*, size_t),
    	valarray::operator=, valarray::sum, valarray::min, valarray::max,
    	_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT, _DEFINE_BINARY_OPERATOR):
    	Likewise.

diff --git a/libstdc++-v3/doc/xml/manual/using.xml b/libstdc++-v3/doc/xml/manual/using.xml
index 34b4883..a6447d4 100644
--- a/libstdc++-v3/doc/xml/manual/using.xml
+++ b/libstdc++-v3/doc/xml/manual/using.xml
@@ -903,11 +903,22 @@ g++ -Winvalid-pch -I. -include stdc++.h -H -g -O2 hello.cc -o test.exe
       </para>
     </listitem></varlistentry>
 
+    <varlistentry><term><code>_GLIBCXX_ASSERTIONS</code></term>
+    <listitem>
+      <para>
+	Undefined by default. When defined, enables extra error checking in
+        the form of precondition assertions, such as bounds checking in
+        strings and null pointer checks when dereferencing smart pointers.
+      </para>
+    </listitem></varlistentry>
     <varlistentry><term><code>_GLIBCXX_DEBUG</code></term>
     <listitem>
       <para>
 	Undefined by default. When defined, compiles user code using
 	the <link linkend="manual.ext.debug_mode">debug mode</link>.
+        When defined, <code>_GLIBCXX_ASSERTIONS</code> is defined
+        automatically, so all the assertions that enables are also enabled
+        in debug mode.
       </para>
     </listitem></varlistentry>
     <varlistentry><term><code>_GLIBCXX_DEBUG_PEDANTIC</code></term>
diff --git a/libstdc++-v3/include/backward/auto_ptr.h b/libstdc++-v3/include/backward/auto_ptr.h
index a6aa2eb..c2bd1aa 100644
--- a/libstdc++-v3/include/backward/auto_ptr.h
+++ b/libstdc++-v3/include/backward/auto_ptr.h
@@ -180,7 +180,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       element_type&
       operator*() const throw() 
       {
-	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	__glibcxx_assert(_M_ptr != 0);
 	return *_M_ptr; 
       }
       
@@ -193,7 +193,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       element_type*
       operator->() const throw() 
       {
-	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	__glibcxx_assert(_M_ptr != 0);
 	return _M_ptr; 
       }
       
diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
index 3ba6fc8..3226617 100644
--- a/libstdc++-v3/include/bits/basic_string.h
+++ b/libstdc++-v3/include/bits/basic_string.h
@@ -830,7 +830,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       const_reference
       operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
       {
-	_GLIBCXX_DEBUG_ASSERT(__pos <= size());
+	__glibcxx_assert(__pos <= size());
 	return _M_data()[__pos];
       }
 
@@ -849,7 +849,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       {
         // Allow pos == size() both in C++98 mode, as v3 extension,
 	// and in C++11 mode.
-	_GLIBCXX_DEBUG_ASSERT(__pos <= size());
+	__glibcxx_assert(__pos <= size());
         // In pedantic mode be strict in C++98 mode.
 	_GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
 	return _M_data()[__pos];
@@ -905,7 +905,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       reference
       front() noexcept
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	return operator[](0);
       }
 
@@ -916,7 +916,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       const_reference
       front() const noexcept
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	return operator[](0);
       }
 
@@ -927,7 +927,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       reference
       back() noexcept
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	return operator[](this->size() - 1);
       }
 
@@ -938,7 +938,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       const_reference
       back() const noexcept
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	return operator[](this->size() - 1);
       }
 #endif
@@ -1520,7 +1520,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       void
       pop_back() noexcept
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	_M_erase(size() - 1, 1);
       }
 #endif // C++11
@@ -3276,7 +3276,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
       const_reference
       operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
       {
-	_GLIBCXX_DEBUG_ASSERT(__pos <= size());
+	__glibcxx_assert(__pos <= size());
 	return _M_data()[__pos];
       }
 
@@ -3295,7 +3295,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
       {
         // Allow pos == size() both in C++98 mode, as v3 extension,
 	// and in C++11 mode.
-	_GLIBCXX_DEBUG_ASSERT(__pos <= size());
+	__glibcxx_assert(__pos <= size());
         // In pedantic mode be strict in C++98 mode.
 	_GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size());
 	_M_leak();
@@ -3354,7 +3354,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
       reference
       front()
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	return operator[](0);
       }
 
@@ -3365,7 +3365,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
       const_reference
       front() const _GLIBCXX_NOEXCEPT
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	return operator[](0);
       }
 
@@ -3376,7 +3376,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
       reference
       back()
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	return operator[](this->size() - 1);
       }
 
@@ -3387,7 +3387,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
       const_reference
       back() const _GLIBCXX_NOEXCEPT
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	return operator[](this->size() - 1);
       }
 #endif
@@ -3877,7 +3877,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
       void
       pop_back() // FIXME C++11: should be noexcept.
       {
-	_GLIBCXX_DEBUG_ASSERT(!empty());
+	__glibcxx_assert(!empty());
 	erase(size() - 1, 1);
       }
 #endif // C++11
diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config
index d450f61..924f13e 100644
--- a/libstdc++-v3/include/bits/c++config
+++ b/libstdc++-v3/include/bits/c++config
@@ -138,7 +138,7 @@
 # endif
 #endif
 
-// Macro for extern template, ie controling template linkage via use
+// Macro for extern template, ie controlling template linkage via use
 // of extern keyword on template declaration. As documented in the g++
 // manual, it inhibits all implicit instantiations and is used
 // throughout the library to avoid multiple weak definitions for
@@ -350,8 +350,6 @@ namespace std
 	 namespace _GLIBCXX_STD_C { _GLIBCXX_BEGIN_NAMESPACE_VERSION
 # define _GLIBCXX_END_NAMESPACE_CONTAINER \
 	 _GLIBCXX_END_NAMESPACE_VERSION }
-# undef _GLIBCXX_EXTERN_TEMPLATE
-# define _GLIBCXX_EXTERN_TEMPLATE -1
 #endif
 
 #ifdef _GLIBCXX_PARALLEL
@@ -414,8 +412,19 @@ namespace std
 # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL
 #endif
 
+// Debug Mode implies checking assertions.
+#ifdef _GLIBCXX_DEBUG
+# define _GLIBCXX_ASSERTIONS
+#endif
+
+// Disable std::string explicit instantiation declarations in order to assert.
+#ifdef _GLIBCXX_ASSERTIONS
+# undef _GLIBCXX_EXTERN_TEMPLATE
+# define _GLIBCXX_EXTERN_TEMPLATE -1
+#endif
+
 // Assert.
-#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PARALLEL)
+#if !defined(_GLIBCXX_ASSERTIONS) && !defined(_GLIBCXX_PARALLEL)
 # define __glibcxx_assert(_Condition)
 #else
 namespace std
diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h
index 5905e60..b29df30 100644
--- a/libstdc++-v3/include/bits/random.h
+++ b/libstdc++-v3/include/bits/random.h
@@ -1680,7 +1680,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   _IntType __b = std::numeric_limits<_IntType>::max())
 	: _M_a(__a), _M_b(__b)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
+	  __glibcxx_assert(_M_a <= _M_b);
 	}
 
 	result_type
@@ -1881,7 +1881,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   _RealType __b = _RealType(1))
 	: _M_a(__a), _M_b(__b)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
+	  __glibcxx_assert(_M_a <= _M_b);
 	}
 
 	result_type
@@ -2099,7 +2099,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   _RealType __stddev = _RealType(1))
 	: _M_mean(__mean), _M_stddev(__stddev)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_stddev > _RealType(0));
+	  __glibcxx_assert(_M_stddev > _RealType(0));
 	}
 
 	_RealType
@@ -2517,7 +2517,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   _RealType __beta_val = _RealType(1))
 	: _M_alpha(__alpha_val), _M_beta(__beta_val)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
+	  __glibcxx_assert(_M_alpha > _RealType(0));
 	  _M_initialize();
 	}
 
@@ -3582,7 +3582,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       param_type(double __p = 0.5)
       : _M_p(__p)
       {
-	_GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
+	__glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
       }
 
       double
@@ -3791,7 +3791,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	param_type(_IntType __t = _IntType(1), double __p = 0.5)
 	: _M_t(__t), _M_p(__p)
 	{
-	  _GLIBCXX_DEBUG_ASSERT((_M_t >= _IntType(0))
+	  __glibcxx_assert((_M_t >= _IntType(0))
 				&& (_M_p >= 0.0)
 				&& (_M_p <= 1.0));
 	  _M_initialize();
@@ -4022,7 +4022,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	param_type(double __p = 0.5)
 	: _M_p(__p)
 	{
-	  _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
+	  __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
 	  _M_initialize();
 	}
 
@@ -4221,7 +4221,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	param_type(_IntType __k = 1, double __p = 0.5)
 	: _M_k(__k), _M_p(__p)
 	{
-	  _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
+	  __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
 	}
 
 	_IntType
@@ -4444,7 +4444,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	param_type(double __mean = 1.0)
 	: _M_mean(__mean)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
+	  __glibcxx_assert(_M_mean > 0.0);
 	  _M_initialize();
 	}
 
@@ -4659,7 +4659,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	param_type(_RealType __lambda = _RealType(1))
 	: _M_lambda(__lambda)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_lambda > _RealType(0));
+	  __glibcxx_assert(_M_lambda > _RealType(0));
 	}
 
 	_RealType
diff --git a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h
index a23c2c9..07fed56 100644
--- a/libstdc++-v3/include/bits/regex.h
+++ b/libstdc++-v3/include/bits/regex.h
@@ -1693,7 +1693,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       const_reference
       operator[](size_type __sub) const
       {
-	_GLIBCXX_DEBUG_ASSERT( ready() );
+	__glibcxx_assert( ready() );
 	return __sub < size()
 	       ? _Base_type::operator[](__sub)
 	       : _M_unmatched_sub();
@@ -1710,7 +1710,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       const_reference
       prefix() const
       {
-	_GLIBCXX_DEBUG_ASSERT( ready() );
+	__glibcxx_assert( ready() );
 	return !empty() ? _M_prefix() : _M_unmatched_sub();
       }
 
@@ -1725,7 +1725,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
       const_reference
       suffix() const
       {
-	_GLIBCXX_DEBUG_ASSERT( ready() );
+	__glibcxx_assert( ready() );
 	return !empty() ? _M_suffix() : _M_unmatched_sub();
       }
 
diff --git a/libstdc++-v3/include/bits/regex.tcc b/libstdc++-v3/include/bits/regex.tcc
index fedc2b9..ec220fd 100644
--- a/libstdc++-v3/include/bits/regex.tcc
+++ b/libstdc++-v3/include/bits/regex.tcc
@@ -362,7 +362,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	   const match_results<_Bi_iter, _Alloc>::char_type* __fmt_last,
 	   match_flag_type __flags) const
     {
-      _GLIBCXX_DEBUG_ASSERT( ready() );
+      __glibcxx_assert( ready() );
       regex_traits<char_type> __traits;
       typedef std::ctype<char_type> __ctype_type;
       const __ctype_type&
@@ -535,7 +535,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 				   | regex_constants::match_not_null
 				   | regex_constants::match_continuous))
 		    {
-		      _GLIBCXX_DEBUG_ASSERT(_M_match[0].matched);
+		      __glibcxx_assert(_M_match[0].matched);
 		      auto& __prefix = _M_match._M_prefix();
 		      __prefix.first = __prefix_first;
 		      __prefix.matched = __prefix.first != __prefix.second;
@@ -550,7 +550,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  _M_flags |= regex_constants::match_prev_avail;
 	  if (regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags))
 	    {
-	      _GLIBCXX_DEBUG_ASSERT(_M_match[0].matched);
+	      __glibcxx_assert(_M_match[0].matched);
 	      auto& __prefix = _M_match._M_prefix();
 	      __prefix.first = __prefix_first;
 	      __prefix.matched = __prefix.first != __prefix.second;
diff --git a/libstdc++-v3/include/bits/regex_automaton.tcc b/libstdc++-v3/include/bits/regex_automaton.tcc
index cecc407..f6f63a1 100644
--- a/libstdc++-v3/include/bits/regex_automaton.tcc
+++ b/libstdc++-v3/include/bits/regex_automaton.tcc
@@ -216,13 +216,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  auto& __ref = _M_nfa[__v];
 	  if (__ref._M_next != _S_invalid_state_id)
 	    {
-	      _GLIBCXX_DEBUG_ASSERT(__m.count(__ref._M_next) > 0);
+	      __glibcxx_assert(__m.count(__ref._M_next) > 0);
 	      __ref._M_next = __m[__ref._M_next];
 	    }
 	  if (__ref._M_has_alt())
 	    if (__ref._M_alt != _S_invalid_state_id)
 	      {
-		_GLIBCXX_DEBUG_ASSERT(__m.count(__ref._M_alt) > 0);
+		__glibcxx_assert(__m.count(__ref._M_alt) > 0);
 		__ref._M_alt = __m[__ref._M_alt];
 	      }
 	}
diff --git a/libstdc++-v3/include/bits/regex_compiler.tcc b/libstdc++-v3/include/bits/regex_compiler.tcc
index 9a62311..336a2e8 100644
--- a/libstdc++-v3/include/bits/regex_compiler.tcc
+++ b/libstdc++-v3/include/bits/regex_compiler.tcc
@@ -83,7 +83,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       if (!_M_match_token(_ScannerT::_S_token_eof))
 	__throw_regex_error(regex_constants::error_paren);
       __r._M_append(_M_pop());
-      _GLIBCXX_DEBUG_ASSERT(_M_stack.empty());
+      __glibcxx_assert(_M_stack.empty());
       __r._M_append(_M_nfa->_M_insert_subexpr_end());
       __r._M_append(_M_nfa->_M_insert_accept());
       _M_nfa->_M_eliminate_dummy();
@@ -399,7 +399,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _Compiler<_TraitsT>::
     _M_insert_character_class_matcher()
     {
-      _GLIBCXX_DEBUG_ASSERT(_M_value.size() == 1);
+      __glibcxx_assert(_M_value.size() == 1);
       _BracketMatcher<_TraitsT, __icase, __collate> __matcher
 	(_M_ctype.is(_CtypeT::upper, _M_value[0]), _M_traits);
       __matcher._M_add_character_class(_M_value, false);
diff --git a/libstdc++-v3/include/bits/regex_executor.tcc b/libstdc++-v3/include/bits/regex_executor.tcc
index 3fd17f6..a13f0d5 100644
--- a/libstdc++-v3/include/bits/regex_executor.tcc
+++ b/libstdc++-v3/include/bits/regex_executor.tcc
@@ -305,7 +305,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	// If matched, keep going; else just return and try another state.
 	case _S_opcode_backref:
 	  {
-	    _GLIBCXX_DEBUG_ASSERT(__dfs_mode);
+	    __glibcxx_assert(__dfs_mode);
 	    auto& __submatch = _M_cur_results[__state._M_backref_index];
 	    if (!__submatch.matched)
 	      break;
@@ -333,7 +333,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	case _S_opcode_accept:
 	  if (__dfs_mode)
 	    {
-	      _GLIBCXX_DEBUG_ASSERT(!_M_has_sol);
+	      __glibcxx_assert(!_M_has_sol);
 	      if (__match_mode == _Match_mode::_Exact)
 		_M_has_sol = _M_current == _M_end;
 	      else
@@ -347,7 +347,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		    _M_results = _M_cur_results;
 		  else // POSIX
 		    {
-		      _GLIBCXX_DEBUG_ASSERT(_M_states._M_get_sol_pos());
+		      __glibcxx_assert(_M_states._M_get_sol_pos());
 		      // Here's POSIX's logic: match the longest one. However
 		      // we never know which one (lhs or rhs of "|") is longer
 		      // unless we try both of them and compare the results.
@@ -400,7 +400,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    }
 	  break;
 	default:
-	  _GLIBCXX_DEBUG_ASSERT(false);
+	  __glibcxx_assert(false);
 	}
     }
 
diff --git a/libstdc++-v3/include/bits/regex_scanner.tcc b/libstdc++-v3/include/bits/regex_scanner.tcc
index 1555669..c158c65 100644
--- a/libstdc++-v3/include/bits/regex_scanner.tcc
+++ b/libstdc++-v3/include/bits/regex_scanner.tcc
@@ -84,7 +84,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_M_scan_in_brace();
       else
 	{
-	  _GLIBCXX_DEBUG_ASSERT(false);
+	  __glibcxx_assert(false);
 	}
     }
 
@@ -186,7 +186,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		_M_token = __it->second;
 		return;
 	      }
-	  _GLIBCXX_DEBUG_ASSERT(false);
+	  __glibcxx_assert(false);
 	}
       else
 	{
diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h
index 75f1a0d..1a96b4c 100644
--- a/libstdc++-v3/include/bits/shared_ptr_base.h
+++ b/libstdc++-v3/include/bits/shared_ptr_base.h
@@ -1029,7 +1029,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	reset(_Tp1* __p) // _Tp1 must be complete.
 	{
 	  // Catch self-reset errors.
-	  _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
+	  __glibcxx_assert(__p == 0 || __p != _M_ptr);
 	  __shared_ptr(__p).swap(*this);
 	}
 
@@ -1047,7 +1047,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typename std::add_lvalue_reference<_Tp>::type
       operator*() const noexcept
       {
-	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
+	__glibcxx_assert(_M_ptr != 0);
 	return *_M_ptr;
       }
 
diff --git a/libstdc++-v3/include/bits/stl_iterator_base_funcs.h b/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
index 0f77329..5d6d028 100644
--- a/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
+++ b/libstdc++-v3/include/bits/stl_iterator_base_funcs.h
@@ -145,7 +145,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       // concept requirements
       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
-      _GLIBCXX_DEBUG_ASSERT(__n >= 0);
+      __glibcxx_assert(__n >= 0);
       while (__n--)
 	++__i;
     }
diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h
index bb96951..6344923 100644
--- a/libstdc++-v3/include/bits/unique_ptr.h
+++ b/libstdc++-v3/include/bits/unique_ptr.h
@@ -287,7 +287,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typename add_lvalue_reference<element_type>::type
       operator*() const
       {
-	_GLIBCXX_DEBUG_ASSERT(get() != pointer());
+	__glibcxx_assert(get() != pointer());
 	return *get();
       }
 
@@ -555,7 +555,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typename std::add_lvalue_reference<element_type>::type
       operator[](size_t __i) const
       {
-	_GLIBCXX_DEBUG_ASSERT(get() != pointer());
+	__glibcxx_assert(get() != pointer());
 	return get()[__i];
       }
 
diff --git a/libstdc++-v3/include/debug/debug.h b/libstdc++-v3/include/debug/debug.h
index 6b52b0a..b5935fe 100644
--- a/libstdc++-v3/include/debug/debug.h
+++ b/libstdc++-v3/include/debug/debug.h
@@ -62,7 +62,6 @@ namespace __gnu_debug
 
 # define __glibcxx_requires_cond(_Cond,_Msg)
 # define __glibcxx_requires_valid_range(_First,_Last)
-# define __glibcxx_requires_non_empty_range(_First,_Last)
 # define __glibcxx_requires_sorted(_First,_Last)
 # define __glibcxx_requires_sorted_pred(_First,_Last,_Pred)
 # define __glibcxx_requires_sorted_set(_First1,_Last1,_First2)
@@ -73,7 +72,6 @@ namespace __gnu_debug
 # define __glibcxx_requires_partitioned_upper_pred(_First,_Last,_Value,_Pred)
 # define __glibcxx_requires_heap(_First,_Last)
 # define __glibcxx_requires_heap_pred(_First,_Last,_Pred)
-# define __glibcxx_requires_nonempty()
 # define __glibcxx_requires_string(_String)
 # define __glibcxx_requires_string_len(_String,_Len)
 # define __glibcxx_requires_subscript(_N)
@@ -82,6 +80,18 @@ namespace __gnu_debug
 # define __glibcxx_requires_irreflexive_pred(_First,_Last,_Pred)
 # define __glibcxx_requires_irreflexive_pred2(_First,_Last,_Pred)
 
+#ifdef _GLIBCXX_ASSERTIONS
+// Verify that [_First, _Last) forms a non-empty iterator range.
+# define __glibcxx_requires_non_empty_range(_First,_Last) \
+  __glibcxx_assert(_First != _Last)
+// Verify that the container is nonempty
+# define __glibcxx_requires_nonempty() \
+  __glibcxx_assert(! this->empty())
+#else
+# define __glibcxx_requires_non_empty_range(_First,_Last)
+# define __glibcxx_requires_nonempty()
+#endif
+
 #else
 
 # include <debug/macros.h>
diff --git a/libstdc++-v3/include/experimental/fs_path.h b/libstdc++-v3/include/experimental/fs_path.h
index d103312..5daef12 100644
--- a/libstdc++-v3/include/experimental/fs_path.h
+++ b/libstdc++-v3/include/experimental/fs_path.h
@@ -341,8 +341,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
 
     path(string_type __str, _Type __type) : _M_pathname(__str), _M_type(__type)
     {
-      _GLIBCXX_DEBUG_ASSERT(!empty());
-      _GLIBCXX_DEBUG_ASSERT(_M_type != _Type::_Multi);
+      __glibcxx_assert(!empty());
+      __glibcxx_assert(_M_type != _Type::_Multi);
     }
 
     enum class _Split { _Stem, _Extension };
@@ -948,15 +948,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
   inline path::iterator&
   path::iterator::operator++()
   {
-    _GLIBCXX_DEBUG_ASSERT(_M_path != nullptr);
+    __glibcxx_assert(_M_path != nullptr);
     if (_M_path->_M_type == _Type::_Multi)
       {
-	_GLIBCXX_DEBUG_ASSERT(_M_cur != _M_path->_M_cmpts.end());
+	__glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
 	++_M_cur;
       }
     else
       {
-	_GLIBCXX_DEBUG_ASSERT(!_M_at_end);
+	__glibcxx_assert(!_M_at_end);
 	_M_at_end = true;
       }
     return *this;
@@ -965,15 +965,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
   inline path::iterator&
   path::iterator::operator--()
   {
-    _GLIBCXX_DEBUG_ASSERT(_M_path != nullptr);
+    __glibcxx_assert(_M_path != nullptr);
     if (_M_path->_M_type == _Type::_Multi)
       {
-	_GLIBCXX_DEBUG_ASSERT(_M_cur != _M_path->_M_cmpts.begin());
+	__glibcxx_assert(_M_cur != _M_path->_M_cmpts.begin());
 	--_M_cur;
       }
     else
       {
-	_GLIBCXX_DEBUG_ASSERT(_M_at_end);
+	__glibcxx_assert(_M_at_end);
 	_M_at_end = false;
       }
     return *this;
@@ -982,10 +982,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
   inline path::iterator::reference
   path::iterator::operator*() const
   {
-    _GLIBCXX_DEBUG_ASSERT(_M_path != nullptr);
+    __glibcxx_assert(_M_path != nullptr);
     if (_M_path->_M_type == _Type::_Multi)
       {
-	_GLIBCXX_DEBUG_ASSERT(_M_cur != _M_path->_M_cmpts.end());
+	__glibcxx_assert(_M_cur != _M_path->_M_cmpts.end());
 	return *_M_cur;
       }
     return *_M_path;
diff --git a/libstdc++-v3/include/experimental/string_view b/libstdc++-v3/include/experimental/string_view
index 9c2b773..9dca400 100644
--- a/libstdc++-v3/include/experimental/string_view
+++ b/libstdc++-v3/include/experimental/string_view
@@ -180,7 +180,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       operator[](size_type __pos) const
       {
 	// TODO: Assert to restore in a way compatible with the constexpr.
-	// _GLIBCXX_DEBUG_ASSERT(__pos < this->_M_len);
+	// __glibcxx_assert(__pos < this->_M_len);
 	return *(this->_M_str + __pos);
       }
 
@@ -200,7 +200,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       front() const
       {
 	// TODO: Assert to restore in a way compatible with the constexpr.
-	// _GLIBCXX_DEBUG_ASSERT(this->_M_len > 0);
+	// __glibcxx_assert(this->_M_len > 0);
 	return *this->_M_str;
       }
 
@@ -208,7 +208,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       back() const
       {
 	// TODO: Assert to restore in a way compatible with the constexpr.
-	// _GLIBCXX_DEBUG_ASSERT(this->_M_len > 0);
+	// __glibcxx_assert(this->_M_len > 0);
 	return *(this->_M_str + this->_M_len - 1);
       }
 
@@ -221,7 +221,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void
       remove_prefix(size_type __n)
       {
-	_GLIBCXX_DEBUG_ASSERT(this->_M_len >= __n);
+	__glibcxx_assert(this->_M_len >= __n);
 	this->_M_str += __n;
 	this->_M_len -= __n;
       }
diff --git a/libstdc++-v3/include/ext/random b/libstdc++-v3/include/ext/random
index 37bc732..be6db5d 100644
--- a/libstdc++-v3/include/ext/random
+++ b/libstdc++-v3/include/ext/random
@@ -415,8 +415,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   _RealType __beta_val = _RealType(1))
 	: _M_alpha(__alpha_val), _M_beta(__beta_val)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
-	  _GLIBCXX_DEBUG_ASSERT(_M_beta > _RealType(0));
+	  __glibcxx_assert(_M_alpha > _RealType(0));
+	  __glibcxx_assert(_M_beta > _RealType(0));
 	}
 
 	_RealType
@@ -669,8 +669,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  else if (__dist == _Dimen * (_Dimen + 1) / 2)
 	    _M_init_lower(__meanbegin, __meanend, __varcovbegin, __varcovend);
 	  else
-	    _M_init_diagonal(__meanbegin, __meanend,
-			     __varcovbegin, __varcovend);
+	    {
+	      __glibcxx_assert(__dist == _Dimen);
+	      _M_init_diagonal(__meanbegin, __meanend,
+			       __varcovbegin, __varcovend);
+	    }
 	}
 
 	param_type(std::initializer_list<_RealType> __mean,
@@ -688,8 +691,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    _M_init_lower(__mean.begin(), __mean.end(),
 			  __varcov.begin(), __varcov.end());
 	  else
-	    _M_init_diagonal(__mean.begin(), __mean.end(),
-			     __varcov.begin(), __varcov.end());
+	    {
+	      __glibcxx_assert(__varcov.size() == _Dimen);
+	      _M_init_diagonal(__mean.begin(), __mean.end(),
+			       __varcov.begin(), __varcov.end());
+	    }
 	}
 
 	std::array<_RealType, _Dimen>
@@ -945,8 +951,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   result_type __sigma_val = result_type(1))
 	: _M_nu(__nu_val), _M_sigma(__sigma_val)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_nu >= result_type(0));
-	  _GLIBCXX_DEBUG_ASSERT(_M_sigma > result_type(0));
+	  __glibcxx_assert(_M_nu >= result_type(0));
+	  __glibcxx_assert(_M_sigma > result_type(0));
 	}
 
 	result_type
@@ -1187,8 +1193,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   result_type __omega_val = result_type(1))
 	: _M_mu(__mu_val), _M_omega(__omega_val)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_mu >= result_type(0.5L));
-	  _GLIBCXX_DEBUG_ASSERT(_M_omega > result_type(0));
+	  __glibcxx_assert(_M_mu >= result_type(0.5L));
+	  __glibcxx_assert(_M_omega > result_type(0));
 	}
 
 	result_type
@@ -1420,8 +1426,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   result_type __mu_val = result_type(1))
 	: _M_alpha(__alpha_val), _M_mu(__mu_val)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_alpha > result_type(0));
-	  _GLIBCXX_DEBUG_ASSERT(_M_mu > result_type(0));
+	  __glibcxx_assert(_M_alpha > result_type(0));
+	  __glibcxx_assert(_M_mu > result_type(0));
 	}
 
 	result_type
@@ -1655,9 +1661,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   result_type __nu_val = result_type(1))
 	: _M_lambda(__lambda_val), _M_mu(__mu_val), _M_nu(__nu_val)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_lambda > result_type(0));
-	  _GLIBCXX_DEBUG_ASSERT(_M_mu > result_type(0));
-	  _GLIBCXX_DEBUG_ASSERT(_M_nu > result_type(0));
+	  __glibcxx_assert(_M_lambda > result_type(0));
+	  __glibcxx_assert(_M_mu > result_type(0));
+	  __glibcxx_assert(_M_nu > result_type(0));
 	}
 
 	result_type
@@ -1893,7 +1899,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   result_type __b = result_type(1))
 	: _M_a(__a), _M_b(__b)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
+	  __glibcxx_assert(_M_a <= _M_b);
 	}
 
 	result_type
@@ -2129,8 +2135,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   result_type __omega = result_type(1))
 	: _M_q(__q), _M_omega(__omega)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_q > result_type(0));
-	  _GLIBCXX_DEBUG_ASSERT(_M_q < result_type(1));
+	  __glibcxx_assert(_M_q > result_type(0));
+	  __glibcxx_assert(_M_q < result_type(1));
 	}
 
 	result_type
@@ -2364,9 +2370,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   _RealType __c = _RealType(1))
 	: _M_a(__a), _M_b(__b), _M_c(__c)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
-	  _GLIBCXX_DEBUG_ASSERT(_M_b <= _M_c);
-	  _GLIBCXX_DEBUG_ASSERT(_M_a < _M_c);
+	  __glibcxx_assert(_M_a <= _M_b);
+	  __glibcxx_assert(_M_b <= _M_c);
+	  __glibcxx_assert(_M_a < _M_c);
 
 	  _M_r_ab = (_M_b - _M_a) / (_M_c - _M_a);
 	  _M_f_ab_ac = (_M_b - _M_a) * (_M_c - _M_a);
@@ -2620,8 +2626,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	: _M_mu(__mu), _M_kappa(__kappa)
 	{
 	  const _RealType __pi = __gnu_cxx::__math_constants<_RealType>::__pi;
-	  _GLIBCXX_DEBUG_ASSERT(_M_mu >= -__pi && _M_mu <= __pi);
-	  _GLIBCXX_DEBUG_ASSERT(_M_kappa >= _RealType(0));
+	  __glibcxx_assert(_M_mu >= -__pi && _M_mu <= __pi);
+	  __glibcxx_assert(_M_kappa >= _RealType(0));
 
 	  auto __tau = std::sqrt(_RealType(4) * _M_kappa * _M_kappa
 				 + _RealType(1)) + _RealType(1);
@@ -2857,8 +2863,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   result_type __n = 1)
 	: _M_N{__N}, _M_K{__K}, _M_n{__n}
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_N >= _M_K);
-	  _GLIBCXX_DEBUG_ASSERT(_M_N >= _M_n);
+	  __glibcxx_assert(_M_N >= _M_K);
+	  __glibcxx_assert(_M_N >= _M_n);
 	}
 
 	result_type
@@ -3114,7 +3120,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		   result_type __b = result_type(1))
 	: _M_a(__a), _M_b(__b)
 	{
-	  _GLIBCXX_DEBUG_ASSERT(_M_b > result_type(0));
+	  __glibcxx_assert(_M_b > result_type(0));
 	}
 
 	result_type
diff --git a/libstdc++-v3/include/ext/vstring.h b/libstdc++-v3/include/ext/vstring.h
index 63349dd..94af25e 100644
--- a/libstdc++-v3/include/ext/vstring.h
+++ b/libstdc++-v3/include/ext/vstring.h
@@ -536,7 +536,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       const_reference
       operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
       {
-	_GLIBCXX_DEBUG_ASSERT(__pos <= this->size());
+	__glibcxx_assert(__pos <= this->size());
 	return this->_M_data()[__pos];
       }
 
@@ -555,7 +555,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       {
         // Allow pos == size() both in C++98 mode, as v3 extension,
 	// and in C++11 mode.
-	_GLIBCXX_DEBUG_ASSERT(__pos <= this->size());
+	__glibcxx_assert(__pos <= this->size());
         // In pedantic mode be strict in C++98 mode.
 	_GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L
 				 || __pos < this->size());
diff --git a/libstdc++-v3/include/std/complex b/libstdc++-v3/include/std/complex
index f2a6cf9..5ed4fd5 100644
--- a/libstdc++-v3/include/std/complex
+++ b/libstdc++-v3/include/std/complex
@@ -668,7 +668,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline complex<_Tp>
     polar(const _Tp& __rho, const _Tp& __theta)
     {
-      _GLIBCXX_DEBUG_ASSERT( __rho >= 0 );
+      __glibcxx_assert( __rho >= 0 );
       return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
     }
 
diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex
index 38950b6..5e5ced1 100644
--- a/libstdc++-v3/include/std/mutex
+++ b/libstdc++-v3/include/std/mutex
@@ -302,7 +302,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   public:
 
     timed_mutex() = default;
-    ~timed_mutex() { _GLIBCXX_DEBUG_ASSERT( !_M_locked ); }
+    ~timed_mutex() { __glibcxx_assert( !_M_locked ); }
 
     timed_mutex(const timed_mutex&) = delete;
     timed_mutex& operator=(const timed_mutex&) = delete;
@@ -351,7 +351,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     unlock()
     {
       lock_guard<mutex> __lk(_M_mut);
-      _GLIBCXX_DEBUG_ASSERT( _M_locked );
+      __glibcxx_assert( _M_locked );
       _M_locked = false;
       _M_cv.notify_one();
     }
@@ -380,7 +380,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   public:
 
     recursive_timed_mutex() = default;
-    ~recursive_timed_mutex() { _GLIBCXX_DEBUG_ASSERT( _M_count == 0 ); }
+    ~recursive_timed_mutex() { __glibcxx_assert( _M_count == 0 ); }
 
     recursive_timed_mutex(const recursive_timed_mutex&) = delete;
     recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
@@ -449,8 +449,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     unlock()
     {
       lock_guard<mutex> __lk(_M_mut);
-      _GLIBCXX_DEBUG_ASSERT( _M_owner == this_thread::get_id() );
-      _GLIBCXX_DEBUG_ASSERT( _M_count > 0 );
+      __glibcxx_assert( _M_owner == this_thread::get_id() );
+      __glibcxx_assert( _M_count > 0 );
       if (--_M_count == 0)
 	{
 	  _M_owner = {};
diff --git a/libstdc++-v3/include/std/shared_mutex b/libstdc++-v3/include/std/shared_mutex
index 69107cc..5ae492d 100644
--- a/libstdc++-v3/include/std/shared_mutex
+++ b/libstdc++-v3/include/std/shared_mutex
@@ -85,14 +85,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       else if (__ret == EPERM)
 	__throw_system_error(int(errc::operation_not_permitted));
       // Errors not handled: EBUSY, EINVAL
-      _GLIBCXX_DEBUG_ASSERT(__ret == 0);
+      __glibcxx_assert(__ret == 0);
     }
 
     ~__shared_mutex_pthread()
     {
       int __ret __attribute((__unused__)) = pthread_rwlock_destroy(&_M_rwlock);
       // Errors not handled: EBUSY, EINVAL
-      _GLIBCXX_DEBUG_ASSERT(__ret == 0);
+      __glibcxx_assert(__ret == 0);
     }
 #endif
 
@@ -106,7 +106,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       if (__ret == EDEADLK)
 	__throw_system_error(int(errc::resource_deadlock_would_occur));
       // Errors not handled: EINVAL
-      _GLIBCXX_DEBUG_ASSERT(__ret == 0);
+      __glibcxx_assert(__ret == 0);
     }
 
     bool
@@ -115,7 +115,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       int __ret = pthread_rwlock_trywrlock(&_M_rwlock);
       if (__ret == EBUSY) return false;
       // Errors not handled: EINVAL
-      _GLIBCXX_DEBUG_ASSERT(__ret == 0);
+      __glibcxx_assert(__ret == 0);
       return true;
     }
 
@@ -124,7 +124,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       int __ret __attribute((__unused__)) = pthread_rwlock_unlock(&_M_rwlock);
       // Errors not handled: EPERM, EBUSY, EINVAL
-      _GLIBCXX_DEBUG_ASSERT(__ret == 0);
+      __glibcxx_assert(__ret == 0);
     }
 
     // Shared ownership
@@ -143,7 +143,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       if (__ret == EDEADLK)
 	__throw_system_error(int(errc::resource_deadlock_would_occur));
       // Errors not handled: EINVAL
-      _GLIBCXX_DEBUG_ASSERT(__ret == 0);
+      __glibcxx_assert(__ret == 0);
     }
 
     bool
@@ -155,7 +155,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // an exception.
       if (__ret == EBUSY || __ret == EAGAIN) return false;
       // Errors not handled: EINVAL
-      _GLIBCXX_DEBUG_ASSERT(__ret == 0);
+      __glibcxx_assert(__ret == 0);
       return true;
     }
 
@@ -224,7 +224,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     ~__shared_mutex_cv()
     {
-      _GLIBCXX_DEBUG_ASSERT( _M_state == 0 );
+      __glibcxx_assert( _M_state == 0 );
     }
 
     __shared_mutex_cv(const __shared_mutex_cv&) = delete;
@@ -259,7 +259,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     unlock()
     {
       lock_guard<mutex> __lk(_M_mut);
-      _GLIBCXX_DEBUG_ASSERT( _M_write_entered() );
+      __glibcxx_assert( _M_write_entered() );
       _M_state = 0;
       // call notify_all() while mutex is held so that another thread can't
       // lock and unlock the mutex then destroy *this before we make the call.
@@ -294,7 +294,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     unlock_shared()
     {
       lock_guard<mutex> __lk(_M_mut);
-      _GLIBCXX_DEBUG_ASSERT( _M_readers() > 0 );
+      __glibcxx_assert( _M_readers() > 0 );
       auto __prev = _M_state--;
       if (_M_write_entered())
 	{
@@ -422,7 +422,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	if (__ret == ETIMEDOUT || __ret == EDEADLK)
 	  return false;
 	// Errors not handled: EINVAL
-	_GLIBCXX_DEBUG_ASSERT(__ret == 0);
+	__glibcxx_assert(__ret == 0);
 	return true;
       }
 
@@ -474,7 +474,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	if (__ret == ETIMEDOUT)
 	  return false;
 	// Errors not handled: EINVAL
-	_GLIBCXX_DEBUG_ASSERT(__ret == 0);
+	__glibcxx_assert(__ret == 0);
 	return true;
       }
 
diff --git a/libstdc++-v3/include/std/valarray b/libstdc++-v3/include/std/valarray
index 8275249..f566e0a 100644
--- a/libstdc++-v3/include/std/valarray
+++ b/libstdc++-v3/include/std/valarray
@@ -621,7 +621,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
     : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
     { 
-      _GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0);
+      __glibcxx_assert(__p != 0 || __n == 0);
       std::__valarray_copy_construct(__p, __p + __n, _M_data); 
     }
 
@@ -779,7 +779,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
     {
-      _GLIBCXX_DEBUG_ASSERT(_M_size == __sa._M_sz);
+      __glibcxx_assert(_M_size == __sa._M_sz);
       std::__valarray_copy(__sa._M_array, __sa._M_sz,
 			   __sa._M_stride, _Array<_Tp>(_M_data));
       return *this;
@@ -789,7 +789,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
     {
-      _GLIBCXX_DEBUG_ASSERT(_M_size == __ga._M_index.size());
+      __glibcxx_assert(_M_size == __ga._M_index.size());
       std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
 			   _Array<_Tp>(_M_data), _M_size);
       return *this;
@@ -799,7 +799,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
     {
-      _GLIBCXX_DEBUG_ASSERT(_M_size == __ma._M_sz);
+      __glibcxx_assert(_M_size == __ma._M_sz);
       std::__valarray_copy(__ma._M_array, __ma._M_mask,
 			   _Array<_Tp>(_M_data), _M_size);
       return *this;
@@ -809,7 +809,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
     {
-      _GLIBCXX_DEBUG_ASSERT(_M_size == __ia._M_sz);
+      __glibcxx_assert(_M_size == __ia._M_sz);
       std::__valarray_copy(__ia._M_array, __ia._M_index,
 			   _Array<_Tp>(_M_data), _M_size);
       return *this;
@@ -925,7 +925,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline _Tp
     valarray<_Tp>::sum() const
     {
-      _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
+      __glibcxx_assert(_M_size > 0);
       return std::__valarray_sum(_M_data, _M_data + _M_size);
     }
 
@@ -1032,7 +1032,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline _Tp
     valarray<_Tp>::min() const
     {
-      _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
+      __glibcxx_assert(_M_size > 0);
       return *std::min_element(_M_data, _M_data + _M_size);
     }
 
@@ -1040,7 +1040,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline _Tp
     valarray<_Tp>::max() const
     {
-      _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
+      __glibcxx_assert(_M_size > 0);
       return *std::max_element(_M_data, _M_data + _M_size);
     }
   
@@ -1090,7 +1090,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     inline valarray<_Tp>&						\
     valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v)		\
     {									\
-      _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size);                    \
+      __glibcxx_assert(_M_size == __v._M_size);                    \
       _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, 		\
 			       _Array<_Tp>(__v._M_data));		\
       return *this;							\
@@ -1138,7 +1138,7 @@ _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
                  typename __fun<_Name, _Tp>::result_type>               \
     operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w)	\
     {									\
-      _GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size());                  \
+      __glibcxx_assert(__v.size() == __w.size());                  \
       typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; \
       typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
       return _Expr<_Closure, _Rt>(_Closure(__v, __w));                  \

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]