LLVM  12.0.0git
AllocatorBase.h
Go to the documentation of this file.
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)>(
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)>(
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.
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.
97 
98  void PrintStats() const {}
99 };
100 
101 } // namespace llvm
102 
103 #endif // LLVM_SUPPORT_ALLOCATORBASE_H
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void * Allocate(size_t Size, size_t Alignment)
Allocate Size bytes of Alignment aligned memory.
Definition: AllocatorBase.h:37
void PrintStats() const
Definition: AllocatorBase.h:98
This file defines counterparts of C library allocation functions defined in the namespace &#39;std&#39;...
#define LLVM_ATTRIBUTE_RETURNS_NONNULL
Definition: Compiler.h:257
void Deallocate(const void *Ptr, size_t Size, size_t Alignment)
Definition: AllocatorBase.h:91
std::enable_if_t<!std::is_same< std::remove_cv_t< T >, void >::value, void > Deallocate(T *Ptr, size_t Num=1)
Deallocate space for a sequence of objects without constructing them.
Definition: AllocatorBase.h:75
void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment)
Deallocate a buffer of memory with the given size and alignment.
Definition: MemAlloc.cpp:23
T * Allocate(size_t Num=1)
Allocate space for a sequence of objects without constructing them.
Definition: AllocatorBase.h:68
uint32_t Size
Definition: Profile.cpp:46
void Deallocate(const void *Ptr, size_t Size, size_t Alignment)
Deallocate Ptr to Size bytes of memory allocated by this allocator.
Definition: AllocatorBase.h:51
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * allocate_buffer(size_t Size, size_t Alignment)
Allocate a buffer of memory with the given size and alignment.
Definition: MemAlloc.cpp:14
LLVM_ATTRIBUTE_RETURNS_NONNULL void * Allocate(size_t Size, size_t Alignment)
Definition: AllocatorBase.h:84
CRTP base class providing obvious overloads for the core Allocate() methods of LLVM-style allocators...
Definition: AllocatorBase.h:33