mirror of
https://gcc.gnu.org/git/gcc.git
synced 2024-12-06 02:04:03 +08:00
31905f3498
2006-01-03 Paolo Carlini <pcarlini@suse.de> * include/bits/stl_list.h (_List_base<>::_M_get_Node_allocator): Add. (_M_get_Tp_allocator, get_allocator): Tidy. (list<>::list(const list&), insert(iterator, size_type, const value_type&), insert(iterator, _InputIterator, _InputIterator)): Use _M_get_Node_allocator. * include/bits/stl_tree.h (_Rb_tree<>::_M_get_Node_allocator()): Add. (_Rb_tree(const _Rb_tree<>&): Use it. * include/bits/stl_deque.h (_Deque_base<>::_M_get_map_allocator, get_allocator): Tidy. * include/bits/stl_vector.h (_Vector_base<>::get_allocator): Tidy. * testsuite/23_containers/map/operators/1_neg.cc: Adjust dg-error line numbers. * testsuite/23_containers/set/operators/1_neg.cc: Likewise. * testsuite/testsuite_allocator.h (uneq_allocator<>::swap): Fix. * testsuite/testsuite_allocator.h (class uneq_allocator): A simple non-empty testing allocator which can be endowed of a "personality" at construction time. From-SVN: r109280
444 lines
12 KiB
C++
444 lines
12 KiB
C++
// -*- C++ -*-
|
|
// Testing allocator for the C++ library testsuite.
|
|
//
|
|
// Copyright (C) 2002, 2003, 2004, 2005, 2006 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
|
|
// terms of the GNU General Public License as published by the
|
|
// Free Software Foundation; either version 2, or (at your option)
|
|
// any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License along
|
|
// with this library; see the file COPYING. If not, write to the Free
|
|
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
// USA.
|
|
//
|
|
// As a special exception, you may use this file as part of a free software
|
|
// library without restriction. Specifically, if other files instantiate
|
|
// templates or use macros or inline functions from this file, or you compile
|
|
// this file and link it with other files to produce an executable, this
|
|
// file does not by itself cause the resulting executable to be covered by
|
|
// the GNU General Public License. This exception does not however
|
|
// invalidate any other reasons why the executable file might be covered by
|
|
// the GNU General Public License.
|
|
|
|
// This file provides an test instrumentation allocator that can be
|
|
// used to verify allocation functionality of standard library
|
|
// containers. 2002.11.25 smw
|
|
|
|
#ifndef _GLIBCXX_TESTSUITE_ALLOCATOR_H
|
|
#define _GLIBCXX_TESTSUITE_ALLOCATOR_H
|
|
|
|
#include <cstddef>
|
|
#include <limits>
|
|
#include <tr1/unordered_map>
|
|
#include <cassert>
|
|
|
|
namespace
|
|
{
|
|
bool new_called = false;
|
|
bool delete_called = false;
|
|
};
|
|
|
|
namespace __gnu_test
|
|
{
|
|
class allocation_tracker
|
|
{
|
|
public:
|
|
typedef std::size_t size_type;
|
|
|
|
static void*
|
|
allocate(size_type blocksize)
|
|
{
|
|
allocationTotal_ += blocksize;
|
|
return ::operator new(blocksize);
|
|
}
|
|
|
|
static void
|
|
construct() { constructCount_++; }
|
|
|
|
static void
|
|
destroy() { destructCount_++; }
|
|
|
|
static void
|
|
deallocate(void* p, size_type blocksize)
|
|
{
|
|
::operator delete(p);
|
|
deallocationTotal_ += blocksize;
|
|
}
|
|
|
|
static size_type
|
|
allocationTotal() { return allocationTotal_; }
|
|
|
|
static size_type
|
|
deallocationTotal() { return deallocationTotal_; }
|
|
|
|
static int
|
|
constructCount() { return constructCount_; }
|
|
|
|
static int
|
|
destructCount() { return destructCount_; }
|
|
|
|
static void
|
|
resetCounts()
|
|
{
|
|
allocationTotal_ = 0;
|
|
deallocationTotal_ = 0;
|
|
constructCount_ = 0;
|
|
destructCount_ = 0;
|
|
}
|
|
|
|
private:
|
|
static size_type allocationTotal_;
|
|
static size_type deallocationTotal_;
|
|
static int constructCount_;
|
|
static int destructCount_;
|
|
};
|
|
|
|
// A simple basic allocator that just forwards to the
|
|
// allocation_tracker to fulfill memory requests. This class is
|
|
// templated on the target object type, but tracker isn't.
|
|
template<class T>
|
|
class tracker_alloc
|
|
{
|
|
public:
|
|
typedef T value_type;
|
|
typedef T* pointer;
|
|
typedef const T* const_pointer;
|
|
typedef T& reference;
|
|
typedef const T& const_reference;
|
|
typedef std::size_t size_type;
|
|
typedef std::ptrdiff_t difference_type;
|
|
|
|
template<class U> struct rebind { typedef tracker_alloc<U> other; };
|
|
|
|
pointer
|
|
address(reference value) const
|
|
{ return &value; }
|
|
|
|
const_pointer
|
|
address(const_reference value) const
|
|
{ return &value; }
|
|
|
|
tracker_alloc() throw()
|
|
{ }
|
|
|
|
tracker_alloc(const tracker_alloc&) throw()
|
|
{ }
|
|
|
|
template<class U>
|
|
tracker_alloc(const tracker_alloc<U>&) throw()
|
|
{ }
|
|
|
|
~tracker_alloc() throw()
|
|
{ }
|
|
|
|
size_type
|
|
max_size() const throw()
|
|
{ return std::numeric_limits<std::size_t>::max() / sizeof(T); }
|
|
|
|
pointer
|
|
allocate(size_type n, const void* = 0)
|
|
{
|
|
return static_cast<pointer>(allocation_tracker::allocate(n * sizeof(T)));
|
|
}
|
|
|
|
void
|
|
construct(pointer p, const T& value)
|
|
{
|
|
new (p) T(value);
|
|
allocation_tracker::construct();
|
|
}
|
|
|
|
void
|
|
destroy(pointer p)
|
|
{
|
|
p->~T();
|
|
allocation_tracker::destroy();
|
|
}
|
|
|
|
void
|
|
deallocate(pointer p, size_type num)
|
|
{ allocation_tracker::deallocate(p, num * sizeof(T)); }
|
|
};
|
|
|
|
template<class T1, class T2>
|
|
bool
|
|
operator==(const tracker_alloc<T1>&, const tracker_alloc<T2>&) throw()
|
|
{ return true; }
|
|
|
|
template<class T1, class T2>
|
|
bool
|
|
operator!=(const tracker_alloc<T1>&, const tracker_alloc<T2>&) throw()
|
|
{ return false; }
|
|
|
|
bool
|
|
check_construct_destroy(const char* tag, int expected_c, int expected_d);
|
|
|
|
template<typename Alloc, bool uses_global_new>
|
|
bool
|
|
check_new(Alloc a = Alloc())
|
|
{
|
|
bool test __attribute__((unused)) = true;
|
|
a.allocate(10);
|
|
test &= ( new_called == uses_global_new );
|
|
return test;
|
|
}
|
|
|
|
template<typename Alloc, bool uses_global_delete>
|
|
bool
|
|
check_delete(Alloc a = Alloc())
|
|
{
|
|
bool test __attribute__((unused)) = true;
|
|
typename Alloc::pointer p = a.allocate(10);
|
|
a.deallocate(p, 10);
|
|
test &= ( delete_called == uses_global_delete );
|
|
return test;
|
|
}
|
|
|
|
template<typename Alloc>
|
|
bool
|
|
check_deallocate_null()
|
|
{
|
|
// Let's not core here...
|
|
Alloc a;
|
|
a.deallocate(NULL, 1);
|
|
a.deallocate(NULL, 10);
|
|
return true;
|
|
}
|
|
|
|
template<typename Alloc>
|
|
bool
|
|
check_allocate_max_size()
|
|
{
|
|
Alloc a;
|
|
try
|
|
{
|
|
a.allocate(a.max_size() + 1);
|
|
}
|
|
catch(std::bad_alloc&)
|
|
{
|
|
return true;
|
|
}
|
|
catch(...)
|
|
{
|
|
throw;
|
|
}
|
|
throw;
|
|
}
|
|
|
|
|
|
// A simple allocator which can be constructed endowed of a given
|
|
// "personality" (an integer), queried in operator== to simulate the
|
|
// behavior of realworld "unequal" allocators (i.e., not exploiting
|
|
// the provision in 20.1.5/4, first bullet). A global unordered_map,
|
|
// filled at allocation time with (pointer, personality) pairs, is
|
|
// then consulted to enforce the requirements in Table 32 about
|
|
// deallocation vs allocator equality. Note that this allocator is
|
|
// swappable, not assignable, consistently with Option 3 of DR 431
|
|
// (see N1599).
|
|
struct uneq_allocator_base
|
|
{
|
|
typedef std::tr1::unordered_map<void*, int> map_type;
|
|
|
|
// Avoid static initialization troubles and/or bad interactions
|
|
// with tests linking testsuite_allocator.o and playing globally
|
|
// with operator new/delete.
|
|
static map_type&
|
|
get_map()
|
|
{
|
|
static map_type alloc_map;
|
|
return alloc_map;
|
|
}
|
|
};
|
|
|
|
template<typename Tp>
|
|
class uneq_allocator
|
|
: private uneq_allocator_base
|
|
{
|
|
public:
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef Tp* pointer;
|
|
typedef const Tp* const_pointer;
|
|
typedef Tp& reference;
|
|
typedef const Tp& const_reference;
|
|
typedef Tp value_type;
|
|
|
|
template<typename Tp1>
|
|
struct rebind
|
|
{ typedef uneq_allocator<Tp1> other; };
|
|
|
|
uneq_allocator() throw()
|
|
: personality(0) { }
|
|
|
|
uneq_allocator(int person) throw()
|
|
: personality(person) { }
|
|
|
|
template<typename Tp1>
|
|
uneq_allocator(const uneq_allocator<Tp1>& b) throw()
|
|
: personality(b.get_personality()) { }
|
|
|
|
int get_personality() const { return personality; }
|
|
|
|
pointer
|
|
address(reference x) const { return &x; }
|
|
|
|
const_pointer
|
|
address(const_reference x) const { return &x; }
|
|
|
|
pointer
|
|
allocate(size_type n, const void* = 0)
|
|
{
|
|
if (__builtin_expect(n > this->max_size(), false))
|
|
std::__throw_bad_alloc();
|
|
|
|
pointer p = static_cast<Tp*>(::operator new(n * sizeof(Tp)));
|
|
try
|
|
{
|
|
get_map().insert(map_type::value_type(reinterpret_cast<void*>(p),
|
|
personality));
|
|
}
|
|
catch(...)
|
|
{
|
|
::operator delete(p);
|
|
__throw_exception_again;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
void
|
|
deallocate(pointer p, size_type)
|
|
{
|
|
assert( p );
|
|
|
|
map_type::iterator it = get_map().find(reinterpret_cast<void*>(p));
|
|
assert( it != get_map().end() );
|
|
|
|
// Enforce requirements in Table 32 about deallocation vs
|
|
// allocator equality.
|
|
assert( it->second == personality );
|
|
|
|
get_map().erase(it);
|
|
::operator delete(p);
|
|
}
|
|
|
|
size_type
|
|
max_size() const throw()
|
|
{ return size_t(-1) / sizeof(Tp); }
|
|
|
|
void
|
|
construct(pointer p, const Tp& val)
|
|
{ ::new(p) Tp(val); }
|
|
|
|
void
|
|
destroy(pointer p) { p->~Tp(); }
|
|
|
|
private:
|
|
// Not assignable...
|
|
uneq_allocator&
|
|
operator=(const uneq_allocator&);
|
|
|
|
// ... yet swappable!
|
|
friend inline void
|
|
swap(uneq_allocator& a, uneq_allocator& b)
|
|
{ std::swap(a.personality, b.personality); }
|
|
|
|
template<typename Tp1>
|
|
friend inline bool
|
|
operator==(const uneq_allocator& a, const uneq_allocator<Tp1>& b)
|
|
{ return a.personality == b.personality; }
|
|
|
|
template<typename Tp1>
|
|
friend inline bool
|
|
operator!=(const uneq_allocator& a, const uneq_allocator<Tp1>& b)
|
|
{ return !(a == b); }
|
|
|
|
int personality;
|
|
};
|
|
|
|
|
|
template<typename Tp>
|
|
class throw_allocator
|
|
{
|
|
public:
|
|
typedef std::size_t size_type;
|
|
typedef std::ptrdiff_t difference_type;
|
|
typedef Tp* pointer;
|
|
typedef const Tp* const_pointer;
|
|
typedef Tp& reference;
|
|
typedef const Tp& const_reference;
|
|
typedef Tp value_type;
|
|
|
|
template<typename Tp1>
|
|
struct rebind
|
|
{ typedef throw_allocator<Tp1> other; };
|
|
|
|
throw_allocator() throw()
|
|
: count(size_type(-1)) { }
|
|
|
|
throw_allocator(size_type c) throw()
|
|
: count(c) { }
|
|
|
|
template<typename Tp1>
|
|
throw_allocator(const throw_allocator<Tp1>& b) throw()
|
|
: count(b.get_count()) { }
|
|
|
|
size_type get_count() const { return count; }
|
|
|
|
pointer
|
|
address(reference x) const { return &x; }
|
|
|
|
const_pointer
|
|
address(const_reference x) const { return &x; }
|
|
|
|
pointer
|
|
allocate(size_type n, const void* = 0)
|
|
{
|
|
if (count == 0)
|
|
throw std::bad_alloc();
|
|
|
|
if (count != size_type(-1))
|
|
--count;
|
|
|
|
return static_cast<Tp*>(::operator new(n * sizeof(Tp)));
|
|
}
|
|
|
|
void
|
|
deallocate(pointer p, size_type)
|
|
{ ::operator delete(p); }
|
|
|
|
size_type
|
|
max_size() const throw()
|
|
{ return size_type(-1) / sizeof(Tp); }
|
|
|
|
void
|
|
construct(pointer p, const Tp& val)
|
|
{ ::new(p) Tp(val); }
|
|
|
|
void
|
|
destroy(pointer p) { p->~Tp(); }
|
|
|
|
private:
|
|
template<typename Tp1>
|
|
friend inline bool
|
|
operator==(const throw_allocator&, const throw_allocator<Tp1>&)
|
|
{ return true; }
|
|
|
|
template<typename Tp1>
|
|
friend inline bool
|
|
operator!=(const throw_allocator&, const throw_allocator<Tp1>&)
|
|
{ return false; }
|
|
|
|
size_type count;
|
|
};
|
|
}; // namespace __gnu_test
|
|
|
|
#endif // _GLIBCXX_TESTSUITE_ALLOCATOR_H
|