feat(crashdump): Add crash dump functionality

Author: slurmlord

Core/GameEngine/CMakeLists.txt

@@ -71,6 +71,8 @@ set(GAMEENGINE_SRC
 #    Include/Common/MapObject.h
 #    Include/Common/MapReaderWriterInfo.h
 #    Include/Common/MessageStream.h
+    Include/Common/MiniDumper.h
+    Include/Common/MiniDumper_compat.h
 #    Include/Common/MiniLog.h
     Include/Common/MiscAudio.h
 #    Include/Common/MissionStats.h
@@ -658,6 +660,7 @@ set(GAMEENGINE_SRC
 #    Source/Common/System/List.cpp
     Source/Common/System/LocalFile.cpp
     Source/Common/System/LocalFileSystem.cpp
+    Source/Common/System/MiniDumper.cpp
 #    Source/Common/System/ObjectStatusTypes.cpp
 #    Source/Common/System/QuotedPrintable.cpp
 #    Source/Common/System/Radar.cpp

Core/GameEngine/Include/Common/GameMemory.h

@@ -223,6 +223,9 @@ class MemoryPool;
 class MemoryPoolFactory;
 class DynamicMemoryAllocator;
 class BlockCheckpointInfo;
+#ifdef RTS_ENABLE_CRASHDUMP
+class AllocationRangeIterator;
+#endif
 
 // TYPE DEFINES ///////////////////////////////////////////////////////////////
 
@@ -279,6 +282,14 @@ class Checkpointable
 };
 #endif
 
+#ifdef RTS_ENABLE_CRASHDUMP
+struct MemoryPoolAllocatedRange
+{
+	char* allocationAddr;
+	size_t allocationSize;
+};
+#endif
+
 // ----------------------------------------------------------------------------
 /**
 	A MemoryPool provides a way to efficiently allocate objects of the same (or similar)
@@ -384,6 +395,9 @@ class MemoryPool
 		/// return true iff this block was allocated by this pool.
 		Bool debugIsBlockInPool(void *pBlock);
 	#endif
+#ifdef RTS_ENABLE_CRASHDUMP
+		friend class AllocationRangeIterator;
+#endif
 };
 
 // ----------------------------------------------------------------------------
@@ -474,13 +488,70 @@ class DynamicMemoryAllocator
 		Bool debugIsPoolInDma(MemoryPool *pool);
 
 	#endif	// MEMORYPOOL_DEBUG
+#ifdef RTS_ENABLE_CRASHDUMP
+		Int getRawBlockCount() const;
+		void fillAllocationRangeForRawBlockN(const Int n, MemoryPoolAllocatedRange& allocationRange) const;
+#endif
 };
 
 // ----------------------------------------------------------------------------
 #ifdef MEMORYPOOL_DEBUG
 enum { MAX_SPECIAL_USED = 256 };
 #endif
 
+#ifdef RTS_ENABLE_CRASHDUMP
+class AllocationRangeIterator {
+	typedef const MemoryPoolAllocatedRange value_type;
+	typedef const MemoryPoolAllocatedRange* pointer;
+	typedef const MemoryPoolAllocatedRange& reference;
+public:
+
+	AllocationRangeIterator(const MemoryPoolFactory* factory);
+	AllocationRangeIterator(MemoryPool& pool, MemoryPoolBlob& blob) {
+		m_currentPool = &pool;
+		m_currentBlobInPool = &blob;
+		m_factory = NULL;
+		m_range = MemoryPoolAllocatedRange();
+	};
+
+	AllocationRangeIterator(MemoryPool* pool, MemoryPoolBlob* blob)
+	{
+		m_currentPool = pool;
+		m_currentBlobInPool = blob;
+		m_factory = NULL;
+		m_range = MemoryPoolAllocatedRange();
+	};
+
+	AllocationRangeIterator()
+	{
+		m_currentPool = NULL;
+		m_currentBlobInPool = NULL;
+		m_factory = NULL;
+		m_range = MemoryPoolAllocatedRange();
+	};
+
+	reference operator*() { UpdateRange(); return m_range; }
+	pointer operator->() { UpdateRange(); return &m_range; }
+
+	// Prefix increment
+	AllocationRangeIterator& operator++() { MoveToNextBlob(); return *this; }
+
+	// Postfix increment
+	AllocationRangeIterator operator++(int) { AllocationRangeIterator tmp = *this; ++(*this); return tmp; }
+
+	friend bool operator== (const AllocationRangeIterator& a, const AllocationRangeIterator& b) { return a.m_currentBlobInPool == b.m_currentBlobInPool; };
+	friend bool operator!= (const AllocationRangeIterator& a, const AllocationRangeIterator& b) { return a.m_currentBlobInPool != b.m_currentBlobInPool; };
+
+private:
+	const MemoryPoolFactory* m_factory;
+	MemoryPool* m_currentPool;
+	MemoryPoolBlob* m_currentBlobInPool;
+	MemoryPoolAllocatedRange m_range;
+	void UpdateRange();
+	void MoveToNextBlob();
+};
+#endif
+
 // ----------------------------------------------------------------------------
 /**
 	The class that manages all the MemoryPools and DynamicMemoryAllocators.
@@ -573,6 +644,19 @@ class MemoryPoolFactory
 		void debugResetCheckpoints();
 
 	#endif
+#ifdef RTS_ENABLE_CRASHDUMP
+		AllocationRangeIterator cbegin() const {
+			return AllocationRangeIterator(this);
+		}
+
+		AllocationRangeIterator cend() const {
+			return AllocationRangeIterator(NULL, NULL);
+		}
+
+		Int getMemoryPoolCount() const;
+		MemoryPool* getMemoryPoolN(const Int n) const;
+		friend class AllocationRangeIterator;
+#endif
 };
 
 // how many bytes are we allowed to 'waste' per pool allocation before the debug code starts yelling at us...

Core/GameEngine/Include/Common/MiniDumper.h

@@ -0,0 +1,120 @@
+/*
+**	Command & Conquer Generals Zero Hour(tm)
+**	Copyright 2025 TheSuperHackers
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#ifdef RTS_ENABLE_CRASHDUMP
+#include <imagehlp.h>
+#include "Common/MiniDumper_compat.h"
+
+class MiniDumper
+{
+public:
+	MiniDumper()
+	{
+		m_miniDumpInitialized = false;
+		m_extendedInfoRequested = false;
+		m_dbgHlp = NULL;
+		m_pMiniDumpWriteDump = NULL;
+		m_dumpRequested = NULL;
+		m_dumpComplete = NULL;
+		m_quitting = NULL;
+		m_dumpThread = NULL;
+		m_dumpThreadId = 0;
+		m_dumpObjectsState = 0;
+		m_dumpObjectsSubState = 0;
+		m_dmaRawBlockIndex = 0;
+		memset(m_dumpDir, 0, ARRAY_SIZE(m_dumpDir));
+		memset(m_dumpFile, 0, ARRAY_SIZE(m_dumpFile));
+		memset(m_sysDbgHelpPath, 0, ARRAY_SIZE(m_sysDbgHelpPath));
+	};
+
+	void Initialize(const AsciiString& userDirPath);
+	Bool IsInitialized() const;
+	void TriggerMiniDump(Bool extendedInfo = false);
+	void TriggerMiniDumpForException(struct _EXCEPTION_POINTERS* e_info, Bool extendedInfo = false);
+	void ShutDown();
+	static LONG WINAPI DumpingExceptionFilter(struct _EXCEPTION_POINTERS* e_info);
+private:
+	void CreateMiniDump(Bool extendedInfo);
+	BOOL DumpMemoryObjects(ULONG64& memoryBase, ULONG& memorySize);
+	void CleanupResources();
+
+	// Callbacks from dbghelp
+	static BOOL CALLBACK MiniDumpCallback(PVOID CallbackParam, PMINIDUMP_CALLBACK_INPUT CallbackInput, PMINIDUMP_CALLBACK_OUTPUT CallbackOutput);
+	BOOL CallbackInternal(const MINIDUMP_CALLBACK_INPUT& input, MINIDUMP_CALLBACK_OUTPUT& output);
+
+	// Thread procs
+	static DWORD WINAPI MiniDumpThreadProc(LPVOID lpParam);
+	DWORD ThreadProcInternal();
+
+	// Dump file directory bookkeeping
+	Bool InitializeDumpDirectory(const AsciiString& userDirPath);
+	static void KeepNewestFiles(const std::string& directory, const std::string& fileWildcard, const Int keepCount);
+
+	// Struct to hold file information
+	struct FileInfo {
+		std::string name;
+		FILETIME lastWriteTime;
+	};
+
+	static bool CompareByLastWriteTime(const FileInfo& a, const FileInfo& b);
+
+private:
+	Bool m_miniDumpInitialized;
+	Bool m_extendedInfoRequested;
+
+	// Path buffers
+	Char m_dumpDir[MAX_PATH];
+	Char m_dumpFile[MAX_PATH];
+	Char m_sysDbgHelpPath[MAX_PATH];
+
+	// Module handles
+	HMODULE m_dbgHlp;
+
+	// Event handles
+	HANDLE m_dumpRequested;
+	HANDLE m_dumpComplete;
+	HANDLE m_quitting;
+
+	// Thread handles
+	HANDLE m_dumpThread;
+	DWORD m_dumpThreadId;
+
+	// Internal memory dumping progress state
+	int m_dumpObjectsState;
+	int m_dumpObjectsSubState;
+	int m_dmaRawBlockIndex;
+
+	AllocationRangeIterator m_RangeIter;
+	AllocationRangeIterator m_endRangeIter;
+
+	// Function pointer to MiniDumpWriteDump in dbghelp.dll
+	typedef BOOL(WINAPI* MiniDumpWriteDump_t)(
+		HANDLE hProcess,
+		DWORD ProcessId,
+		HANDLE hFile,
+		MINIDUMP_TYPE DumpType,
+		PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
+		PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
+		PMINIDUMP_CALLBACK_INFORMATION CallbackParam
+		);
+
+	MiniDumpWriteDump_t m_pMiniDumpWriteDump;
+};
+#endif