mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 04:02:41 +01:00
497a019107
This lets it use sized deallocation and make more efficient alignment decisions. Also adjust BumpPtrAllocator to always allocate at alignof(std::max_align_t).
104 lines
3.9 KiB
C++
104 lines
3.9 KiB
C++
//===- 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 LLVM_SUPPORT_ALLOCATORBASE_H
|
|
#define LLVM_SUPPORT_ALLOCATORBASE_H
|
|
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/MemAlloc.h"
|
|
|
|
namespace llvm {
|
|
|
|
/// 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<std::remove_cv_t<T>, void>::value, 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() {}
|
|
|
|
LLVM_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 llvm
|
|
|
|
#endif // LLVM_SUPPORT_ALLOCATORBASE_H
|