1 files changed, 200 insertions, 0 deletions
diff --git a/libbase/include/core/memory/AllocatorBase.h b/libbase/include/core/memory/AllocatorBase.h
new file mode 100644
index 0000000..af6f5ca
--- /dev/null
+++ b/libbase/include/core/memory/AllocatorBase.h
@@ -0,0 +1,200 @@
+/*
+ RCC-Project
+
+ Copyright (C) 2026 Richard Qin
+
+ This file is part of RCC-Project.
+
+ RCC-Project 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 3 of the License, or (at your option) any
+ later version.
+
+ RCC-Project 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
+ RCC-Project; see the file COPYING. If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+//===- AllocatorBase.h - Simple memory allocation abstraction ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines MallocAllocator. MallocAllocator conforms to the LLVM
+/// "Allocator" concept which consists of an Allocate method accepting a size
+/// and alignment, and a Deallocate accepting a pointer and size. Further, the
+/// LLVM "Allocator" concept has overloads of Allocate and Deallocate for
+/// setting size and alignment based on the final type. These overloads are
+/// typically provided by a base class template \c AllocatorBase.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LIBBASE_SUPPORT_ALLOCATORBASE_H
+#define LIBBASE_SUPPORT_ALLOCATORBASE_H
+
+#ifdef _MSC_VER
+#define LIBBASE_ALLOCATORHOLDER_EMPTYBASE __declspec (empty_bases)
+#else
+#define LIBBASE_ALLOCATORHOLDER_EMPTYBASE
+#endif // _MSC_VER
+
+#include "core/compiler/Compiler.h"
+#include "core/memory/MemAlloc.h"
+#include <type_traits>
+#include <utility>
+
+namespace libbase
+{
+
+/// CRTP base class providing obvious overloads for the core \c
+/// Allocate() methods of LLVM-style allocators.
+///
+/// This base class both documents the full public interface exposed by all
+/// LLVM-style allocators, and redirects all of the overloads to a single core
+/// set of methods which the derived class must define.
+template <typename DerivedT> class AllocatorBase
+{
+public:
+  /// Allocate \a Size bytes of \a Alignment aligned memory. This method
+  /// must be implemented by \c DerivedT.
+  void *
+  Allocate (size_t Size, size_t Alignment)
+  {
+#ifdef __clang__
+    static_assert (static_cast<void *(AllocatorBase::*) (size_t, size_t)> (
+                       &AllocatorBase::Allocate) !=
+                       static_cast<void *(DerivedT::*) (size_t, size_t)> (
+                           &DerivedT::Allocate),
+                   "Class derives from AllocatorBase without implementing the "
+                   "core Allocate(size_t, size_t) overload!");
+#endif
+    return static_cast<DerivedT *> (this)->Allocate (Size, Alignment);
+  }
+
+  /// Deallocate \a Ptr to \a Size bytes of memory allocated by this
+  /// allocator.
+  void
+  Deallocate (const void *Ptr, size_t Size, size_t Alignment)
+  {
+#ifdef __clang__
+    static_assert (
+        static_cast<void (AllocatorBase::*) (const void *, size_t, size_t)> (
+            &AllocatorBase::Deallocate) !=
+            static_cast<void (DerivedT::*) (const void *, size_t, size_t)> (
+                &DerivedT::Deallocate),
+        "Class derives from AllocatorBase without implementing the "
+        "core Deallocate(void *) overload!");
+#endif
+    return static_cast<DerivedT *> (this)->Deallocate (Ptr, Size, Alignment);
+  }
+
+  // The rest of these methods are helpers that redirect to one of the above
+  // core methods.
+
+  /// Allocate space for a sequence of objects without constructing them.
+  template <typename T>
+  T *
+  Allocate (size_t Num = 1)
+  {
+    return static_cast<T *> (Allocate (Num * sizeof (T), alignof (T)));
+  }
+
+  /// Deallocate space for a sequence of objects without constructing them.
+  template <typename T>
+  std::enable_if_t<!std::is_same_v<std::remove_cv_t<T>, void>, void>
+  Deallocate (T *Ptr, size_t Num = 1)
+  {
+    Deallocate (static_cast<const void *> (Ptr), Num * sizeof (T), alignof (T));
+  }
+};
+
+class MallocAllocator : public AllocatorBase<MallocAllocator>
+{
+public:
+  void
+  Reset ()
+  {
+  }
+
+  LIBBASE_ATTRIBUTE_RETURNS_NONNULL void *
+  Allocate (size_t Size, size_t Alignment)
+  {
+    return allocate_buffer (Size, Alignment);
+  }
+
+  // Pull in base class overloads.
+  using AllocatorBase<MallocAllocator>::Allocate;
+
+  void
+  Deallocate (const void *Ptr, size_t Size, size_t Alignment)
+  {
+    deallocate_buffer (const_cast<void *> (Ptr), Size, Alignment);
+  }
+
+  // Pull in base class overloads.
+  using AllocatorBase<MallocAllocator>::Deallocate;
+
+  void
+  PrintStats () const
+  {
+  }
+};
+
+namespace detail
+{
+
+template <typename Alloc> class AllocatorHolder : Alloc
+{
+public:
+  AllocatorHolder () = default;
+  AllocatorHolder (const Alloc &A) : Alloc (A)
+  {
+  }
+  AllocatorHolder (Alloc &&A) : Alloc (std::move (A))
+  {
+  }
+  Alloc &
+  getAllocator ()
+  {
+    return *this;
+  }
+  const Alloc &
+  getAllocator () const
+  {
+    return *this;
+  }
+};
+
+template <typename Alloc> class AllocatorHolder<Alloc &>
+{
+  Alloc &A;
+
+public:
+  AllocatorHolder (Alloc &A) : A (A)
+  {
+  }
+  Alloc &
+  getAllocator ()
+  {
+    return A;
+  }
+  const Alloc &
+  getAllocator () const
+  {
+    return A;
+  }
+};
+
+} // namespace detail
+
+} // namespace libbase
+
+#endif // LIBBASE_SUPPORT_ALLOCATORBASE_H