fix: rework allocator for alignment mode

Author: qubka

include/plg/allocator.hpp

@@ -47,26 +47,33 @@ namespace plg {
 
 			size_type size = n * sizeof(T);
 			if (std::is_constant_evaluated()) {
-				return static_cast<T*>(::operator new(size));
+				if constexpr (alignof(T) > alignof(std::max_align_t)) {
+					return static_cast<T*>(::operator new(size, std::align_val_t{alignof(T)}));
+				} else {
+					return static_cast<T*>(::operator new(size));
+				}
 			} else {
 				return malloc_allocate(size);
 			}
 		}
 
 		constexpr void deallocate(T* p, [[maybe_unused]] size_type n) {
 			if (std::is_constant_evaluated()) {
-				::operator delete(p);
+				if constexpr (alignof(T) > alignof(std::max_align_t)) {
+					::operator delete(p, std::align_val_t{alignof(T)});
+				} else {
+					::operator delete(p);
+				}
 			} else {
-				std::free(p);
+				malloc_deallocate(p);
 			}
 		}
 
 	private:
 		static T* malloc_allocate(size_type size) {
 			T* ret;
 			if constexpr (alignof(T) > alignof(std::max_align_t)) {
-				size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1);
-				ret = static_cast<T*>(aligned_allocate(alignof(T), aligned_size));
+				ret = static_cast<T*>(aligned_allocate(size));
 			} else {
 				ret = static_cast<T*>(std::malloc(size));
 			}
@@ -76,6 +83,14 @@ namespace plg {
 			return ret;
 		}
 
+		static void malloc_deallocate(T* ptr) {
+			if constexpr (alignof(T) > alignof(std::max_align_t)) {
+				aligned_deallocate(ptr);
+			} else {
+				std::free(ptr);
+			}
+		}
+
 		[[noreturn]] static void throw_bad_array_new_length() {
 			PLUGIFY_THROW("bad array new length", std::bad_array_new_length);
 		}
@@ -84,11 +99,20 @@ namespace plg {
 			PLUGIFY_THROW("bad allocation", std::bad_alloc);
 		}
 
-		static void* aligned_allocate(size_type alignment, size_type size) {
+		static void* aligned_allocate(size_type size) {
+#if PLUGIFY_PLATFORM_WINDOWS
+			return _aligned_malloc(size, alignof(T));
+#else
+			size_type aligned_size = (size + (alignof(T) - 1)) & ~(alignof(T) - 1);
+			return std::aligned_alloc(alignof(T), aligned_size);
+#endif // PLUGIFY_PLATFORM_WINDOWS
+		}
+
+		static void aligned_deallocate(void* ptr) {
 #if PLUGIFY_PLATFORM_WINDOWS
-			return _aligned_malloc(size, alignment);
+			_aligned_free(ptr);
 #else
-			return std::aligned_alloc(alignment, size);
+			std::free(ptr);
 #endif // PLUGIFY_PLATFORM_WINDOWS
 		}
 	};