OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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
This commit is contained in:
Benjamin Kosnik 2002-11-16 17:16:31 +00:00 committed by Benjamin Kosnik
parent 5dab517fa0
commit af5fb6ab3b
6 changed files with 983 additions and 879 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,16 @@
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> 2002-11-15 Rainer Orth <ro@TechFak.Uni-Bielefeld.DE>
* src/ios.cc [_GLIBCPP_HAVE_UNISTD_H]: Include unistd.h. * src/ios.cc [_GLIBCPP_HAVE_UNISTD_H]: Include unistd.h.

138
libstdc++-v3/include/bits/stl_alloc.h
View File

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

1535
libstdc++-v3/include/bits/stl_vector.h
View File

File diff suppressed because it is too large Load Diff

122
libstdc++-v3/include/bits/vector.tcc
View File

@ -63,7 +63,7 @@
namespace std namespace std
{ {
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
reserve(size_type __n) 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 typename vector<_Tp,_Alloc>::iterator
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
insert(iterator __position, const value_type& __x) insert(iterator __position, const value_type& __x)
@ -98,7 +98,7 @@ namespace std
return begin() + __n; return begin() + __n;
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
typename vector<_Tp,_Alloc>::iterator typename vector<_Tp,_Alloc>::iterator
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
erase(iterator __position) erase(iterator __position)
@ -110,7 +110,7 @@ namespace std
return __position; return __position;
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
typename vector<_Tp,_Alloc>::iterator typename vector<_Tp,_Alloc>::iterator
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
erase(iterator __first, iterator __last) erase(iterator __first, iterator __last)
@ -121,7 +121,7 @@ namespace std
return __first; return __first;
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
vector<_Tp,_Alloc>& vector<_Tp,_Alloc>&
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
operator=(const vector<_Tp,_Alloc>& __x) operator=(const vector<_Tp,_Alloc>& __x)
@ -152,7 +152,7 @@ namespace std
return *this; return *this;
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_fill_assign(size_t __n, const value_type& __val) _M_fill_assign(size_t __n, const value_type& __val)
@ -171,7 +171,7 @@ namespace std
erase(fill_n(begin(), __n, __val), end()); erase(fill_n(begin(), __n, __val), end());
} }
template <typename _Tp, typename _Alloc> template <typename _InputIter> template<typename _Tp, typename _Alloc> template<typename _InputIter>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag) _M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
@ -185,7 +185,7 @@ namespace std
insert(end(), __first, __last); insert(end(), __first, __last);
} }
template <typename _Tp, typename _Alloc> template <typename _ForwardIter> template<typename _Tp, typename _Alloc> template<typename _ForwardIter>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_assign_aux(_ForwardIter __first, _ForwardIter __last, _M_assign_aux(_ForwardIter __first, _ForwardIter __last,
@ -216,7 +216,7 @@ namespace std
} }
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_insert_aux(iterator __position, const _Tp& __x) _M_insert_aux(iterator __position, const _Tp& __x)
@ -259,7 +259,7 @@ namespace std
} }
#ifdef _GLIBCPP_DEPRECATED #ifdef _GLIBCPP_DEPRECATED
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_insert_aux(iterator __position) _M_insert_aux(iterator __position)
@ -302,63 +302,64 @@ namespace std
} }
#endif #endif
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_fill_insert(iterator __position, size_type __n, const value_type& __x) _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
{ {
if (__n != 0) 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; value_type __x_copy = __x;
iterator __old_finish(_M_finish); const size_type __elems_after = end() - __position;
if (__elems_after > __n) iterator __old_finish(_M_finish);
{ if (__elems_after > __n)
uninitialized_copy(_M_finish - __n, _M_finish, _M_finish); {
_M_finish += __n; uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
copy_backward(__position, __old_finish - __n, __old_finish); _M_finish += __n;
fill(__position, __position + __n, __x_copy); copy_backward(__position, __old_finish - __n, __old_finish);
} fill(__position, __position + __n, __x_copy);
else }
{ else
uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy); {
_M_finish += __n - __elems_after; uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);
uninitialized_copy(__position, __old_finish, _M_finish); _M_finish += __n - __elems_after;
_M_finish += __elems_after; uninitialized_copy(__position, __old_finish, _M_finish);
fill(__position, __old_finish, __x_copy); _M_finish += __elems_after;
} fill(__position, __old_finish, __x_copy);
} }
}
else else
{ {
const size_type __old_size = size(); const size_type __old_size = size();
const size_type __len = __old_size + max(__old_size, __n); const size_type __len = __old_size + max(__old_size, __n);
iterator __new_start(_M_allocate(__len)); iterator __new_start(_M_allocate(__len));
iterator __new_finish(__new_start); iterator __new_finish(__new_start);
try try
{ {
__new_finish = uninitialized_copy(begin(), __position, __new_finish = uninitialized_copy(begin(), __position,
__new_start); __new_start);
__new_finish = uninitialized_fill_n(__new_finish, __n, __x); __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
__new_finish __new_finish = uninitialized_copy(__position, end(),
= uninitialized_copy(__position, end(), __new_finish); __new_finish);
} }
catch(...) catch(...)
{ {
_Destroy(__new_start,__new_finish); _Destroy(__new_start,__new_finish);
_M_deallocate(__new_start.base(),__len); _M_deallocate(__new_start.base(),__len);
__throw_exception_again; __throw_exception_again;
} }
_Destroy(_M_start, _M_finish); _Destroy(_M_start, _M_finish);
_M_deallocate(_M_start, _M_end_of_storage - _M_start); _M_deallocate(_M_start, _M_end_of_storage - _M_start);
_M_start = __new_start.base(); _M_start = __new_start.base();
_M_finish = __new_finish.base(); _M_finish = __new_finish.base();
_M_end_of_storage = __new_start.base() + __len; _M_end_of_storage = __new_start.base() + __len;
} }
} }
} }
template <typename _Tp, typename _Alloc> template <typename _InputIterator> template<typename _Tp, typename _Alloc> template<typename _InputIterator>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_range_insert(iterator __pos, _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 void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_range_insert(iterator __position, _M_range_insert(iterator __position,_ForwardIterator __first,
_ForwardIterator __first, _ForwardIterator __last, _ForwardIterator __last, forward_iterator_tag)
forward_iterator_tag)
{ {
if (__first != __last) if (__first != __last)
{ {

33
libstdc++-v3/testsuite/20_util/allocator_members.cc
View File

@ -1,6 +1,6 @@
// 2001-06-14 Benjamin Kosnik <bkoz@redhat.com> // 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 // 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 // software; you can redistribute it and/or modify it under the
@ -21,6 +21,7 @@
// 20.4.1.1 allocator members // 20.4.1.1 allocator members
#include <memory> #include <memory>
#include <stdexcept>
#include <cstdlib> #include <cstdlib>
#include <testsuite_hooks.h> #include <testsuite_hooks.h>
@ -42,7 +43,7 @@ void operator delete(void *v) throw()
return std::free(v); return std::free(v);
} }
int main(void) void test01()
{ {
bool test = true; bool test = true;
std::allocator<gnu> obj; std::allocator<gnu> obj;
@ -55,6 +56,34 @@ int main(void)
obj.deallocate(pobj, 256); obj.deallocate(pobj, 256);
VERIFY( check_delete ); 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; return 0;
} }

21
libstdc++-v3/testsuite/23_containers/vector_capacity.cc
View File

@ -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() int main()
{ {
test01(); test01();
test02(); test02();
test03();
return 0; return 0;
} }