Merge branch 'main' of https://github.com/EpicGames/zen

6 files changed, 97 insertions, 79 deletions

diff --git a/zencore/include/zencore/except.h b/zencore/include/zencore/except.h
index 08330e4bc..5cfefb1e2 100644
--- a/zencore/include/zencore/except.h
+++ b/zencore/include/zencore/except.h
@@ -15,63 +15,20 @@
 namespace zen {
 
 #if ZEN_PLATFORM_WINDOWS
-class WindowsException : public std::exception
-{
-public:
-	WindowsException(std::string_view Message)
-	{
-		m_hResult = HRESULT_FROM_WIN32(GetLastError());
-		m_Message = Message;
-	}
-
-	WindowsException(HRESULT hRes, std::string_view Message)
-	{
-		m_hResult = hRes;
-		m_Message = Message;
-	}
-
-	WindowsException(HRESULT hRes, const char* Message, const char* Detail)
-	{
-		m_hResult = hRes;
-
-		ExtendableStringBuilder<128> msg;
-		msg.Append(Message);
-		msg.Append(" (detail: '");
-		msg.Append(Detail);
-		msg.Append("')");
-
-		m_Message = msg.c_str();
-	}
-
-	virtual const char* what() const override { return m_Message.c_str(); }
-
-private:
-	std::string m_Message;
-	HRESULT		m_hResult;
-};
-
-ZENCORE_API void ThrowSystemException(HRESULT hRes, std::string_view Message);
+ZENCORE_API void ThrowSystemException [[noreturn]] (HRESULT hRes, std::string_view Message);
 #endif	// ZEN_PLATFORM_WINDOWS
 
-ZENCORE_API void ThrowLastError(std::string_view Message);
+ZENCORE_API void ThrowLastError [[noreturn]] (std::string_view Message);
 
 #if __cpp_lib_source_location
-ZENCORE_API void ThrowLastError(std::string_view Message, const std::source_location& Location);
+ZENCORE_API void ThrowLastError [[noreturn]] (std::string_view Message, const std::source_location& Location);
 #endif
 
+ZENCORE_API void ThrowSystemError [[noreturn]] (uint32_t ErrorCode, std::string_view Message);
+
 ZENCORE_API std::string GetLastErrorAsString();
 ZENCORE_API std::string GetWindowsErrorAsString(uint32_t Win32ErrorCode);
 
-inline void
-ThrowSystemException(const char* Message)
-{
-#if ZEN_PLATFORM_WINDOWS
-	throw WindowsException(Message);
-#else
-	ThrowLastError(Message);
-#endif
-}
-
 inline int32_t
 GetLastError()
 {
diff --git a/zencore/include/zencore/session.h b/zencore/include/zencore/session.h
index 2da41b2c8..dd90197bf 100644
--- a/zencore/include/zencore/session.h
+++ b/zencore/include/zencore/session.h
@@ -8,6 +8,7 @@ namespace zen {
 
 struct Oid;
 
-ZENCORE_API Oid GetSessionId();
+ZENCORE_API [[nodiscard]] Oid			   GetSessionId();
+ZENCORE_API [[nodiscard]] std::string_view GetSessionIdString();
 
 }  // namespace zen
diff --git a/zencore/include/zencore/testutils.h b/zencore/include/zencore/testutils.h
new file mode 100644
index 000000000..72d985d5c
--- /dev/null
+++ b/zencore/include/zencore/testutils.h
@@ -0,0 +1,31 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <filesystem>
+
+namespace zen {
+
+std::filesystem::path CreateTemporaryDirectory();
+
+class ScopedTemporaryDirectory
+{
+public:
+	ScopedTemporaryDirectory();
+	~ScopedTemporaryDirectory();
+
+	std::filesystem::path& Path() { return m_RootPath; }
+
+private:
+	std::filesystem::path m_RootPath;
+};
+
+struct ScopedCurrentDirectoryChange
+{
+	std::filesystem::path OldPath{std::filesystem::current_path()};
+
+	ScopedCurrentDirectoryChange() { std::filesystem::current_path(CreateTemporaryDirectory()); }
+	~ScopedCurrentDirectoryChange() { std::filesystem::current_path(OldPath); }
+};
+
+}  // namespace zen
diff --git a/zencore/include/zencore/thread.h b/zencore/include/zencore/thread.h
index e65867ec4..7889682cd 100644
--- a/zencore/include/zencore/thread.h
+++ b/zencore/include/zencore/thread.h
@@ -4,9 +4,7 @@
 
 #include "zencore.h"
 
-#if !ZEN_PLATFORM_WINDOWS
-#	include <shared_mutex>
-#endif
+#include <shared_mutex>
 
 #include <vector>
 
@@ -66,11 +64,7 @@ public:
 	};
 
 private:
-#if ZEN_PLATFORM_WINDOWS
-	void* m_Srw = nullptr;
-#else
 	std::shared_mutex m_Mutex;
-#endif
 };
 
 /** Basic abstraction of a simple event synchronization mechanism (aka 'binary semaphore')
diff --git a/zencore/include/zencore/uid.h b/zencore/include/zencore/uid.h
index f095c49ef..f4e9ab65a 100644
--- a/zencore/include/zencore/uid.h
+++ b/zencore/include/zencore/uid.h
@@ -60,6 +60,7 @@ struct Oid
 	const Oid&				 Generate();
 	[[nodiscard]] static Oid FromHexString(const std::string_view String);
 	StringBuilderBase&		 ToString(StringBuilderBase& OutString) const;
+	void					 ToString(char OutString[StringLength]);
 	[[nodiscard]] static Oid FromMemory(const void* Ptr);
 
 	auto				 operator<=>(const Oid& rhs) const = default;
diff --git a/zencore/include/zencore/zencore.h b/zencore/include/zencore/zencore.h
index da17e61e3..310f6c4ed 100644
--- a/zencore/include/zencore/zencore.h
+++ b/zencore/include/zencore/zencore.h
@@ -3,7 +3,7 @@
 #pragma once
 
 #include <cinttypes>
-#include <exception>
+#include <stdexcept>
 #include <string>
 
 //////////////////////////////////////////////////////////////////////////
@@ -90,37 +90,69 @@
 // Assert
 //
 
+#if ZEN_PLATFORM_WINDOWS
+// Tells the compiler to put the decorated function in a certain section (aka. segment) of the executable.
+#	define ZEN_CODE_SECTION(Name) __declspec(code_seg(Name))
+#	define ZEN_FORCENOINLINE	   __declspec(noinline) /* Force code to NOT be inline */
+#else
+#	define ZEN_CODE_SECTION(Name)
+#	define ZEN_FORCENOINLINE
+#endif
+
+#if ZEN_ARCH_ARM64
+// On ARM we can't do this because the executable will require jumps larger
+// than the branch instruction can handle. Clang will only generate
+// the trampolines in the .text segment of the binary. If the uedbg segment
+// is present it will generate code that it cannot link.
+#	define ZEN_DEBUG_SECTION
+#else
+// We'll put all assert implementation code into a separate section in the linked
+// executable. This code should never execute so using a separate section keeps
+// it well off the hot path and hopefully out of the instruction cache. It also
+// facilitates reasoning about the makeup of a compiled/linked binary.
+#	define ZEN_DEBUG_SECTION ZEN_CODE_SECTION(".zcold")
+#endif	// DO_CHECK || DO_GUARD_SLOW
+
 namespace zen {
 
-class AssertException : public std::exception
+class AssertException : public std::logic_error
 {
 public:
-	AssertException(const char* Msg);
-	~AssertException();
-
-	[[nodiscard]] virtual char const* what() const noexcept override { return m_Msg.c_str(); }
-
-private:
-	std::string m_Msg;
+	AssertException(const char* Msg) : std::logic_error(Msg) {}
 };
 
 }  // namespace zen
 
-#define ZEN_ASSERT(x, ...)                \
-	do                                    \
-	{                                     \
-		if (x)                            \
-			break;                        \
-		throw ::zen::AssertException{#x}; \
+template<typename RetType = void, class InnerType, typename... ArgTypes>
+RetType ZEN_FORCENOINLINE ZEN_DEBUG_SECTION
+DispatchAssert(InnerType&& Inner, ArgTypes const&... Args)
+{
+	return Inner(Args...);
+}
+
+#define ZEN_ASSERT(x, ...)                                                                                                  \
+	do                                                                                                                      \
+	{                                                                                                                       \
+		if (x) [[unlikely]]                                                                                                 \
+			break;                                                                                                          \
+		struct Impl                                                                                                         \
+		{                                                                                                                   \
+			static void ZEN_FORCENOINLINE ZEN_DEBUG_SECTION ExecThrow [[noreturn]] () { throw ::zen::AssertException{#x}; } \
+		};                                                                                                                  \
+		Impl::ExecThrow();                                                                                                  \
 	} while (false)
 
 #ifndef NDEBUG
-#	define ZEN_ASSERT_SLOW(x, ...)           \
-		do                                    \
-		{                                     \
-			if (x)                            \
-				break;                        \
-			throw ::zen::AssertException{#x}; \
+#	define ZEN_ASSERT_SLOW(x, ...)                                                                                             \
+		do                                                                                                                      \
+		{                                                                                                                       \
+			if (x) [[unlikely]]                                                                                                 \
+				break;                                                                                                          \
+			struct Impl                                                                                                         \
+			{                                                                                                                   \
+				static void ZEN_FORCENOINLINE ZEN_DEBUG_SECTION ExecThrow [[noreturn]] () { throw ::zen::AssertException{#x}; } \
+			};                                                                                                                  \
+			Impl::ExecThrow();                                                                                                  \
 		} while (false)
 #else
 #	define ZEN_ASSERT_SLOW(x, ...)
@@ -148,17 +180,19 @@ char (&ZenArrayCountHelper(const T (&)[N]))[N + 1];
 
 #define ZEN_UNUSED(...)			 ((void)__VA_ARGS__)
 #define ZEN_NOT_IMPLEMENTED(...) ZEN_ASSERT(false, __VA_ARGS__)
-#define ZENCORE_API	 // Placeholder to allow DLL configs in the future
+#define ZENCORE_API	 // Placeholder to allow DLL configs in the future (maybe)
 
 namespace zen {
 
 ZENCORE_API bool IsPointerToStack(const void* ptr);	 // Query if pointer is within the stack of the currently executing thread
 ZENCORE_API bool IsApplicationExitRequested();
 ZENCORE_API void RequestApplicationExit(int ExitCode);
+ZENCORE_API bool IsDebuggerPresent();
+ZENCORE_API bool IsInteractiveSession();
 
 ZENCORE_API void zencore_forcelinktests();
 
-}
+}  // namespace zen
 
 //////////////////////////////////////////////////////////////////////////