WIPde/memory-stomp-detector

6 files changed, 188 insertions, 19 deletions

diff --git a/src/zencore/include/zencore/zen-new-delete.h b/src/zencore/include/zencore/zen-new-delete.h
new file mode 100644
index 000000000..27c53b4e2
--- /dev/null
+++ b/src/zencore/include/zencore/zen-new-delete.h
@@ -0,0 +1,71 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zencore/zencore.h>
+
+#if ZEN_USE_MIMALLOC
+
+#	define zen_new_aligned mi_aligned_alloc
+#	define zen_free		mi_free
+
+#else
+
+#	include <new>
+
+#	if defined(_MSC_VER) && defined(_Ret_notnull_) && defined(_Post_writable_byte_size_)
+// stay consistent with VCRT definitions
+#		define mi_decl_new(n)		   [[nodiscard]] _Ret_notnull_ _Post_writable_byte_size_(n)
+#		define mi_decl_new_nothrow(n) [[nodiscard]] _Ret_maybenull_ _Success_(return != NULL) _Post_writable_byte_size_(n)
+#	else
+#		define mi_decl_new(n)		   [[nodiscard]]
+#		define mi_decl_new_nothrow(n) [[nodiscard]]
+#	endif
+
+void
+operator delete(void* p) noexcept
+{
+	zen_free(p);
+};
+void
+operator delete[](void* p) noexcept
+{
+	zen_free(p);
+};
+
+void
+operator delete(void* p, const std::nothrow_t&) noexcept
+{
+	zen_free(p);
+}
+void
+operator delete[](void* p, const std::nothrow_t&) noexcept
+{
+	zen_free(p);
+}
+
+mi_decl_new(n) void*
+operator new(std::size_t n) noexcept(false)
+{
+	return zen_new(n);
+}
+mi_decl_new(n) void*
+operator new[](std::size_t n) noexcept(false)
+{
+	return zen_new(n);
+}
+
+mi_decl_new_nothrow(n) void*
+operator new(std::size_t n, const std::nothrow_t& tag) noexcept
+{
+	(void)(tag);
+	return zen_new(n);
+}
+mi_decl_new_nothrow(n) void*
+operator new[](std::size_t n, const std::nothrow_t& tag) noexcept
+{
+	(void)(tag);
+	return zen_new(n);
+}
+
+#endif
diff --git a/src/zencore/include/zencore/zencore.h b/src/zencore/include/zencore/zencore.h
index d21c0e7e2..600406acb 100644
--- a/src/zencore/include/zencore/zencore.h
+++ b/src/zencore/include/zencore/zencore.h
@@ -23,6 +23,13 @@
 #	define ZEN_DEBUG_SECTION ZEN_CODE_SECTION(".zcold")
 #endif
 
+void  zen_free(void* p) noexcept;
+void  zen_free_size(void* p, std::size_t n) noexcept;
+void* zen_new(std::size_t n) noexcept;
+void* zen_new_aligned(std::size_t n, size_t al) noexcept;
+void  zen_free_aligned(void* p, size_t al) noexcept;
+void  zen_free_size_aligned(void* p, std::size_t n, size_t al) noexcept;
+
 namespace zen {
 
 struct CallstackFrames;
diff --git a/src/zencore/iobuffer.cpp b/src/zencore/iobuffer.cpp
index e1e8750a1..29f643105 100644
--- a/src/zencore/iobuffer.cpp
+++ b/src/zencore/iobuffer.cpp
@@ -53,12 +53,12 @@ IoBufferCore::AllocateBuffer(size_t InSize, size_t Alignment) const
 	}
 #endif	// ZEN_PLATFORM_WINDOWS
 
-#if ZEN_USE_MIMALLOC
-	void* Ptr = mi_aligned_alloc(Alignment, RoundUp(InSize, Alignment));
-	m_Flags.fetch_or(kIoBufferAlloc, std::memory_order_relaxed);
-#else
+	//#if ZEN_USE_MIMALLOC
+	//	void* Ptr = zen_new_aligned(Alignment, RoundUp(InSize, Alignment));
+	//	m_Flags.fetch_or(kIoBufferAlloc, std::memory_order_relaxed);
+	//#else
 	void* Ptr = Memory::Alloc(InSize, Alignment);
-#endif
+	//#endif
 
 	if (!Ptr)
 	{
@@ -85,12 +85,12 @@ IoBufferCore::FreeBuffer()
 	}
 #endif	// ZEN_PLATFORM_WINDOWS
 
-#if ZEN_USE_MIMALLOC
-	if (LocalFlags & kIoBufferAlloc)
-	{
-		return mi_free(const_cast<void*>(m_DataPtr));
-	}
-#endif
+	//#if ZEN_USE_MIMALLOC
+	//	if (LocalFlags & kIoBufferAlloc)
+	//	{
+	//		return zen_free(const_cast<void*>(m_DataPtr));
+	//	}
+	//#endif
 
 	ZEN_UNUSED(LocalFlags);
 	return Memory::Free(const_cast<void*>(m_DataPtr));
@@ -559,8 +559,8 @@ IoBufferBuilder::ReadFromFileMaybe(const IoBuffer& InBuffer)
 		DWORD dwNumberOfBytesRead = 0;
 		BOOL  Success = ::ReadFile(FileRef.FileHandle, OutBuffer.MutableData(), DWORD(NumberOfBytesToRead), &dwNumberOfBytesRead, &Ovl);
 #else
-		int	 Fd		 = int(intptr_t(FileRef.FileHandle));
-		int	 Result	 = pread(Fd, OutBuffer.MutableData(), size_t(FileRef.FileChunkSize), off_t(FileRef.FileChunkOffset));
+		int Fd = int(intptr_t(FileRef.FileHandle));
+		int Result = pread(Fd, OutBuffer.MutableData(), size_t(FileRef.FileChunkSize), off_t(FileRef.FileChunkOffset));
 		bool Success = (Result >= 0);
 
 		uint32_t dwNumberOfBytesRead = uint32_t(Result);
@@ -615,7 +615,7 @@ IoBufferBuilder::MakeFromFile(const std::filesystem::path& FileName, uint64_t Of
 	DataFile.GetSize((ULONGLONG&)FileSize);
 #else
 	int Flags = O_RDONLY | O_CLOEXEC;
-	int Fd	  = open(FileName.c_str(), Flags);
+	int Fd = open(FileName.c_str(), Flags);
 	if (Fd < 0)
 	{
 		return {};
@@ -684,7 +684,7 @@ IoBufferBuilder::MakeFromTemporaryFile(const std::filesystem::path& FileName)
 
 	Handle = DataFile.Detach();
 #else
-	int Fd	 = open(FileName.native().c_str(), O_RDONLY);
+	int Fd = open(FileName.native().c_str(), O_RDONLY);
 	if (Fd < 0)
 	{
 		return {};
diff --git a/src/zencore/memory.cpp b/src/zencore/memory.cpp
index 808c9fcb6..ead6dbe6d 100644
--- a/src/zencore/memory.cpp
+++ b/src/zencore/memory.cpp
@@ -26,8 +26,8 @@ AlignedAllocImpl(size_t Size, size_t Alignment)
 	// platforms return null if this requirement isn't met.
 	Size = (Size + Alignment - 1) & ~(Alignment - 1);
 
-#if ZEN_USE_MIMALLOC
-	return mi_aligned_alloc(Alignment, Size);
+#if ZEN_USE_MIMALLOC || 1
+	return zen_new_aligned(Size, Alignment);
 #elif ZEN_PLATFORM_WINDOWS
 	return _aligned_malloc(Size, Alignment);
 #else
@@ -41,8 +41,8 @@ AlignedFreeImpl(void* ptr)
 	if (ptr == nullptr)
 		return;
 
-#if ZEN_USE_MIMALLOC
-	return mi_free(ptr);
+#if ZEN_USE_MIMALLOC || 1
+	return zen_free(ptr);
 #elif ZEN_PLATFORM_WINDOWS
 	_aligned_free(ptr);
 #else
diff --git a/src/zencore/zencore.cpp b/src/zencore/zencore.cpp
index 9c48b355b..b7a2e2dc4 100644
--- a/src/zencore/zencore.cpp
+++ b/src/zencore/zencore.cpp
@@ -36,6 +36,95 @@
 
 #include <atomic>
 
+struct MemHeader
+{
+	size_t	Size = ~0u;
+	uint8_t Buffer[64 - sizeof(size_t)];
+};
+
+struct MemTail
+{
+	uint8_t Buffer[64];
+};
+
+void
+zen_free(void* p) noexcept
+{
+	MemHeader* Header = (MemHeader*)p;
+	Header			  = &Header[-1];
+	for (std::size_t HeaderPad = 0; HeaderPad < 64 - sizeof(size_t); HeaderPad++)
+	{
+		ZEN_ASSERT(Header->Buffer[HeaderPad] == 0x7f);
+	}
+	const size_t PadAlignment = 8;
+	std::size_t	 AlignedSize  = (Header->Size + PadAlignment - 1) & ~(PadAlignment - 1);
+	std::size_t	 PadSize	  = AlignedSize - Header->Size;
+	uint8_t*	 TailPtr	  = (uint8_t*)(p);
+	TailPtr += Header->Size;
+	std::size_t TailSize = PadSize + sizeof(MemTail);
+	for (std::size_t TailPad = 0; TailPad < TailSize; TailPad++)
+	{
+		ZEN_ASSERT(TailPtr[TailPad] == 0x7f);
+	}
+#if ZEN_PLATFORM_WINDOWS
+	_aligned_free((void*)Header);
+#else
+	std::free(ptr);
+#endif
+}
+
+void
+zen_free_size(void* p, std::size_t n) noexcept
+{
+	ZEN_UNUSED(n);
+	zen_free(p);
+}
+
+void*
+zen_new(std::size_t n) noexcept
+{
+	return zen_new_aligned(n, 1);
+}
+
+void*
+zen_new_aligned(std::size_t n, size_t al) noexcept
+{
+	const size_t PadAlignment = 8;
+	std::size_t	 AlignedSize  = (n + PadAlignment - 1) & ~(PadAlignment - 1);
+
+	size_t alloc_size = sizeof(MemHeader) + AlignedSize + sizeof(MemTail);
+
+#if ZEN_PLATFORM_WINDOWS
+	void* Ptr = _aligned_malloc(alloc_size, al);
+#else
+	void* Ptr = std::aligned_alloc(Alignment, alloc_size);
+#endif
+
+	MemHeader* Header = (MemHeader*)Ptr;
+	memset(Header, 0x7f, sizeof(MemHeader));
+	Header->Size		= n;
+	void*		Result	= &Header[1];
+	std::size_t PadSize = AlignedSize - n;
+	uint8_t*	TailPtr = (uint8_t*)(Result);
+	TailPtr += n;
+	memset(TailPtr, 0x7f, PadSize + sizeof(MemTail));
+	return Result;
+}
+
+void
+zen_free_aligned(void* p, size_t al) noexcept
+{
+	ZEN_UNUSED(al);
+	zen_free(p);
+}
+
+void
+zen_free_size_aligned(void* p, std::size_t n, size_t al) noexcept
+{
+	ZEN_UNUSED(n, al);
+	zen_free(p);
+}
+
 namespace zen::assert {
 
 void
diff --git a/src/zenserver/main.cpp b/src/zenserver/main.cpp
index b96118484..81f5b1c8d 100644
--- a/src/zenserver/main.cpp
+++ b/src/zenserver/main.cpp
@@ -24,6 +24,8 @@
 ZEN_THIRD_PARTY_INCLUDES_START
 #	include <mimalloc-new-delete.h>
 ZEN_THIRD_PARTY_INCLUDES_END
+#else
+#	include <zencore/zen-new-delete.h>
 #endif
 
 #if ZEN_PLATFORM_WINDOWS