re PR libstdc++/8230 (Buggy allocator behaviour)

2002-11-15  Benjamin Kosnik  <bkoz@redhat.com>
            Gabriel Dos Reis  <gdr@integrable-solutions.net>

	PR libstdc++/8230
	* include/bits/stl_alloc.h: Use builtin_expect for the most
	obvious limit checks.
	(__default_alloc_template::allocate): Check for null, throw
	bad_alloc.
	* include/bits/vector.tcc: Formatting tweaks.
	* include/bits/stl_vector.h: Same.
	* testsuite/20_util/allocator_members.cc (test02): Add.
	* testsuite/23_containers/vector_capacity.cc (test03): Add.

Co-Authored-By: Gabriel Dos Reis <gdr@integrable-solutions.net>

From-SVN: r59169

libstdc++-v3/ChangeLog

+2002-11-15  Benjamin Kosnik  <bkoz@redhat.com>
+            Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+	PR libstdc++/8230
+	* include/bits/stl_alloc.h: Use builtin_expect for the most
+	obvious limit checks.
+	(__default_alloc_template::allocate): Check for null, throw
+	bad_alloc.
+	* include/bits/vector.tcc: Formatting tweaks.
+	* include/bits/stl_vector.h: Same.	
+	* testsuite/20_util/allocator_members.cc (test02): Add.
+	* testsuite/23_containers/vector_capacity.cc (test03): Add.
+	
 2002-11-15  Rainer Orth  <ro@TechFak.Uni-Bielefeld.DE>
 
 	* src/ios.cc [_GLIBCPP_HAVE_UNISTD_H]: Include unistd.h.

libstdc++-v3/include/bits/stl_alloc.h

@@ -139,7 +139,8 @@ namespace std
       allocate(size_t __n)
       {
         void* __result = malloc(__n);
-        if (0 == __result) __result = _S_oom_malloc(__n);
+        if (__builtin_expect(__result == 0, 0))
+	  __result = _S_oom_malloc(__n);
         return __result;
       }
 
@@ -152,7 +153,7 @@ namespace std
       reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
       {
         void* __result = realloc(__p, __new_sz);
-        if (0 == __result)
+        if (__builtin_expect(__result == 0, 0))
           __result = _S_oom_realloc(__p, __new_sz);
         return __result;
       }
@@ -181,8 +182,8 @@ namespace std
       for (;;)
         {
           __my_malloc_handler = __malloc_alloc_oom_handler;
-          if (0 == __my_malloc_handler)
-            std::__throw_bad_alloc();
+          if (__builtin_expect(__my_malloc_handler == 0, 0))
+            __throw_bad_alloc();
           (*__my_malloc_handler)();
           __result = malloc(__n);
           if (__result)
@@ -202,8 +203,8 @@ namespace std
       for (;;)
         {
           __my_malloc_handler = __malloc_alloc_oom_handler;
-          if (0 == __my_malloc_handler)
-            std::__throw_bad_alloc();
+          if (__builtin_expect(__my_malloc_handler == 0, 0))
+            __throw_bad_alloc();
           (*__my_malloc_handler)();
           __result = realloc(__p, __n);
           if (__result)
@@ -232,7 +233,12 @@ namespace std
     public:
       static _Tp*
       allocate(size_t __n)
-      { return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
+      {
+	_Tp* __ret = 0;
+	if (__n)
+	  __ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
+	return __ret;
+      }
   
       static _Tp*
       allocate()
@@ -293,8 +299,8 @@ namespace std
       {
         char* __real_p = (char*)__p - (int) _S_extra;
         assert(*(size_t*)__real_p == __old_sz);
-        char* __result = (char*)
-          _Alloc::reallocate(__real_p, __old_sz + (int) _S_extra,
+        char* __result = (char*) _Alloc::reallocate(__real_p, 
+						    __old_sz + (int) _S_extra,
 						    __new_sz + (int) _S_extra);
         *(size_t*)__result = __new_sz;
         return __result + (int) _S_extra;
@@ -362,7 +368,7 @@ namespace std
 
       static size_t
       _S_freelist_index(size_t __bytes)
-      { return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1); }
+      { return (((__bytes) + (size_t)_ALIGN - 1)/(size_t)_ALIGN - 1); }
 
       // Returns an object of size __n, and optionally adds to size __n
       // free list.
@@ -402,7 +408,7 @@ namespace std
 	    else
 	      __atomic_add(&_S_force_new, -1);
 	    // Trust but verify...
-	    assert (_S_force_new != 0);
+	    assert(_S_force_new != 0);
 	  }
 
 	if ((__n > (size_t) _MAX_BYTES) || (_S_force_new > 0))
@@ -416,13 +422,15 @@ namespace std
 	    // unwinding.
 	    _Lock __lock_instance;
 	    _Obj* __restrict__ __result = *__my_free_list;
-	    if (__result == 0)
+	    if (__builtin_expect(__result == 0, 0))
 	      __ret = _S_refill(_S_round_up(__n));
 	    else
 	      {
 		*__my_free_list = __result -> _M_free_list_link;
 		__ret = __result;
 	      }	    
+	    if (__builtin_expect(__ret == 0, 0))
+	      __throw_bad_alloc();
 	  }
 	return __ret;
       }
@@ -510,7 +518,7 @@ namespace std
               *__my_free_list = (_Obj*)_S_start_free;
             }
           _S_start_free = (char*) __new_alloc::allocate(__bytes_to_get);
-          if (0 == _S_start_free)
+          if (_S_start_free == 0)
             {
               size_t __i;
               _Obj* volatile* __my_free_list;
@@ -523,7 +531,7 @@ namespace std
                 {
                   __my_free_list = _S_free_list + _S_freelist_index(__i);
                   __p = *__my_free_list;
-                  if (0 != __p)
+                  if (__p != 0)
                     {
                       *__my_free_list = __p -> _M_free_list_link;
                       _S_start_free = (char*)__p;
@@ -579,7 +587,7 @@ namespace std
 	  else
 	    __current_obj -> _M_free_list_link = __next_obj;
 	}
-      return(__result);
+      return __result;
     }
 
 
@@ -600,7 +608,7 @@ namespace std
       __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
       memcpy(__result, __p, __copy_sz);
       deallocate(__p, __old_sz);
-      return(__result);
+      return __result;
     }
 #endif
 
@@ -669,13 +677,20 @@ namespace std
       const_pointer
       address(const_reference __x) const { return &__x; }
 
-      // __n is permitted to be 0.  The C++ standard says nothing about what
-      // the return value is when __n == 0.
+      // NB: __n is permitted to be 0.  The C++ standard says nothing
+      // about what the return value is when __n == 0.
       _Tp*
       allocate(size_type __n, const void* = 0)
       {
-        return __n != 0
-          ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp))) : 0;
+	_Tp* __ret = 0;
+	if (__n)
+	  {
+	    if (__n <= this->max_size())
+	      __ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
+	    else
+	      __throw_bad_alloc();
+	  }
+	return __ret;
       }
 
       // __p is not permitted to be a null pointer.
@@ -719,12 +734,13 @@ namespace std
 
   /**
    *  @if maint
-   *  Allocator adaptor to turn an "SGI" style allocator (e.g., __alloc,
-   *  __malloc_alloc_template) into a "standard" conforming allocator.  Note
-   *  that this adaptor does *not* assume that all objects of the underlying
-   *  alloc class are identical, nor does it assume that all of the underlying
-   *  alloc's member functions are static member functions.  Note, also, that
-   *  __allocator<_Tp, __alloc> is essentially the same thing as allocator<_Tp>.
+   *  Allocator adaptor to turn an "SGI" style allocator (e.g.,
+   *  __alloc, __malloc_alloc_template) into a "standard" conforming
+   *  allocator.  Note that this adaptor does *not* assume that all
+   *  objects of the underlying alloc class are identical, nor does it
+   *  assume that all of the underlying alloc's member functions are
+   *  static member functions.  Note, also, that __allocator<_Tp,
+   *  __alloc> is essentially the same thing as allocator<_Tp>.
    *  @endif
    *  (See @link Allocators allocators info @endlink for more.)
    */
@@ -761,13 +777,15 @@ namespace std
       const_pointer
       address(const_reference __x) const { return &__x; }
 
-    // __n is permitted to be 0.
+      // NB: __n is permitted to be 0.  The C++ standard says nothing
+      // about what the return value is when __n == 0.
       _Tp*
       allocate(size_type __n, const void* = 0)
       {
-      return __n != 0
-        ? static_cast<_Tp*>(__underlying_alloc.allocate(__n * sizeof(_Tp)))
-        : 0;
+	_Tp* __ret = 0;
+	if (__n)
+	  __ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
+	return __ret;
       }
 
       // __p is not permitted to be a null pointer.

libstdc++-v3/include/bits/vector.tcc

@@ -63,7 +63,7 @@
 
 namespace std
 {
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     void
     vector<_Tp,_Alloc>::
     reserve(size_type __n)
@@ -82,7 +82,7 @@ namespace std
 	}
     }
   
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     typename vector<_Tp,_Alloc>::iterator
     vector<_Tp,_Alloc>::
     insert(iterator __position, const value_type& __x)
@@ -98,7 +98,7 @@ namespace std
       return begin() + __n;
     }
   
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     typename vector<_Tp,_Alloc>::iterator
     vector<_Tp,_Alloc>::
     erase(iterator __position)
@@ -110,7 +110,7 @@ namespace std
       return __position;
     }
   
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     typename vector<_Tp,_Alloc>::iterator
     vector<_Tp,_Alloc>::
     erase(iterator __first, iterator __last)
@@ -121,7 +121,7 @@ namespace std
       return __first;
     }
   
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     vector<_Tp,_Alloc>&
     vector<_Tp,_Alloc>::
     operator=(const vector<_Tp,_Alloc>& __x)
@@ -152,7 +152,7 @@ namespace std
       return *this;
     }
   
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     void
     vector<_Tp,_Alloc>::
     _M_fill_assign(size_t __n, const value_type& __val)
@@ -171,7 +171,7 @@ namespace std
         erase(fill_n(begin(), __n, __val), end());
     }
   
-  template <typename _Tp, typename _Alloc> template <typename _InputIter>
+  template<typename _Tp, typename _Alloc> template<typename _InputIter>
     void
     vector<_Tp,_Alloc>::
     _M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
@@ -185,7 +185,7 @@ namespace std
         insert(end(), __first, __last);
     }
   
-  template <typename _Tp, typename _Alloc> template <typename _ForwardIter>
+  template<typename _Tp, typename _Alloc> template<typename _ForwardIter>
     void
     vector<_Tp,_Alloc>::
     _M_assign_aux(_ForwardIter __first, _ForwardIter __last,
@@ -216,7 +216,7 @@ namespace std
       }
     }
   
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     void
     vector<_Tp,_Alloc>::
     _M_insert_aux(iterator __position, const _Tp& __x)
@@ -259,7 +259,7 @@ namespace std
     }
   
   #ifdef _GLIBCPP_DEPRECATED
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     void
     vector<_Tp,_Alloc>::
     _M_insert_aux(iterator __position)
@@ -302,14 +302,15 @@ namespace std
     }
   #endif
   
-  template <typename _Tp, typename _Alloc>
+  template<typename _Tp, typename _Alloc>
     void
     vector<_Tp,_Alloc>::
     _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
     {
       if (__n != 0)
       {
-        if (size_type(_M_end_of_storage - _M_finish) >= __n) {
+        if (size_type(_M_end_of_storage - _M_finish) >= __n) 
+	  {
            value_type __x_copy = __x;
 	   const size_type __elems_after = end() - __position;
 	   iterator __old_finish(_M_finish);
@@ -340,8 +341,8 @@ namespace std
 		__new_finish = uninitialized_copy(begin(), __position,
 						  __new_start);
 		__new_finish = uninitialized_fill_n(__new_finish, __n, __x);
-              __new_finish
-                = uninitialized_copy(__position, end(), __new_finish);
+		__new_finish = uninitialized_copy(__position, end(), 
+						  __new_finish);
 	      }
 	    catch(...)
 	      {
@@ -358,7 +359,7 @@ namespace std
       }
     }
   
-  template <typename _Tp, typename _Alloc> template <typename _InputIterator>
+  template<typename _Tp, typename _Alloc> template<typename _InputIterator>
     void
     vector<_Tp,_Alloc>::
     _M_range_insert(iterator __pos,
@@ -372,12 +373,11 @@ namespace std
       }
     }
   
-  template <typename _Tp, typename _Alloc> template <typename _ForwardIterator>
+  template<typename _Tp, typename _Alloc> template<typename _ForwardIterator>
     void
     vector<_Tp,_Alloc>::
-    _M_range_insert(iterator __position,
-                    _ForwardIterator __first, _ForwardIterator __last,
-                    forward_iterator_tag)
+    _M_range_insert(iterator __position,_ForwardIterator __first, 
+		    _ForwardIterator __last, forward_iterator_tag)
     {
       if (__first != __last)
       {

libstdc++-v3/testsuite/20_util/allocator_members.cc

 // 2001-06-14  Benjamin Kosnik  <bkoz@redhat.com>
 
-// Copyright (C) 2001 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -21,6 +21,7 @@
 // 20.4.1.1 allocator members
 
 #include <memory>
+#include <stdexcept>
 #include <cstdlib>
 #include <testsuite_hooks.h>
 
@@ -42,7 +43,7 @@ void operator delete(void *v) throw()
   return std::free(v);
 }
 
-int main(void)
+void test01()
 {
   bool test = true;
   std::allocator<gnu> obj;
@@ -55,6 +56,34 @@ int main(void)
 
   obj.deallocate(pobj, 256);
   VERIFY( check_delete );
+}
+
+// libstdc++/8230
+void test02()
+{
+  bool test = true;
+  try 
+    {
+      std::allocator<int> alloc;
+      const std::allocator<int>::size_type n = alloc.max_size();
+      int* p = alloc.allocate(n + 1);
+      p[n] = 2002;
+    } 
+  catch(const std::bad_alloc& e) 
+    {
+      // Allowed.
+      test = true;
+    }
+  catch(...) 
+    {
+      test = false;
+    }
+  VERIFY( test );
+}
 
+int main()
+{
+  test01();
+  test02();
   return 0;
 }

libstdc++-v3/testsuite/23_containers/vector_capacity.cc

@@ -99,9 +99,30 @@ void test02()
   }
 }
 
+void test03()
+{
+  bool test = true;
+  std::vector<int> v;
+  try
+    {
+      v.resize(v.max_size());  
+      v[v.max_size() - 1] = 2002;
+    }
+  catch (const std::bad_alloc& error)
+    {
+      test = true;
+    }
+  catch (...)
+    {
+      test = false;
+    }
+  VERIFY( test );
+}
+
 int main()
 {
   test01();
   test02();
+  test03();
   return 0;
 }