1// Allocators -*- C++ -*- 2 3// Copyright (C) 2001-2015 Free Software Foundation, Inc. 4// 5// This file is part of the GNU ISO C++ Library. This library is free 6// software; you can redistribute it and/or modify it under the 7// terms of the GNU General Public License as published by the 8// Free Software Foundation; either version 3, or (at your option) 9// any later version. 10 11// This library is distributed in the hope that it will be useful, 12// but WITHOUT ANY WARRANTY; without even the implied warranty of 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14// GNU General Public License for more details. 15 16// Under Section 7 of GPL version 3, you are granted additional 17// permissions described in the GCC Runtime Library Exception, version 18// 3.1, as published by the Free Software Foundation. 19 20// You should have received a copy of the GNU General Public License and 21// a copy of the GCC Runtime Library Exception along with this program; 22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23// <http://www.gnu.org/licenses/>. 24 25/* 26 * Copyright (c) 1996-1997 27 * Silicon Graphics Computer Systems, Inc. 28 * 29 * Permission to use, copy, modify, distribute and sell this software 30 * and its documentation for any purpose is hereby granted without fee, 31 * provided that the above copyright notice appear in all copies and 32 * that both that copyright notice and this permission notice appear 33 * in supporting documentation. Silicon Graphics makes no 34 * representations about the suitability of this software for any 35 * purpose. It is provided "as is" without express or implied warranty. 36 */ 37 38/** @file ext/debug_allocator.h 39 * This file is a GNU extension to the Standard C++ Library. 40 */ 41 42#ifndef _DEBUG_ALLOCATOR_H 43#define _DEBUG_ALLOCATOR_H 1 44 45#include <stdexcept> 46#include <bits/functexcept.h> 47#include <ext/alloc_traits.h> 48 49namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) 50{ 51_GLIBCXX_BEGIN_NAMESPACE_VERSION 52 53 using std::size_t; 54 55 /** 56 * @brief A meta-allocator with debugging bits. 57 * @ingroup allocators 58 * 59 * This is precisely the allocator defined in the C++03 Standard. 60 */ 61 template<typename _Alloc> 62 class debug_allocator 63 { 64 template<typename> friend class debug_allocator; 65 66 typedef __alloc_traits<_Alloc> _Traits; 67 68 public: 69 typedef typename _Traits::size_type size_type; 70 typedef typename _Traits::difference_type difference_type; 71 typedef typename _Traits::pointer pointer; 72 typedef typename _Traits::const_pointer const_pointer; 73 typedef typename _Traits::reference reference; 74 typedef typename _Traits::const_reference const_reference; 75 typedef typename _Traits::value_type value_type; 76 77 template<typename _Up> 78 class rebind 79 { 80 typedef typename _Traits::template rebind<_Up>::other __other; 81 82 public: 83 typedef debug_allocator<__other> other; 84 }; 85 86 private: 87 // _M_extra is the number of objects that correspond to the 88 // extra space where debug information is stored. 89 size_type _M_extra; 90 91 _Alloc _M_allocator; 92 93 template<typename _Alloc2, 94 typename = typename _Alloc2::template rebind<value_type>::other> 95 struct __convertible 96 { }; 97 98 template<typename _Alloc2> 99 struct __convertible<_Alloc2, _Alloc> 100 { 101 typedef void* __type; 102 }; 103 104 size_type _S_extra() 105 { 106 const size_t __obj_size = sizeof(value_type); 107 return (sizeof(size_type) + __obj_size - 1) / __obj_size; 108 } 109 110 public: 111 debug_allocator() : _M_extra(_S_extra()) { } 112 113 template<typename _Alloc2> 114 debug_allocator(const debug_allocator<_Alloc2>& __a2, 115 typename __convertible<_Alloc2>::__type = 0) 116 : _M_allocator(__a2._M_allocator), _M_extra(_S_extra()) { } 117 118 debug_allocator(const _Alloc& __a) 119 : _M_allocator(__a), _M_extra(_S_extra()) { } 120 121 pointer 122 allocate(size_type __n) 123 { 124 pointer __res = _M_allocator.allocate(__n + _M_extra); 125 size_type* __ps = reinterpret_cast<size_type*>(__res); 126 *__ps = __n; 127 return __res + _M_extra; 128 } 129 130 pointer 131 allocate(size_type __n, const void* __hint) 132 { 133 pointer __res = _M_allocator.allocate(__n + _M_extra, __hint); 134 size_type* __ps = reinterpret_cast<size_type*>(__res); 135 *__ps = __n; 136 return __res + _M_extra; 137 } 138 139 void 140 deallocate(pointer __p, size_type __n) 141 { 142 using std::__throw_runtime_error; 143 if (__p) 144 { 145 pointer __real_p = __p - _M_extra; 146 if (*reinterpret_cast<size_type*>(__real_p) != __n) 147 __throw_runtime_error("debug_allocator::deallocate wrong size"); 148 _M_allocator.deallocate(__real_p, __n + _M_extra); 149 } 150 else 151 __throw_runtime_error("debug_allocator::deallocate null pointer"); 152 } 153 154 void 155 construct(pointer __p, const value_type& __val) 156 { _Traits::construct(_M_allocator, __p, __val); } 157 158#if __cplusplus >= 201103L 159 template<typename _Tp, typename... _Args> 160 void 161 construct(_Tp* __p, _Args&&... __args) 162 { 163 _Traits::construct(_M_allocator, __p, 164 std::forward<_Args>(__args)...); 165 } 166#endif 167 168 template<typename _Tp> 169 void 170 destroy(_Tp* __p) 171 { _Traits::destroy(_M_allocator, __p); } 172 173 size_type 174 max_size() const throw() 175 { return _Traits::max_size(_M_allocator) - _M_extra; } 176 177 friend bool 178 operator==(const debug_allocator& __lhs, const debug_allocator& __rhs) 179 { return __lhs._M_allocator == __rhs._M_allocator; } 180 }; 181 182 template<typename _Alloc> 183 inline bool 184 operator!=(const debug_allocator<_Alloc>& __lhs, 185 const debug_allocator<_Alloc>& __rhs) 186 { return !(__lhs == __rhs); } 187 188_GLIBCXX_END_NAMESPACE_VERSION 189} // namespace 190 191#endif 192