1 //===- AllocatorBase.h - Simple memory allocation abstraction ---*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// \file 9 /// 10 /// This file defines MallocAllocator. MallocAllocator conforms to the LLVM 11 /// "Allocator" concept which consists of an Allocate method accepting a size 12 /// and alignment, and a Deallocate accepting a pointer and size. Further, the 13 /// LLVM "Allocator" concept has overloads of Allocate and Deallocate for 14 /// setting size and alignment based on the final type. These overloads are 15 /// typically provided by a base class template \c AllocatorBase. 16 /// 17 //===----------------------------------------------------------------------===// 18 19 #ifndef LLVM_SUPPORT_ALLOCATORBASE_H 20 #define LLVM_SUPPORT_ALLOCATORBASE_H 21 22 #include "llvm/Support/Compiler.h" 23 #include "llvm/Support/MemAlloc.h" 24 25 namespace llvm { 26 27 /// CRTP base class providing obvious overloads for the core \c 28 /// Allocate() methods of LLVM-style allocators. 29 /// 30 /// This base class both documents the full public interface exposed by all 31 /// LLVM-style allocators, and redirects all of the overloads to a single core 32 /// set of methods which the derived class must define. 33 template <typename DerivedT> class AllocatorBase { 34 public: 35 /// Allocate \a Size bytes of \a Alignment aligned memory. This method 36 /// must be implemented by \c DerivedT. 37 void *Allocate(size_t Size, size_t Alignment) { 38 #ifdef __clang__ 39 static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>( 40 &AllocatorBase::Allocate) != 41 static_cast<void *(DerivedT::*)(size_t, size_t)>( 42 &DerivedT::Allocate), 43 "Class derives from AllocatorBase without implementing the " 44 "core Allocate(size_t, size_t) overload!"); 45 #endif 46 return static_cast<DerivedT *>(this)->Allocate(Size, Alignment); 47 } 48 49 /// Deallocate \a Ptr to \a Size bytes of memory allocated by this 50 /// allocator. 51 void Deallocate(const void *Ptr, size_t Size, size_t Alignment) { 52 #ifdef __clang__ 53 static_assert( 54 static_cast<void (AllocatorBase::*)(const void *, size_t, size_t)>( 55 &AllocatorBase::Deallocate) != 56 static_cast<void (DerivedT::*)(const void *, size_t, size_t)>( 57 &DerivedT::Deallocate), 58 "Class derives from AllocatorBase without implementing the " 59 "core Deallocate(void *) overload!"); 60 #endif 61 return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size, Alignment); 62 } 63 64 // The rest of these methods are helpers that redirect to one of the above 65 // core methods. 66 67 /// Allocate space for a sequence of objects without constructing them. 68 template <typename T> T *Allocate(size_t Num = 1) { 69 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T))); 70 } 71 72 /// Deallocate space for a sequence of objects without constructing them. 73 template <typename T> 74 std::enable_if_t<!std::is_same<std::remove_cv_t<T>, void>::value, void> 75 Deallocate(T *Ptr, size_t Num = 1) { 76 Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T), alignof(T)); 77 } 78 }; 79 80 class MallocAllocator : public AllocatorBase<MallocAllocator> { 81 public: 82 void Reset() {} 83 84 LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) { 85 return allocate_buffer(Size, Alignment); 86 } 87 88 // Pull in base class overloads. 89 using AllocatorBase<MallocAllocator>::Allocate; 90 91 void Deallocate(const void *Ptr, size_t Size, size_t Alignment) { 92 deallocate_buffer(const_cast<void *>(Ptr), Size, Alignment); 93 } 94 95 // Pull in base class overloads. 96 using AllocatorBase<MallocAllocator>::Deallocate; 97 98 void PrintStats() const {} 99 }; 100 101 } // namespace llvm 102 103 #endif // LLVM_SUPPORT_ALLOCATORBASE_H 104