Remove HERE macro

Some cleanup.
Add location to some functions.

Utilities/Config.cpp

@@ -7,8 +7,6 @@
 #include <typeinfo>
 #include <charconv>
 
-[[noreturn]] void report_fatal_error(const std::string&);
-
 LOG_CHANNEL(cfg_log, "CFG");
 
 namespace cfg
@@ -18,7 +16,7 @@ namespace cfg
 	{
 		if (_type != type::node)
 		{
-			cfg_log.fatal("Invalid root node" HERE);
+			cfg_log.fatal("Invalid root node");
 		}
 	}
 
@@ -29,7 +27,7 @@ namespace cfg
 		{
 			if (pair.first == name)
 			{
-				cfg_log.fatal("Node already exists: %s" HERE, name);
+				cfg_log.fatal("Node already exists: %s", name);
 			}
 		}
 
@@ -38,12 +36,12 @@ namespace cfg
 
 	bool _base::from_string(const std::string&, bool)
 	{
-		report_fatal_error("from_string() purecall" HERE);
+		fmt::throw_exception("from_string() purecall");
 	}
 
 	bool _base::from_list(std::vector<std::string>&&)
 	{
-		report_fatal_error("from_list() purecall" HERE);
+		fmt::throw_exception("from_list() purecall");
 	}
 
 	// Emit YAML

Utilities/File.cpp

@@ -900,14 +900,19 @@ bool fs::utime(const std::string& path, s64 atime, s64 mtime)
 #endif
 }
 
-void fs::file::xnull() const
+[[noreturn]] void fs::xnull(const src_loc& loc)
 {
-	fmt::throw_exception("fs::file is null");
+	fmt::throw_exception("Null object.%s", loc);
 }
 
-void fs::file::xfail() const
+[[noreturn]] void fs::xfail(const src_loc& loc)
 {
-	fmt::throw_exception("Unexpected fs::error %s", g_tls_error);
+	fmt::throw_exception("Unexpected fs::error %s%s", g_tls_error, loc);
+}
+
+[[noreturn]] void fs::xovfl()
+{
+	fmt::throw_exception("Stream overflow.");
 }
 
 fs::file::file(const std::string& path, bs_t<open_mode> mode)
@@ -1056,7 +1061,7 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 				whence == seek_set ? FILE_BEGIN :
 				whence == seek_cur ? FILE_CURRENT :
 				whence == seek_end ? FILE_END :
-				(fmt::throw_exception("Invalid whence (0x%x)" HERE, whence), 0);
+				(fmt::throw_exception("Invalid whence (0x%x)", whence), 0);
 
 			if (!SetFilePointerEx(m_handle, pos, &pos, mode))
 			{
@@ -1194,7 +1199,7 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 				whence == seek_set ? SEEK_SET :
 				whence == seek_cur ? SEEK_CUR :
 				whence == seek_end ? SEEK_END :
-				(fmt::throw_exception("Invalid whence (0x%x)" HERE, whence), 0);
+				(fmt::throw_exception("Invalid whence (0x%x)", whence), 0);
 
 			const auto result = ::lseek(m_fd, offset, mode);
 
@@ -1318,11 +1323,6 @@ fs::native_handle fs::file::get_handle() const
 #endif
 }
 
-void fs::dir::xnull() const
-{
-	fmt::throw_exception("fs::dir is null");
-}
-
 bool fs::dir::open(const std::string& path)
 {
 	if (path.empty())

Utilities/File.h

@@ -134,6 +134,12 @@ namespace fs
 		virtual std::unique_ptr<dir_base> open_dir(const std::string& path) = 0;
 	};
 
+	[[noreturn]] void xnull(const src_loc&);
+	[[noreturn]] void xfail(const src_loc&);
+	[[noreturn]] void xovfl();
+
+	constexpr struct pod_tag_t{} pod_tag;
+
 	// Get virtual device for specified path (nullptr for real path)
 	std::shared_ptr<device_base> get_virtual_device(const std::string& path);
 
@@ -186,9 +192,6 @@ namespace fs
 	{
 		std::unique_ptr<file_base> m_file;
 
-		[[noreturn]] void xnull() const;
-		[[noreturn]] void xfail() const;
-
 	public:
 		// Default constructor
 		file() = default;
@@ -230,144 +233,226 @@ namespace fs
 		}
 
 		// Change file size (possibly appending zero bytes)
-		bool trunc(u64 length) const
+		bool trunc(u64 length,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->trunc(length);
 		}
 
 		// Get file information
-		stat_t stat() const
+		stat_t stat(
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->stat();
 		}
 
 		// Sync file buffers
-		void sync() const
+		void sync(
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->sync();
 		}
 
 		// Read the data from the file and return the amount of data written in buffer
-		u64 read(void* buffer, u64 count) const
+		u64 read(void* buffer, u64 count,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION(), ...) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->read(buffer, count);
 		}
 
 		// Write the data to the file and return the amount of data actually written
-		u64 write(const void* buffer, u64 count) const
+		u64 write(const void* buffer, u64 count,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION(), ...) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->write(buffer, count);
 		}
 
 		// Change current position, returns resulting position
-		u64 seek(s64 offset, seek_mode whence = seek_set) const
+		u64 seek(s64 offset, seek_mode whence = seek_set,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->seek(offset, whence);
 		}
 
 		// Get file size
-		u64 size() const
+		u64 size(
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->size();
 		}
 
 		// Get current position
-		u64 pos() const
+		u64 pos(
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->seek(0, seek_cur);
 		}
 
-		// Write std::string unconditionally
-		const file& write(const std::string& str) const
+		// Write std::basic_string unconditionally
+		template <typename T>
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, const file&> write(const std::basic_string<T>& str,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (write(str.data(), str.size()) != str.size()) xfail();
+			if (write(str.data(), str.size() * sizeof(T), line, col, file, func) != str.size() * sizeof(T)) xfail({line, col, file, func});
 			return *this;
 		}
 
 		// Write POD unconditionally
 		template <typename T>
-		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, const file&> write(const T& data) const
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, const file&> write(const T& data,
+			pod_tag_t = pod_tag,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (write(std::addressof(data), sizeof(T)) != sizeof(T)) xfail();
+			if (write(std::addressof(data), sizeof(T), line, col, file, func) != sizeof(T)) xfail({line, col, file, func});
 			return *this;
 		}
 
 		// Write POD std::vector unconditionally
 		template <typename T>
-		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, const file&> write(const std::vector<T>& vec) const
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, const file&> write(const std::vector<T>& vec,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (write(vec.data(), vec.size() * sizeof(T)) != vec.size() * sizeof(T)) xfail();
+			if (write(vec.data(), vec.size() * sizeof(T), line, col, file, func) != vec.size() * sizeof(T)) xfail({line, col, file, func});
 			return *this;
 		}
 
-		// Read std::string, size must be set by resize() method
-		bool read(std::string& str) const
+		// Read std::basic_string, size must be set by resize() method
+		template <typename T>
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::basic_string<T>& str,
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION(),
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN()) const
 		{
-			return read(&str[0], str.size()) == str.size();
+			return read(&str[0], str.size() * sizeof(T), line, col, file, func) == str.size() * sizeof(T);
 		}
 
-		// Read std::string
-		bool read(std::string& str, std::size_t size) const
+		// Read std::basic_string
+		template <typename T>
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::basic_string<T>& str, std::size_t size,
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION(),
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN()) const
 		{
 			str.resize(size);
-			return read(&str[0], size) == size;
+			return read(&str[0], size * sizeof(T), line, col, file, func) == size * sizeof(T);
 		}
 
 		// Read POD, sizeof(T) is used
 		template <typename T>
-		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(T& data) const
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(T& data,
+			pod_tag_t = pod_tag,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			return read(&data, sizeof(T)) == sizeof(T);
+			return read(&data, sizeof(T), line, col, file, func) == sizeof(T);
 		}
 
 		// Read POD std::vector, size must be set by resize() method
 		template <typename T>
-		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::vector<T>& vec) const
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::vector<T>& vec,
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION(),
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN()) const
 		{
-			return read(vec.data(), sizeof(T) * vec.size()) == sizeof(T) * vec.size();
+			return read(vec.data(), sizeof(T) * vec.size(), line, col, file, func) == sizeof(T) * vec.size();
 		}
 
 		// Read POD std::vector
 		template <typename T>
-		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::vector<T>& vec, std::size_t size) const
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::vector<T>& vec, std::size_t size,
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION(),
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN()) const
 		{
 			vec.resize(size);
-			return read(vec.data(), sizeof(T) * size) == sizeof(T) * size;
+			return read(vec.data(), sizeof(T) * size, line, col, file, func) == sizeof(T) * size;
 		}
 
 		// Read POD (experimental)
 		template <typename T>
-		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, T> read() const
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, T> read(
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
 			T result;
-			if (!read(result)) xfail();
+			if (!read(result, pod_tag, line, col, file, func)) xfail({line, col, file, func});
 			return result;
 		}
 
-		// Read full file to std::string
-		std::string to_string() const
+		// Read full file to std::basic_string
+		template <typename T = char>
+		std::basic_string<T> to_string(
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			std::string result;
-			result.resize(size());
-			if (seek(0), !read(result)) xfail();
+			std::basic_string<T> result;
+			result.resize(size() / sizeof(T));
+			if (seek(0), !read(result, file, func, line, col)) xfail({line, col, file, func});
 			return result;
 		}
 
 		// Read full file to std::vector
 		template<typename T>
-		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, std::vector<T>> to_vector() const
+		std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, std::vector<T>> to_vector(
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
 			std::vector<T> result;
 			result.resize(size() / sizeof(T));
-			if (seek(0), !read(result)) xfail();
+			if (seek(0), !read(result, file, func, line, col)) xfail({line, col, file, func});
 			return result;
 		}
 
@@ -375,9 +460,13 @@ namespace fs
 		native_handle get_handle() const;
 
 		// Gathered write
-		u64 write_gather(const iovec_clone* buffers, u64 buf_count) const
+		u64 write_gather(const iovec_clone* buffers, u64 buf_count,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_file) xnull();
+			if (!m_file) xnull({line, col, file, func});
 			return m_file->write_gather(buffers, buf_count);
 		}
 	};
@@ -386,8 +475,6 @@ namespace fs
 	{
 		std::unique_ptr<dir_base> m_dir;
 
-		[[noreturn]] void xnull() const;
-
 	public:
 		dir() = default;
 
@@ -423,16 +510,24 @@ namespace fs
 		}
 
 		// Get next directory entry
-		bool read(dir_entry& out) const
+		bool read(dir_entry& out,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_dir) xnull();
+			if (!m_dir) xnull({line, col, file, func});
 			return m_dir->read(out);
 		}
 
 		// Reset to the beginning
-		void rewind() const
+		void rewind(
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION()) const
 		{
-			if (!m_dir) xnull();
+			if (!m_dir) xnull({line, col, file, func});
 			return m_dir->rewind();
 		}
 
@@ -578,7 +673,7 @@ namespace fs
 
 			if (old_size + size < old_size)
 			{
-				fmt::raw_error("fs::container_stream<>::write(): overflow");
+				xovfl();
 			}
 
 			if (pos > old_size)

Utilities/JIT.cpp

@@ -328,7 +328,7 @@ struct MemoryManager1 : llvm::RTDyldMemoryManager
 
 	[[noreturn]] static void null()
 	{
-		fmt::throw_exception("Null function" HERE);
+		fmt::throw_exception("Null function");
 	}
 
 	llvm::JITSymbol findSymbol(const std::string& name) override

Utilities/JIT.h

@@ -148,7 +148,7 @@ inline FT build_function_asm(F&& builder)
 
 	X86Assembler compiler(&code);
 	builder(std::ref(compiler), args);
-	ASSERT(compiler.getLastError() == 0);
+	ensure(compiler.getLastError() == 0);
 
 	FT result;
 

Utilities/StrFmt.cpp

@@ -242,13 +242,32 @@ void fmt_class_string<v128>::format(std::string& out, u64 arg)
 	fmt::append(out, "0x%016llx%016llx", vec._u64[1], vec._u64[0]);
 }
 
-namespace fmt
+template <>
+void fmt_class_string<src_loc>::format(std::string& out, u64 arg)
 {
-	void raw_error(const char* msg)
+	const src_loc& loc = get_object(arg);
+
+	if (loc.col != umax)
 	{
-		thread_ctrl::emergency_exit(msg);
+		fmt::append(out, "\n(in file %s:%s[:%s]", loc.file, loc.line, loc.col);
+	}
+	else
+	{
+		fmt::append(out, "\n(in file %s:%s", loc.file, loc.line);
 	}
 
+	if (loc.func && *loc.func)
+	{
+		fmt::append(out, ", in function %s)", loc.func);
+	}
+	else
+	{
+		out += ')';
+	}
+}
+
+namespace fmt
+{
 	void raw_verify_error(const src_loc& loc)
 	{
 		std::string out{"Verification failed"};
@@ -266,24 +285,7 @@ namespace fmt
 		}
 #endif
 
-		if (loc.col != umax)
-		{
-			fmt::append(out, "\n(in file %s:%s[:%s]", loc.file, loc.line, loc.col);
-		}
-		else
-		{
-			fmt::append(out, "\n(in file %s:%s", loc.file, loc.line);
-		}
-
-		if (loc.func && *loc.func)
-		{
-			fmt::append(out, ", in function %s)", loc.func);
-		}
-		else
-		{
-			out += ')';
-		}
-
+		fmt::append(out, "%s", loc);
 		thread_ctrl::emergency_exit(out);
 	}
 
@@ -298,31 +300,15 @@ namespace fmt
 			out += ")";
 		}
 
-		if (loc.col != umax)
-		{
-			fmt::append(out, "\n(in file %s:%s[:%s]", loc.file, loc.line, loc.col);
-		}
-		else
-		{
-			fmt::append(out, "\n(in file %s:%s", loc.file, loc.line);
-		}
-
-		if (loc.func && *loc.func)
-		{
-			fmt::append(out, ", in function %s)", loc.func);
-		}
-		else
-		{
-			out += ')';
-		}
-
+		fmt::append(out, "%s", loc);
 		thread_ctrl::emergency_exit(out);
 	}
 
-	void raw_throw_exception(const char* fmt, const fmt_type_info* sup, const u64* args)
+	void raw_throw_exception(const src_loc& loc, const char* fmt, const fmt_type_info* sup, const u64* args)
 	{
 		std::string out;
 		raw_append(out, fmt, sup, args);
+		fmt::append(out, "%s", loc);
 		thread_ctrl::emergency_exit(out);
 	}
 

Utilities/StrFmt.h

@@ -289,13 +289,23 @@ namespace fmt
 	}
 
 	// Internal exception message formatting template, must be explicitly specialized or instantiated in cpp to minimize code bloat
-	[[noreturn]] void raw_throw_exception(const char*, const fmt_type_info*, const u64*);
+	[[noreturn]] void raw_throw_exception(const src_loc&, const char*, const fmt_type_info*, const u64*);
 
 	// Throw exception with formatting
-	template <typename... Args>
-	[[noreturn]] SAFE_BUFFERS FORCE_INLINE void throw_exception(const char* fmt, const Args&... args)
+	template <typename CharT, std::size_t N, typename... Args>
+	struct throw_exception
 	{
-		static constexpr fmt_type_info type_list[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
-		raw_throw_exception(fmt, type_list, fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
-	}
+		[[noreturn]] SAFE_BUFFERS FORCE_INLINE throw_exception(const CharT(&fmt)[N], const Args&... args,
+			u32 line = __builtin_LINE(),
+			u32 col = __builtin_COLUMN(),
+			const char* file = __builtin_FILE(),
+			const char* func = __builtin_FUNCTION())
+		{
+			static constexpr fmt_type_info type_list[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
+			raw_throw_exception({line, col, file, func}, reinterpret_cast<const char*>(fmt), type_list, fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+		}
+	};
+
+	template <typename CharT, std::size_t N, typename... Args>
+	throw_exception(const CharT(&)[N], const Args&...) -> throw_exception<CharT, N, Args...>;
 }

Utilities/Thread.cpp

@@ -91,6 +91,9 @@ thread_local u64 g_tls_wait_fail = 0;
 thread_local bool g_tls_access_violation_recovered = false;
 extern thread_local std::string(*g_tls_log_prefix)();
 
+// Report error and call std::abort(), defined in main.cpp
+[[noreturn]] void report_fatal_error(const std::string&);
+
 template <>
 void fmt_class_string<std::thread::id>::format(std::string& out, u64 arg)
 {

Utilities/Thread.h

@@ -11,9 +11,6 @@
 #include "mutex.h"
 #include "lockless.h"
 
-// Report error and call std::abort(), defined in main.cpp
-[[noreturn]] void report_fatal_error(const std::string&);
-
 // Hardware core layout
 enum class native_core_arrangement : u32
 {

Utilities/address_range.h

@@ -92,7 +92,7 @@ namespace utils
 		void set_length(const u32 new_length)
 		{
 			end = start + new_length - 1;
-			ASSERT(valid());
+			ensure(valid());
 		}
 
 		u32 next_address() const

Utilities/bin_patch.cpp

@@ -524,7 +524,7 @@ bool patch_engine::read_patch_node(patch_info& info, YAML::Node node, const YAML
 	if (!node)
 	{
 		append_log_message(log_messages, fmt::format("Skipping invalid patch node %s. (key: %s)", info.description, info.hash));
-		patch_log.error("Skipping invalid patch node %s. (key: %s)" HERE, info.description, info.hash);
+		patch_log.error("Skipping invalid patch node %s. (key: %s)", info.description, info.hash);
 		return false;
 	}
 
@@ -600,7 +600,7 @@ static std::size_t apply_modification(const patch_engine::patch_info& patch, u8*
 				// This patch is out of range for this segment
 				continue;
 			}
-			
+
 			offset -= ls_addr;
 		}
 

Utilities/types.h

@@ -34,7 +34,6 @@
 #define SAFE_BUFFERS __declspec(safebuffers)
 #define NEVER_INLINE __declspec(noinline)
 #define FORCE_INLINE __forceinline
-#define RESTRICT __restrict
 
 #else // not _MSC_VER
 
@@ -51,7 +50,6 @@
 #define SAFE_BUFFERS __attribute__((no_stack_protector))
 #define NEVER_INLINE __attribute__((noinline)) inline
 #define FORCE_INLINE __attribute__((always_inline)) inline
-#define RESTRICT __restrict__
 
 #endif // _MSC_VER
 
@@ -63,25 +61,14 @@
 // Variant pattern matching helper
 #define MATCH(arg, ...) constexpr(std::is_same_v<std::decay_t<decltype(arg)>, __VA_ARGS__>)
 
-#define CONCATENATE_DETAIL(x, y) x ## y
-#define CONCATENATE(x, y) CONCATENATE_DETAIL(x, y)
-
-#define STRINGIZE_DETAIL(x) #x ""
-#define STRINGIZE(x) STRINGIZE_DETAIL(x)
-
-#define HERE "\n(in file " __FILE__ ":" STRINGIZE(__LINE__) ")"
-
 #define DECLARE(...) decltype(__VA_ARGS__) __VA_ARGS__
 
 #define STR_CASE(...) case __VA_ARGS__: return #__VA_ARGS__
 
-
-#define ASSERT(...) ((__VA_ARGS__) ? void() : fmt::raw_error("Assertion failed: " STRINGIZE(__VA_ARGS__) HERE))
-
 #if defined(_DEBUG) || defined(_AUDIT)
-#define AUDIT(...) ASSERT(__VA_ARGS__)
+#define AUDIT(...) (static_cast<void>(ensure(__VA_ARGS__)))
 #else
-#define AUDIT(...) ((void)0)
+#define AUDIT(...) (static_cast<void>(0))
 #endif
 
 #if __cpp_lib_bit_cast >= 201806L
@@ -777,7 +764,6 @@ struct src_loc
 
 namespace fmt
 {
-	[[noreturn]] void raw_error(const char* msg);
 	[[noreturn]] void raw_verify_error(const src_loc& loc);
 	[[noreturn]] void raw_narrow_error(const src_loc& loc, const fmt_type_info* sup, u64 arg);
 }