yuzu-emu/yuzu-android
1
0
Fork 0
mirror of https://github.com/yuzu-emu/yuzu-android.git synced 2024-11-26 21:55:40 +01:00
Code Issues Packages Projects Releases Wiki Activity

Common: Correct alignment allocator to work on C++14 or higher.

Browse Source
This commit is contained in:
Fernando Sahmkow 2019-07-19 11:11:42 -04:00
parent 9bede4eeed
commit 0901c33753
1 changed files with 19 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/common/alignment.h
View File

@ -3,10 +3,8 @@
#pragma once #pragma once
#include <cstddef> #include <cstddef>
#include <cstdlib> #include <memory>
#include <type_traits> #include <type_traits>
#include <malloc.h>
#include <stdlib.h>
namespace Common { namespace Common {
@ -43,59 +41,43 @@ constexpr bool IsWordAligned(T value) {
template <typename T, std::size_t Align = 16> template <typename T, std::size_t Align = 16>
class AlignmentAllocator { class AlignmentAllocator {
public: public:
typedef T value_type; using value_type = T;
typedef std::size_t size_type; using size_type = std::size_t;
typedef std::ptrdiff_t difference_type; using difference_type = std::ptrdiff_t;
typedef T* pointer; using pointer = T*;
typedef const T* const_pointer; using const_pointer = const T*;
typedef T& reference; using reference = T&;
typedef const T& const_reference; using const_reference = const T&;
public: public:
inline AlignmentAllocator() throw() {}
template <typename T2> pointer address(reference r) {
inline AlignmentAllocator(const AlignmentAllocator<T2, Align>&) throw() {} return std::addressof(r);
inline ~AlignmentAllocator() throw() {}
inline pointer adress(reference r) {
return &r;
} }
inline const_pointer adress(const_reference r) const { const_pointer address(const_reference r) const {
return &r; return std::addressof(r);
} }
#if (defined _MSC_VER) pointer allocate(size_type n) {
inline pointer allocate(size_type n) { return static_cast<pointer>(::operator new(n, std::align_val_t{Align}));
return (pointer)_aligned_malloc(n * sizeof(value_type), Align);
} }
inline void deallocate(pointer p, size_type) { void deallocate(pointer p, size_type) {
_aligned_free(p); ::operator delete(p, std::align_val_t{Align});
}
#else
inline pointer allocate(size_type n) {
return (pointer)std::aligned_alloc(Align, n * sizeof(value_type));
} }
inline void deallocate(pointer p, size_type) { void construct(pointer p, const value_type& wert) {
std::free(p);
}
#endif
inline void construct(pointer p, const value_type& wert) {
new (p) value_type(wert); new (p) value_type(wert);
} }
inline void destroy(pointer p) { void destroy(pointer p) {
p->~value_type(); p->~value_type();
} }
inline size_type max_size() const throw() { size_type max_size() const noexcept {
return size_type(-1) / sizeof(value_type); return size_type(-1) / sizeof(value_type);
} }