1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef MIN_ALLOCATOR_H 11 #define MIN_ALLOCATOR_H 12 13 #include <cstddef> 14 #include <cstdlib> 15 #include <cstddef> 16 #include <cassert> 17 18 #include "test_macros.h" 19 20 template <class T> 21 class bare_allocator 22 { 23 public: 24 typedef T value_type; 25 26 bare_allocator() TEST_NOEXCEPT {} 27 28 template <class U> 29 bare_allocator(bare_allocator<U>) TEST_NOEXCEPT {} 30 31 T* allocate(std::size_t n) 32 { 33 return static_cast<T*>(::operator new(n*sizeof(T))); 34 } 35 36 void deallocate(T* p, std::size_t) 37 { 38 return ::operator delete(static_cast<void*>(p)); 39 } 40 41 friend bool operator==(bare_allocator, bare_allocator) {return true;} 42 friend bool operator!=(bare_allocator x, bare_allocator y) {return !(x == y);} 43 }; 44 45 46 template <class T> 47 class no_default_allocator 48 { 49 #if TEST_STD_VER >= 11 50 no_default_allocator() = delete; 51 #else 52 no_default_allocator(); 53 #endif 54 struct construct_tag {}; 55 explicit no_default_allocator(construct_tag) {} 56 57 public: 58 static no_default_allocator create() { 59 construct_tag tag; 60 return no_default_allocator(tag); 61 } 62 63 public: 64 typedef T value_type; 65 66 template <class U> 67 no_default_allocator(no_default_allocator<U>) TEST_NOEXCEPT {} 68 69 T* allocate(std::size_t n) 70 { 71 return static_cast<T*>(::operator new(n*sizeof(T))); 72 } 73 74 void deallocate(T* p, std::size_t) 75 { 76 return ::operator delete(static_cast<void*>(p)); 77 } 78 79 friend bool operator==(no_default_allocator, no_default_allocator) {return true;} 80 friend bool operator!=(no_default_allocator x, no_default_allocator y) {return !(x == y);} 81 }; 82 83 struct malloc_allocator_base { 84 static size_t alloc_count; 85 static size_t dealloc_count; 86 static bool disable_default_constructor; 87 88 static size_t outstanding_alloc() { 89 assert(alloc_count >= dealloc_count); 90 return (alloc_count - dealloc_count); 91 } 92 93 static void reset() { 94 assert(outstanding_alloc() == 0); 95 disable_default_constructor = false; 96 alloc_count = 0; 97 dealloc_count = 0; 98 } 99 }; 100 101 102 size_t malloc_allocator_base::alloc_count = 0; 103 size_t malloc_allocator_base::dealloc_count = 0; 104 bool malloc_allocator_base::disable_default_constructor = false; 105 106 107 template <class T> 108 class malloc_allocator : public malloc_allocator_base 109 { 110 public: 111 typedef T value_type; 112 113 malloc_allocator() TEST_NOEXCEPT { assert(!disable_default_constructor); } 114 115 template <class U> 116 malloc_allocator(malloc_allocator<U>) TEST_NOEXCEPT {} 117 118 T* allocate(std::size_t n) 119 { 120 ++alloc_count; 121 return static_cast<T*>(std::malloc(n*sizeof(T))); 122 } 123 124 void deallocate(T* p, std::size_t) 125 { 126 ++dealloc_count; 127 std::free(static_cast<void*>(p)); 128 } 129 130 friend bool operator==(malloc_allocator, malloc_allocator) {return true;} 131 friend bool operator!=(malloc_allocator x, malloc_allocator y) {return !(x == y);} 132 }; 133 134 135 #if TEST_STD_VER >= 11 136 137 #include <memory> 138 139 template <class T, class = std::integral_constant<size_t, 0> > class min_pointer; 140 template <class T, class ID> class min_pointer<const T, ID>; 141 template <class ID> class min_pointer<void, ID>; 142 template <class ID> class min_pointer<const void, ID>; 143 template <class T> class min_allocator; 144 145 template <class ID> 146 class min_pointer<const void, ID> 147 { 148 const void* ptr_; 149 public: 150 min_pointer() TEST_NOEXCEPT = default; 151 min_pointer(std::nullptr_t) TEST_NOEXCEPT : ptr_(nullptr) {} 152 template <class T> 153 min_pointer(min_pointer<T, ID> p) TEST_NOEXCEPT : ptr_(p.ptr_) {} 154 155 explicit operator bool() const {return ptr_ != nullptr;} 156 157 friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;} 158 friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);} 159 template <class U, class XID> friend class min_pointer; 160 }; 161 162 template <class ID> 163 class min_pointer<void, ID> 164 { 165 void* ptr_; 166 public: 167 min_pointer() TEST_NOEXCEPT = default; 168 min_pointer(std::nullptr_t) TEST_NOEXCEPT : ptr_(nullptr) {} 169 template <class T, 170 class = typename std::enable_if 171 < 172 !std::is_const<T>::value 173 >::type 174 > 175 min_pointer(min_pointer<T, ID> p) TEST_NOEXCEPT : ptr_(p.ptr_) {} 176 177 explicit operator bool() const {return ptr_ != nullptr;} 178 179 friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;} 180 friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);} 181 template <class U, class XID> friend class min_pointer; 182 }; 183 184 template <class T, class ID> 185 class min_pointer 186 { 187 T* ptr_; 188 189 explicit min_pointer(T* p) TEST_NOEXCEPT : ptr_(p) {} 190 public: 191 min_pointer() TEST_NOEXCEPT = default; 192 min_pointer(std::nullptr_t) TEST_NOEXCEPT : ptr_(nullptr) {} 193 explicit min_pointer(min_pointer<void, ID> p) TEST_NOEXCEPT : ptr_(static_cast<T*>(p.ptr_)) {} 194 195 explicit operator bool() const {return ptr_ != nullptr;} 196 197 typedef std::ptrdiff_t difference_type; 198 typedef T& reference; 199 typedef T* pointer; 200 typedef T value_type; 201 typedef std::random_access_iterator_tag iterator_category; 202 203 reference operator*() const {return *ptr_;} 204 pointer operator->() const {return ptr_;} 205 206 min_pointer& operator++() {++ptr_; return *this;} 207 min_pointer operator++(int) {min_pointer tmp(*this); ++ptr_; return tmp;} 208 209 min_pointer& operator--() {--ptr_; return *this;} 210 min_pointer operator--(int) {min_pointer tmp(*this); --ptr_; return tmp;} 211 212 min_pointer& operator+=(difference_type n) {ptr_ += n; return *this;} 213 min_pointer& operator-=(difference_type n) {ptr_ -= n; return *this;} 214 215 min_pointer operator+(difference_type n) const 216 { 217 min_pointer tmp(*this); 218 tmp += n; 219 return tmp; 220 } 221 222 friend min_pointer operator+(difference_type n, min_pointer x) 223 { 224 return x + n; 225 } 226 227 min_pointer operator-(difference_type n) const 228 { 229 min_pointer tmp(*this); 230 tmp -= n; 231 return tmp; 232 } 233 234 friend difference_type operator-(min_pointer x, min_pointer y) 235 { 236 return x.ptr_ - y.ptr_; 237 } 238 239 reference operator[](difference_type n) const {return ptr_[n];} 240 241 friend bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;} 242 friend bool operator> (min_pointer x, min_pointer y) {return y < x;} 243 friend bool operator<=(min_pointer x, min_pointer y) {return !(y < x);} 244 friend bool operator>=(min_pointer x, min_pointer y) {return !(x < y);} 245 246 static min_pointer pointer_to(T& t) {return min_pointer(std::addressof(t));} 247 248 friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;} 249 friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);} 250 template <class U, class XID> friend class min_pointer; 251 template <class U> friend class min_allocator; 252 }; 253 254 template <class T, class ID> 255 class min_pointer<const T, ID> 256 { 257 const T* ptr_; 258 259 explicit min_pointer(const T* p) : ptr_(p) {} 260 public: 261 min_pointer() TEST_NOEXCEPT = default; 262 min_pointer(std::nullptr_t) : ptr_(nullptr) {} 263 min_pointer(min_pointer<T, ID> p) : ptr_(p.ptr_) {} 264 explicit min_pointer(min_pointer<const void, ID> p) : ptr_(static_cast<const T*>(p.ptr_)) {} 265 266 explicit operator bool() const {return ptr_ != nullptr;} 267 268 typedef std::ptrdiff_t difference_type; 269 typedef const T& reference; 270 typedef const T* pointer; 271 typedef const T value_type; 272 typedef std::random_access_iterator_tag iterator_category; 273 274 reference operator*() const {return *ptr_;} 275 pointer operator->() const {return ptr_;} 276 277 min_pointer& operator++() {++ptr_; return *this;} 278 min_pointer operator++(int) {min_pointer tmp(*this); ++ptr_; return tmp;} 279 280 min_pointer& operator--() {--ptr_; return *this;} 281 min_pointer operator--(int) {min_pointer tmp(*this); --ptr_; return tmp;} 282 283 min_pointer& operator+=(difference_type n) {ptr_ += n; return *this;} 284 min_pointer& operator-=(difference_type n) {ptr_ -= n; return *this;} 285 286 min_pointer operator+(difference_type n) const 287 { 288 min_pointer tmp(*this); 289 tmp += n; 290 return tmp; 291 } 292 293 friend min_pointer operator+(difference_type n, min_pointer x) 294 { 295 return x + n; 296 } 297 298 min_pointer operator-(difference_type n) const 299 { 300 min_pointer tmp(*this); 301 tmp -= n; 302 return tmp; 303 } 304 305 friend difference_type operator-(min_pointer x, min_pointer y) 306 { 307 return x.ptr_ - y.ptr_; 308 } 309 310 reference operator[](difference_type n) const {return ptr_[n];} 311 312 friend bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;} 313 friend bool operator> (min_pointer x, min_pointer y) {return y < x;} 314 friend bool operator<=(min_pointer x, min_pointer y) {return !(y < x);} 315 friend bool operator>=(min_pointer x, min_pointer y) {return !(x < y);} 316 317 static min_pointer pointer_to(const T& t) {return min_pointer(std::addressof(t));} 318 319 friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;} 320 friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);} 321 template <class U, class XID> friend class min_pointer; 322 }; 323 324 template <class T, class ID> 325 inline 326 bool 327 operator==(min_pointer<T, ID> x, std::nullptr_t) 328 { 329 return !static_cast<bool>(x); 330 } 331 332 template <class T, class ID> 333 inline 334 bool 335 operator==(std::nullptr_t, min_pointer<T, ID> x) 336 { 337 return !static_cast<bool>(x); 338 } 339 340 template <class T, class ID> 341 inline 342 bool 343 operator!=(min_pointer<T, ID> x, std::nullptr_t) 344 { 345 return static_cast<bool>(x); 346 } 347 348 template <class T, class ID> 349 inline 350 bool 351 operator!=(std::nullptr_t, min_pointer<T, ID> x) 352 { 353 return static_cast<bool>(x); 354 } 355 356 template <class T> 357 class min_allocator 358 { 359 public: 360 typedef T value_type; 361 typedef min_pointer<T> pointer; 362 363 min_allocator() = default; 364 template <class U> 365 min_allocator(min_allocator<U>) {} 366 367 pointer allocate(std::ptrdiff_t n) 368 { 369 return pointer(static_cast<T*>(::operator new(n*sizeof(T)))); 370 } 371 372 void deallocate(pointer p, std::ptrdiff_t) 373 { 374 return ::operator delete(p.ptr_); 375 } 376 377 friend bool operator==(min_allocator, min_allocator) {return true;} 378 friend bool operator!=(min_allocator x, min_allocator y) {return !(x == y);} 379 }; 380 381 template <class T> 382 class explicit_allocator 383 { 384 public: 385 typedef T value_type; 386 387 explicit_allocator() TEST_NOEXCEPT {} 388 389 template <class U> 390 explicit explicit_allocator(explicit_allocator<U>) TEST_NOEXCEPT {} 391 392 T* allocate(std::size_t n) 393 { 394 return static_cast<T*>(::operator new(n*sizeof(T))); 395 } 396 397 void deallocate(T* p, std::size_t) 398 { 399 return ::operator delete(static_cast<void*>(p)); 400 } 401 402 friend bool operator==(explicit_allocator, explicit_allocator) {return true;} 403 friend bool operator!=(explicit_allocator x, explicit_allocator y) {return !(x == y);} 404 }; 405 406 #endif // TEST_STD_VER >= 11 407 408 #endif // MIN_ALLOCATOR_H 409
