Try using C++17's aligned new, maybe works natively on MSYS?

src/librawspeed/adt/AlignedAllocator.h

@@ -20,7 +20,6 @@
 
 #pragma once
 
-#include "AddressSanitizer.h"
 #include "adt/Invariant.h"
 #include "common/Common.h"
 #include "common/RawspeedException.h"
@@ -33,47 +32,6 @@
 
 namespace rawspeed {
 
-namespace impl {
-
-[[nodiscard]] inline void* __attribute__((malloc, warn_unused_result,
-                                          alloc_size(1), alloc_align(2)))
-alignedMalloc(size_t size, size_t alignment) {
-  invariant(isPowerOfTwo(alignment)); // for posix_memalign, _aligned_malloc
-  invariant(isAligned(alignment, sizeof(void*))); // for posix_memalign
-  invariant(isAligned(size, alignment));          // for aligned_alloc
-
-  void* ptr = nullptr;
-
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-  // workaround ASAN's broken allocator_may_return_null option
-  // plus, avoidance of libFuzzer's rss_limit_mb option
-  // if trying to alloc more than 2GB, just return null.
-  // else it would abort() the whole program...
-  if (size > 2UL << 30UL)
-    return ptr;
-#endif
-
-#if defined(_WIN32) || defined(_WIN64)
-  ptr = _aligned_malloc(size, alignment);
-#else
-  ptr = std::aligned_alloc(alignment, size);
-#endif
-
-  invariant(isAligned(ptr, alignment));
-
-  return ptr;
-}
-
-inline void alignedFree(void* ptr) {
-#if defined(_WIN32) || defined(_WIN64)
-  _aligned_free(ptr);
-#else
-  std::free(ptr); // NOLINT
-#endif
-}
-
-} // namespace impl
-
 template <class T, int alignment> class AlignedAllocator {
   using self = AlignedAllocator<T, alignment>;
   using allocator_traits = std::allocator_traits<self>;
@@ -86,30 +44,37 @@ template <class T, int alignment> class AlignedAllocator {
   };
 
   [[nodiscard]] T* allocate(std::size_t numElts) const {
-    static_assert(alignment >= alignof(T), "insufficient alignment");
+    static_assert(size_t(alignment) >= alignof(T), "insufficient alignment");
     invariant(numElts > 0 && "Should not be trying to allocate no elements");
     assert(numElts <= allocator_traits::max_size(*this) &&
            "Can allocate this many elements.");
     invariant(numElts <= SIZE_MAX / sizeof(T) &&
               "Byte count calculation will not overflow");
 
     std::size_t numBytes = sizeof(T) * numElts;
-    std::size_t numPaddedBytes = roundUp(numBytes, alignment);
-    invariant(numPaddedBytes >= numBytes &&
-              "Alignment did not cause wraparound.");
 
-    auto* r = static_cast<T*>(impl::alignedMalloc(numPaddedBytes, alignment));
+#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+    // workaround ASAN's broken allocator_may_return_null option
+    // plus, avoidance of libFuzzer's rss_limit_mb option
+    // if trying to alloc more than 2GB, just return null.
+    // else it would abort() the whole program...
+    if (numBytes > 2UL << 30UL)
+      ThrowRSE("FUZZ alloc bailout (%zu bytes)", numBytes);
+#endif
+
+    auto* r = static_cast<T*>(operator new(
+        numBytes, static_cast<std::align_val_t>(alignment)));
+    invariant(isAligned(r, alignment));
     if (!r)
-      ThrowRSE("Out of memory while trying to allocate %zu bytes",
-               numPaddedBytes);
-    ASan::PoisonMemoryRegion(r + numElts, numPaddedBytes - numBytes);
+      ThrowRSE("Out of memory while trying to allocate %zu bytes", numBytes);
     return r;
   }
 
   void deallocate(T* p, std::size_t n) const noexcept {
     invariant(p);
     invariant(n > 0);
-    impl::alignedFree(p);
+    invariant(isAligned(p, alignment));
+    operator delete(p, static_cast<std::align_val_t>(alignment));
   }
 
   using propagate_on_container_copy_assignment = std::true_type;