Mmapper with Neko's review fixes (#2503)

DeS

.clang-format

@@ -0,0 +1,33 @@
+Standard: Cpp11
+UseTab: ForIndentation
+TabWidth: 1
+IndentWidth: 1
+AccessModifierOffset: -1
+PointerAlignment: Left
+NamespaceIndentation: All
+ColumnLimit: 200
+BreakBeforeBraces: Allman
+BreakConstructorInitializersBeforeComma: true
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: false
+AlwaysBreakTemplateDeclarations: true
+AllowShortIfStatementsOnASingleLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: false
+AllowShortLoopsOnASingleLine: true
+Cpp11BracedListStyle: true
+IndentCaseLabels: false
+SortIncludes: false
+ReflowComments: true
+AlignConsecutiveAssignments: true
+AlignTrailingComments: true
+AlignAfterOpenBracket: DontAlign
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+BinPackArguments: true
+BinPackParameters: true
+AlwaysBreakAfterReturnType: None
+KeepEmptyLinesAtTheStartOfBlocks: true
+IndentWrappedFunctionNames: false
+
+#SpaceAfterTemplateKeyword: false

.editorconfig

@@ -0,0 +1,7 @@
+root = true
+
+[*.{h,cpp,hpp}]
+charset = utf-8
+indent_style = tab
+indent_size = 4
+trim_trailing_whitespace = true

.gitmodules

@@ -12,7 +12,7 @@
 [submodule "llvm"]
 	path = llvm
 	url = https://github.com/llvm-mirror/llvm
-	branch = release_36
+	branch = release_38
 [submodule "rsx_program_decompiler"]
 	path = rsx_program_decompiler
 	url = https://github.com/RPCS3/rsx_program_decompiler
@@ -35,3 +35,9 @@
 [submodule "3rdparty/pugixml"]
 	path = 3rdparty/pugixml
 	url = https://github.com/RPCS3/pugixml
+[submodule "3rdparty/cereal"]
+	path = 3rdparty/cereal
+	url = https://github.com/USCiLab/cereal.git
+[submodule "rsx-debugger"]
+	path = rsx-debugger
+	url = https://github.com/RPCS3/rsx-debugger.git

.mention-bot

@@ -1,3 +1,3 @@
 {
-  "userBlacklist": ["AlexAltea", "tambry"]
+  "userBlacklist": ["AlexAltea", "tambry", "DHrpcs3"]
 }

.travis.yml

@@ -1,90 +1,96 @@
 language: cpp
-sudo: required
+sudo: false
 dist: trusty
 
 os:
- - linux
- - osx
+  - linux
+  #- osx
 
 osx_image: xcode6.4
 
 compiler:
- - clang
- - gcc
+  - clang
+  - gcc
+
+cache:
+  ccache: true
+  directories:
+    - $HOME/hombebrew_cache
 
 env:
   global:
-   - secure: "Vf+FY48nip9JppMnq11105NealdErSWsoUhHo63/V3V+LKfA9guenxCp93/qoSIdSGC/sJwb0yIIMGvkTT/rxDJNh6Z+BWUTb2E0WEIIQbvTJNOSUzoq7dfF1LT61XjVjByFzcbC2xjtaBowmcAYEs1jGUUuEjYVCMmD5lY8hUg="
-   # Which Travis environment to run Coverity on
-   - coverity_scan_run_condition='"$TRAVIS_OS_NAME" = linux -a "$CC" = gcc'
-   # Test mode is for testing if it's working with Coverity. Change to true if testing, to avoid reaching the quota.
-   - coverity_scan_script_test_mode=false
+    - secure: "Vf+FY48nip9JppMnq11105NealdErSWsoUhHo63/V3V+LKfA9guenxCp93/qoSIdSGC/sJwb0yIIMGvkTT/rxDJNh6Z+BWUTb2E0WEIIQbvTJNOSUzoq7dfF1LT61XjVjByFzcbC2xjtaBowmcAYEs1jGUUuEjYVCMmD5lY8hUg="
+    # Which Travis environment to run Coverity on
+    - coverity_scan_run_condition='"$TRAVIS_OS_NAME" = linux -a "$CC" = gcc'
+    # Test mode is for testing if it's working with Coverity. Change to true if testing, to avoid reaching the quota.
+    - coverity_scan_script_test_mode=false
 
 matrix:
- exclude:
-  - os: osx
-    compiler: gcc
+  exclude:
+    - os: osx
+      compiler: gcc
 
 git:
   submodules: false
 
 before_install:
-# shutdown services on Travis, which may have a memory impact
-  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      sudo apt-get install -y libwxgtk3.0-dev;
-    fi;
   - if [ "$TRAVIS_OS_NAME" = "linux" ] && [ "$CXX" = "g++" ]; then
       export CXX="g++-5" CC="gcc-5" CXXFLAGS="-Wno-format-security";
       export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01';
     fi;
-# Add coverall for C++ so coverall.io could be triggered. Even it should be --coverage and gcov.
+  # Add coverall for C++ so coverall.io could be triggered. Even it should be --coverage and gcov.
   - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      sudo pip install cpp-coveralls requests[security];
+      pip install --user cpp-coveralls requests[security];
     else
       brew update; brew update;
-      brew install glew wxwidgets llvm36;
+      brew install ccache glew wxwidgets llvm38;
     fi;
 
 before_script:
- - git submodule update --init rsx_program_decompiler asmjit 3rdparty/ffmpeg 3rdparty/pugixml 3rdparty/GSL 3rdparty/libpng Vulkan/glslang Vulkan/Vulkan-LoaderAndValidationLayers Utilities/yaml-cpp
- - mkdir build
- - cd build
- - if [ "$TRAVIS_OS_NAME" = "linux" ]; then cmake ..; else cmake .. -DLLVM_DIR=/usr/local/opt/llvm36/lib/llvm-3.6/share/llvm/cmake; fi
+  - git submodule update --init rsx_program_decompiler asmjit 3rdparty/ffmpeg 3rdparty/pugixml 3rdparty/GSL 3rdparty/libpng Utilities/yaml-cpp 3rdparty/cereal
+  - mkdir build
+  - cd build
+  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+      cmake ..;
+    else
+      cmake .. -DLLVM_DIR=/usr/local/opt/llvm38/lib/llvm-3.8/share/llvm/cmake;
+    fi;
 
 script:
-# Add a command to show all the variables. May be useful for debugging Travis.
-# - echo "--Shell Export Lists START--" ; export -p; echo "--Shell Export Lists STOP--";
-# And to ensure the versions of toolchain
-- echo "--CXX version?"; "$CXX" --version; echo "--CXX version confirmed";
-- if [ "$COVERITY_SCAN_BRANCH" != 1 ]; then make -j 4; fi
+  # Add a command to show all the variables. May be useful for debugging Travis.
+  #- echo "--Shell Export Lists START--" ; export -p; echo "--Shell Export Lists STOP--";
+  # And to ensure the versions of toolchain
+  - echo "--CXX version?"; "$CXX" --version; echo "--CXX version confirmed";
+  - if [ "$COVERITY_SCAN_BRANCH" != 1 ]; then make -j 3; fi
 
 addons:
   apt:
     sources:
-    - ubuntu-toolchain-r-test
-#    - llvm-toolchain-trusty-3.6 temporarily disabled
+      - ubuntu-toolchain-r-test
+      #- llvm-toolchain-trusty-3.8 temporarily disabled
     packages:
-    - cmake
-    - libopenal-dev
-    - freeglut3-dev
-    - libglew-dev
-    - libc6-dev
-#    - llvm-3.6
-#    - llvm-3.6-dev
-    - libedit-dev
-    - g++-5
-    - gcc-5
-#    - clang-3.6
-    - libstdc++-5-dev
-    - lib32stdc++6
-    - zlib1g-dev
+      - cmake
+      - libopenal-dev
+      - freeglut3-dev
+      - libglew-dev
+      - libc6-dev
+      #- llvm-3.8
+      #- llvm-3.8-dev
+      - libedit-dev
+      - g++-5
+      - gcc-5
+      #- clang-3.6
+      - libstdc++-5-dev
+      - lib32stdc++6
+      - zlib1g-dev
+      - libwxgtk3.0-dev
   coverity_scan:
     project:
       name: $TRAVIS_REPO_SLUG
       description: "PS3 emulator/debugger"
-    notification_email: raul.tambre@gmail.com
-    build_command: "make -j 4"
+    notification_email: nekotekina@gmail.com
+    build_command: "make -j 3"
     branch_pattern: coverity_scan
 
 after_success:
-- if [ "$COVERITY_SCAN_BRANCH" != 1 ] && [ "$TRAVIS_OS_NAME" = linux ]; then coveralls --extension .c --extension .cpp --extension .h; fi
+  - if [ "$COVERITY_SCAN_BRANCH" != 1 ] && [ "$TRAVIS_OS_NAME" = linux ]; then coveralls --extension .c --extension .cpp --extension .h; fi

CMakeLists.txt

@@ -11,6 +11,20 @@ if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
 	message( FATAL_ERROR "RPCS3 can only be compiled on 64-bit platforms." )
 endif()
 
+if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
+	message( FATAL_ERROR "RPCS3 requires at least gcc-5.1." )
+endif()
+
+if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 6.1)
+	message( FATAL_ERROR "RPCS3 can't be compiled with gcc-6.1, see #1691." )
+endif()
+
+find_program(CCACHE_FOUND ccache)
+if (CCACHE_FOUND)
+	set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+	set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+endif()
+
 add_definitions(-DCMAKE_BUILD)
 
 # We use libpng's static library and don't need to build the shared library and run the tests
@@ -22,6 +36,8 @@ if (NOT USE_SYSTEM_LIBPNG)
 	add_subdirectory( 3rdparty/libpng )
 endif()
 
+option(VULKAN_PREBUILT "" OFF)
+
 # TODO: do real installation, including copying directory structure
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${PROJECT_BINARY_DIR}/bin")
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${PROJECT_BINARY_DIR}/bin")

README.md

@@ -4,12 +4,14 @@ RPCS3
 [![Build Status](https://travis-ci.org/RPCS3/rpcs3.svg?branch=master)](https://travis-ci.org/RPCS3/rpcs3)
 [![Build status](https://ci.appveyor.com/api/projects/status/411c4clmiohtx7eo/branch/master?svg=true)](https://ci.appveyor.com/project/rpcs3/rpcs3/branch/master)
 [![Coverity Status](https://img.shields.io/coverity/scan/3960.svg)](https://scan.coverity.com/projects/3960)
-[![Coverage Status](https://coveralls.io/repos/RPCS3/rpcs3/badge.svg)](https://coveralls.io/r/RPCS3/rpcs3)
 
 An open-source PlayStation 3 emulator/debugger written in C++.
 
-You can find some basic information in the [FAQ](https://github.com/RPCS3/rpcs3/wiki/FAQ). For discussion about this emulator and PS3 emulation please visit the [official forums](http://www.emunewz.net/forum/forumdisplay.php?fid=162).
+You can find some basic information in the [FAQ](https://github.com/RPCS3/rpcs3/wiki/FAQ). For discussion about this emulator and PS3 emulation please visit the [official forums](http://www.emunewz.net/forum/forumdisplay.php?fid=172).
 
+Official Discord server: https://discord.me/RPCS3
+
+Support Nekotekina on Patreon: https://www.patreon.com/Nekotekina
 
 ### Development
 
@@ -25,27 +27,33 @@ __Windows__
 * [Python 3.3+](https://www.python.org/downloads/) (required; add to PATH)
 
 __Linux__
-* GCC 5.1+ or Clang 3.5.0+
-* Debian & Ubuntu: `sudo apt-get install cmake build-essential libopenal-dev libwxgtk3.0-dev libglew-dev zlib1g-dev libedit-dev libvulkan-dev`
+* GCC 5.1+ or Clang 3.5.0+ ([not GCC 6.1](https://github.com/RPCS3/rpcs3/issues/1691))
+* Debian & Ubuntu: `sudo apt-get install cmake build-essential libopenal-dev libwxgtk3.0-dev libglew-dev zlib1g-dev libedit-dev libvulkan-dev git`
 * Arch: `sudo pacman -S glew openal wxgtk cmake llvm`
 
 __Mac OSX__
+Mac OSX is not supported at this moment because it doesn't meet system requirements (OpenGL 4.3)
 * Xcode 6+ (tested with Xcode 6.4)
 * Install with Homebrew: `brew install glew wxwidgets`
 * Remove '-framework QuickTime' from '_ldflags' in /usr/local/bin/wx-config
 
-
 ### Building
 
-To initialize the repository don't forget to execute `git submodule update --init` to pull the submodules.
-* __Windows__:
-1) Open the *.SLN* file.
-2) Build the projects in *__BUILD_BEFORE* folder: right-click on every project > *Build*.
-3) Press *BUILD* > *Build Solution* or *Rebuild Solution*.
-* __Linux & Mac OSX__:
-If you want to build with LLVM, then LLVM 3.8 is required.
-`cd rpcs3 && cmake CMakeLists.txt && make && cd ../` then run with `cd bin && ./rpcs3`.
+- __Windows__: </br>
+1) To initialize the repository don't forget to execute `git submodule update --init` to pull the submodules. </br>
+2) Open the *.SLN* file. </br>
+3) Build the projects in *__BUILD_BEFORE* folder: right-click on every project > *Build*. </br>
+4) Press *BUILD* > *Build Solution* or *Rebuild Solution*. </br>
+
+- __Linux & Mac OSX__: </br>
+1) `git clone https://github.com/RPCS3/rpcs3.git` </br>
+2) `cd rpcs3/` </br>
+3) `git submodule update --init` </br>
+4) `cmake CMakeLists.txt && make GitVersion && make` </br>
+5) Run RPCS3 with `./bin/rpcs3` </br>
+
 If you are on OSX and want to build with llvm don't forget to add `-DLLVM_DIR=...` (or wherever llvm brew was installed) to cmake invocation.
+
 When using GDB, configure it to ignore SIGSEGV signal (`handle SIGSEGV nostop noprint`).
 
 ##### CMake Build Options (Linux & Mac OSX)
@@ -56,5 +64,6 @@ Build against the shared libpng instead of using the builtin one. libpng 1.6+ hi
 - ```-DUSE_SYSTEM_FFMPEG=ON/OFF``` (default = *OFF*) </br>
 Build against the shared ffmpeg libraries instead of using the builtin patched version. Try this if the builtin version breaks the OpenGL renderer for you.
 
-### Support
-* [Donate by PayPal](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=MPJ3S9XQXCE3G)
+### License
+
+Most files are licensed under the terms of GNU GPLv2 License, see LICENSE file for details. Some files may be licensed differently, check appropriate file headers for details.

Utilities/Atomic.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "types.h"
-#include "Platform.h"
 
 // Helper class, provides access to compiler-specific atomic intrinsics
 template<typename T, std::size_t Size>
@@ -143,26 +142,38 @@ struct atomic_storage
 		return atomic_storage<T>::sub_fetch(dest, 1);
 	}
 
+	static inline bool test_and_set(T& dest, T mask)
+	{
+		return (atomic_storage<T>::fetch_or(dest, mask) & mask) != 0;
+	}
+
+	static inline bool test_and_reset(T& dest, T mask)
+	{
+		return (atomic_storage<T>::fetch_and(dest, ~mask) & mask) != 0;
+	}
+
+	static inline bool test_and_complement(T& dest, T mask)
+	{
+		return (atomic_storage<T>::fetch_xor(dest, mask) & mask) != 0;
+	}
+
 	static inline bool bts(T& dest, uint bit)
 	{
-		const T mask = static_cast<T>(1) << bit;
-		return (atomic_storage<T>::fetch_or(dest, mask) & mask) != 0;
+		return atomic_storage<T>::test_and_set(dest, static_cast<T>(1) << bit);
 	}
 
 	static inline bool btr(T& dest, uint bit)
 	{
-		const T mask = static_cast<T>(1) << bit;
-		return (atomic_storage<T>::fetch_and(dest, ~mask) & mask) != 0;
+		return atomic_storage<T>::test_and_reset(dest, static_cast<T>(1) << bit);
 	}
 
 	static inline bool btc(T& dest, uint bit)
 	{
-		const T mask = static_cast<T>(1) << bit;
-		return (atomic_storage<T>::fetch_xor(dest, mask) & mask) != 0;
+		return atomic_storage<T>::test_and_complement(dest, static_cast<T>(1) << bit);
 	}
 };
 
-/* The rest: ugly MSVC intrinsics + possibly __asm__ implementations (TODO) */
+/* The rest: ugly MSVC intrinsics + inline asm implementations */
 
 template<typename T>
 struct atomic_storage<T, 1> : atomic_storage<T, 0>
@@ -285,6 +296,30 @@ struct atomic_storage<T, 2> : atomic_storage<T, 0>
 		short r = _InterlockedDecrement16((volatile short*)&dest);
 		return (T&)r;
 	}
+#else
+	static inline bool bts(T& dest, uint bit)
+	{
+		bool result;
+		ushort _bit = (ushort)bit;
+		__asm__("lock btsw %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (_bit) : "cc");
+		return result;
+	}
+
+	static inline bool btr(T& dest, uint bit)
+	{
+		bool result;
+		ushort _bit = (ushort)bit;
+		__asm__("lock btrw %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (_bit) : "cc");
+		return result;
+	}
+
+	static inline bool btc(T& dest, uint bit)
+	{
+		bool result;
+		ushort _bit = (ushort)bit;
+		__asm__("lock btcw %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (_bit) : "cc");
+		return result;
+	}
 #endif
 };
 
@@ -363,6 +398,27 @@ struct atomic_storage<T, 4> : atomic_storage<T, 0>
 	{
 		return _interlockedbittestandreset((volatile long*)&dest, bit) != 0;
 	}
+#else
+	static inline bool bts(T& dest, uint bit)
+	{
+		bool result;
+		__asm__("lock btsl %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (bit) : "cc");
+		return result;
+	}
+
+	static inline bool btr(T& dest, uint bit)
+	{
+		bool result;
+		__asm__("lock btrl %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (bit) : "cc");
+		return result;
+	}
+
+	static inline bool btc(T& dest, uint bit)
+	{
+		bool result;
+		__asm__("lock btcl %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (bit) : "cc");
+		return result;
+	}
 #endif
 };
 
@@ -441,6 +497,30 @@ struct atomic_storage<T, 8> : atomic_storage<T, 0>
 	{
 		return _interlockedbittestandreset64((volatile llong*)&dest, bit) != 0;
 	}
+#else
+	static inline bool bts(T& dest, uint bit)
+	{
+		bool result;
+		ullong _bit = bit;
+		__asm__("lock btsq %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (_bit) : "cc");
+		return result;
+	}
+
+	static inline bool btr(T& dest, uint bit)
+	{
+		bool result;
+		ullong _bit = bit;
+		__asm__("lock btrq %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (_bit) : "cc");
+		return result;
+	}
+
+	static inline bool btc(T& dest, uint bit)
+	{
+		bool result;
+		ullong _bit = bit;
+		__asm__("lock btcq %2, %0\n" "setc %1" : "+m" (dest), "=r" (result) : "Ir" (_bit) : "cc");
+		return result;
+	}
 #endif
 };
 
@@ -456,7 +536,7 @@ struct atomic_storage<T, 16> : atomic_storage<T, 0>
 
 	static inline T load(const T& dest)
 	{
-		llong result[2];
+		llong result[2]{0, 0};
 		_InterlockedCompareExchange128((volatile llong*)&dest, 0, 0, result);
 		return *(T*)+result;
 	}
@@ -478,6 +558,8 @@ struct atomic_storage<T, 16> : atomic_storage<T, 0>
 		return *(T*)+cmp;
 	}
 #endif
+
+	// TODO
 };
 
 template<typename T1, typename T2, typename>
@@ -630,21 +712,16 @@ struct atomic_test_and_set
 {
 	bool operator()(T1& lhs, const T2& rhs) const
 	{
-		return lhs.test_and_set(rhs);
+		return test_and_set(lhs, rhs);
 	}
 };
 
 template<typename T1, typename T2>
 struct atomic_test_and_set<T1, T2, std::enable_if_t<std::is_integral<T1>::value && std::is_convertible<T2, T1>::value>>
 {
-	static inline bool op(T1& lhs, const T2& rhs)
-	{
-		return (atomic_storage<T1>::fetch_or(lhs, rhs) & rhs) != 0;
-	}
-
-	static constexpr auto fetch_op = &op;
-	static constexpr auto op_fetch = &op;
-	static constexpr auto atomic_op = &op;
+	static constexpr auto fetch_op = &atomic_storage<T1>::test_and_set;
+	static constexpr auto op_fetch = &atomic_storage<T1>::test_and_set;
+	static constexpr auto atomic_op = &atomic_storage<T1>::test_and_set;
 };
 
 template<typename T1, typename T2, typename>
@@ -652,21 +729,16 @@ struct atomic_test_and_reset
 {
 	bool operator()(T1& lhs, const T2& rhs) const
 	{
-		return lhs.test_and_reset(rhs);
+		return test_and_reset(lhs, rhs);
 	}
 };
 
 template<typename T1, typename T2>
 struct atomic_test_and_reset<T1, T2, std::enable_if_t<std::is_integral<T1>::value && std::is_convertible<T2, T1>::value>>
 {
-	static inline bool op(T1& lhs, const T2& rhs)
-	{
-		return (atomic_storage<T1>::fetch_and(lhs, ~rhs) & rhs) != 0;
-	}
-
-	static constexpr auto fetch_op = &op;
-	static constexpr auto op_fetch = &op;
-	static constexpr auto atomic_op = &op;
+	static constexpr auto fetch_op = &atomic_storage<T1>::test_and_reset;
+	static constexpr auto op_fetch = &atomic_storage<T1>::test_and_reset;
+	static constexpr auto atomic_op = &atomic_storage<T1>::test_and_reset;
 };
 
 template<typename T1, typename T2, typename>
@@ -674,21 +746,16 @@ struct atomic_test_and_complement
 {
 	bool operator()(T1& lhs, const T2& rhs) const
 	{
-		return lhs.test_and_complement(rhs);
+		return test_and_complement(lhs, rhs);
 	}
 };
 
 template<typename T1, typename T2>
 struct atomic_test_and_complement<T1, T2, std::enable_if_t<std::is_integral<T1>::value && std::is_convertible<T2, T1>::value>>
 {
-	static inline bool op(T1& lhs, const T2& rhs)
-	{
-		return (atomic_storage<T1>::fetch_xor(lhs, rhs) & rhs) != 0;
-	}
-
-	static constexpr auto fetch_op = &op;
-	static constexpr auto op_fetch = &op;
-	static constexpr auto atomic_op = &op;
+	static constexpr auto fetch_op = &atomic_storage<T1>::test_and_complement;
+	static constexpr auto op_fetch = &atomic_storage<T1>::test_and_complement;
+	static constexpr auto atomic_op = &atomic_storage<T1>::test_and_complement;
 };
 
 // Atomic type with lock-free and standard layout guarantees (and appropriate limitations)
@@ -954,12 +1021,6 @@ public:
 		return atomic_op(atomic_post_dec<type>{});
 	}
 
-	template<typename T2 = T>
-	auto test(const T2& rhs) const
-	{
-		return load().test(rhs);
-	}
-
 	template<typename T2 = T>
 	auto test_and_set(const T2& rhs)
 	{

Utilities/BEType.h

@@ -1,56 +1,58 @@
 #pragma once
 
 #include "types.h"
-#include "Platform.h"
 
+// 128-bit vector type and also se_storage<> storage type
 union alignas(16) v128
 {
 	char _bytes[16];
 
-	template<typename T, std::size_t N, std::size_t M>
+	template <typename T, std::size_t N, std::size_t M>
 	struct masked_array_t // array type accessed as (index ^ M)
 	{
 		T m_data[N];
 
 	public:
-		T& operator [](std::size_t index)
+		T& operator[](std::size_t index)
 		{
 			return m_data[index ^ M];
 		}
 
-		const T& operator [](std::size_t index) const
+		const T& operator[](std::size_t index) const
 		{
 			return m_data[index ^ M];
 		}
 	};
 
 #if IS_LE_MACHINE == 1
-	template<typename T, std::size_t N = 16 / sizeof(T)> using normal_array_t = masked_array_t<T, N, 0>;
-	template<typename T, std::size_t N = 16 / sizeof(T)> using reversed_array_t = masked_array_t<T, N, N - 1>;
+	template <typename T, std::size_t N = 16 / sizeof(T)>
+	using normal_array_t = masked_array_t<T, N, 0>;
+	template <typename T, std::size_t N = 16 / sizeof(T)>
+	using reversed_array_t = masked_array_t<T, N, N - 1>;
 #endif
 
-	normal_array_t<u64>   _u64;
-	normal_array_t<s64>   _s64;
+	normal_array_t<u64> _u64;
+	normal_array_t<s64> _s64;
 	reversed_array_t<u64> u64r;
 	reversed_array_t<s64> s64r;
 
-	normal_array_t<u32>   _u32;
-	normal_array_t<s32>   _s32;
+	normal_array_t<u32> _u32;
+	normal_array_t<s32> _s32;
 	reversed_array_t<u32> u32r;
 	reversed_array_t<s32> s32r;
 
-	normal_array_t<u16>   _u16;
-	normal_array_t<s16>   _s16;
+	normal_array_t<u16> _u16;
+	normal_array_t<s16> _s16;
 	reversed_array_t<u16> u16r;
 	reversed_array_t<s16> s16r;
 
-	normal_array_t<u8>    _u8;
-	normal_array_t<s8>    _s8;
-	reversed_array_t<u8>  u8r;
-	reversed_array_t<s8>  s8r;
+	normal_array_t<u8> _u8;
+	normal_array_t<s8> _s8;
+	reversed_array_t<u8> u8r;
+	reversed_array_t<s8> s8r;
 
-	normal_array_t<f32>   _f;
-	normal_array_t<f64>   _d;
+	normal_array_t<f32> _f;
+	normal_array_t<f64> _d;
 	reversed_array_t<f32> fr;
 	reversed_array_t<f64> dr;
 
@@ -80,7 +82,7 @@ union alignas(16) v128
 				return (data & mask) != 0;
 			}
 
-			bit_element& operator =(const bool right)
+			bit_element& operator=(const bool right)
 			{
 				if (right)
 				{
@@ -93,7 +95,7 @@ union alignas(16) v128
 				return *this;
 			}
 
-			bit_element& operator =(const bit_element& right)
+			bit_element& operator=(const bit_element& right)
 			{
 				if (right)
 				{
@@ -108,7 +110,7 @@ union alignas(16) v128
 		};
 
 		// Index 0 returns the MSB and index 127 returns the LSB
-		bit_element operator [](u32 index)
+		bit_element operator[](u32 index)
 		{
 #if IS_LE_MACHINE == 1
 			return bit_element(m_data[1 - (index >> 6)], 0x8000000000000000ull >> (index & 0x3F));
@@ -116,14 +118,13 @@ union alignas(16) v128
 		}
 
 		// Index 0 returns the MSB and index 127 returns the LSB
-		bool operator [](u32 index) const
+		bool operator[](u32 index) const
 		{
 #if IS_LE_MACHINE == 1
 			return (m_data[1 - (index >> 6)] & (0x8000000000000000ull >> (index & 0x3F))) != 0;
 #endif
 		}
-	}
-	_bit;
+	} _bit;
 
 	static v128 from64(u64 _0, u64 _1 = 0)
 	{
@@ -277,12 +278,12 @@ union alignas(16) v128
 		return fromV(_mm_cmpeq_epi32(left.vi, right.vi));
 	}
 
-	bool operator ==(const v128& right) const
+	bool operator==(const v128& right) const
 	{
 		return _u64[0] == right._u64[0] && _u64[1] == right._u64[1];
 	}
 
-	bool operator !=(const v128& right) const
+	bool operator!=(const v128& right) const
 	{
 		return _u64[0] != right._u64[0] || _u64[1] != right._u64[1];
 	}
@@ -298,43 +299,69 @@ union alignas(16) v128
 		_u64[0] = 0;
 		_u64[1] = 0;
 	}
-
-	std::string to_hex() const;
-
-	std::string to_xyzw() const;
 };
 
-inline v128 operator |(const v128& left, const v128& right)
+inline v128 operator|(const v128& left, const v128& right)
 {
 	return v128::fromV(_mm_or_si128(left.vi, right.vi));
 }
 
-inline v128 operator &(const v128& left, const v128& right)
+inline v128 operator&(const v128& left, const v128& right)
 {
 	return v128::fromV(_mm_and_si128(left.vi, right.vi));
 }
 
-inline v128 operator ^(const v128& left, const v128& right)
+inline v128 operator^(const v128& left, const v128& right)
 {
 	return v128::fromV(_mm_xor_si128(left.vi, right.vi));
 }
 
-inline v128 operator ~(const v128& other)
+inline v128 operator~(const v128& other)
 {
 	return v128::from64(~other._u64[0], ~other._u64[1]);
 }
 
-#define IS_INTEGER(t) (std::is_integral<t>::value || std::is_enum<t>::value)
-#define IS_BINARY_COMPARABLE(t1, t2) (IS_INTEGER(t1) && IS_INTEGER(t2) && sizeof(t1) == sizeof(t2))
-
-template<typename T, std::size_t Size = sizeof(T)>
+template <typename T, std::size_t Align, std::size_t Size>
 struct se_storage
 {
-	static_assert(!Size, "Bad se_storage<> type");
+	using type = std::aligned_storage_t<Size, Align>;
+
+	// Unoptimized generic byteswap for unaligned data
+	static void reverse(u8* dst, const u8* src)
+	{
+		for (std::size_t i = 0; i < Size; i++)
+		{
+			dst[i] = src[Size - 1 - i];
+		}
+	}
+
+	static type to(const T& src)
+	{
+		type result;
+		reverse(reinterpret_cast<u8*>(&result), reinterpret_cast<const u8*>(&src));
+		return result;
+	}
+
+	static T from(const type& src)
+	{
+		T result;
+		reverse(reinterpret_cast<u8*>(&result), reinterpret_cast<const u8*>(&src));
+		return result;
+	}
+
+	static type copy(const type& src)
+	{
+		type result;
+		for (std::size_t i = 0; i < Size; i++)
+		{
+			reinterpret_cast<u8*>(&result)[i] = reinterpret_cast<const u8*>(&src)[i];
+		}
+		return result;
+	}
 };
 
-template<typename T>
-struct se_storage<T, 2>
+template <typename T>
+struct se_storage<T, 2, 2>
 {
 	using type = u16;
 
@@ -357,10 +384,15 @@ struct se_storage<T, 2>
 		const u16 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
+
+	static inline T copy(const T& src)
+	{
+		return src;
+	}
 };
 
-template<typename T>
-struct se_storage<T, 4>
+template <typename T>
+struct se_storage<T, 4, 4>
 {
 	using type = u32;
 
@@ -383,10 +415,15 @@ struct se_storage<T, 4>
 		const u32 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
+
+	static inline T copy(const T& src)
+	{
+		return src;
+	}
 };
 
-template<typename T>
-struct se_storage<T, 8>
+template <typename T>
+struct se_storage<T, 8, 8>
 {
 	using type = u64;
 
@@ -409,10 +446,15 @@ struct se_storage<T, 8>
 		const u64 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
+
+	static inline T copy(const T& src)
+	{
+		return src;
+	}
 };
 
-template<typename T>
-struct se_storage<T, 16>
+template <typename T>
+struct se_storage<T, 16, 16>
 {
 	using type = v128;
 
@@ -431,43 +473,20 @@ struct se_storage<T, 16>
 		const v128 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
-};
 
-template<typename T> using se_storage_t = typename se_storage<T>::type;
-
-template<typename T1, typename T2>
-struct se_convert
-{
-	using type_from = std::remove_cv_t<T1>;
-	using type_to = std::remove_cv_t<T2>;
-	using stype_from = se_storage_t<std::remove_cv_t<T1>>;
-	using stype_to = se_storage_t<std::remove_cv_t<T2>>;
-	using storage_from = se_storage<std::remove_cv_t<T1>>;
-	using storage_to = se_storage<std::remove_cv_t<T2>>;
-
-	static inline std::enable_if_t<std::is_same<type_from, type_to>::value, stype_to> convert(const stype_from& data)
+	static inline T copy(const T& src)
 	{
-		return data;
-	}
-
-	static inline stype_to convert(const stype_from& data, ...)
-	{
-		return storage_to::to(storage_from::from(data));
+		return src;
 	}
 };
 
-static struct se_raw_tag_t {} constexpr se_raw{};
-
-template<typename T, bool Se = true>
-class se_t;
-
 // Switched endianness
-template<typename T>
-class se_t<T, true>
+template <typename T, std::size_t Align>
+class se_t<T, true, Align>
 {
 	using type = typename std::remove_cv<T>::type;
-	using stype = se_storage_t<type>;
-	using storage = se_storage<type>;
+	using stype = typename se_storage<type, Align>::type;
+	using storage = se_storage<type, Align>;
 
 	stype m_data;
 
@@ -476,24 +495,6 @@ class se_t<T, true>
 	static_assert(!std::is_array<type>::value, "se_t<> error: invalid type (array)");
 	static_assert(sizeof(type) == alignof(type), "se_t<> error: unexpected alignment");
 
-	template<typename T2, typename = void>
-	struct bool_converter
-	{
-		static inline bool to_bool(const se_t<T2>& value)
-		{
-			return static_cast<bool>(value.value());
-		}
-	};
-
-	template<typename T2>
-	struct bool_converter<T2, std::enable_if_t<std::is_integral<T2>::value>>
-	{
-		static inline bool to_bool(const se_t<T2>& value)
-		{
-			return value.m_data != 0;
-		}
-	};
-
 public:
 	se_t() = default;
 
@@ -503,27 +504,15 @@ public:
 		: m_data(storage::to(value))
 	{
 	}
-	
-	// Construct directly from raw data (don't use)
-	constexpr se_t(const stype& raw_value, const se_raw_tag_t&)
-		: m_data(raw_value)
-	{
-	}
 
 	type value() const
 	{
 		return storage::from(m_data);
 	}
 
-	// Access underlying raw data (don't use)
-	constexpr const stype& raw_data() const noexcept
-	{
-		return m_data;
-	}
-	
-	se_t& operator =(const se_t&) = default;
+	se_t& operator=(const se_t&) = default;
 
-	se_t& operator =(type value)
+	se_t& operator=(type value)
 	{
 		return m_data = storage::to(value), *this;
 	}
@@ -534,181 +523,127 @@ public:
 	{
 		return storage::from(m_data);
 	}
-
-	// Optimization
-	explicit operator bool() const
-	{
-		return bool_converter<type>::to_bool(*this);
-	}
-
-	// Optimization
-	template<typename T2>
-	std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator &=(const se_t<T2>& right)
-	{
-		return m_data &= right.raw_data(), *this;
-	}
-
-	// Optimization
-	template<typename CT>
-	std::enable_if_t<std::is_integral<T>::value && std::is_convertible<CT, T>::value, se_t&> operator &=(CT right)
-	{
-		return m_data &= storage::to(right), *this;
-	}
-
-	// Optimization
-	template<typename T2>
-	std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator |=(const se_t<T2>& right)
-	{
-		return m_data |= right.raw_data(), *this;
-	}
-
-	// Optimization
-	template<typename CT>
-	std::enable_if_t<std::is_integral<T>::value && std::is_convertible<CT, T>::value, se_t&> operator |=(CT right)
-	{
-		return m_data |= storage::to(right), *this;
-	}
-
-	// Optimization
-	template<typename T2>
-	std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator ^=(const se_t<T2>& right)
-	{
-		return m_data ^= right.raw_data(), *this;
-	}
-
-	// Optimization
-	template<typename CT>
-	std::enable_if_t<std::is_integral<T>::value && std::is_convertible<CT, T>::value, se_t&> operator ^=(CT right)
-	{
-		return m_data ^= storage::to(right), *this;
-	}
 };
 
 // Native endianness
-template<typename T>
-class se_t<T, false>
+template <typename T, std::size_t Align>
+class se_t<T, false, Align>
 {
 	using type = typename std::remove_cv<T>::type;
+	using stype = typename se_storage<type, Align>::type;
+	using storage = se_storage<type, Align>;
 
 	static_assert(!std::is_pointer<type>::value, "se_t<> error: invalid type (pointer)");
 	static_assert(!std::is_reference<type>::value, "se_t<> error: invalid type (reference)");
 	static_assert(!std::is_array<type>::value, "se_t<> error: invalid type (array)");
 	static_assert(sizeof(type) == alignof(type), "se_t<> error: unexpected alignment");
 
-	type m_data;
+	stype m_data;
 
 public:
 	se_t() = default;
 
-	constexpr se_t(type value)
-		: m_data(value)
+	se_t(type value)
+		: m_data(reinterpret_cast<const stype&>(value))
 	{
 	}
 
-	// Construct directly from raw data (don't use)
-	constexpr se_t(const type& raw_value, const se_raw_tag_t&)
-		: m_data(raw_value)
+	type value() const
 	{
+		return storage::copy(reinterpret_cast<const type&>(m_data));
 	}
 
-	constexpr type value() const
-	{
-		return m_data;
-	}
+	se_t& operator=(const se_t& value) = default;
 
-	// Access underlying raw data (don't use)
-	constexpr const type& raw_data() const noexcept
+	se_t& operator=(type value)
 	{
-		return m_data;
-	}
-
-	se_t& operator =(const se_t& value) = default;
-
-	se_t& operator =(type value)
-	{
-		return m_data = value, *this;
+		return m_data = reinterpret_cast<const stype&>(value), *this;
 	}
 
 	using simple_type = simple_t<T>;
 
-	constexpr operator type() const
+	operator type() const
 	{
-		return m_data;
-	}
-
-	template<typename CT>
-	std::enable_if_t<std::is_integral<T>::value && std::is_convertible<CT, T>::value, se_t&> operator &=(const CT& right)
-	{
-		return m_data &= right, *this;
-	}
-
-	template<typename CT>
-	std::enable_if_t<std::is_integral<T>::value && std::is_convertible<CT, T>::value, se_t&> operator |=(const CT& right)
-	{
-		return m_data |= right, *this;
-	}
-
-	template<typename CT>
-	std::enable_if_t<std::is_integral<T>::value && std::is_convertible<CT, T>::value, se_t&> operator ^=(const CT& right)
-	{
-		return m_data ^= right, *this;
+		return storage::copy(reinterpret_cast<const type&>(m_data));
 	}
 };
 
-// se_t with native endianness (alias)
-template<typename T> using nse_t = se_t<T, false>;
+// se_t<> with native endianness
+template <typename T, std::size_t Align = alignof(T)>
+using nse_t = se_t<T, false, Align>;
 
-template<typename T, bool Se, typename T1>
-inline se_t<T, Se>& operator +=(se_t<T, Se>& left, const T1& right)
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator+=(se_t<T, Se, Align>& left, const T1& right)
 {
 	auto value = left.value();
 	return left = (value += right);
 }
 
-template<typename T, bool Se, typename T1>
-inline se_t<T, Se>& operator -=(se_t<T, Se>& left, const T1& right)
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator-=(se_t<T, Se, Align>& left, const T1& right)
 {
 	auto value = left.value();
 	return left = (value -= right);
 }
 
-template<typename T, bool Se, typename T1>
-inline se_t<T, Se>& operator *=(se_t<T, Se>& left, const T1& right)
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator*=(se_t<T, Se, Align>& left, const T1& right)
 {
 	auto value = left.value();
 	return left = (value *= right);
 }
 
-template<typename T, bool Se, typename T1>
-inline se_t<T, Se>& operator /=(se_t<T, Se>& left, const T1& right)
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator/=(se_t<T, Se, Align>& left, const T1& right)
 {
 	auto value = left.value();
 	return left = (value /= right);
 }
 
-template<typename T, bool Se, typename T1>
-inline se_t<T, Se>& operator %=(se_t<T, Se>& left, const T1& right)
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator%=(se_t<T, Se, Align>& left, const T1& right)
 {
 	auto value = left.value();
 	return left = (value %= right);
 }
 
-template<typename T, bool Se, typename T1>
-inline se_t<T, Se>& operator <<=(se_t<T, Se>& left, const T1& right)
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator&=(se_t<T, Se, Align>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value &= right);
+}
+
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator|=(se_t<T, Se, Align>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value |= right);
+}
+
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator^=(se_t<T, Se, Align>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value ^= right);
+}
+
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator<<=(se_t<T, Se, Align>& left, const T1& right)
 {
 	auto value = left.value();
 	return left = (value <<= right);
 }
 
-template<typename T, bool Se, typename T1>
-inline se_t<T, Se>& operator >>=(se_t<T, Se>& left, const T1& right)
+template <typename T, bool Se, std::size_t Align, typename T1>
+inline se_t<T, Se, Align>& operator>>=(se_t<T, Se, Align>& left, const T1& right)
 {
 	auto value = left.value();
 	return left = (value >>= right);
 }
 
-template<typename T, bool Se>
-inline se_t<T, Se> operator ++(se_t<T, Se>& left, int)
+template <typename T, bool Se, std::size_t Align>
+inline se_t<T, Se, Align> operator++(se_t<T, Se, Align>& left, int)
 {
 	auto value = left.value();
 	auto result = value++;
@@ -716,8 +651,8 @@ inline se_t<T, Se> operator ++(se_t<T, Se>& left, int)
 	return result;
 }
 
-template<typename T, bool Se>
-inline se_t<T, Se> operator --(se_t<T, Se>& left, int)
+template <typename T, bool Se, std::size_t Align>
+inline se_t<T, Se, Align> operator--(se_t<T, Se, Align>& left, int)
 {
 	auto value = left.value();
 	auto result = value--;
@@ -725,173 +660,111 @@ inline se_t<T, Se> operator --(se_t<T, Se>& left, int)
 	return result;
 }
 
-template<typename T, bool Se>
-inline se_t<T, Se>& operator ++(se_t<T, Se>& right)
+template <typename T, bool Se, std::size_t Align>
+inline se_t<T, Se, Align>& operator++(se_t<T, Se, Align>& right)
 {
 	auto value = right.value();
 	return right = ++value;
 }
 
-template<typename T, bool Se>
-inline se_t<T, Se>& operator --(se_t<T, Se>& right)
+template <typename T, bool Se, std::size_t Align>
+inline se_t<T, Se, Align>& operator--(se_t<T, Se, Align>& right)
 {
 	auto value = right.value();
 	return right = --value;
 }
 
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2), bool> operator ==(const se_t<T1>& left, const se_t<T2>& right)
-{
-	return left.raw_data() == right.raw_data();
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<std::is_integral<T1>::value && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2), bool> operator ==(const se_t<T1>& left, T2 right)
-{
-	return left.raw_data() == se_storage<T1>::to(right);
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_INTEGER(T1) && std::is_integral<T2>::value && sizeof(T1) <= sizeof(T2), bool> operator ==(T1 left, const se_t<T2>& right)
-{
-	return se_storage<T2>::to(left) == right.raw_data();
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2), bool> operator !=(const se_t<T1>& left, const se_t<T2>& right)
-{
-	return left.raw_data() != right.raw_data();
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<std::is_integral<T1>::value && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2), bool> operator !=(const se_t<T1>& left, T2 right)
-{
-	return left.raw_data() != se_storage<T1>::to(right);
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_INTEGER(T1) && std::is_integral<T2>::value && sizeof(T1) <= sizeof(T2), bool> operator !=(T1 left, const se_t<T2>& right)
-{
-	return se_storage<T2>::to(left) != right.raw_data();
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2) && sizeof(T1) >= 4, se_t<decltype(T1() & T2())>> operator &(const se_t<T1>& left, const se_t<T2>& right)
-{
-	return{ left.raw_data() & right.raw_data(), se_raw };
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<std::is_integral<T1>::value && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2) && sizeof(T1) >= 4, se_t<decltype(T1() & T2())>> operator &(const se_t<T1>& left, T2 right)
-{
-	return{ left.raw_data() & se_storage<T1>::to(right), se_raw };
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_INTEGER(T1) && std::is_integral<T2>::value && sizeof(T1) <= sizeof(T2) && sizeof(T2) >= 4, se_t<decltype(T1() & T2())>> operator &(T1 left, const se_t<T2>& right)
-{
-	return{ se_storage<T2>::to(left) & right.raw_data(), se_raw };
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2) && sizeof(T1) >= 4, se_t<decltype(T1() | T2())>> operator |(const se_t<T1>& left, const se_t<T2>& right)
-{
-	return{ left.raw_data() | right.raw_data(), se_raw };
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<std::is_integral<T1>::value && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2) && sizeof(T1) >= 4, se_t<decltype(T1() | T2())>> operator |(const se_t<T1>& left, T2 right)
-{
-	return{ left.raw_data() | se_storage<T1>::to(right), se_raw };
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_INTEGER(T1) && std::is_integral<T2>::value && sizeof(T1) <= sizeof(T2) && sizeof(T2) >= 4, se_t<decltype(T1() | T2())>> operator |(T1 left, const se_t<T2>& right)
-{
-	return{ se_storage<T2>::to(left) | right.raw_data(), se_raw };
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2) && sizeof(T1) >= 4, se_t<decltype(T1() ^ T2())>> operator ^(const se_t<T1>& left, const se_t<T2>& right)
-{
-	return{ left.raw_data() ^ right.raw_data(), se_raw };
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<std::is_integral<T1>::value && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2) && sizeof(T1) >= 4, se_t<decltype(T1() ^ T2())>> operator ^(const se_t<T1>& left, T2 right)
-{
-	return{ left.raw_data() ^ se_storage<T1>::to(right), se_raw };
-}
-
-// Optimization
-template<typename T1, typename T2>
-inline std::enable_if_t<IS_INTEGER(T1) && std::is_integral<T2>::value && sizeof(T1) <= sizeof(T2) && sizeof(T2) >= 4, se_t<decltype(T1() ^ T2())>> operator ^(T1 left, const se_t<T2>& right)
-{
-	return{ se_storage<T2>::to(left) ^ right.raw_data(), se_raw };
-}
-
-// Optimization
-template<typename T>
-inline std::enable_if_t<std::is_integral<T>::value && sizeof(T) >= 4, se_t<decltype(~T())>> operator ~(const se_t<T>& right)
-{
-	return{ ~right.raw_data(), se_raw };
-}
-
 #if IS_LE_MACHINE == 1
-template<typename T> using be_t = se_t<T, true>;
-template<typename T> using le_t = se_t<T, false>;
+template <typename T, std::size_t Align = alignof(T)>
+using be_t = se_t<T, true, Align>;
+template <typename T, std::size_t Align = alignof(T)>
+using le_t = se_t<T, false, Align>;
 #endif
 
 // Type converter: converts native endianness arithmetic/enum types to appropriate se_t<> type
-template<typename T, bool Se, typename = void>
+template <typename T, bool Se, typename = void>
 struct to_se
 {
+	template <typename T2, typename = void>
+	struct to_se_
+	{
+		using type = T2;
+	};
+
+	template <typename T2>
+	struct to_se_<T2, std::enable_if_t<std::is_arithmetic<T2>::value || std::is_enum<T2>::value>>
+	{
+		using type = se_t<T2, Se>;
+	};
+
 	// Convert arithmetic and enum types
-	using type = typename std::conditional<std::is_arithmetic<T>::value || std::is_enum<T>::value, se_t<T, Se>, T>::type;
+	using type = typename to_se_<T>::type;
 };
 
-template<bool Se> struct to_se<v128, Se> { using type = se_t<v128, Se>; };
-template<bool Se> struct to_se<bool, Se> { using type = bool; };
-template<bool Se> struct to_se<char, Se> { using type = char; };
-template<bool Se> struct to_se<u8, Se>   { using type = u8; };
-template<bool Se> struct to_se<s8, Se>   { using type = s8; };
+template <bool Se>
+struct to_se<v128, Se>
+{
+	using type = se_t<v128, Se>;
+};
 
-template<typename T, bool Se>
-struct to_se<const T, Se, std::enable_if_t<!std::is_array<T>::value>> 
+template <bool Se>
+struct to_se<u128, Se>
+{
+	using type = se_t<u128, Se>;
+};
+
+template <bool Se>
+struct to_se<s128, Se>
+{
+	using type = se_t<s128, Se>;
+};
+
+template <bool Se>
+struct to_se<bool, Se>
+{
+	using type = bool;
+};
+
+template <bool Se>
+struct to_se<char, Se>
+{
+	using type = char;
+};
+
+template <bool Se>
+struct to_se<u8, Se>
+{
+	using type = u8;
+};
+
+template <bool Se>
+struct to_se<s8, Se>
+{
+	using type = s8;
+};
+
+template <typename T, bool Se>
+struct to_se<const T, Se, std::enable_if_t<!std::is_array<T>::value>>
 {
 	// Move const qualifier
 	using type = const typename to_se<T, Se>::type;
 };
 
-template<typename T, bool Se>
+template <typename T, bool Se>
 struct to_se<volatile T, Se, std::enable_if_t<!std::is_array<T>::value && !std::is_const<T>::value>>
 {
 	// Move volatile qualifier
 	using type = volatile typename to_se<T, Se>::type;
 };
 
-template<typename T, bool Se>
+template <typename T, bool Se>
 struct to_se<T[], Se>
 {
 	// Move array qualifier
 	using type = typename to_se<T, Se>::type[];
 };
 
-template<typename T, bool Se, std::size_t N>
+template <typename T, bool Se, std::size_t N>
 struct to_se<T[N], Se>
 {
 	// Move array qualifier
@@ -900,25 +773,27 @@ struct to_se<T[N], Se>
 
 // BE/LE aliases for to_se<>
 #if IS_LE_MACHINE == 1
-template<typename T> using to_be_t = typename to_se<T, true>::type;
-template<typename T> using to_le_t = typename to_se<T, false>::type;
+template <typename T>
+using to_be_t = typename to_se<T, true>::type;
+template <typename T>
+using to_le_t = typename to_se<T, false>::type;
 #endif
 
 // BE/LE aliases for atomic_t
 #if IS_LE_MACHINE == 1
-template<typename T> using atomic_be_t = atomic_t<be_t<T>>;
-template<typename T> using atomic_le_t = atomic_t<le_t<T>>;
+template <typename T>
+using atomic_be_t = atomic_t<be_t<T>>;
+template <typename T>
+using atomic_le_t = atomic_t<le_t<T>>;
 #endif
 
-// Formatting for BE/LE data
-template<typename T, bool Se>
-struct unveil<se_t<T, Se>, void>
+template <typename T, bool Se, std::size_t Align>
+struct fmt_unveil<se_t<T, Se, Align>, void>
 {
-	static inline auto get(const se_t<T, Se>& arg)
+	using type = typename fmt_unveil<T>::type;
+
+	static inline auto get(const se_t<T, Se, Align>& arg)
 	{
-		return unveil<T>::get(arg);
+		return fmt_unveil<T>::get(arg);
 	}
 };
-
-#undef IS_BINARY_COMPARABLE
-#undef IS_INTEGER

Utilities/BitField.h

@@ -7,15 +7,16 @@ struct bf_base
 {
 	using type = T;
 	using vtype = simple_t<type>;
+	using utype = typename std::make_unsigned<vtype>::type;
 
 	// Datatype bitsize
-	static constexpr uint bitmax = sizeof(T) * CHAR_BIT; static_assert(N - 1 < bitmax, "bf_base<> error: N out of bounds");
+	static constexpr uint bitmax = sizeof(T) * 8; static_assert(N - 1 < bitmax, "bf_base<> error: N out of bounds");
 	
 	// Field bitsize
 	static constexpr uint bitsize = N;
 
 	// Value mask
-	static constexpr vtype vmask = static_cast<vtype>(~std::make_unsigned_t<vtype>{} >> (bitmax - bitsize));
+	static constexpr utype vmask = static_cast<utype>(~utype{} >> (bitmax - bitsize));
 
 protected:
 	type m_data;
@@ -27,14 +28,15 @@ struct bf_t : bf_base<T, N>
 {
 	using type = typename bf_t::type;
 	using vtype = typename bf_t::vtype;
+	using utype = typename bf_t::utype;
 
 	// Field offset
 	static constexpr uint bitpos = I; static_assert(bitpos + N <= bf_t::bitmax, "bf_t<> error: I out of bounds");
 
 	// Get bitmask of size N, at I pos
-	static constexpr vtype data_mask()
+	static constexpr utype data_mask()
 	{
-		return bf_t::vmask << bitpos;
+		return static_cast<utype>(~utype{} >> (bf_t::bitmax - bf_t::bitsize) << bitpos);
 	}
 
 	// Bitfield extraction helper
@@ -50,7 +52,7 @@ struct bf_t : bf_base<T, N>
 		// Load unsigned value
 		static constexpr T2 extract(const T& data)
 		{
-			return (data >> bitpos) & bf_t::vmask;
+			return static_cast<T2>((static_cast<utype>(data) >> bitpos) & bf_t::vmask);
 		}
 	};
 
@@ -60,7 +62,7 @@ struct bf_t : bf_base<T, N>
 		// Load signed value (sign-extended)
 		static constexpr T2 extract(const T& data)
 		{
-			return data << (bf_t::bitmax - bitpos - N) >> (bf_t::bitmax - N);
+			return static_cast<T2>(static_cast<vtype>(static_cast<utype>(data) << (bf_t::bitmax - bitpos - N)) >> (bf_t::bitmax - N));
 		}
 	};
 
@@ -73,7 +75,7 @@ struct bf_t : bf_base<T, N>
 	// Bitfield insertion
 	static constexpr vtype insert(vtype value)
 	{
-		return (value & bf_t::vmask) << bitpos;
+		return static_cast<vtype>((value & bf_t::vmask) << bitpos);
 	}
 
 	// Load bitfield value
@@ -85,7 +87,7 @@ struct bf_t : bf_base<T, N>
 	// Load raw data with mask applied
 	constexpr T unshifted() const
 	{
-		return this->m_data & data_mask();
+		return static_cast<T>(this->m_data & data_mask());
 	}
 
 	// Optimized bool conversion (must be removed if inappropriate)
@@ -97,14 +99,14 @@ struct bf_t : bf_base<T, N>
 	// Store bitfield value
 	bf_t& operator =(vtype value)
 	{
-		this->m_data = (this->m_data & ~data_mask()) | insert(value);
+		this->m_data = static_cast<vtype>((this->m_data & ~data_mask()) | insert(value));
 		return *this;
 	}
 
 	vtype operator ++(int)
 	{
-		vtype result = *this;
-		*this = result + 1;
+		utype result = *this;
+		*this = static_cast<vtype>(result + 1);
 		return result;
 	}
 
@@ -115,8 +117,8 @@ struct bf_t : bf_base<T, N>
 
 	vtype operator --(int)
 	{
-		vtype result = *this;
-		*this = result - 1;
+		utype result = *this;
+		*this = static_cast<vtype>(result - 1);
 		return result;
 	}
 
@@ -142,19 +144,19 @@ struct bf_t : bf_base<T, N>
 
 	bf_t& operator &=(vtype right)
 	{
-		this->m_data &= (right & bf_t::vmask) << bitpos;
+		this->m_data &= static_cast<vtype>((static_cast<utype>(right) & bf_t::vmask) << bitpos);
 		return *this;
 	}
 
 	bf_t& operator |=(vtype right)
 	{
-		this->m_data |= (right & bf_t::vmask) << bitpos;
+		this->m_data |= static_cast<vtype>((static_cast<utype>(right) & bf_t::vmask) << bitpos);
 		return *this;
 	}
 
 	bf_t& operator ^=(vtype right)
 	{
-		this->m_data ^= (right & bf_t::vmask) << bitpos;
+		this->m_data ^= static_cast<vtype>((static_cast<utype>(right) & bf_t::vmask) << bitpos);
 		return *this;
 	}
 };
@@ -165,23 +167,24 @@ struct cf_t : bf_base<typename F::type, F::bitsize + cf_t<Fields...>::bitsize>
 {
 	using type = typename cf_t::type;
 	using vtype = typename cf_t::vtype;
+	using utype = typename cf_t::utype;
 
 	// Get disjunction of all "data" masks of concatenated values
 	static constexpr vtype data_mask()
 	{
-		return F::data_mask() | cf_t<Fields...>::data_mask();
+		return static_cast<vtype>(F::data_mask() | cf_t<Fields...>::data_mask());
 	}
 
 	// Extract all bitfields and concatenate
 	static constexpr vtype extract(const type& data)
 	{
-		return F::extract(data) << cf_t<Fields...>::bitsize | cf_t<Fields...>::extract(data);
+		return static_cast<vtype>(static_cast<utype>(F::extract(data)) << cf_t<Fields...>::bitsize | cf_t<Fields...>::extract(data));
 	}
 
 	// Split bitfields and insert them
 	static constexpr vtype insert(vtype value)
 	{
-		return F::insert(value >> cf_t<Fields...>::bitsize) | cf_t<Fields...>::insert(value);
+		return static_cast<vtype>(F::insert(value >> cf_t<Fields...>::bitsize) | cf_t<Fields...>::insert(value));
 	}
 
 	// Load value
@@ -242,3 +245,36 @@ struct ff_t : bf_base<T, N>
 		return V;
 	}
 };
+
+template<typename T, uint I, uint N>
+struct fmt_unveil<bf_t<T, I, N>, void>
+{
+	using type = typename fmt_unveil<simple_t<T>>::type;
+
+	static inline auto get(const bf_t<T, I, N>& bf)
+	{
+		return fmt_unveil<type>::get(bf);
+	}
+};
+
+template<typename F, typename... Fields>
+struct fmt_unveil<cf_t<F, Fields...>, void>
+{
+	using type = typename fmt_unveil<simple_t<typename F::type>>::type;
+
+	static inline auto get(const cf_t<F, Fields...>& cf)
+	{
+		return fmt_unveil<type>::get(cf);
+	}
+};
+
+template<typename T, T V, uint N>
+struct fmt_unveil<ff_t<T, V, N>, void>
+{
+	using type = typename fmt_unveil<simple_t<T>>::type;
+
+	static inline auto get(const ff_t<T, V, N>& ff)
+	{
+		return fmt_unveil<type>::get(ff);
+	}
+};

Utilities/BitSet.h

@@ -1,258 +0,0 @@
-#pragma once
-
-#include "types.h"
-
-// Small bitset for enum class types with available values [0, BitSize).
-// T must be either enum type or convertible to (registered with via simple_t<T>).
-// Internal representation is single value of type T.
-template<typename T, std::size_t BitSize = sizeof(T) * CHAR_BIT>
-struct bitset_t
-{
-	using type = simple_t<T>;
-	using under = std::underlying_type_t<type>;
-	enum class raw_type : under {};
-
-	static constexpr auto bitsize = BitSize;
-
-	bitset_t() = default;
-
-	constexpr bitset_t(type _enum_const)
-		: m_value(static_cast<type>(shift(_enum_const)))
-	{
-	}
-
-	constexpr bitset_t(raw_type raw_value)
-		: m_value(static_cast<T>(static_cast<under>(raw_value)))
-	{
-	}
-
-	// Get underlying value
-	constexpr under _value() const
-	{
-		return static_cast<under>(m_value);
-	}
-
-	explicit constexpr operator bool() const
-	{
-		return _value() ? true : false;
-	}
-
-	bitset_t& operator +=(bitset_t rhs)
-	{
-		return *this = static_cast<raw_type>(_value() | rhs._value());
-	}
-
-	bitset_t& operator -=(bitset_t rhs)
-	{
-		return *this = static_cast<raw_type>(_value() & ~rhs._value());
-	}
-
-	bitset_t& operator &=(bitset_t rhs)
-	{
-		return *this = static_cast<raw_type>(_value() & rhs._value());
-	}
-
-	bitset_t& operator ^=(bitset_t rhs)
-	{
-		return *this = static_cast<raw_type>(_value() ^ rhs._value());
-	}
-
-	friend constexpr bitset_t operator +(bitset_t lhs, bitset_t rhs)
-	{
-		return static_cast<raw_type>(lhs._value() | rhs._value());
-	}
-
-	friend constexpr bitset_t operator -(bitset_t lhs, bitset_t rhs)
-	{
-		return static_cast<raw_type>(lhs._value() & ~rhs._value());
-	}
-
-	friend constexpr bitset_t operator &(bitset_t lhs, bitset_t rhs)
-	{
-		return static_cast<raw_type>(lhs._value() & rhs._value());
-	}
-
-	friend constexpr bitset_t operator ^(bitset_t lhs, bitset_t rhs)
-	{
-		return static_cast<raw_type>(lhs._value() ^ rhs._value());
-	}
-
-	bool test(bitset_t rhs) const
-	{
-		const under v = _value();
-		const under s = rhs._value();
-		return (v & s) != 0;
-	}
-
-	bool test_and_set(bitset_t rhs)
-	{
-		const under v = _value();
-		const under s = rhs._value();
-		*this = static_cast<raw_type>(v | s);
-		return (v & s) != 0;
-	}
-
-	bool test_and_reset(bitset_t rhs)
-	{
-		const under v = _value();
-		const under s = rhs._value();
-		*this = static_cast<raw_type>(v & ~s);
-		return (v & s) != 0;
-	}
-
-	bool test_and_complement(bitset_t rhs)
-	{
-		const under v = _value();
-		const under s = rhs._value();
-		*this = static_cast<raw_type>(v ^ s);
-		return (v & s) != 0;
-	}
-
-private:
-	static constexpr under shift(const T& value)
-	{
-		return static_cast<under>(value) < BitSize ? static_cast<under>(1) << static_cast<under>(value) : throw value;
-	}
-
-	T m_value;
-};
-
-template<typename T, typename RT = T>
-constexpr RT make_bitset()
-{
-	return RT{};
-}
-
-// Fold enum constants into bitset_t<> (must be implemented with constexpr initializer_list constructor instead)
-template<typename T = void, typename Arg, typename... Args, typename RT = std::conditional_t<std::is_void<T>::value, bitset_t<Arg>, T>>
-constexpr RT make_bitset(Arg&& _enum_const, Args&&... args)
-{
-	return RT{ std::forward<Arg>(_enum_const) } + make_bitset<RT>(std::forward<Args>(args)...);
-}
-
-template<typename T, typename CT>
-struct atomic_add<bitset_t<T>, CT, std::enable_if_t<std::is_enum<T>::value>>
-{
-	using under = typename bitset_t<T>::under;
-	using raw_type = typename bitset_t<T>::raw_type;
-
-	static inline bitset_t<T> op1(bitset_t<T>& left, bitset_t<T> right)
-	{
-		return static_cast<raw_type>(atomic_storage<under>::fetch_or(reinterpret_cast<under&>(left), right._value()));
-	}
-
-	static constexpr auto fetch_op = &op1;
-
-	static inline bitset_t<T> op2(bitset_t<T>& left, bitset_t<T> right)
-	{
-		return static_cast<raw_type>(atomic_storage<under>::or_fetch(reinterpret_cast<under&>(left), right._value()));
-	}
-
-	static constexpr auto op_fetch = &op2;
-	static constexpr auto atomic_op = &op2;
-};
-
-template<typename T, typename CT>
-struct atomic_sub<bitset_t<T>, CT, std::enable_if_t<std::is_enum<T>::value>>
-{
-	using under = typename bitset_t<T>::under;
-	using raw_type = typename bitset_t<T>::raw_type;
-
-	static inline bitset_t<T> op1(bitset_t<T>& left, bitset_t<T> right)
-	{
-		return static_cast<raw_type>(atomic_storage<under>::fetch_and(reinterpret_cast<under&>(left), ~right._value()));
-	}
-
-	static constexpr auto fetch_op = &op1;
-
-	static inline bitset_t<T> op2(bitset_t<T>& left, bitset_t<T> right)
-	{
-		return static_cast<raw_type>(atomic_storage<under>::and_fetch(reinterpret_cast<under&>(left), ~right._value()));
-	}
-
-	static constexpr auto op_fetch = &op2;
-	static constexpr auto atomic_op = &op2;
-};
-
-template<typename T, typename CT>
-struct atomic_and<bitset_t<T>, CT, std::enable_if_t<std::is_enum<T>::value>>
-{
-	using under = typename bitset_t<T>::under;
-	using raw_type = typename bitset_t<T>::raw_type;
-
-	static inline bitset_t<T> op1(bitset_t<T>& left, bitset_t<T> right)
-	{
-		return static_cast<raw_type>(atomic_storage<under>::fetch_and(reinterpret_cast<under&>(left), right._value()));
-	}
-
-	static constexpr auto fetch_op = &op1;
-
-	static inline bitset_t<T> op2(bitset_t<T>& left, bitset_t<T> right)
-	{
-		return static_cast<raw_type>(atomic_storage<under>::and_fetch(reinterpret_cast<under&>(left), right._value()));
-	}
-
-	static constexpr auto op_fetch = &op2;
-	static constexpr auto atomic_op = &op2;
-};
-
-template<typename T, typename CT>
-struct atomic_xor<bitset_t<T>, CT, std::enable_if_t<std::is_enum<T>::value>>
-{
-	using under = typename bitset_t<T>::under;
-	using raw_type = typename bitset_t<T>::raw_type;
-
-	static inline bitset_t<T> op1(bitset_t<T>& left, bitset_t<T> right)
-	{
-		return static_cast<raw_type>(atomic_storage<under>::fetch_xor(reinterpret_cast<under&>(left), right._value()));
-	}
-
-	static constexpr auto fetch_op = &op1;
-
-	static inline bitset_t<T> op2(bitset_t<T>& left, bitset_t<T> right)
-	{
-		return static_cast<raw_type>(atomic_storage<under>::xor_fetch(reinterpret_cast<under&>(left), right._value()));
-	}
-
-	static constexpr auto op_fetch = &op2;
-	static constexpr auto atomic_op = &op2;
-};
-
-template<typename T>
-struct atomic_test_and_set<bitset_t<T>, T, std::enable_if_t<std::is_enum<T>::value>>
-{
-	using under = typename bitset_t<T>::under;
-
-	static inline bool _op(bitset_t<T>& left, const T& value)
-	{
-		return atomic_storage<under>::bts(reinterpret_cast<under&>(left), static_cast<uint>(value));
-	}
-
-	static constexpr auto atomic_op = &_op;
-};
-
-template<typename T>
-struct atomic_test_and_reset<bitset_t<T>, T, std::enable_if_t<std::is_enum<T>::value>>
-{
-	using under = typename bitset_t<T>::under;
-
-	static inline bool _op(bitset_t<T>& left, const T& value)
-	{
-		return atomic_storage<under>::btr(reinterpret_cast<under&>(left), static_cast<uint>(value));
-	}
-
-	static constexpr auto atomic_op = &_op;
-};
-
-template<typename T>
-struct atomic_test_and_complement<bitset_t<T>, T, std::enable_if_t<std::is_enum<T>::value>>
-{
-	using under = typename bitset_t<T>::under;
-
-	static inline bool _op(bitset_t<T>& left, const T& value)
-	{
-		return atomic_storage<under>::btc(reinterpret_cast<under&>(left), static_cast<uint>(value));
-	}
-
-	static constexpr auto atomic_op = &_op;
-};

Utilities/Config.cpp

@@ -12,7 +12,7 @@ namespace cfg
 	{
 		if (_type != type::node)
 		{
-			throw std::logic_error("Invalid root node");
+			fmt::throw_exception<std::logic_error>("Invalid root node" HERE);
 		}
 	}
 
@@ -21,7 +21,7 @@ namespace cfg
 	{
 		if (!owner.m_nodes.emplace(name, this).second)
 		{
-			throw std::logic_error("Node already exists");
+			fmt::throw_exception<std::logic_error>("Node already exists: %s" HERE, name);
 		}
 	}
 
@@ -32,7 +32,7 @@ namespace cfg
 			return *static_cast<const node&>(*this).m_nodes.at(name);
 		}
 
-		throw std::logic_error("Invalid node type");
+		fmt::throw_exception<std::logic_error>("Invalid node type" HERE);
 	}
 
 	entry_base& entry_base::operator[](const char* name) const
@@ -42,7 +42,17 @@ namespace cfg
 			return *static_cast<const node&>(*this).m_nodes.at(name);
 		}
 
-		throw std::logic_error("Invalid node type");
+		fmt::throw_exception<std::logic_error>("Invalid node type" HERE);
+	}
+
+	bool entry_base::from_string(const std::string&)
+	{
+		fmt::throw_exception<std::logic_error>("from_string() purecall" HERE);
+	}
+
+	bool entry_base::from_list(std::vector<std::string>&&)
+	{
+		fmt::throw_exception<std::logic_error>("from_list() purecall" HERE);
 	}
 
 	// Emit YAML
@@ -85,6 +95,62 @@ bool cfg::try_to_int64(s64* out, const std::string& value, s64 min, s64 max)
 	return true;
 }
 
+bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) func, const std::string& value)
+{
+	for (u64 i = 0;; i++)
+	{
+		std::string var;
+		func(var, i);
+
+		if (var == value)
+		{
+			if (out) *out = i;
+			return true;
+		}
+
+		std::string hex;
+		fmt_class_string<u64>::format(hex, i);
+		if (var == hex)
+		{
+			break;
+		}
+	}
+
+	try
+	{
+		const auto val = std::stoull(value, nullptr, 0);
+
+		if (out) *out = val;
+		return true;
+	}
+	catch (...)
+	{
+		return false;
+	}
+}
+
+std::vector<std::string> cfg::try_to_enum_list(decltype(&fmt_class_string<int>::format) func)
+{
+	std::vector<std::string> result;
+
+	for (u64 i = 0;; i++)
+	{
+		std::string var;
+		func(var, i);
+
+		std::string hex;
+		fmt_class_string<u64>::format(hex, i);
+		if (var == hex)
+		{
+			break;
+		}
+
+		result.emplace_back(std::move(var));
+	}
+
+	return result;
+}
+
 void cfg::encode(YAML::Emitter& out, const cfg::entry_base& rhs)
 {
 	switch (rhs.get_type())
@@ -195,6 +261,22 @@ void cfg::node::from_default()
 	}
 }
 
+void cfg::bool_entry::from_default()
+{
+	value = def;
+}
+
+void cfg::string_entry::from_default()
+{
+	*this = def;
+}
+
+void cfg::set_entry::from_default()
+{
+	std::lock_guard<std::mutex> lock(m_mutex);
+	m_set = {};
+}
+
 cfg::root_node& cfg::get_root()
 {
 	// Magic static

Utilities/Config.h

@@ -2,6 +2,7 @@
 
 #include "Utilities/types.h"
 #include "Utilities/Atomic.h"
+#include "Utilities/StrFmt.h"
 
 #include <initializer_list>
 #include <exception>
@@ -18,6 +19,12 @@ namespace cfg
 	// Convert string to signed integer
 	bool try_to_int64(s64* out, const std::string& value, s64 min, s64 max);
 
+	// Internal hack
+	bool try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) func, const std::string&);
+
+	// Internal hack
+	std::vector<std::string> try_to_enum_list(decltype(&fmt_class_string<int>::format) func);
+
 	// Config tree entry type.
 	enum class type : uint
 	{
@@ -62,10 +69,7 @@ namespace cfg
 		}
 
 		// Try to convert from string (optional)
-		virtual bool from_string(const std::string&)
-		{
-			throw std::logic_error("from_string() not specified");
-		}
+		virtual bool from_string(const std::string&);
 
 		// Get string list (optional)
 		virtual std::vector<std::string> to_list() const
@@ -74,10 +78,7 @@ namespace cfg
 		}
 
 		// Set multiple values. Implementation-specific, optional.
-		virtual bool from_list(std::vector<std::string>&&)
-		{
-			throw std::logic_error("from_list() not specified");
-		}
+		virtual bool from_list(std::vector<std::string>&&);
 	};
 
 	// Config tree node which contains another nodes
@@ -140,10 +141,7 @@ namespace cfg
 			return *this;
 		}
 
-		void from_default() override
-		{
-			value = def;
-		}
+		void from_default() override;
 
 		std::string to_string() const override
 		{
@@ -179,7 +177,7 @@ namespace cfg
 			for (const auto& v : init)
 			{
 				// Ensure elements are unique
-				VERIFY(map.emplace(v.first, v.second).second);
+				verify(HERE), map.emplace(v.first, v.second).second;
 			}
 
 			return map;
@@ -216,7 +214,7 @@ namespace cfg
 		}
 
 		map_entry(node& owner, const std::string& name, std::size_t def_index, init_type init)
-			: map_entry(owner, name, def_index < init.size() ? (init.begin() + def_index)->first : throw std::logic_error("Invalid default value index"), init)
+			: map_entry(owner, name, (init.begin() + (def_index < init.size() ? def_index : 0))->first, init)
 		{
 		}
 
@@ -296,26 +294,20 @@ namespace cfg
 
 		std::string to_string() const override
 		{
-			for (std::size_t i = 0; i < sizeof(bijective<T, const char*>::map) / sizeof(bijective_pair<T, const char*>); i++)
-			{
-				if (bijective<T, const char*>::map[i].v1 == m_value)
-				{
-					return bijective<T, const char*>::map[i].v2;
-				}
-			}
-
-			return{}; // TODO: ???
+			std::string result;
+			fmt_class_string<T>::format(result, fmt_unveil<T>::get(m_value));
+			return result; // TODO: ???
 		}
 
 		bool from_string(const std::string& value) override
 		{
-			for (std::size_t i = 0; i < sizeof(bijective<T, const char*>::map) / sizeof(bijective_pair<T, const char*>); i++)
+			u64 result;
+
+			if (try_to_enum_value(&result, &fmt_class_string<T>::format, value))
 			{
-				if (bijective<T, const char*>::map[i].v2 == value)
-				{
-					m_value = bijective<T, const char*>::map[i].v1;
-					return true;
-				}
+				// No narrowing check, it's hard to do right there
+				m_value = static_cast<T>(static_cast<std::underlying_type_t<T>>(result));
+				return true;
 			}
 
 			return false;
@@ -323,14 +315,7 @@ namespace cfg
 
 		std::vector<std::string> to_list() const override
 		{
-			std::vector<std::string> result;
-
-			for (std::size_t i = 0; i < sizeof(bijective<T, const char*>::map) / sizeof(bijective_pair<T, const char*>); i++)
-			{
-				result.emplace_back(bijective<T, const char*>::map[i].v2);
-			}
-
-			return result;
+			return try_to_enum_list(&fmt_class_string<T>::format);
 		}
 	};
 
@@ -364,7 +349,7 @@ namespace cfg
 		{
 			if (value < Min || value > Max)
 			{
-				throw fmt::exception("Value out of the valid range: %lld" HERE, s64{ value });
+				fmt::throw_exception("Value out of the valid range: %lld" HERE, s64{ value });
 			}
 
 			m_value = value;
@@ -440,10 +425,7 @@ namespace cfg
 			return m_value.size();
 		}
 
-		void from_default() override
-		{
-			*this = def;
-		}
+		void from_default() override;
 
 		std::string to_string() const override
 		{
@@ -485,11 +467,7 @@ namespace cfg
 			m_set = std::move(set);
 		}
 
-		void from_default() override
-		{
-			std::lock_guard<std::mutex> lock(m_mutex);
-			m_set = {};
-		}
+		void from_default() override;
 
 		std::vector<std::string> to_list() const override
 		{

Utilities/File.cpp

@@ -1,7 +1,8 @@
 #include "File.h"
+#include "mutex.h"
 #include "StrFmt.h"
-#include "Macro.h"
-#include "SharedMutex.h"
+#include "BEType.h"
+#include "Crypto/sha1.h"
 
 #include <unordered_map>
 #include <algorithm>
@@ -14,36 +15,35 @@
 
 static std::unique_ptr<wchar_t[]> to_wchar(const std::string& source)
 {
-	const auto buf_size = source.size() + 1; // size + null terminator
+	// String size + null terminator
+	const std::size_t buf_size = source.size() + 1;
 
-	const int size = source.size() < INT_MAX ? static_cast<int>(buf_size) : throw fmt::exception("to_wchar(): invalid source length (0x%llx)", source.size());
+	// Safe size
+	const int size = narrow<int>(buf_size, "to_wchar" HERE);
 
-	std::unique_ptr<wchar_t[]> buffer(new wchar_t[buf_size]); // allocate buffer assuming that length is the max possible size
+	// Buffer for max possible output length
+	std::unique_ptr<wchar_t[]> buffer(new wchar_t[buf_size]);
 
-	if (!MultiByteToWideChar(CP_UTF8, 0, source.c_str(), size, buffer.get(), size))
-	{
-		throw fmt::exception("to_wchar(): MultiByteToWideChar() failed: error %u.", GetLastError());
-	}
+	verify("to_wchar" HERE), MultiByteToWideChar(CP_UTF8, 0, source.c_str(), size, buffer.get(), size);
 
 	return buffer;
 }
 
-static void to_utf8(std::string& result, const wchar_t* source)
+static void to_utf8(std::string& out, const wchar_t* source)
 {
-	const auto length = std::wcslen(source);
+	// String size
+	const std::size_t length = std::wcslen(source);
 
-	const int buf_size = length <= INT_MAX / 3 ? static_cast<int>(length) * 3 + 1 : throw fmt::exception("to_utf8(): invalid source length (0x%llx)", length);
+	// Safe buffer size for max possible output length (including null terminator)
+	const int buf_size = narrow<int>(length * 3 + 1, "to_utf8" HERE);
 
-	result.resize(buf_size); // set max possible length for utf-8 + null terminator
+	// Resize buffer
+	out.resize(buf_size - 1);
 
-	if (const int nwritten = WideCharToMultiByte(CP_UTF8, 0, source, static_cast<int>(length) + 1, &result.front(), buf_size, NULL, NULL))
-	{
-		result.resize(nwritten - 1); // fix the size, remove null terminator
-	}
-	else
-	{
-		throw fmt::exception("to_utf8(): WideCharToMultiByte() failed: error %u.", GetLastError());
-	}
+	const int result = WideCharToMultiByte(CP_UTF8, 0, source, static_cast<int>(length) + 1, &out.front(), buf_size, NULL, NULL);
+
+	// Fix the size
+	out.resize(verify("to_utf8" HERE, result) - 1);
 }
 
 static time_t to_time(const ULARGE_INTEGER& ft)
@@ -69,16 +69,28 @@ static time_t to_time(const FILETIME& ft)
 	return to_time(v);
 }
 
+static FILETIME from_time(s64 _time)
+{
+	const ullong wtime = (_time + 11644473600ULL) * 10000000ULL;
+	FILETIME result;
+	result.dwLowDateTime = static_cast<DWORD>(wtime);
+	result.dwHighDateTime = static_cast<DWORD>(wtime >> 32);
+	return result;
+}
+
 static fs::error to_error(DWORD e)
 {
 	switch (e)
 	{
 	case ERROR_FILE_NOT_FOUND: return fs::error::noent;
 	case ERROR_PATH_NOT_FOUND: return fs::error::noent;
+	case ERROR_ACCESS_DENIED: return fs::error::acces;
 	case ERROR_ALREADY_EXISTS: return fs::error::exist;
 	case ERROR_FILE_EXISTS: return fs::error::exist;
 	case ERROR_NEGATIVE_SEEK: return fs::error::inval;
-	default: throw fmt::exception("Unknown Win32 error: %u.", e);
+	case ERROR_DIRECTORY: return fs::error::inval;
+	case ERROR_INVALID_NAME: return fs::error::inval;
+	default: fmt::throw_exception("Unknown Win32 error: %u.", e);
 	}
 }
 
@@ -92,6 +104,7 @@ static fs::error to_error(DWORD e)
 #include <libgen.h>
 #include <string.h>
 #include <unistd.h>
+#include <utime.h>
 
 #if defined(__APPLE__) || defined(__FreeBSD__)
 #include <copyfile.h>
@@ -107,7 +120,8 @@ static fs::error to_error(int e)
 	case ENOENT: return fs::error::noent;
 	case EEXIST: return fs::error::exist;
 	case EINVAL: return fs::error::inval;
-	default: throw fmt::exception("Unknown system error: %d.", e);
+	case EACCES: return fs::error::acces;
+	default: fmt::throw_exception("Unknown system error: %d.", e);
 	}
 }
 
@@ -134,6 +148,18 @@ namespace fs
 		static device_manager instance;
 		return instance;
 	}
+
+	file_base::~file_base()
+	{
+	}
+
+	dir_base::~dir_base()
+	{
+	}
+
+	device_base::~device_base()
+	{
+	}
 }
 
 std::shared_ptr<fs::device_base> fs::device_manager::get_device(const std::string& path)
@@ -170,7 +196,7 @@ std::shared_ptr<fs::device_base> fs::get_virtual_device(const std::string& path)
 
 std::shared_ptr<fs::device_base> fs::set_virtual_device(const std::string& name, const std::shared_ptr<device_base>& device)
 {
-	EXPECTS(name.size() > 2 && name[0] == '/' && name[1] == '/' && name.find('/', 2) == -1);
+	verify(HERE), name.size() > 2, name[0] == '/', name[1] == '/', name.find('/', 2) == -1;
 
 	return get_device_manager().set_device(name, device);
 }
@@ -199,33 +225,6 @@ std::string fs::get_parent_dir(const std::string& path)
 	}
 }
 
-static const auto test_get_parent_dir = []() -> bool
-{
-	// Success:
-	VERIFY(fs::get_parent_dir("/x/y///") == "/x");
-	VERIFY(fs::get_parent_dir("/x/y/") == "/x");
-	VERIFY(fs::get_parent_dir("/x/y") == "/x");
-	VERIFY(fs::get_parent_dir("x:/y") == "x:");
-	VERIFY(fs::get_parent_dir("//x/y") == "//x");
-
-	// Failure:
-	VERIFY(fs::get_parent_dir("").empty());
-	VERIFY(fs::get_parent_dir("x/").empty());
-	VERIFY(fs::get_parent_dir("x").empty());
-	VERIFY(fs::get_parent_dir("x///").empty());
-	VERIFY(fs::get_parent_dir("/x/").empty());
-	VERIFY(fs::get_parent_dir("/x").empty());
-	VERIFY(fs::get_parent_dir("/").empty());
-	VERIFY(fs::get_parent_dir("//").empty());
-	VERIFY(fs::get_parent_dir("//x").empty());
-	VERIFY(fs::get_parent_dir("//x/").empty());
-	VERIFY(fs::get_parent_dir("///").empty());
-	VERIFY(fs::get_parent_dir("///x").empty());
-	VERIFY(fs::get_parent_dir("///x/").empty());
-
-	return false;
-}();
-
 bool fs::stat(const std::string& path, stat_t& info)
 {
 	if (auto device = get_virtual_device(path))
@@ -461,7 +460,7 @@ bool fs::rename(const std::string& from, const std::string& to)
 
 	if (device != get_virtual_device(to))
 	{
-		throw fmt::exception("fs::rename() between different devices not implemented.\nFrom: %s\nTo: %s", from, to);
+		fmt::throw_exception("fs::rename() between different devices not implemented.\nFrom: %s\nTo: %s", from, to);
 	}
 
 	if (device)
@@ -494,7 +493,7 @@ bool fs::copy_file(const std::string& from, const std::string& to, bool overwrit
 
 	if (device != get_virtual_device(to) || device) // TODO
 	{
-		throw fmt::exception("fs::copy_file() for virtual devices not implemented.\nFrom: %s\nTo: %s", from, to);
+		fmt::throw_exception("fs::copy_file() for virtual devices not implemented.\nFrom: %s\nTo: %s", from, to);
 	}
 
 #ifdef _WIN32
@@ -616,50 +615,92 @@ bool fs::truncate_file(const std::string& path, u64 length)
 #endif
 }
 
+bool fs::utime(const std::string& path, s64 atime, s64 mtime)
+{
+	if (auto device = get_virtual_device(path))
+	{
+		return device->utime(path, atime, mtime);
+	}
+
+#ifdef _WIN32
+	// Open the file
+	const auto handle = CreateFileW(to_wchar(path).get(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	if (handle == INVALID_HANDLE_VALUE)
+	{
+		g_tls_error = to_error(GetLastError());
+		return false;
+	}
+
+	FILETIME _atime = from_time(atime);
+	FILETIME _mtime = from_time(mtime);
+	if (!SetFileTime(handle, nullptr, &_atime, &_mtime))
+	{
+		g_tls_error = to_error(GetLastError());
+		CloseHandle(handle);
+		return false;
+	}
+
+	CloseHandle(handle);
+	return true;
+#else
+	::utimbuf buf;
+	buf.actime = atime;
+	buf.modtime = mtime;
+
+	if (::utime(path.c_str(), &buf) != 0)
+	{
+		g_tls_error = to_error(errno);
+		return false;
+	}
+
+	return true;
+#endif
+}
+
 void fs::file::xnull() const
 {
-	throw std::logic_error("fs::file is null");
+	fmt::throw_exception<std::logic_error>("fs::file is null");
 }
 
 void fs::file::xfail() const
 {
-	throw fmt::exception("Unexpected fs::error %u", g_tls_error);
+	fmt::throw_exception("Unexpected fs::error %s", g_tls_error);
 }
 
-bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
+fs::file::file(const std::string& path, bs_t<open_mode> mode)
 {
 	if (auto device = get_virtual_device(path))
 	{
 		if (auto&& _file = device->open(path, mode))
 		{
 			m_file = std::move(_file);
-			return true;
+			return;
 		}
 
-		return false;
+		return;
 	}
 
 #ifdef _WIN32
 	DWORD access = 0;
-	if (mode & fs::read) access |= GENERIC_READ;
-	if (mode & fs::write) access |= mode & fs::append ? FILE_APPEND_DATA : GENERIC_WRITE;
+	if (test(mode & fs::read)) access |= GENERIC_READ;
+	if (test(mode & fs::write)) access |= test(mode & fs::append) ? FILE_APPEND_DATA : GENERIC_WRITE;
 
 	DWORD disp = 0;
-	if (mode & fs::create)
+	if (test(mode & fs::create))
 	{
 		disp =
-			mode & fs::excl ? CREATE_NEW :
-			mode & fs::trunc ? CREATE_ALWAYS : OPEN_ALWAYS;
+			test(mode & fs::excl) ? CREATE_NEW :
+			test(mode & fs::trunc) ? CREATE_ALWAYS : OPEN_ALWAYS;
 	}
 	else
 	{
-		if (mode & fs::excl)
+		if (test(mode & fs::excl))
 		{
 			g_tls_error = error::inval;
-			return false;
+			return;
 		}
 
-		disp = mode & fs::trunc ? TRUNCATE_EXISTING : OPEN_EXISTING;
+		disp = test(mode & fs::trunc) ? TRUNCATE_EXISTING : OPEN_EXISTING;
 	}
 
 	const HANDLE handle = CreateFileW(to_wchar(path).get(), access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
@@ -667,7 +708,7 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 	if (handle == INVALID_HANDLE_VALUE)
 	{
 		g_tls_error = to_error(GetLastError());
-		return false;
+		return;
 	}
 
 	class windows_file final : public file_base
@@ -688,10 +729,7 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 		stat_t stat() override
 		{
 			FILE_BASIC_INFO basic_info;
-			if (!GetFileInformationByHandleEx(m_handle, FileBasicInfo, &basic_info, sizeof(FILE_BASIC_INFO)))
-			{
-				throw fmt::exception("Win32 error: %u." HERE, GetLastError());
-			}
+			verify("file::stat" HERE), GetFileInformationByHandleEx(m_handle, FileBasicInfo, &basic_info, sizeof(FILE_BASIC_INFO));
 
 			stat_t info;
 			info.is_directory = (basic_info.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
@@ -722,27 +760,17 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 				return false;
 			}
 
-			const BOOL result = SetEndOfFile(m_handle); // change file size
-
-			if (!result || !SetFilePointerEx(m_handle, old, NULL, FILE_BEGIN)) // restore position
-			{
-				throw fmt::exception("Win32 error: %u." HERE, GetLastError());
-			}
-
-			return result != FALSE;
+			verify("file::trunc" HERE), SetEndOfFile(m_handle), SetFilePointerEx(m_handle, old, NULL, FILE_BEGIN);
+			return true;
 		}
 
 		u64 read(void* buffer, u64 count) override
 		{
 			// TODO (call ReadFile multiple times if count is too big)
-			const int size = ::narrow<int>(count, "Too big count" HERE);
-			EXPECTS(size >= 0);
+			const int size = narrow<int>(count, "file::read" HERE);
 
 			DWORD nread;
-			if (!ReadFile(m_handle, buffer, size, &nread, NULL))
-			{
-				throw fmt::exception("Win32 error: %u." HERE, GetLastError());
-			}
+			verify("file::read" HERE), ReadFile(m_handle, buffer, size, &nread, NULL);
 
 			return nread;
 		}
@@ -750,14 +778,10 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 		u64 write(const void* buffer, u64 count) override
 		{
 			// TODO (call WriteFile multiple times if count is too big)
-			const int size = ::narrow<int>(count, "Too big count" HERE);
-			EXPECTS(size >= 0);
+			const int size = narrow<int>(count, "file::write" HERE);
 
 			DWORD nwritten;
-			if (!WriteFile(m_handle, buffer, size, &nwritten, NULL))
-			{
-				throw fmt::exception("Win32 error: %u." HERE, GetLastError());
-			}
+			verify("file::write" HERE), WriteFile(m_handle, buffer, size, &nwritten, NULL);
 
 			return nwritten;
 		}
@@ -771,12 +795,9 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 				whence == seek_set ? FILE_BEGIN :
 				whence == seek_cur ? FILE_CURRENT :
 				whence == seek_end ? FILE_END :
-				throw fmt::exception("Invalid whence (0x%x)" HERE, whence);
+				(fmt::throw_exception("Invalid whence (0x%x)" HERE, whence), 0);
 
-			if (!SetFilePointerEx(m_handle, pos, &pos, mode))
-			{
-				throw fmt::exception("Win32 error: %u." HERE, GetLastError());
-			}
+			verify("file::seek" HERE), SetFilePointerEx(m_handle, pos, &pos, mode);
 
 			return pos.QuadPart;
 		}
@@ -784,10 +805,7 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 		u64 size() override
 		{
 			LARGE_INTEGER size;
-			if (!GetFileSizeEx(m_handle, &size))
-			{
-				throw fmt::exception("Win32 error: %u." HERE, GetLastError());
-			}
+			verify("file::size" HERE), GetFileSizeEx(m_handle, &size);
 
 			return size.QuadPart;
 		}
@@ -797,21 +815,21 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 #else
 	int flags = 0;
 
-	if (mode & fs::read && mode & fs::write) flags |= O_RDWR;
-	else if (mode & fs::read) flags |= O_RDONLY;
-	else if (mode & fs::write) flags |= O_WRONLY;
+	if (test(mode & fs::read) && test(mode & fs::write)) flags |= O_RDWR;
+	else if (test(mode & fs::read)) flags |= O_RDONLY;
+	else if (test(mode & fs::write)) flags |= O_WRONLY;
 
-	if (mode & fs::append) flags |= O_APPEND;
-	if (mode & fs::create) flags |= O_CREAT;
-	if (mode & fs::trunc) flags |= O_TRUNC;
-	if (mode & fs::excl) flags |= O_EXCL;
+	if (test(mode & fs::append)) flags |= O_APPEND;
+	if (test(mode & fs::create)) flags |= O_CREAT;
+	if (test(mode & fs::trunc)) flags |= O_TRUNC;
+	if (test(mode & fs::excl)) flags |= O_EXCL;
 
 	const int fd = ::open(path.c_str(), flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 
 	if (fd == -1)
 	{
 		g_tls_error = to_error(errno);
-		return false;
+		return;
 	}
 
 	class unix_file final : public file_base
@@ -832,10 +850,7 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 		stat_t stat() override
 		{
 			struct ::stat file_info;
-			if (::fstat(m_fd, &file_info) != 0)
-			{
-				throw fmt::exception("System error: %d." HERE, errno);
-			}
+			verify("file::stat" HERE), ::fstat(m_fd, &file_info) == 0;
 
 			stat_t info;
 			info.is_directory = S_ISDIR(file_info.st_mode);
@@ -862,10 +877,7 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 		u64 read(void* buffer, u64 count) override
 		{
 			const auto result = ::read(m_fd, buffer, count);
-			if (result == -1)
-			{
-				throw fmt::exception("System error: %d." HERE, errno);
-			}
+			verify("file::read" HERE), result != -1;
 
 			return result;
 		}
@@ -873,10 +885,7 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 		u64 write(const void* buffer, u64 count) override
 		{
 			const auto result = ::write(m_fd, buffer, count);
-			if (result == -1)
-			{
-				throw fmt::exception("System error: %d." HERE, errno);
-			}
+			verify("file::write" HERE), result != -1;
 
 			return result;
 		}
@@ -887,13 +896,10 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 				whence == seek_set ? SEEK_SET :
 				whence == seek_cur ? SEEK_CUR :
 				whence == seek_end ? SEEK_END :
-				throw fmt::exception("Invalid whence (0x%x)" HERE, whence);
+				(fmt::throw_exception("Invalid whence (0x%x)" HERE, whence), 0);
 
 			const auto result = ::lseek(m_fd, offset, mode);
-			if (result == -1)
-			{
-				throw fmt::exception("System error: %d." HERE, errno);
-			}
+			verify("file::seek" HERE), result != -1;
 
 			return result;
 		}
@@ -901,10 +907,7 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 		u64 size() override
 		{
 			struct ::stat file_info;
-			if (::fstat(m_fd, &file_info) != 0)
-			{
-				throw fmt::exception("System error: %d." HERE, errno);
-			}
+			verify("file::size" HERE), ::fstat(m_fd, &file_info) == 0;
 
 			return file_info.st_size;
 		}
@@ -912,8 +915,6 @@ bool fs::file::open(const std::string& path, bitset_t<open_mode> mode)
 
 	m_file = std::make_unique<unix_file>(fd);
 #endif
-
-	return true;
 }
 
 fs::file::file(const void* ptr, std::size_t size)
@@ -934,35 +935,42 @@ fs::file::file(const void* ptr, std::size_t size)
 
 		fs::stat_t stat() override
 		{
-			throw std::logic_error("Not supported" HERE);
+			fmt::raw_error("fs::file::memory_stream::stat(): not supported");
 		}
 
 		bool trunc(u64 length) override
 		{
-			throw std::logic_error("Not allowed" HERE);
+			return false;
 		}
 
 		u64 read(void* buffer, u64 count) override
 		{
-			const u64 start = m_pos;
-			const u64 end = seek(count, fs::seek_cur);
-			const u64 read_size = end >= start ? end - start : throw std::logic_error("Stream overflow" HERE);
-			std::memcpy(buffer, m_ptr + start, read_size);
-			return read_size;
+			if (m_pos < m_size)
+			{
+				// Get readable size
+				if (const u64 result = std::min<u64>(count, m_size - m_pos))
+				{
+					std::memcpy(buffer, m_ptr + m_pos, result);
+					m_pos += result;
+					return result;
+				}
+			}
+
+			return 0;
 		}
 
 		u64 write(const void* buffer, u64 count) override
 		{
-			throw std::logic_error("Not allowed" HERE);
+			return 0;
 		}
 
 		u64 seek(s64 offset, fs::seek_mode whence) override
 		{
 			return
-				whence == fs::seek_set ? m_pos = std::min<u64>(offset, m_size) :
-				whence == fs::seek_cur ? m_pos = std::min<u64>(offset + m_pos, m_size) :
-				whence == fs::seek_end ? m_pos = std::min<u64>(offset + m_size, m_size) :
-				throw fmt::exception("Invalid whence (0x%x)" HERE, whence);
+				whence == fs::seek_set ? m_pos = offset :
+				whence == fs::seek_cur ? m_pos = offset + m_pos :
+				whence == fs::seek_end ? m_pos = offset + m_size :
+				(fmt::raw_error("fs::file::memory_stream::seek(): invalid whence"), 0);
 		}
 
 		u64 size() override
@@ -976,7 +984,7 @@ fs::file::file(const void* ptr, std::size_t size)
 
 void fs::dir::xnull() const
 {
-	throw std::logic_error("fs::dir is null");
+	fmt::throw_exception<std::logic_error>("fs::dir is null");
 }
 
 bool fs::dir::open(const std::string& path)
@@ -994,7 +1002,7 @@ bool fs::dir::open(const std::string& path)
 
 #ifdef _WIN32
 	WIN32_FIND_DATAW found;
-	const auto handle = FindFirstFileW(to_wchar(path + "/*").get(), &found);
+	const auto handle = FindFirstFileExW(to_wchar(path + "/*").get(), FindExInfoBasic, &found, FindExSearchNameMatch, NULL, FIND_FIRST_EX_CASE_SENSITIVE | FIND_FIRST_EX_LARGE_FETCH);
 
 	if (handle == INVALID_HANDLE_VALUE)
 	{
@@ -1004,8 +1012,6 @@ bool fs::dir::open(const std::string& path)
 
 	class windows_dir final : public dir_base
 	{
-		const HANDLE m_handle;
-
 		std::vector<dir_entry> m_entries;
 		std::size_t m_pos = 0;
 
@@ -1025,33 +1031,24 @@ bool fs::dir::open(const std::string& path)
 		}
 
 	public:
-		windows_dir(HANDLE handle, const WIN32_FIND_DATAW& found)
-			: m_handle(handle)
+		windows_dir(HANDLE handle, WIN32_FIND_DATAW& found)
 		{
 			add_entry(found);
-		}
 
-		~windows_dir()
-		{
-			FindClose(m_handle);
+			while (FindNextFileW(handle, &found))
+			{
+				add_entry(found);
+			}
+
+			verify("dir::read" HERE), ERROR_NO_MORE_FILES == GetLastError();
+			FindClose(handle);
 		}
 
 		bool read(dir_entry& out) override
 		{
-			if (m_pos == m_entries.size())
+			if (m_pos >= m_entries.size())
 			{
-				WIN32_FIND_DATAW found;
-				if (!FindNextFileW(m_handle, &found))
-				{
-					if (ERROR_NO_MORE_FILES == GetLastError())
-					{
-						return false;
-					}
-
-					throw fmt::exception("Win32 error: %u." HERE, GetLastError());
-				}
-
-				add_entry(found);
+				return false;
 			}
 
 			out = m_entries[m_pos++];
@@ -1098,10 +1095,7 @@ bool fs::dir::open(const std::string& path)
 			}
 
 			struct ::stat file_info;
-			if (::fstatat(::dirfd(m_dd), found->d_name, &file_info, 0) != 0)
-			{
-				throw fmt::exception("System error: %d." HERE, errno);
-			}
+			verify("dir::read" HERE), ::fstatat(::dirfd(m_dd), found->d_name, &file_info, 0) == 0;
 
 			info.name = found->d_name;
 			info.is_directory = S_ISDIR(file_info.st_mode);
@@ -1131,11 +1125,22 @@ const std::string& fs::get_config_dir()
 	// Use magic static
 	static const std::string s_dir = []
 	{
-#ifdef _WIN32
-		return get_executable_dir(); // ?
-#else
 		std::string dir;
 
+#ifdef _WIN32
+		wchar_t buf[2048];
+		if (GetModuleFileName(NULL, buf, ::size32(buf)) - 1 >= ::size32(buf) - 1)
+		{
+			MessageBoxA(0, fmt::format("GetModuleFileName() failed: error %u.", GetLastError()).c_str(), "fs::get_config_dir()", MB_ICONERROR);
+			return dir; // empty
+		}
+
+		to_utf8(dir, buf); // Convert to UTF-8
+
+		std::replace(dir.begin(), dir.end(), '\\', '/');
+
+		dir.resize(dir.rfind('/') + 1);
+#else
 		if (const char* home = ::getenv("XDG_CONFIG_HOME"))
 			dir = home;
 		else if (const char* home = ::getenv("HOME"))
@@ -1148,63 +1153,85 @@ const std::string& fs::get_config_dir()
 		if (!is_dir(dir) && !create_path(dir))
 		{
 			std::printf("Failed to create configuration directory '%s' (%d).\n", dir.c_str(), errno);
-			return get_executable_dir();
 		}
+#endif
 
 		return dir;
-#endif
 	}();
 
 	return s_dir;
 }
 
-const std::string& fs::get_executable_dir()
+std::string fs::get_data_dir(const std::string& prefix, const std::string& location, const std::string& suffix)
 {
-	// Use magic static
 	static const std::string s_dir = []
 	{
-		std::string dir;
+		const std::string& dir = get_config_dir() + "data/";
 
-#ifdef _WIN32
-		wchar_t buf[2048];
-		if (GetModuleFileName(NULL, buf, ::size32(buf)) - 1 >= ::size32(buf) - 1)
+		if (!is_dir(dir) && !create_path(dir))
 		{
-			MessageBoxA(0, fmt::format("GetModuleFileName() failed: error %u.", GetLastError()).c_str(), "fs::get_executable_dir()", MB_ICONERROR);
-			return dir; // empty
-		}
-	
-		to_utf8(dir, buf); // Convert to UTF-8
-
-		std::replace(dir.begin(), dir.end(), '\\', '/');
-
-#elif __APPLE__
-		char buf[4096];
-		u32 size = sizeof(buf);
-		if (_NSGetExecutablePath(buf, &size))
-		{
-			std::printf("_NSGetExecutablePath() failed (size=0x%x).\n", size);
-			return dir; // empty
+			return get_config_dir();
 		}
 
-		dir = buf;
-#else
-		char buf[4096];
-		const auto size = ::readlink("/proc/self/exe", buf, sizeof(buf));
-		if (size <= 0 || size >= sizeof(buf))
-		{
-			std::printf("readlink(/proc/self/exe) failed (%d).\n", errno);
-			return dir; // empty
-		}
-
-		dir.assign(buf, size);
-#endif
-	
-		// Leave only path
-		dir.resize(dir.rfind('/') + 1);
 		return dir;
 	}();
 
-	return s_dir;
+	std::vector<u8> buf;
+	buf.reserve(location.size() + 1);
+
+	// Normalize location
+	for (char c : location)
+	{
+#ifdef _WIN32
+		if (c == '/' || c == '\\')
+#else
+		if (c == '/')
+#endif
+		{
+			if (buf.empty() || buf.back() != '/')
+			{
+				buf.push_back('/');
+			}
+
+			continue;
+		}
+		
+		buf.push_back(c);
+	}
+
+	// Calculate hash
+	u8 hash[20];
+	sha1(buf.data(), buf.size(), hash);
+
+	// Concatenate
+	std::string&& result = fmt::format("%s%s/%016llx%08x-%s/", s_dir, prefix, reinterpret_cast<be_t<u64>&>(hash[0]), reinterpret_cast<be_t<u32>&>(hash[8]), suffix);
+
+	if (!is_dir(result))
+	{
+		// Create dir if necessary
+		if (create_path(result))
+		{
+			// Acknowledge original location
+			file(result + ".location", rewrite).write(buf);
+		}
+	}
+
+	return result;
+}
+
+std::string fs::get_data_dir(const std::string& prefix, const std::string& path)
+{
+#ifdef _WIN32
+	const auto& delim = "/\\";
+#else
+	const auto& delim = "/";
+#endif
+
+	// Extract file name and location
+	const std::string& location = fs::get_parent_dir(path);
+	const std::size_t name_pos = path.find_first_not_of(delim, location.size());
+
+	return fs::get_data_dir(prefix, location, name_pos == -1 ? std::string{} : path.substr(name_pos));
 }
 
 void fs::remove_all(const std::string& path, bool remove_root)
@@ -1257,3 +1284,37 @@ u64 fs::get_dir_size(const std::string& path)
 
 	return result;
 }
+
+template<>
+void fmt_class_string<fs::seek_mode>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](auto arg)
+	{
+		switch (arg)
+		{
+		STR_CASE(fs::seek_mode::seek_set);
+		STR_CASE(fs::seek_mode::seek_cur);
+		STR_CASE(fs::seek_mode::seek_end);
+		}
+
+		return unknown;
+	});
+}
+
+template<>
+void fmt_class_string<fs::error>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](auto arg)
+	{
+		switch (arg)
+		{
+		case fs::error::ok: return "OK";
+
+		case fs::error::inval: return "Invalid arguments";
+		case fs::error::noent: return "Not found";
+		case fs::error::exist: return "Already exists";
+		}
+
+		return unknown;
+	});
+}

Utilities/File.h

@@ -1,17 +1,17 @@
 #pragma once
 
+#include "types.h"
+#include "bit_set.h"
+
 #include <memory>
 #include <string>
 #include <vector>
-#include <type_traits>
-
-#include "types.h"
-#include "BitSet.h"
+#include <algorithm>
 
 namespace fs
 {
 	// File open mode flags
-	enum struct open_mode : u32
+	enum class open_mode : u32
 	{
 		read,
 		write,
@@ -19,16 +19,18 @@ namespace fs
 		create,
 		trunc,
 		excl,
+
+		__bitset_enum_max
 	};
 
-	constexpr bitset_t<open_mode> read    = open_mode::read; // Enable reading
-	constexpr bitset_t<open_mode> write   = open_mode::write; // Enable writing
-	constexpr bitset_t<open_mode> append  = open_mode::append; // Always append to the end of the file
-	constexpr bitset_t<open_mode> create  = open_mode::create; // Create file if it doesn't exist
-	constexpr bitset_t<open_mode> trunc   = open_mode::trunc; // Clear opened file if it's not empty
-	constexpr bitset_t<open_mode> excl    = open_mode::excl; // Failure if the file already exists (used with `create`)
+	constexpr auto read    = +open_mode::read; // Enable reading
+	constexpr auto write   = +open_mode::write; // Enable writing
+	constexpr auto append  = +open_mode::append; // Always append to the end of the file
+	constexpr auto create  = +open_mode::create; // Create file if it doesn't exist
+	constexpr auto trunc   = +open_mode::trunc; // Clear opened file if it's not empty
+	constexpr auto excl    = +open_mode::excl; // Failure if the file already exists (used with `create`)
 
-	constexpr bitset_t<open_mode> rewrite = write + create + trunc;
+	constexpr auto rewrite = open_mode::write + open_mode::create + open_mode::trunc;
 
 	// File seek mode
 	enum class seek_mode : u32
@@ -56,7 +58,7 @@ namespace fs
 	// File handle base
 	struct file_base
 	{
-		virtual ~file_base() = default;
+		virtual ~file_base();
 
 		virtual stat_t stat() = 0;
 		virtual bool trunc(u64 length) = 0;
@@ -75,7 +77,7 @@ namespace fs
 	// Directory handle base
 	struct dir_base
 	{
-		virtual ~dir_base() = default;
+		virtual ~dir_base();
 
 		virtual bool read(dir_entry&) = 0;
 		virtual void rewind() = 0;
@@ -84,7 +86,7 @@ namespace fs
 	// Virtual device
 	struct device_base
 	{
-		virtual ~device_base() = default;
+		virtual ~device_base();
 
 		virtual bool stat(const std::string& path, stat_t& info) = 0;
 		virtual bool remove_dir(const std::string& path) = 0;
@@ -92,8 +94,9 @@ namespace fs
 		virtual bool rename(const std::string& from, const std::string& to) = 0;
 		virtual bool remove(const std::string& path) = 0;
 		virtual bool trunc(const std::string& path, u64 length) = 0;
+		virtual bool utime(const std::string& path, s64 atime, s64 mtime) = 0;
 
-		virtual std::unique_ptr<file_base> open(const std::string& path, bitset_t<open_mode> mode) = 0;
+		virtual std::unique_ptr<file_base> open(const std::string& path, bs_t<open_mode> mode) = 0;
 		virtual std::unique_ptr<dir_base> open_dir(const std::string& path) = 0;
 	};
 
@@ -139,6 +142,9 @@ namespace fs
 	// Change file size (possibly appending zeros)
 	bool truncate_file(const std::string& path, u64 length);
 
+	// Set file access/modification time
+	bool utime(const std::string& path, s64 atime, s64 mtime);
+
 	class file final
 	{
 		std::unique_ptr<file_base> m_file;
@@ -151,17 +157,19 @@ namespace fs
 		file() = default;
 
 		// Open file with specified mode
-		explicit file(const std::string& path, bitset_t<open_mode> mode = ::fs::read)
-		{
-			open(path, mode);
-		}
-
-		// Open file with specified mode
-		bool open(const std::string& path, bitset_t<open_mode> mode = ::fs::read);
+		explicit file(const std::string& path, bs_t<open_mode> mode = ::fs::read);		
 
 		// Open memory for read
 		explicit file(const void* ptr, std::size_t size);
 
+		// Open file with specified args (forward to constructor)
+		template <typename... Args>
+		bool open(Args&&... args)
+		{
+			*this = fs::file(std::forward<Args>(args)...);
+			return m_file.operator bool();
+		}
+
 		// Check whether the handle is valid (opened file)
 		explicit operator bool() const
 		{
@@ -436,8 +444,11 @@ namespace fs
 	// Get configuration directory
 	const std::string& get_config_dir();
 
-	// Get executable directory
-	const std::string& get_executable_dir();
+	// Get data/cache directory for specified prefix and suffix
+	std::string get_data_dir(const std::string& prefix, const std::string& location, const std::string& suffix);
+
+	// Get data/cache directory for specified prefix and path (suffix will be filename)
+	std::string get_data_dir(const std::string& prefix, const std::string& path);
 
 	// Delete directory and all its contents recursively
 	void remove_all(const std::string& path, bool remove_root = true);
@@ -452,8 +463,108 @@ namespace fs
 		inval,
 		noent,
 		exist,
+		acces,
 	};
 
 	// Error code returned
 	extern thread_local error g_tls_error;
+
+	template <typename T>
+	struct container_stream final : file_base
+	{
+		// T can be a reference, but this is not recommended
+		using value_type = typename std::remove_reference_t<T>::value_type;
+
+		T obj;
+		u64 pos;
+
+		container_stream(T&& obj)
+			: obj(std::forward<T>(obj))
+			, pos(0)
+		{
+		}
+
+		~container_stream() override
+		{
+		}
+
+		stat_t stat() override
+		{
+			fmt::raw_error("fs::container_stream<>::stat(): not supported");
+		}
+
+		bool trunc(u64 length) override
+		{
+			obj.resize(length);
+			return true;
+		}
+
+		u64 read(void* buffer, u64 size) override
+		{
+			const u64 end = obj.size();
+
+			if (pos < end)
+			{
+				// Get readable size
+				if (const u64 max = std::min<u64>(size, end - pos))
+				{
+					std::copy(obj.cbegin() + pos, obj.cbegin() + pos + max, static_cast<value_type*>(buffer));
+					pos = pos + max;
+					return max;
+				}
+			}
+
+			return 0;
+		}
+
+		u64 write(const void* buffer, u64 size) override
+		{
+			const u64 old_size = obj.size();
+
+			if (old_size + size < old_size)
+			{
+				fmt::raw_error("fs::container_stream<>::write(): overflow");
+			}
+
+			if (pos > old_size)
+			{
+				// Fill gap if necessary (default-initialized)
+				obj.resize(pos);
+			}
+
+			const auto src = static_cast<const value_type*>(buffer);
+
+			// Overwrite existing part
+			const u64 overlap = std::min<u64>(obj.size() - pos, size);
+			std::copy(src, src + overlap, obj.begin() + pos);
+
+			// Append new data
+			obj.insert(obj.end(), src + overlap, src + size);
+			pos += size;
+
+			return size;
+		}
+
+		u64 seek(s64 offset, seek_mode whence) override
+		{
+			return
+				whence == fs::seek_set ? pos = offset :
+				whence == fs::seek_cur ? pos = offset + pos :
+				whence == fs::seek_end ? pos = offset + size() :
+				(fmt::raw_error("fs::container_stream<>::seek(): invalid whence"), 0);
+		}
+
+		u64 size() override
+		{
+			return obj.size();
+		}
+	};
+
+	template <typename T>
+	file make_stream(T&& container = T{})
+	{
+		file result;
+		result.reset(std::make_unique<container_stream<T>>(std::forward<T>(container)));
+		return result;
+	}
 }

Utilities/JIT.cpp

@@ -7,7 +7,6 @@
 #include <array>
 
 #include "types.h"
-#include "Macro.h"
 #include "StrFmt.h"
 #include "File.h"
 #include "Log.h"
@@ -46,7 +45,7 @@ static const u64 s_memory_size = 0x20000000;
 static void* const s_memory = []() -> void*
 {
 #ifdef _WIN32
-	for (u64 addr = 0x1000000; addr <= 0x60000000; addr += 0x1000000)
+	for (u64 addr = 0x10000000; addr <= 0x60000000; addr += 0x1000000)
 	{
 		if (VirtualAlloc((void*)addr, s_memory_size, MEM_RESERVE, PAGE_NOACCESS))
 		{
@@ -60,47 +59,51 @@ static void* const s_memory = []() -> void*
 #endif
 }();
 
+// Code section
+static u8* s_code_addr;
+static u64 s_code_size;
+
 // EH frames
 static u8* s_unwind_info;
 static u64 s_unwind_size;
 
 #ifdef _WIN32
-static std::vector<RUNTIME_FUNCTION> s_unwind; // Custom .pdata section replacement
+static std::vector<std::vector<RUNTIME_FUNCTION>> s_unwind; // .pdata
 #endif
 
 // Helper class
 struct MemoryManager final : llvm::RTDyldMemoryManager
 {
-	std::unordered_map<std::string, std::uintptr_t> table;
+	std::unordered_map<std::string, std::uintptr_t>& m_link;
 
-	MemoryManager(std::unordered_map<std::string, std::uintptr_t>&& table)
-		: table(std::move(table))
+	MemoryManager(std::unordered_map<std::string, std::uintptr_t>& table)
+		: m_link(table)
 	{
 	}
 
 	[[noreturn]] static void null()
 	{
-		throw std::runtime_error("Null function" HERE);
+		fmt::throw_exception("Null function" HERE);
 	}
 
 	virtual u64 getSymbolAddress(const std::string& name) override
 	{
-		if (u64 addr = RTDyldMemoryManager::getSymbolAddress(name))
-		{
-			// This may be bad if LLVM requests some built-in functions like fma.
-			LOG_ERROR(GENERAL, "LLVM: Symbol requested %s -> 0x%016llx", name, addr);
-			return addr;
-		}
+		const auto found = m_link.find(name);
 
-		const auto found = table.find(name);
-
-		if (found != table.end())
+		if (found != m_link.end())
 		{
 			return found->second;
 		}
 
+		if (u64 addr = RTDyldMemoryManager::getSymbolAddress(name))
+		{
+			// This may be bad if LLVM requests some built-in functions like fma.
+			LOG_ERROR(GENERAL, "LLVM: Symbol requested: %s -> 0x%016llx", name, addr);
+			return addr;
+		}
+
 		// It's fine if some function is never called, for example.
-		LOG_ERROR(GENERAL, "LLVM: Linkage failed for %s", name);
+		LOG_ERROR(GENERAL, "LLVM: Symbol not found: %s", name);
 		return (u64)null;
 	}
 
@@ -121,11 +124,14 @@ struct MemoryManager final : llvm::RTDyldMemoryManager
 		if (::mprotect(m_next, size, PROT_READ | PROT_WRITE | PROT_EXEC))
 #endif
 		{
-			LOG_FATAL(GENERAL, "LLVM: Failed to allocate memory at 0x%p", m_next);
+			LOG_FATAL(GENERAL, "LLVM: Failed to allocate memory at %p", m_next);
 			return nullptr;
 		}
 
-		LOG_SUCCESS(GENERAL, "LLVM: Code section %u '%s' allocated -> 0x%p (size=0x%llx, aligned 0x%x)", sec_id, sec_name.data(), m_next, size, align);
+		s_code_addr = (u8*)m_next;
+		s_code_size = size;
+
+		LOG_NOTICE(GENERAL, "LLVM: Code section %u '%s' allocated -> %p (size=0x%llx, aligned 0x%x)", sec_id, sec_name.data(), m_next, size, align);
 		return (u8*)std::exchange(m_next, (void*)next);
 	}
 
@@ -140,23 +146,36 @@ struct MemoryManager final : llvm::RTDyldMemoryManager
 			return nullptr;
 		}
 
+		if (!is_ro)
+		{
+			LOG_ERROR(GENERAL, "LLVM: Writeable data section not supported!");
+		}
+
 #ifdef _WIN32
 		if (!VirtualAlloc(m_next, size, MEM_COMMIT, PAGE_READWRITE))
 #else
 		if (::mprotect(m_next, size, PROT_READ | PROT_WRITE))
 #endif
 		{
-			LOG_FATAL(GENERAL, "LLVM: Failed to allocate memory at 0x%p", m_next);
+			LOG_FATAL(GENERAL, "LLVM: Failed to allocate memory at %p", m_next);
 			return nullptr;
 		}
 
-		LOG_SUCCESS(GENERAL, "LLVM: Data section %u '%s' allocated -> 0x%p (size=0x%llx, aligned 0x%x, %s)", sec_id, sec_name.data(), m_next, size, align, is_ro ? "ro" : "rw");
+		LOG_NOTICE(GENERAL, "LLVM: Data section %u '%s' allocated -> %p (size=0x%llx, aligned 0x%x, %s)", sec_id, sec_name.data(), m_next, size, align, is_ro ? "ro" : "rw");
 		return (u8*)std::exchange(m_next, (void*)next);
 	}
 
 	virtual bool finalizeMemory(std::string* = nullptr) override
 	{
-		// TODO: make sections read-only when necessary
+		// TODO: make only read-only sections read-only
+//#ifdef _WIN32
+//		DWORD op;
+//		VirtualProtect(s_memory, (u64)m_next - (u64)s_memory, PAGE_READONLY, &op);
+//		VirtualProtect(s_code_addr, s_code_size, PAGE_EXECUTE_READ, &op);
+//#else
+//		::mprotect(s_memory, (u64)m_next - (u64)s_memory, PROT_READ);
+//		::mprotect(s_code_addr, s_code_size, PROT_READ | PROT_EXEC);
+//#endif
 		return false;
 	}
 
@@ -178,19 +197,24 @@ struct MemoryManager final : llvm::RTDyldMemoryManager
 	~MemoryManager()
 	{
 #ifdef _WIN32
-		if (!RtlDeleteFunctionTable(s_unwind.data()))
+		for (auto&& unwind : s_unwind)
 		{
-			LOG_FATAL(GENERAL, "RtlDeleteFunctionTable(addr=0x%p) failed! Error %u", s_unwind_info, GetLastError());
+			if (!RtlDeleteFunctionTable(unwind.data()))
+			{
+				LOG_FATAL(GENERAL, "RtlDeleteFunctionTable() failed! Error %u", GetLastError());
+			}
 		}
 
+		s_unwind.clear();
+
 		if (!VirtualFree(s_memory, 0, MEM_DECOMMIT))
 		{
-			LOG_FATAL(GENERAL, "VirtualFree(0x%p) failed! Error %u", s_memory, GetLastError());
+			LOG_FATAL(GENERAL, "VirtualFree(%p) failed! Error %u", s_memory, GetLastError());
 		}
 #else
-		if (::mprotect(s_memory, s_memory_size, PROT_NONE))
+		if (!::mmap(s_memory, s_memory_size, PROT_NONE, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0))
 		{
-			LOG_FATAL(GENERAL, "mprotect(0x%p) failed! Error %d", s_memory, errno);
+			LOG_FATAL(GENERAL, "mmap(%p) failed! Error %d", s_memory, errno);
 		}
 
 		// TODO: unregister EH frames if necessary
@@ -204,47 +228,100 @@ private:
 // Helper class
 struct EventListener final : llvm::JITEventListener
 {
+	std::string path;
+
 	virtual void NotifyObjectEmitted(const llvm::object::ObjectFile& obj, const llvm::RuntimeDyld::LoadedObjectInfo& inf) override
 	{
-		const llvm::StringRef elf = obj.getData();
-		fs::file(fs::get_config_dir() + "LLVM.obj", fs::rewrite)
-			.write(elf.data(), elf.size());
+		if (!path.empty())
+		{
+			const llvm::StringRef elf = obj.getData();
+			fs::file(path, fs::rewrite).write(elf.data(), elf.size());
+		}
 	}
 };
 
 static EventListener s_listener;
 
-jit_compiler::jit_compiler(std::unique_ptr<llvm::Module>&& _module, std::unordered_map<std::string, std::uintptr_t>&& table)
+static void dummy()
 {
-	EXPECTS(s_memory);
+}
 
-	std::string result;
+jit_compiler::jit_compiler(std::unordered_map<std::string, std::uintptr_t> init_linkage_info)
+	: m_link(std::move(init_linkage_info))
+{
+#ifdef _MSC_VER
+	m_link.emplace("__chkstk", (u64)&dummy);
+#endif
 
-	const auto module_ptr = _module.get();
+	verify(HERE), s_memory;
 
 	// Initialization
 	llvm::InitializeNativeTarget();
 	llvm::InitializeNativeTargetAsmPrinter();
 	LLVMLinkInMCJIT();
+	m_cpu = llvm::sys::getHostCPUName();
 
-	m_engine.reset(llvm::EngineBuilder(std::move(_module))
+	if (m_cpu == "skylake")
+	{
+		m_cpu = "haswell";
+	}
+
+	std::string result;
+
+	m_engine.reset(llvm::EngineBuilder(std::make_unique<llvm::Module>("", g_llvm_ctx))
 		.setErrorStr(&result)
-		.setMCJITMemoryManager(std::make_unique<MemoryManager>(std::move(table)))
+		.setMCJITMemoryManager(std::make_unique<MemoryManager>(m_link))
 		.setOptLevel(llvm::CodeGenOpt::Aggressive)
-		.setRelocationModel(llvm::Reloc::PIC_)
-		.setCodeModel((u64)s_memory <= 0x60000000 ? llvm::CodeModel::Medium : llvm::CodeModel::Large) // TODO
-		.setMCPU(llvm::sys::getHostCPUName())
+		.setCodeModel((u64)s_memory <= 0x60000000 ? llvm::CodeModel::Small : llvm::CodeModel::Large) // TODO
+		.setMCPU(m_cpu)
 		.create());
 
 	if (!m_engine)
 	{
-		throw fmt::exception("LLVM: Failed to create ExecutionEngine: %s", result);
+		fmt::throw_exception("LLVM: Failed to create ExecutionEngine: %s", result);
 	}
 
 	m_engine->setProcessAllSections(true); // ???
 	m_engine->RegisterJITEventListener(&s_listener);
+}
+
+void jit_compiler::load(std::unique_ptr<llvm::Module> module, std::unique_ptr<llvm::object::ObjectFile> object)
+{
+	s_listener.path.clear();
+
+	auto* module_ptr = module.get();
+
+	m_engine->addModule(std::move(module));
+	m_engine->addObjectFile(std::move(object));
 	m_engine->finalizeObject();
 
+	m_map.clear();
+
+	for (auto& func : module_ptr->functions())
+	{
+		const std::string& name = func.getName();
+
+		if (!m_link.count(name))
+		{
+			// Register compiled function
+			m_map[name] = m_engine->getFunctionAddress(name);
+		}
+	}
+
+	init();
+}
+
+void jit_compiler::make(std::unique_ptr<llvm::Module> module, std::string path)
+{
+	s_listener.path = std::move(path);
+
+	auto* module_ptr = module.get();
+
+	m_engine->addModule(std::move(module));
+	m_engine->finalizeObject();
+
+	m_map.clear();
+
 	for (auto& func : module_ptr->functions())
 	{
 		if (!func.empty())
@@ -259,6 +336,11 @@ jit_compiler::jit_compiler(std::unique_ptr<llvm::Module>&& _module, std::unorder
 		func.deleteBody();
 	}
 
+	init();
+}
+
+void jit_compiler::init()
+{
 #ifdef _WIN32
 	// Register .xdata UNWIND_INFO (.pdata section is empty for some reason)
 	std::set<u64> func_set;
@@ -268,26 +350,24 @@ jit_compiler::jit_compiler(std::unique_ptr<llvm::Module>&& _module, std::unorder
 		func_set.emplace(pair.second);
 	}
 
-	// Hack (cannot obtain last function size)
-	func_set.emplace(::align(*--func_set.end() + 4096, 4096));
-
 	const u64 base = (u64)s_memory;
 	const u8* bits = s_unwind_info;
 
-	s_unwind.clear();
-	s_unwind.reserve(m_map.size());
+	std::vector<RUNTIME_FUNCTION> unwind;
+	unwind.reserve(m_map.size());
 
-	for (auto it = func_set.begin(), end = --func_set.end(); it != end; it++)
+	for (const u64 addr : func_set)
 	{
-		const u64 addr = *it;
-		const u64 next = *func_set.upper_bound(addr);
+		// Find next function address
+		const auto _next = func_set.upper_bound(addr);
+		const u64 next = _next != func_set.end() ? *_next : (u64)s_code_addr + s_code_size;
 
 		// Generate RUNTIME_FUNCTION record
 		RUNTIME_FUNCTION uw;
 		uw.BeginAddress = static_cast<u32>(addr - base);
 		uw.EndAddress   = static_cast<u32>(next - base);
 		uw.UnwindData   = static_cast<u32>((u64)bits - base);
-		s_unwind.emplace_back(uw);
+		unwind.emplace_back(uw);
 
 		// Parse .xdata UNWIND_INFO record
 		const u8 flags = *bits++; // Version and flags
@@ -298,6 +378,7 @@ jit_compiler::jit_compiler(std::unique_ptr<llvm::Module>&& _module, std::unorder
 
 		if (flags != 1) 
 		{
+			// Can't happen for trivial code
 			LOG_ERROR(GENERAL, "LLVM: unsupported UNWIND_INFO version/flags (0x%02x)", flags);
 			break;
 		}
@@ -307,16 +388,18 @@ jit_compiler::jit_compiler(std::unique_ptr<llvm::Module>&& _module, std::unorder
 
 	if (s_unwind_info + s_unwind_size != bits)
 	{
-		LOG_FATAL(GENERAL, "LLVM: .xdata analysis failed! (0x%p != 0x%p)", s_unwind_info + s_unwind_size, bits);
+		LOG_ERROR(GENERAL, "LLVM: .xdata analysis failed! (%p != %p)", s_unwind_info + s_unwind_size, bits);
 	}
-	else if (!RtlAddFunctionTable(s_unwind.data(), (DWORD)s_unwind.size(), base))
+	else if (!RtlAddFunctionTable(unwind.data(), (DWORD)unwind.size(), base))
 	{
-		LOG_FATAL(GENERAL, "RtlAddFunctionTable(addr=0x%p) failed! Error %u", s_unwind_info, GetLastError());
+		LOG_ERROR(GENERAL, "RtlAddFunctionTable(%p) failed! Error %u", s_unwind_info, GetLastError());
 	}
 	else
 	{
-		LOG_SUCCESS(GENERAL, "LLVM: UNWIND_INFO registered (addr=0x%p, size=0x%llx)", s_unwind_info, s_unwind_size);
+		LOG_NOTICE(GENERAL, "LLVM: UNWIND_INFO registered (%p, size=0x%llx)", s_unwind_info, s_unwind_size);
 	}
+
+	s_unwind.emplace_back(std::move(unwind));
 #endif
 }
 

Utilities/JIT.h

@@ -8,6 +8,7 @@
 
 #include "types.h"
 
+#include "restore_new.h"
 #ifdef _MSC_VER
 #pragma warning(push, 0)
 #endif
@@ -17,6 +18,7 @@
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
+#include "define_new_memleakdetect.h"
 
 extern llvm::LLVMContext g_llvm_ctx;
 
@@ -29,10 +31,25 @@ class jit_compiler final
 	// Compiled functions
 	std::unordered_map<std::string, std::uintptr_t> m_map;
 
+	// Linkage cache
+	std::unordered_map<std::string, std::uintptr_t> m_link;
+
+	// Arch
+	std::string m_cpu;
+
+	// Internal
+	void init();
+
 public:
-	jit_compiler(std::unique_ptr<llvm::Module>&&, std::unordered_map<std::string, std::uintptr_t>&&);
+	jit_compiler(std::unordered_map<std::string, std::uintptr_t>);
 	~jit_compiler();
 
+	// Compile module
+	void make(std::unique_ptr<llvm::Module>, std::string);
+
+	// Load object
+	void load(std::unique_ptr<llvm::Module>, std::unique_ptr<llvm::object::ObjectFile>);
+
 	// Get compiled function address
 	std::uintptr_t get(const std::string& name) const
 	{
@@ -45,6 +62,12 @@ public:
 
 		return 0;
 	}
+
+	// Get CPU info
+	const std::string& cpu() const
+	{
+		return m_cpu;
+	}
 };
 
 #endif

Utilities/LICENSE_1_0.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

Utilities/Log.cpp

@@ -2,27 +2,41 @@
 #include "File.h"
 #include "StrFmt.h"
 
-#include <cstdarg>
+#include "rpcs3_version.h"
 #include <string>
 
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <chrono>
+#endif
+
 // Thread-specific log prefix provider
 thread_local std::string(*g_tls_log_prefix)() = nullptr;
 
-#ifndef _MSC_VER
-constexpr DECLARE(bijective<logs::level, const char*>::map);
-#endif
+template<>
+void fmt_class_string<logs::level>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](auto lev)
+	{
+		switch (lev)
+		{
+		case logs::level::always: return "Nothing";
+		case logs::level::fatal: return "Fatal";
+		case logs::level::error: return "Error";
+		case logs::level::todo: return "TODO";
+		case logs::level::success: return "Success";
+		case logs::level::warning: return "Warning";
+		case logs::level::notice: return "Notice";
+		case logs::level::trace: return "Trace";
+		}
+
+		return unknown;
+	});
+}
 
 namespace logs
 {
-	struct listener
-	{
-		listener() = default;
-
-		virtual ~listener() = default;
-
-		virtual void log(const channel& ch, level sev, const std::string& text) = 0;
-	};
-
 	class file_writer
 	{
 		// Could be memory-mapped file
@@ -34,10 +48,7 @@ namespace logs
 		virtual ~file_writer() = default;
 
 		// Append raw data
-		void log(const std::string& text);
-
-		// Get current file size (may be used by secondary readers)
-		std::size_t size() const;
+		void log(const char* text, std::size_t size);
 	};
 
 	struct file_listener : public file_writer, public listener
@@ -46,17 +57,52 @@ namespace logs
 			: file_writer(name)
 			, listener()
 		{
+			const std::string& start = fmt::format("\xEF\xBB\xBF" "RPCS3 v%s\n", rpcs3::version.to_string());
+			file_writer::log(start.data(), start.size());
 		}
 
 		// Encode level, current thread name, channel name and write log message
-		virtual void log(const channel& ch, level sev, const std::string& text) override;
+		virtual void log(u64 stamp, const message& msg, const std::string& prefix, const std::string& text) override;
 	};
 
-	static file_listener& get_logger()
+	static file_listener* get_logger()
 	{
 		// Use magic static
 		static file_listener logger("RPCS3.log");
-		return logger;
+		return &logger;
+	}
+
+	static u64 get_stamp()
+	{
+		static struct time_initializer
+		{
+#ifdef _WIN32
+			LARGE_INTEGER freq;
+			LARGE_INTEGER start;
+
+			time_initializer()
+			{
+				QueryPerformanceFrequency(&freq);
+				QueryPerformanceCounter(&start);
+			}
+#else
+			std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+#endif
+
+			u64 get() const
+			{
+#ifdef _WIN32
+				LARGE_INTEGER now;
+				QueryPerformanceCounter(&now);
+				const LONGLONG diff = now.QuadPart - start.QuadPart;
+				return diff / freq.QuadPart * 1'000'000 + diff % freq.QuadPart * 1'000'000 / freq.QuadPart;
+#else
+				return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start).count();
+#endif
+			}
+		} timebase{};
+
+		return timebase.get();
 	}
 
 	channel GENERAL(nullptr, level::notice);
@@ -69,12 +115,39 @@ namespace logs
 	channel ARMv7("ARMv7");
 }
 
-void logs::channel::broadcast(const logs::channel& ch, logs::level sev, const char* fmt...)
+logs::listener::~listener()
 {
-	va_list args;
-	va_start(args, fmt);
-	get_logger().log(ch, sev, fmt::unsafe_vformat(fmt, args));
-	va_end(args);
+}
+
+void logs::listener::add(logs::listener* _new)
+{
+	// Get first (main) listener
+	listener* lis = get_logger();
+
+	// Install new listener at the end of linked list
+	while (lis->m_next || !lis->m_next.compare_and_swap_test(nullptr, _new))
+	{
+		lis = lis->m_next;
+	}
+}
+
+void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u64* args)
+{
+	// Get timestamp
+	const u64 stamp = get_stamp();
+
+	std::string text; fmt::raw_append(text, fmt, sup, args);
+	std::string prefix(g_tls_log_prefix ? g_tls_log_prefix() : "");
+
+	// Get first (main) listener
+	listener* lis = get_logger();
+	
+	// Send message to all listeners
+	while (lis)
+	{
+		lis->log(stamp, *this, prefix, text);
+		lis = lis->m_next;
+	}
 }
 
 [[noreturn]] extern void catch_all_exceptions();
@@ -85,7 +158,7 @@ logs::file_writer::file_writer(const std::string& name)
 	{
 		if (!m_file.open(fs::get_config_dir() + name, fs::rewrite + fs::append))
 		{
-			throw fmt::exception("Can't create log file %s (error %d)", name, fs::g_tls_error);
+			fmt::throw_exception("Can't create log file %s (error %s)", name, fs::g_tls_error);
 		}
 	}
 	catch (...)
@@ -94,54 +167,54 @@ logs::file_writer::file_writer(const std::string& name)
 	}
 }
 
-void logs::file_writer::log(const std::string& text)
+void logs::file_writer::log(const char* text, std::size_t size)
 {
-	m_file.write(text);
+	m_file.write(text, size);
 }
 
-std::size_t logs::file_writer::size() const
+void logs::file_listener::log(u64 stamp, const logs::message& msg, const std::string& prefix, const std::string& _text)
 {
-	return m_file.pos();
-}
-
-void logs::file_listener::log(const logs::channel& ch, logs::level sev, const std::string& text)
-{
-	std::string msg; msg.reserve(text.size() + 200);
+	std::string text; text.reserve(prefix.size() + _text.size() + 200);
 
 	// Used character: U+00B7 (Middle Dot)
-	switch (sev)
+	switch (msg.sev)
 	{
-	case level::always:  msg = u8"·A "; break;
-	case level::fatal:   msg = u8"·F "; break;
-	case level::error:   msg = u8"·E "; break;
-	case level::todo:    msg = u8"·U "; break;
-	case level::success: msg = u8"·S "; break;
-	case level::warning: msg = u8"·W "; break;
-	case level::notice:  msg = u8"·! "; break;
-	case level::trace:   msg = u8"·T "; break;
+	case level::always:  text = u8"·A "; break;
+	case level::fatal:   text = u8"·F "; break;
+	case level::error:   text = u8"·E "; break;
+	case level::todo:    text = u8"·U "; break;
+	case level::success: text = u8"·S "; break;
+	case level::warning: text = u8"·W "; break;
+	case level::notice:  text = u8"·! "; break;
+	case level::trace:   text = u8"·T "; break;
 	}
 
-	// TODO: print time?
+	// Print miscosecond timestamp
+	const u64 hours = stamp / 3600'000'000;
+	const u64 mins = (stamp % 3600'000'000) / 60'000'000;
+	const u64 secs = (stamp % 60'000'000) / 1'000'000;
+	const u64 frac = (stamp % 1'000'000);
+	fmt::append(text, "%u:%02u:%02u.%06u ", hours, mins, secs, frac);
 
-	if (auto prefix = g_tls_log_prefix)
+	if (prefix.size() > 0)
 	{
-		msg += '{';
-		msg += prefix();
-		msg += "} ";
+		text += "{";
+		text += prefix;
+		text += "} ";
 	}
 	
-	if (ch.name)
+	if (msg.ch->name)
 	{
-		msg += ch.name;
-		msg += sev == level::todo ? " TODO: " : ": ";
+		text += msg.ch->name;
+		text += msg.sev == level::todo ? " TODO: " : ": ";
 	}
-	else if (sev == level::todo)
+	else if (msg.sev == level::todo)
 	{
-		msg += "TODO: ";
+		text += "TODO: ";
 	}
 	
-	msg += text;
-	msg += '\n';
+	text += _text;
+	text += '\n';
 
-	file_writer::log(msg);
+	file_writer::log(text.data(), text.size());
 }

Utilities/Log.h

@@ -2,6 +2,7 @@
 
 #include "types.h"
 #include "Atomic.h"
+#include "StrFmt.h"
 
 namespace logs
 {
@@ -17,6 +18,37 @@ namespace logs
 		trace, // lowest level (usually disabled)
 	};
 
+	struct channel;
+
+	// Message information (temporary data)
+	struct message
+	{
+		const channel* ch;
+		level sev;
+
+		// Send log message to global logger instance
+		void broadcast(const char*, const fmt_type_info*, const u64*);
+	};
+
+	class listener
+	{
+		// Next listener (linked list)
+		atomic_t<listener*> m_next{};
+
+		friend struct message;
+
+	public:
+		constexpr listener() = default;
+
+		virtual ~listener();
+
+		// Process log message
+		virtual void log(u64 stamp, const message& msg, const std::string& prefix, const std::string& text) = 0;
+
+		// Add new listener
+		static void add(listener*);
+	};
+
 	struct channel
 	{
 		// Channel prefix (added to every log message)
@@ -34,19 +66,17 @@ namespace logs
 
 		// Formatting function
 		template<typename... Args>
-		void format(level sev, const char* fmt, const Args&... args) const
+		SAFE_BUFFERS FORCE_INLINE void format(level sev, const char* fmt, const Args&... args) const
 		{
-#ifdef _MSC_VER
-			if (sev <= enabled)
-#else
-			if (__builtin_expect(sev <= enabled, 0))
-#endif
-				broadcast(*this, sev, fmt, ::unveil<Args>::get(args)...);
+			if (UNLIKELY(sev <= enabled))
+			{
+				message{this, sev}.broadcast(fmt, fmt::get_type_info<fmt_unveil_t<Args>...>(), fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+			}
 		}
 
 #define GEN_LOG_METHOD(_sev)\
 		template<typename... Args>\
-		void _sev(const char* fmt, const Args&... args) const\
+		SAFE_BUFFERS void _sev(const char* fmt, const Args&... args) const\
 		{\
 			return format<Args...>(level::_sev, fmt, args...);\
 		}
@@ -60,10 +90,6 @@ namespace logs
 		GEN_LOG_METHOD(trace)
 
 #undef GEN_LOG_METHOD
-
-	private:
-		// Send log message to global logger instance
-		static void broadcast(const channel& ch, level sev, const char* fmt...);
 	};
 
 	/* Small set of predefined channels */
@@ -78,28 +104,12 @@ namespace logs
 	extern channel ARMv7;
 }
 
-template<>
-struct bijective<logs::level, const char*>
-{
-	static constexpr bijective_pair<logs::level, const char*> map[]
-	{
-		{ logs::level::always, "Nothing" },
-		{ logs::level::fatal, "Fatal" },
-		{ logs::level::error, "Error" },
-		{ logs::level::todo, "TODO" },
-		{ logs::level::success, "Success" },
-		{ logs::level::warning, "Warning" },
-		{ logs::level::notice, "Notice" },
-		{ logs::level::trace, "Trace" },
-	};
-};
-
 // Legacy:
 
-#define LOG_SUCCESS(ch, fmt, ...) logs::ch.success(fmt, ##__VA_ARGS__)
-#define LOG_NOTICE(ch, fmt, ...)  logs::ch.notice (fmt, ##__VA_ARGS__)
-#define LOG_WARNING(ch, fmt, ...) logs::ch.warning(fmt, ##__VA_ARGS__)
-#define LOG_ERROR(ch, fmt, ...)   logs::ch.error  (fmt, ##__VA_ARGS__)
-#define LOG_TODO(ch, fmt, ...)    logs::ch.todo   (fmt, ##__VA_ARGS__)
-#define LOG_TRACE(ch, fmt, ...)   logs::ch.trace  (fmt, ##__VA_ARGS__)
-#define LOG_FATAL(ch, fmt, ...)   logs::ch.fatal  (fmt, ##__VA_ARGS__)
+#define LOG_SUCCESS(ch, fmt, ...) logs::ch.success("" fmt, ##__VA_ARGS__)
+#define LOG_NOTICE(ch, fmt, ...)  logs::ch.notice ("" fmt, ##__VA_ARGS__)
+#define LOG_WARNING(ch, fmt, ...) logs::ch.warning("" fmt, ##__VA_ARGS__)
+#define LOG_ERROR(ch, fmt, ...)   logs::ch.error  ("" fmt, ##__VA_ARGS__)
+#define LOG_TODO(ch, fmt, ...)    logs::ch.todo   ("" fmt, ##__VA_ARGS__)
+#define LOG_TRACE(ch, fmt, ...)   logs::ch.trace  ("" fmt, ##__VA_ARGS__)
+#define LOG_FATAL(ch, fmt, ...)   logs::ch.fatal  ("" fmt, ##__VA_ARGS__)

Utilities/MTProgressDialog.h

@@ -61,7 +61,7 @@ public:
 		Show();
 	}
 
-	force_inline void Update(const u8 thread_id, const u64 value, const wxString& msg)
+	void Update(const u8 thread_id, const u64 value, const wxString& msg)
 	{
 		if(thread_id > m_cores) return;
 

Utilities/Macro.h

@@ -1,83 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <exception>
-
-template<typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
-constexpr T align(const T& value, std::uint64_t align)
-{
-	return static_cast<T>((value + (align - 1)) & ~(align - 1));
-}
-
-template<typename To, typename From>
-constexpr To narrow_impl(const To& result, const From& value, const char* message)
-{
-	return static_cast<From>(result) != value ? throw std::runtime_error(message) : result;
-}
-
-// Narrow cast (similar to gsl::narrow) with fixed message
-template<typename To, typename From>
-constexpr auto narrow(const From& value, const char* fixed_msg = "::narrow() failed") -> decltype(static_cast<To>(static_cast<From>(std::declval<To>())))
-{
-	return narrow_impl(static_cast<To>(value), value, fixed_msg);
-}
-
-// Return 32 bit .size() for container
-template<typename CT>
-constexpr auto size32(const CT& container, const char* fixed_msg = "::size32() failed") -> decltype(static_cast<std::uint32_t>(container.size()))
-{
-	return narrow<std::uint32_t>(container.size(), fixed_msg);
-}
-
-// Return 32 bit size for an array
-template<typename T, std::size_t Size>
-constexpr std::uint32_t size32(const T(&)[Size])
-{
-	static_assert(Size <= UINT32_MAX, "size32() error: too big");
-	return static_cast<std::uint32_t>(Size);
-}
-
-#define CHECK_SIZE(type, size) static_assert(sizeof(type) == size, "Invalid " #type " type size")
-#define CHECK_ALIGN(type, align) static_assert(alignof(type) == align, "Invalid " #type " type alignment")
-#define CHECK_MAX_SIZE(type, size) static_assert(sizeof(type) <= size, #type " type size is too big")
-#define CHECK_SIZE_ALIGN(type, size, align) CHECK_SIZE(type, size); CHECK_ALIGN(type, align)
-#define CHECK_STORAGE(type, storage) static_assert(sizeof(type) <= sizeof(storage) && alignof(type) <= alignof(decltype(storage)), #type " is too small")
-
-// Return 32 bit sizeof() to avoid widening/narrowing conversions with size_t
-#define SIZE_32(type) static_cast<std::uint32_t>(sizeof(type))
-
-// Return 32 bit alignof() to avoid widening/narrowing conversions with size_t
-#define ALIGN_32(type) static_cast<std::uint32_t>(alignof(type))
-
-// Return 32 bit custom offsetof()
-#define OFFSET_32(type, x) static_cast<std::uint32_t>(reinterpret_cast<std::uintptr_t>(&reinterpret_cast<const volatile char&>(reinterpret_cast<type*>(0ull)->x)))
-
-// Sometimes to avoid writing std::remove_cv_t<>, example: std::is_same<CV T1, CV T2>
-#define CV const volatile
-
-#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)
-
-// Macro set, wraps an expression into lambda
-#define WRAP_EXPR(expr, ...) [&](__VA_ARGS__) { return expr; }
-#define COPY_EXPR(expr, ...) [=](__VA_ARGS__) { return expr; }
-#define PURE_EXPR(expr, ...) [] (__VA_ARGS__) { return expr; }
-
-#define return_ return
-
-#define HERE "\n(in file " __FILE__ ":" STRINGIZE(__LINE__) ")"
-
-// Ensure that the expression is evaluated to true. Always evaluated and allowed to have side effects (unlike assert() macro).
-#define VERIFY(expr) do { if (!(expr)) throw std::runtime_error("Verification failed: " #expr HERE); } while (0)
-
-// EXPECTS() and ENSURES() are intended to check function arguments and results.
-// Expressions are not guaranteed to evaluate.
-#define EXPECTS(expr) do { if (!(expr)) throw std::runtime_error("Precondition failed: " #expr HERE); } while (0)
-#define ENSURES(expr) do { if (!(expr)) throw std::runtime_error("Postcondition failed: " #expr HERE); } while (0)
-
-#define DECLARE(...) decltype(__VA_ARGS__) __VA_ARGS__
-
-#define STR_CASE(value) case value: return #value

Utilities/Platform.cpp

@@ -1,51 +0,0 @@
-#include "Platform.h"
-
-#ifdef __APPLE__
-#include <sys/types.h>
-#include <sys/_types/_timespec.h>
-#include <mach/mach.h>
-#include <mach/clock.h>
-#include <mach/mach_time.h>
-#undef CPU_STATE_MAX
-
-#define MT_NANO (+1.0E-9)
-#define MT_GIGA UINT64_C(1000000000)
-
-// TODO create a list of timers,
-static double mt_timebase = 0.0;
-static uint64_t mt_timestart = 0;
-
-// TODO be more careful in a multithreaded environement
-int clock_gettime(clockid_t clk_id, struct timespec *tp)
-{
-    kern_return_t retval = KERN_SUCCESS;
-    if( clk_id == TIMER_ABSTIME)
-    {
-        if (!mt_timestart) { // only one timer, initilized on the first call to the TIMER
-            mach_timebase_info_data_t tb = { 0 };
-            mach_timebase_info(&tb);
-            mt_timebase = tb.numer;
-            mt_timebase /= tb.denom;
-            mt_timestart = mach_absolute_time();
-        }
-
-        double diff = (mach_absolute_time() - mt_timestart) * mt_timebase;
-        tp->tv_sec = diff * MT_NANO;
-        tp->tv_nsec = diff - (tp->tv_sec * MT_GIGA);
-    }
-    else // other clk_ids are mapped to the coresponding mach clock_service
-    {
-        clock_serv_t cclock;
-        mach_timespec_t mts;
-
-        host_get_clock_service(mach_host_self(), clk_id, &cclock);
-        retval = clock_get_time(cclock, &mts);
-        mach_port_deallocate(mach_task_self(), cclock);
-
-        tp->tv_sec = mts.tv_sec;
-        tp->tv_nsec = mts.tv_nsec;
-    }
-
-    return retval;
-}
-#endif /* __APPLE__ */

Utilities/Platform.h

@@ -1,122 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <immintrin.h>
-#include <emmintrin.h>
-
-#define IS_LE_MACHINE 1
-#define IS_BE_MACHINE 0
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#else
-#include <x86intrin.h>
-#endif
-
-#ifdef _MSC_VER
-#define ASSUME(cond) __assume(cond)
-#define LIKELY(cond) (cond)
-#define UNLIKELY(cond) (cond)
-#else
-#define ASSUME(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)
-#define LIKELY(cond) __builtin_expect(!!(cond), 1)
-#define UNLIKELY(cond) __builtin_expect(!!(cond), 0)
-#endif
-
-// Some platforms don't support thread_local well yet.
-#ifndef _MSC_VER
-#define thread_local __thread
-#endif
-
-#ifdef _MSC_VER
-#define never_inline __declspec(noinline)
-#else
-#define never_inline __attribute__((noinline))
-#endif
-
-#ifdef _MSC_VER
-#define force_inline __forceinline
-#else
-#define force_inline __attribute__((always_inline)) inline
-#endif
-
-#if defined(__GNUG__)
-
-#include <stdlib.h>
-
-#define _fpclass(x) std::fpclassify(x)
-#define INFINITE 0xFFFFFFFF
-
-#ifdef __APPLE__
-
-// XXX only supports a single timer
-#define TIMER_ABSTIME -1
-/* The opengroup spec isn't clear on the mapping from REALTIME to CALENDAR
- being appropriate or not.
- http://pubs.opengroup.org/onlinepubs/009695299/basedefs/time.h.html */
-#define CLOCK_REALTIME  1 // #define CALENDAR_CLOCK 1 from mach/clock_types.h
-#define CLOCK_MONOTONIC 0 // #define SYSTEM_CLOCK 0
-
-typedef int clockid_t;
-
-/* the mach kernel uses struct mach_timespec, so struct timespec
-    is loaded from <sys/_types/_timespec.h> for compatability */
-// struct timespec { time_t tv_sec; long tv_nsec; };
-
-int clock_gettime(clockid_t clk_id, struct timespec *tp);
-
-#endif /* __APPLE__ */
-#endif /* __GNUG__ */
-
-inline std::uint32_t cntlz32(std::uint32_t arg)
-{
-#if defined(_MSC_VER)
-	unsigned long res;
-	return _BitScanReverse(&res, arg) ? res ^ 31 : 32;
-#else
-	return arg ? __builtin_clzll(arg) - 32 : 32;
-#endif
-}
-
-inline std::uint64_t cntlz64(std::uint64_t arg)
-{
-#if defined(_MSC_VER)
-	unsigned long res;
-	return _BitScanReverse64(&res, arg) ? res ^ 63 : 64;
-#else
-	return arg ? __builtin_clzll(arg) : 64;
-#endif
-}
-
-// Helper function, used by ""_u16, ""_u32, ""_u64
-constexpr std::uint8_t to_u8(char c)
-{
-	return static_cast<std::uint8_t>(c);
-}
-
-// Convert 2-byte string to u16 value like reinterpret_cast does
-constexpr std::uint16_t operator""_u16(const char* s, std::size_t length)
-{
-	return length != 2 ? throw s :
-#if IS_LE_MACHINE == 1
-		to_u8(s[1]) << 8 | to_u8(s[0]);
-#endif
-}
-
-// Convert 4-byte string to u32 value like reinterpret_cast does
-constexpr std::uint32_t operator""_u32(const char* s, std::size_t length)
-{
-	return length != 4 ? throw s :
-#if IS_LE_MACHINE == 1
-		to_u8(s[3]) << 24 | to_u8(s[2]) << 16 | to_u8(s[1]) << 8 | to_u8(s[0]);
-#endif
-}
-
-// Convert 8-byte string to u64 value like reinterpret_cast does
-constexpr std::uint64_t operator""_u64(const char* s, std::size_t length)
-{
-	return length != 8 ? throw s :
-#if IS_LE_MACHINE == 1
-		static_cast<std::uint64_t>(to_u8(s[7]) << 24 | to_u8(s[6]) << 16 | to_u8(s[5]) << 8 | to_u8(s[4])) << 32 | to_u8(s[3]) << 24 | to_u8(s[2]) << 16 | to_u8(s[1]) << 8 | to_u8(s[0]);
-#endif
-}

Utilities/Semaphore.cpp

@@ -1,90 +0,0 @@
-#include "Utilities/Semaphore.h"
-
-#include <mutex>
-#include <condition_variable>
-
-struct benaphore::internal
-{
-	std::mutex mutex;
-
-	std::size_t acq_order{};
-	std::size_t rel_order{};
-
-	std::condition_variable cond;
-};
-
-void benaphore::wait_hard()
-{
-	initialize_once();
-
-	std::unique_lock<std::mutex> lock(m_data->mutex);
-
-	// Notify non-zero waiter queue size
-	if (m_value.exchange(-1) == 1)
-	{
-		// Return immediately (acquired)
-		m_value = 0;
-		return;
-	}
-
-	// Remember the order
-	const std::size_t order = ++m_data->acq_order;
-
-	// Wait for the appropriate rel_order (TODO)
-	while (m_data->rel_order < order)
-	{
-		m_data->cond.wait(lock);
-	}
-
-	if (order == m_data->acq_order && m_data->acq_order == m_data->rel_order)
-	{
-		// Cleaup
-		m_data->acq_order = 0;
-		m_data->rel_order = 0;
-		m_value.compare_and_swap(-1, 0);
-	}
-}
-
-void benaphore::post_hard()
-{
-	initialize_once();
-
-	std::unique_lock<std::mutex> lock(m_data->mutex);
-
-	if (m_value.compare_and_swap(0, 1) != -1)
-	{
-		// Do nothing (released)
-		return;
-	}
-
-	if (m_data->acq_order == m_data->rel_order)
-	{
-		m_value = 1;
-		return;
-	}
-
-	// Awake one thread
-	m_data->rel_order += 1;
-		
-	// Unlock and notify
-	lock.unlock();
-	m_data->cond.notify_one();
-}
-
-void benaphore::initialize_once()
-{
-	if (UNLIKELY(!m_data))
-	{
-		auto ptr = new benaphore::internal;
-
-		if (!m_data.compare_and_swap_test(nullptr, ptr))
-		{
-			delete ptr;
-		}
-	}
-}
-
-benaphore::~benaphore()
-{
-	delete m_data;
-}

Utilities/Semaphore.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "types.h"
-#include "Atomic.h"
-#include "Platform.h"
-
-// Binary semaphore
-class benaphore
-{
-	struct internal;
-
-	// Reserved value (-1) enforces *_hard() calls
-	atomic_t<u32> m_value{};
-
-	atomic_t<internal*> m_data{};
-
-	void wait_hard();
-	void post_hard();
-
-public:
-	constexpr benaphore() = default;
-
-	~benaphore();
-
-	// Initialize internal data
-	void initialize_once();
-
-	void wait()
-	{
-		if (UNLIKELY(!m_value.compare_and_swap_test(1, 0)))
-		{
-			wait_hard();
-		}
-	}
-
-	bool try_wait()
-	{
-		return m_value.compare_and_swap_test(1, 0);
-	}
-
-	void post()
-	{
-		if (UNLIKELY(!m_value.compare_and_swap_test(0, 1)))
-		{
-			post_hard();
-		}
-	}
-};

Utilities/SharedMutex.cpp

@@ -1,187 +0,0 @@
-#include "SharedMutex.h"
-
-#include <mutex>
-#include <condition_variable>
-
-struct shared_mutex::internal
-{
-	std::mutex mutex;
-
-	std::size_t rq_size{}; // Reader queue size (threads waiting on m_rcv)
-	std::size_t wq_size{}; // Writer queue size (threads waiting on m_wcv and m_ocv)
-
-	std::condition_variable rcv; // Reader queue
-	std::condition_variable wcv; // Writer queue
-	std::condition_variable ocv; // For current exclusive owner
-};
-
-void shared_mutex::lock_shared_hard()
-{
-	initialize_once();
-
-	std::unique_lock<std::mutex> lock(m_data->mutex);
-
-	// Validate
-	if ((m_ctrl & SM_INVALID_BIT) != 0) throw std::runtime_error("shared_mutex::lock_shared(): Invalid bit");
-	if ((m_ctrl & SM_READER_MASK) == 0) throw std::runtime_error("shared_mutex::lock_shared(): No readers");
-
-	// Notify non-zero reader queue size
-	m_ctrl |= SM_WAITERS_BIT, m_data->rq_size++;
-
-	// Fix excess reader count
-	if ((--m_ctrl & SM_READER_MASK) == 0 && m_data->wq_size)
-	{
-		// Notify exclusive owner
-		m_data->ocv.notify_one();
-	}
-
-	// Obtain the reader lock
-	while (true)
-	{
-		const auto ctrl = m_ctrl.load();
-
-		// Check writers and reader limit
-		if (m_data->wq_size || (ctrl & ~SM_WAITERS_BIT) >= SM_READER_MAX)
-		{
-			m_data->rcv.wait(lock);
-			continue;
-		}
-
-		if (m_ctrl.compare_and_swap_test(ctrl, ctrl + 1))
-		{
-			break;
-		}
-	}
-
-	if (!--m_data->rq_size && !m_data->wq_size)
-	{
-		m_ctrl &= ~SM_WAITERS_BIT;
-	}
-}
-
-void shared_mutex::unlock_shared_notify()
-{
-	initialize_once();
-
-	std::unique_lock<std::mutex> lock(m_data->mutex);
-
-	if ((m_ctrl & SM_READER_MASK) == 0 && m_data->wq_size)
-	{
-		// Notify exclusive owner
-		lock.unlock();
-		m_data->ocv.notify_one();
-	}
-	else if (m_data->rq_size)
-	{
-		// Notify other readers
-		lock.unlock();
-		m_data->rcv.notify_one();
-	}
-}
-
-void shared_mutex::lock_hard()
-{
-	initialize_once();
-
-	std::unique_lock<std::mutex> lock(m_data->mutex);
-
-	// Validate
-	if ((m_ctrl & SM_INVALID_BIT) != 0) throw std::runtime_error("shared_mutex::lock(): Invalid bit");
-
-	// Notify non-zero writer queue size
-	m_ctrl |= SM_WAITERS_BIT, m_data->wq_size++;
-
-	// Obtain the writer lock
-	while (true)
-	{
-		const auto ctrl = m_ctrl.load();
-
-		if (ctrl & SM_WRITER_LOCK)
-		{
-			m_data->wcv.wait(lock);
-			continue;
-		}
-
-		if (m_ctrl.compare_and_swap_test(ctrl, ctrl | SM_WRITER_LOCK))
-		{
-			break;
-		}
-	}
-
-	// Wait for remaining readers
-	while ((m_ctrl & SM_READER_MASK) != 0)
-	{
-		m_data->ocv.wait(lock);
-	}
-
-	if (!--m_data->wq_size && !m_data->rq_size)
-	{
-		m_ctrl &= ~SM_WAITERS_BIT;
-	}
-}
-
-void shared_mutex::unlock_notify()
-{
-	initialize_once();
-
-	std::unique_lock<std::mutex> lock(m_data->mutex);
-
-	if (m_data->wq_size)
-	{
-		// Notify next exclusive owner
-		lock.unlock();
-		m_data->wcv.notify_one();
-	}
-	else if (m_data->rq_size)
-	{
-		// Notify all readers
-		lock.unlock();
-		m_data->rcv.notify_all();
-	}
-}
-
-void shared_mutex::lock_upgrade_hard()
-{
-	unlock_shared();
-	lock();
-}
-
-void shared_mutex::lock_degrade_hard()
-{
-	initialize_once();
-
-	std::unique_lock<std::mutex> lock(m_data->mutex);
-
-	m_ctrl -= SM_WRITER_LOCK - 1;
-
-	if (m_data->rq_size)
-	{
-		// Notify all readers
-		lock.unlock();
-		m_data->rcv.notify_all();
-	}
-	else if (m_data->wq_size)
-	{
-		// Notify next exclusive owner
-		lock.unlock();
-		m_data->wcv.notify_one();
-	}
-}
-
-void shared_mutex::initialize_once()
-{
-	if (UNLIKELY(!m_data))
-	{
-		auto ptr = new shared_mutex::internal;
-
-		if (!m_data.compare_and_swap_test(nullptr, ptr))
-		{
-			delete ptr;
-		}
-	}
-}
-
-shared_mutex::~shared_mutex()
-{
-	delete m_data;
-}

Utilities/SharedMutex.h

@@ -1,180 +0,0 @@
-#pragma once
-
-#include "types.h"
-#include "Atomic.h"
-#include "Platform.h"
-
-//! An attempt to create effective implementation of "shared mutex", lock-free in optimistic case.
-//! All locking and unlocking may be done by a single LOCK XADD or LOCK CMPXCHG instruction.
-//! MSVC implementation of std::shared_timed_mutex seems suboptimal.
-//! std::shared_mutex is not available until C++17.
-class shared_mutex final
-{
-	enum : u32
-	{
-		SM_WRITER_LOCK = 1u << 31, // Exclusive lock flag, must be MSB
-		SM_WAITERS_BIT = 1u << 30, // Flag set if m_wq_size or m_rq_size is non-zero
-		SM_INVALID_BIT = 1u << 29, // Unreachable reader count bit (may be set by incorrect unlock_shared() call)
-
-		SM_READER_MASK = SM_WAITERS_BIT - 1, // Valid reader count bit mask
-		SM_READER_MAX  = 1u << 24, // Max reader count
-	};
-
-	atomic_t<u32> m_ctrl{}; // Control variable: reader count | SM_* flags
-
-	struct internal;
-
-	atomic_t<internal*> m_data{}; // Internal data
-
-	void lock_shared_hard();
-	void unlock_shared_notify();
-
-	void lock_hard();
-	void unlock_notify();
-
-	void lock_upgrade_hard();
-	void lock_degrade_hard();
-
-public:
-	constexpr shared_mutex() = default;
-
-	// Initialize internal data
-	void initialize_once();
-
-	~shared_mutex();
-
-	bool try_lock_shared()
-	{
-		const u32 ctrl = m_ctrl.load();
-
-		return ctrl < SM_READER_MAX && m_ctrl.compare_and_swap_test(ctrl, ctrl + 1);
-	}
-
-	void lock_shared()
-	{
-		// Optimization: unconditional increment, compensated later
-		if (UNLIKELY(m_ctrl++ >= SM_READER_MAX))
-		{
-			lock_shared_hard();
-		}
-	}
-
-	void unlock_shared()
-	{
-		if (UNLIKELY(m_ctrl-- >= SM_READER_MAX))
-		{
-			unlock_shared_notify();
-		}
-	}
-
-	bool try_lock()
-	{
-		return !m_ctrl && m_ctrl.compare_and_swap_test(0, SM_WRITER_LOCK);
-	}
-
-	void lock()
-	{
-		if (UNLIKELY(!m_ctrl.compare_and_swap_test(0, SM_WRITER_LOCK)))
-		{
-			lock_hard();
-		}
-	}
-
-	void unlock()
-	{
-		m_ctrl &= ~SM_WRITER_LOCK;
-
-		if (UNLIKELY(m_ctrl))
-		{
-			unlock_notify();
-		}
-	}
-
-	bool try_lock_upgrade()
-	{
-		return m_ctrl == 1 && m_ctrl.compare_and_swap_test(1, SM_WRITER_LOCK);
-	}
-
-	bool try_lock_degrade()
-	{
-		return m_ctrl == SM_WRITER_LOCK && m_ctrl.compare_and_swap_test(SM_WRITER_LOCK, 1);
-	}
-
-	void lock_upgrade()
-	{
-		if (UNLIKELY(!m_ctrl.compare_and_swap_test(1, SM_WRITER_LOCK)))
-		{
-			lock_upgrade_hard();
-		}
-	}
-
-	void lock_degrade()
-	{
-		if (UNLIKELY(!m_ctrl.compare_and_swap_test(SM_WRITER_LOCK, 1)))
-		{
-			lock_degrade_hard();
-		}
-	}
-};
-
-//! Simplified shared (reader) lock implementation.
-//! std::shared_lock may be used instead if necessary.
-class reader_lock final
-{
-	shared_mutex& m_mutex;
-
-public:
-	reader_lock(const reader_lock&) = delete;
-
-	reader_lock(shared_mutex& mutex)
-		: m_mutex(mutex)
-	{
-		m_mutex.lock_shared();
-	}
-
-	~reader_lock()
-	{
-		m_mutex.unlock_shared();
-	}
-};
-
-//! Simplified exclusive (writer) lock implementation.
-//! std::lock_guard may or std::unique_lock be used instead if necessary.
-class writer_lock final
-{
-	shared_mutex& m_mutex;
-
-public:
-	writer_lock(const writer_lock&) = delete;
-
-	writer_lock(shared_mutex& mutex)
-		: m_mutex(mutex)
-	{
-		m_mutex.lock();
-	}
-
-	~writer_lock()
-	{
-		m_mutex.unlock();
-	}
-};
-
-// Exclusive (writer) lock in the scope of shared (reader) lock.
-class upgraded_lock final
-{
-	shared_mutex& m_mutex;
-
-public:
-	upgraded_lock(const writer_lock&) = delete;
-
-	upgraded_lock(shared_mutex& mutex)
-		: m_mutex(mutex)
-	{
-		m_mutex.lock_upgrade();
-	}
-
-	~upgraded_lock()
-	{
-		m_mutex.lock_degrade();
-	}
-};

Utilities/SleepQueue.h

@@ -1,85 +0,0 @@
-#pragma once
-
-#include <deque>
-
-// Tag used in sleep_entry<> constructor
-static struct defer_sleep_tag {} constexpr defer_sleep{};
-
-// Define sleep queue as std::deque with T* pointers, T - thread type
-template<typename T> using sleep_queue = std::deque<T*>;
-
-// Automatic object handling a thread pointer (T*) in the sleep queue
-// Sleep is called in the constructor (if not null)
-// Awake is called in the destructor (if not null)
-// Sleep queue is actually std::deque with pointers, be careful about the lifetime
-template<typename T, void(T::*Sleep)() = &T::sleep, void(T::*Awake)() = &T::awake>
-class sleep_entry final
-{
-	sleep_queue<T>& m_queue;
-	T& m_thread;
-
-public:
-	// Constructor; enter() not called
-	sleep_entry(sleep_queue<T>& queue, T& entry, const defer_sleep_tag&)
-		: m_queue(queue)
-		, m_thread(entry)
-	{
-		if (Sleep) (m_thread.*Sleep)();
-	}
-
-	// Constructor; calls enter()
-	sleep_entry(sleep_queue<T>& queue, T& entry)
-		: sleep_entry(queue, entry, defer_sleep)
-	{
-		enter();
-	}
-
-	// Destructor; calls leave()
-	~sleep_entry()
-	{
-		leave();
-		if (Awake) (m_thread.*Awake)();
-	}
-
-	// Add thread to the sleep queue
-	void enter()
-	{
-		for (auto t : m_queue)
-		{
-			if (t == &m_thread)
-			{
-				// Already exists, is it an error?
-				return;
-			}
-		}
-		
-		m_queue.emplace_back(&m_thread);
-	}
-
-	// Remove thread from the sleep queue
-	void leave()
-	{
-		for (auto it = m_queue.begin(), end = m_queue.end(); it != end; it++)
-		{
-			if (*it == &m_thread)
-			{
-				m_queue.erase(it);
-				return;
-			}
-		}
-	}
-
-	// Check whether the thread exists in the sleep queue
-	explicit operator bool() const
-	{
-		for (auto it = m_queue.begin(), end = m_queue.end(); it != end; it++)
-		{
-			if (*it == &m_thread)
-			{
-				return true;
-			}
-		}
-
-		return false;
-	}
-};

Utilities/StrFmt.cpp

@@ -1,73 +1,296 @@
 #include "StrFmt.h"
 #include "BEType.h"
 #include "StrUtil.h"
+#include "cfmt.h"
 
-#include <cassert>
-#include <array>
-#include <memory>
 #include <algorithm>
 
-std::string v128::to_hex() const
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <errno.h>
+#endif
+
+template <>
+void fmt_class_string<std::pair<const fmt_type_info*, u64>>::format(std::string& out, u64 arg)
 {
-	return fmt::format("%016llx%016llx", _u64[1], _u64[0]);
-}
+	// Dynamic format arg
+	const auto& pair = get_object(arg);
 
-std::string v128::to_xyzw() const
-{
-	return fmt::format("x: %g y: %g z: %g w: %g", _f[3], _f[2], _f[1], _f[0]);
-}
-
-std::string fmt::unsafe_vformat(const char* fmt, va_list _args) noexcept
-{
-	// Fixed stack buffer for the first attempt
-	std::array<char, 4096> fixed_buf;
-
-	// Possibly dynamically allocated buffer for the second attempt
-	std::unique_ptr<char[]> buf;
-
-	// Pointer to the current buffer
-	char* buf_addr = fixed_buf.data();
-
-	for (std::size_t buf_size = fixed_buf.size();;)
+	if (pair.first)
 	{
-		va_list args;
-		va_copy(args, _args);
-
-#ifndef _MSC_VER
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wformat-security"
-#endif
-		const std::size_t len = std::vsnprintf(buf_addr, buf_size, fmt, args);
-#ifndef _MSC_VER
-#pragma GCC diagnostic pop
-#endif
-		va_end(args);
-
-		assert(len <= INT_MAX);
-
-		if (len < buf_size)
-		{
-			return{ buf_addr, len };
-		}
-
-		buf.reset(buf_addr = new char[buf_size = len + 1]);
+		pair.first->fmt_string(out, pair.second);
 	}
 }
 
-std::string fmt::unsafe_format(const char* fmt...) noexcept
+void fmt_class_string<const void*>::format(std::string& out, u64 arg)
 {
-	va_list args;
-	va_start(args, fmt);
-	auto result = unsafe_vformat(fmt, args);
-	va_end(args);
-
-	return result;
+	if (arg)
+	{
+		fmt::append(out, "%p", reinterpret_cast<const void*>(static_cast<std::uintptr_t>(arg)));
+	}
+	else
+	{
+		out += "(NULL)";		
+	}
 }
 
-fmt::exception_base::exception_base(const char* fmt...)
-	: std::runtime_error((va_start(m_args, fmt), unsafe_vformat(fmt, m_args)))
+void fmt_class_string<const char*>::format(std::string& out, u64 arg)
 {
-	va_end(m_args);
+	if (arg)
+	{
+		out += reinterpret_cast<const char*>(static_cast<std::uintptr_t>(arg));
+	}
+	else
+	{
+		out += "(NULL)";
+	}
+}
+
+template <>
+void fmt_class_string<std::string>::format(std::string& out, u64 arg)
+{
+	out += get_object(arg).c_str(); // TODO?
+}
+
+template <>
+void fmt_class_string<std::vector<char>>::format(std::string& out, u64 arg)
+{
+	const std::vector<char>& obj = get_object(arg);
+	out.append(obj.cbegin(), obj.cend());
+}
+
+template <>
+void fmt_class_string<char>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#hhx", static_cast<char>(arg));
+}
+
+template <>
+void fmt_class_string<uchar>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#hhx", static_cast<uchar>(arg));
+}
+
+template <>
+void fmt_class_string<schar>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#hhx", static_cast<schar>(arg));
+}
+
+template <>
+void fmt_class_string<short>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#hx", static_cast<short>(arg));
+}
+
+template <>
+void fmt_class_string<ushort>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#hx", static_cast<ushort>(arg));
+}
+
+template <>
+void fmt_class_string<int>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#x", static_cast<int>(arg));
+}
+
+template <>
+void fmt_class_string<uint>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#x", static_cast<uint>(arg));
+}
+
+template <>
+void fmt_class_string<long>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#lx", static_cast<long>(arg));
+}
+
+template <>
+void fmt_class_string<ulong>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#lx", static_cast<ulong>(arg));
+}
+
+template <>
+void fmt_class_string<llong>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#llx", static_cast<llong>(arg));
+}
+
+template <>
+void fmt_class_string<ullong>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%#llx", static_cast<ullong>(arg));
+}
+
+template <>
+void fmt_class_string<float>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%gf", static_cast<float>(reinterpret_cast<f64&>(arg)));
+}
+
+template <>
+void fmt_class_string<double>::format(std::string& out, u64 arg)
+{
+	fmt::append(out, "%g", reinterpret_cast<f64&>(arg));
+}
+
+template <>
+void fmt_class_string<bool>::format(std::string& out, u64 arg)
+{
+	out += arg ? "true" : "false";
+}
+
+template <>
+void fmt_class_string<v128>::format(std::string& out, u64 arg)
+{
+	const v128& vec = get_object(arg);
+	fmt::append(out, "0x%016llx%016llx", vec._u64[1], vec._u64[0]);
+}
+
+namespace fmt
+{
+	void raw_error(const char* msg)
+	{
+		throw std::runtime_error{msg};
+	}
+
+	void raw_verify_error(const char* msg, const fmt_type_info* sup, u64 arg)
+	{
+		std::string out{"Verification failed"};
+
+		// Print error code (may be irrelevant)
+#ifdef _WIN32
+		if (DWORD error = GetLastError())
+		{
+			fmt::append(out, " (e=%#x)", error);
+		}
+#else
+		if (int error = errno)
+		{
+			fmt::append(out, " (e=%d)", error);
+		}
+#endif
+
+		if (sup)
+		{
+			out += " (";
+			sup->fmt_string(out, arg); // Print value
+			out += ")";
+		}
+
+		if (msg)
+		{
+			out += ": ";
+			out += msg;
+		}
+
+		throw std::runtime_error{out};
+	}
+
+	void raw_narrow_error(const char* msg, const fmt_type_info* sup, u64 arg)
+	{
+		std::string out{"Narrow error"};
+
+		if (sup)
+		{
+			out += " (";
+			sup->fmt_string(out, arg); // Print value
+			out += ")";
+		}
+
+		if (msg)
+		{
+			out += ": ";
+			out += msg;
+		}
+
+		throw std::range_error{out};
+	}
+
+	// Hidden template
+	template <typename T>
+	void raw_throw_exception(const char* fmt, const fmt_type_info* sup, const u64* args)
+	{
+		std::string out;
+		raw_append(out, fmt, sup, args);
+		throw T{out};
+	}
+
+	// Explicit instantiations (not exhaustive)
+	template void raw_throw_exception<std::runtime_error>(const char*, const fmt_type_info*, const u64*);
+	template void raw_throw_exception<std::logic_error>(const char*, const fmt_type_info*, const u64*);
+	template void raw_throw_exception<std::domain_error>(const char*, const fmt_type_info*, const u64*);
+	template void raw_throw_exception<std::invalid_argument>(const char*, const fmt_type_info*, const u64*);
+	template void raw_throw_exception<std::out_of_range>(const char*, const fmt_type_info*, const u64*);
+	template void raw_throw_exception<std::range_error>(const char*, const fmt_type_info*, const u64*);
+	template void raw_throw_exception<std::overflow_error>(const char*, const fmt_type_info*, const u64*);
+	template void raw_throw_exception<std::underflow_error>(const char*, const fmt_type_info*, const u64*);
+
+	struct cfmt_src;
+}
+
+// Temporary implementation
+struct fmt::cfmt_src
+{
+	const fmt_type_info* sup;
+	const u64* args;
+
+	bool test(std::size_t index) const
+	{
+		if (!sup[index].fmt_string)
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	template <typename T>
+	T get(std::size_t index) const
+	{
+		return *reinterpret_cast<const T*>(reinterpret_cast<const u8*>(args + index));
+	}
+
+	void skip(std::size_t extra)
+	{
+		++sup += extra;
+		++args += extra;
+	}
+
+	std::size_t fmt_string(std::string& out, std::size_t extra) const
+	{
+		const std::size_t start = out.size();
+		sup[extra].fmt_string(out, args[extra]);
+		return out.size() - start;
+	}
+
+	// Returns type size (0 if unknown, pointer, unsigned, assumed max)
+	std::size_t type(std::size_t extra) const
+	{
+// Hack: use known function pointers to determine type
+#define TYPE(type) \
+	if (sup[extra].fmt_string == &fmt_class_string<type>::format) return sizeof(type);
+
+		TYPE(int);
+		TYPE(llong);
+		TYPE(schar);
+		TYPE(short);
+		if (std::is_signed<char>::value) TYPE(char);
+		TYPE(long);
+
+#undef TYPE
+
+		return 0;
+	}
+};
+
+void fmt::raw_append(std::string& out, const char* fmt, const fmt_type_info* sup, const u64* args) noexcept
+{
+	cfmt_append(out, fmt, cfmt_src{sup, args});
 }
 
 std::string fmt::replace_first(const std::string& src, const std::string& from, const std::string& to)
@@ -82,7 +305,7 @@ std::string fmt::replace_first(const std::string& src, const std::string& from,
 	return (pos ? src.substr(0, pos) + to : to) + std::string(src.c_str() + pos + from.length());
 }
 
-std::string fmt::replace_all(const std::string &src, const std::string& from, const std::string& to)
+std::string fmt::replace_all(const std::string& src, const std::string& from, const std::string& to)
 {
 	std::string target = src;
 	for (auto pos = target.find(from); pos != std::string::npos; pos = target.find(from, pos + 1))
@@ -102,7 +325,7 @@ std::vector<std::string> fmt::split(const std::string& source, std::initializer_
 
 	for (size_t cursor_end = 0; cursor_end < source.length(); ++cursor_end)
 	{
-		for (auto &separator : separators)
+		for (auto& separator : separators)
 		{
 			if (strncmp(source.c_str() + cursor_end, separator.c_str(), separator.length()) == 0)
 			{
@@ -111,7 +334,7 @@ std::vector<std::string> fmt::split(const std::string& source, std::initializer_
 					result.push_back(candidate);
 
 				cursor_begin = cursor_end + separator.length();
-				cursor_end = cursor_begin - 1;
+				cursor_end   = cursor_begin - 1;
 				break;
 			}
 		}
@@ -130,7 +353,7 @@ std::string fmt::trim(const std::string& source, const std::string& values)
 	std::size_t begin = source.find_first_not_of(values);
 
 	if (begin == source.npos)
-		return{};
+		return {};
 
 	return source.substr(begin, source.find_last_not_of(values) + 1);
 }
@@ -143,7 +366,7 @@ std::string fmt::to_upper(const std::string& string)
 	return result;
 }
 
-bool fmt::match(const std::string &source, const std::string &mask)
+bool fmt::match(const std::string& source, const std::string& mask)
 {
 	std::size_t source_position = 0, mask_position = 0;
 

Utilities/StrFmt.h

@@ -1,52 +1,265 @@
 #pragma once
 
-#include <cstdarg>
-#include <exception>
-#include <string>
-
-#include "Platform.h"
 #include "types.h"
 
+#include <exception>
+#include <stdexcept>
+#include <string>
+
 namespace fmt
 {
-	std::string unsafe_format(const char* fmt...) noexcept;
-	std::string unsafe_vformat(const char*, va_list) noexcept;
+	template <typename... Args>
+	static std::string format(const char*, const Args&...);
+}
 
-	// Formatting function
-	template<typename... Args>
-	inline std::string format(const char* fmt, const Args&... args)
+template <typename T, typename>
+struct fmt_unveil
+{
+	static_assert(sizeof(T) > 0, "fmt_unveil<>: cannot pass forward-declared object");
+
+	using type = T;
+
+	static inline u64 get(const T& arg)
 	{
-		return unsafe_format(fmt, ::unveil<Args>::get(args)...);
+		return reinterpret_cast<std::uintptr_t>(&arg);
 	}
 
-	// Helper class
-	class exception_base : public std::runtime_error
+	// Temporary value container (can possibly be created by other fmt_unveil<> specializations)
+	struct u64_wrapper
 	{
-		// Helper (there is no other room)
-		va_list m_args;
+		T arg;
 
-	protected:
-		// Internal formatting constructor
-		exception_base(const char* fmt...);
-	};
-
-	// Exception type derived from std::runtime_error with formatting constructor
-	class exception : public exception_base
-	{
-	public:
-		template<typename... Args>
-		exception(const char* fmt, const Args&... args)
-			: exception_base(fmt, ::unveil<Args>::get(args)...)
+		// Allow implicit conversion
+		operator u64() const
 		{
+			return reinterpret_cast<std::uintptr_t>(&arg);
 		}
 	};
 
-	// Narrow cast (similar to gsl::narrow) with exception message formatting
-	template<typename To, typename From, typename... Args>
-	inline auto narrow(const char* format_str, const From& value, const Args&... args) -> decltype(static_cast<To>(static_cast<From>(std::declval<To>())))
+	// This overload resolution takes the precedence
+	static inline u64_wrapper get(T&& arg)
 	{
-		const auto result = static_cast<To>(value);
-		if (static_cast<From>(result) != value) throw fmt::exception(format_str, value, args...);
+		return u64_wrapper{std::move(arg)};
+	}
+};
+
+template <typename T>
+struct fmt_unveil<T, std::enable_if_t<std::is_integral<T>::value && sizeof(T) <= 8 && alignof(T) <= 8>>
+{
+	using type = T;
+
+	static inline u64 get(T arg)
+	{
+		return static_cast<T>(arg);
+	}
+};
+
+template <typename T>
+struct fmt_unveil<T, std::enable_if_t<std::is_floating_point<T>::value && sizeof(T) <= 8 && alignof(T) <= 8>>
+{
+	using type = T;
+
+	// Convert FP to f64 and reinterpret (TODO?)
+	static inline u64 get(const f64 arg)
+	{
+		return *reinterpret_cast<const u64*>(reinterpret_cast<const u8*>(&arg));
+	}
+};
+
+template <typename T>
+struct fmt_unveil<T, std::enable_if_t<std::is_enum<T>::value>>
+{
+	using type = T;
+
+	static inline u64 get(T arg)
+	{
+		return static_cast<std::underlying_type_t<T>>(arg);
+	}
+};
+
+template <typename T>
+struct fmt_unveil<T*, void>
+{
+	using type = const T*;
+
+	static inline u64 get(const T* arg)
+	{
+		return reinterpret_cast<std::uintptr_t>(arg);
+	}
+};
+
+template <typename T, std::size_t N>
+struct fmt_unveil<T[N], void>
+{
+	using type = const T*;
+
+	static inline u64 get(const T* arg)
+	{
+		return reinterpret_cast<std::uintptr_t>(arg);
+	}
+};
+
+template <>
+struct fmt_unveil<b8, void>
+{
+	using type = bool;
+
+	static inline u64 get(const b8& value)
+	{
+		return fmt_unveil<bool>::get(value);
+	}
+};
+
+// String type format provider, also type classifier (format() called if an argument is formatted as "%s")
+template <typename T, typename = void>
+struct fmt_class_string
+{
+	// Formatting function (must be explicitly specialized)
+	static void format(std::string& out, u64 arg);
+
+	// Helper typedef (visible in format())
+	using type = T;
+
+	// Helper function (converts arg to object reference)
+	static SAFE_BUFFERS FORCE_INLINE const T& get_object(u64 arg)
+	{
+		return *reinterpret_cast<const T*>(static_cast<std::uintptr_t>(arg));
+	}
+
+	// Helper function (safely converts arg to enum value)
+	static SAFE_BUFFERS FORCE_INLINE void format_enum(std::string& out, u64 arg, const char* (*get)(T value))
+	{
+		const auto value = static_cast<std::underlying_type_t<T>>(arg);
+
+		// Check narrowing
+		if (static_cast<u64>(value) == arg)
+		{
+			if (const char* str = get(static_cast<T>(value)))
+			{
+				out += str;
+				return;
+			}
+		}
+
+		// Fallback to underlying type formatting
+		fmt_class_string<std::underlying_type_t<T>>::format(out, static_cast<u64>(value));
+	}
+
+	// Helper function (bitset formatting)
+	static SAFE_BUFFERS FORCE_INLINE void format_bitset(std::string& out, u64 arg, const char* prefix, const char* delim, const char* suffix, void (*fmt)(std::string&, u64))
+	{
+		// Start from raw value
+		fmt_class_string<u64>::format(out, arg);
+
+		out += prefix;
+
+		for (u64 i = 0; i < 63; i++)
+		{
+			const u64 mask = 1ull << i;
+
+			if (arg & mask)
+			{
+				fmt(out, i);
+
+				if (arg >> (i + 1))
+				{
+					out += delim;
+				}
+			}
+		}
+
+		if (arg & (1ull << 63))
+		{
+			fmt(out, 63);
+		}
+
+		out += suffix;
+	}
+
+	// Helper constant (may be used in format_enum as lambda return value)
+	static constexpr const char* unknown = nullptr;
+};
+
+template <>
+struct fmt_class_string<const void*, void>
+{
+	static void format(std::string& out, u64 arg);
+};
+
+template <typename T>
+struct fmt_class_string<T*, void> : fmt_class_string<const void*, void>
+{
+	// Classify all pointers as const void*
+};
+
+template <>
+struct fmt_class_string<const char*, void>
+{
+	static void format(std::string& out, u64 arg);
+};
+
+template <>
+struct fmt_class_string<char*, void> : fmt_class_string<const char*>
+{
+	// Classify char* as const char*
+};
+
+struct fmt_type_info
+{
+	decltype(&fmt_class_string<int>::format) fmt_string;
+
+	template <typename T>
+	static constexpr fmt_type_info make()
+	{
+		return fmt_type_info
+		{
+			&fmt_class_string<T>::format,
+		};
+	}
+};
+
+// Argument array type (each element generated via fmt_unveil<>)
+template <typename... Args>
+using fmt_args_t = const u64(&&)[sizeof...(Args) + 1];
+
+namespace fmt
+{
+	template <typename... Args>
+	SAFE_BUFFERS FORCE_INLINE const fmt_type_info* get_type_info()
+	{
+		// Constantly initialized null-terminated list of type-specific information
+		static constexpr fmt_type_info result[sizeof...(Args) + 1]{fmt_type_info::make<Args>()...};
+
 		return result;
 	}
+
+	// Internal formatting function
+	void raw_append(std::string& out, const char*, const fmt_type_info*, const u64*) noexcept;
+
+	// Formatting function
+	template <typename... Args>
+	SAFE_BUFFERS FORCE_INLINE void append(std::string& out, const char* fmt, const Args&... args)
+	{
+		raw_append(out, fmt, fmt::get_type_info<fmt_unveil_t<Args>...>(), fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+	}
+
+	// Formatting function
+	template <typename... Args>
+	SAFE_BUFFERS FORCE_INLINE std::string format(const char* fmt, const Args&... args)
+	{
+		std::string result;
+		append<Args...>(result, fmt, args...);
+		return result;
+	}
+
+	// Internal exception message formatting template, must be explicitly specialized or instantiated in cpp to minimize code bloat
+	template <typename T>
+	[[noreturn]] void raw_throw_exception(const char*, const fmt_type_info*, const u64*);
+
+	// Throw exception with formatting
+	template <typename T = std::runtime_error, typename... Args>
+	[[noreturn]] SAFE_BUFFERS FORCE_INLINE void throw_exception(const char* fmt, const Args&... args)
+	{
+		raw_throw_exception<T>(fmt, fmt::get_type_info<fmt_unveil_t<Args>...>(), fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+	}
 }

Utilities/StrUtil.h

@@ -7,8 +7,8 @@
 #include <functional>
 
 // Copy null-terminated string from std::string to char array with truncation
-template<std::size_t N>
-inline void strcpy_trunc(char(&dst)[N], const std::string& src)
+template <std::size_t N>
+inline void strcpy_trunc(char (&dst)[N], const std::string& src)
 {
 	const std::size_t count = src.size() >= N ? N - 1 : src.size();
 	std::memcpy(dst, src.c_str(), count);
@@ -16,8 +16,8 @@ inline void strcpy_trunc(char(&dst)[N], const std::string& src)
 }
 
 // Copy null-terminated string from char array to another char array with truncation
-template<std::size_t N, std::size_t N2>
-inline void strcpy_trunc(char(&dst)[N], const char(&src)[N2])
+template <std::size_t N, std::size_t N2>
+inline void strcpy_trunc(char (&dst)[N], const char (&src)[N2])
 {
 	const std::size_t count = N2 >= N ? N - 1 : N2;
 	std::memcpy(dst, src, count);
@@ -27,10 +27,10 @@ inline void strcpy_trunc(char(&dst)[N], const char(&src)[N2])
 namespace fmt
 {
 	std::string replace_first(const std::string& src, const std::string& from, const std::string& to);
-	std::string replace_all(const std::string &src, const std::string& from, const std::string& to);
+	std::string replace_all(const std::string& src, const std::string& from, const std::string& to);
 
-	template<size_t list_size>
-	std::string replace_all(std::string src, const std::pair<std::string, std::string>(&list)[list_size])
+	template <size_t list_size>
+	std::string replace_all(std::string src, const std::pair<std::string, std::string> (&list)[list_size])
 	{
 		for (size_t pos = 0; pos < src.length(); ++pos)
 		{
@@ -53,8 +53,8 @@ namespace fmt
 		return src;
 	}
 
-	template<size_t list_size>
-	std::string replace_all(std::string src, const std::pair<std::string, std::function<std::string()>>(&list)[list_size])
+	template <size_t list_size>
+	std::string replace_all(std::string src, const std::pair<std::string, std::function<std::string()>> (&list)[list_size])
 	{
 		for (size_t pos = 0; pos < src.length(); ++pos)
 		{
@@ -80,17 +80,17 @@ namespace fmt
 	std::vector<std::string> split(const std::string& source, std::initializer_list<std::string> separators, bool is_skip_empty = true);
 	std::string trim(const std::string& source, const std::string& values = " \t");
 
-	template<typename T>
+	template <typename T>
 	std::string merge(const T& source, const std::string& separator)
 	{
 		if (!source.size())
 		{
-			return{};
+			return {};
 		}
 
 		std::string result;
 
-		auto it = source.begin();
+		auto it  = source.begin();
 		auto end = source.end();
 		for (--end; it != end; ++it)
 		{
@@ -100,23 +100,23 @@ namespace fmt
 		return result + source.back();
 	}
 
-	template<typename T>
+	template <typename T>
 	std::string merge(std::initializer_list<T> sources, const std::string& separator)
 	{
 		if (!sources.size())
 		{
-			return{};
+			return {};
 		}
 
 		std::string result;
 		bool first = true;
 
-		for (auto &v : sources)
+		for (auto& v : sources)
 		{
 			if (first)
 			{
 				result = fmt::merge(v, separator);
-				first = false;
+				first  = false;
 			}
 			else
 			{
@@ -129,5 +129,5 @@ namespace fmt
 
 	std::string to_upper(const std::string& string);
 
-	bool match(const std::string &source, const std::string &mask);
+	bool match(const std::string& source, const std::string& mask);
 }

Utilities/Thread.h

@@ -1,11 +1,14 @@
 #pragma once
 
+#include "types.h"
+#include "Atomic.h"
+
 #include <exception>
 #include <string>
 #include <memory>
 
-#include "Platform.h"
-#include "Atomic.h"
+#include "sema.h"
+#include "cond.h"
 
 // Will report exception and call std::abort() if put in catch(...)
 [[noreturn]] void catch_all_exceptions();
@@ -17,19 +20,19 @@ class task_stack
 	{
 		std::unique_ptr<task_base> next;
 
-		virtual ~task_base() = default;
+		virtual ~task_base();
 
-		virtual void exec()
+		virtual void invoke()
 		{
 			if (next)
 			{
-				next->exec();
+				next->invoke();
 			}
 		}
 	};
 
-	template<typename F>
-	struct task_type : task_base
+	template <typename F>
+	struct task_type final : task_base
 	{
 		std::remove_reference_t<F> func;
 
@@ -38,10 +41,10 @@ class task_stack
 		{
 		}
 
-		void exec() override
+		void invoke() final override
 		{
 			func();
-			task_base::exec();
+			task_base::invoke();
 		}
 	};
 
@@ -50,7 +53,7 @@ class task_stack
 public:
 	task_stack() = default;
 
-	template<typename F>
+	template <typename F>
 	task_stack(F&& func)
 		: m_stack(new task_type<F>(std::forward<F>(func)))
 	{
@@ -70,11 +73,11 @@ public:
 		m_stack.reset();
 	}
 
-	void exec() const
+	void invoke() const
 	{
 		if (m_stack)
 		{
-			m_stack->exec();
+			m_stack->invoke();
 		}
 	}
 };
@@ -82,20 +85,32 @@ public:
 // Thread control class
 class thread_ctrl final
 {
-public: // TODO
-	struct internal;
-
-private:
+	// Current thread
 	static thread_local thread_ctrl* g_tls_this_thread;
 
-	// Thread handle storage
-	std::aligned_storage_t<16> m_thread;
+	// Self pointer
+	std::shared_ptr<thread_ctrl> m_self;
 
-	// Thread join contention counter
-	atomic_t<u32> m_joining{};
+	// Thread handle (platform-specific)
+	atomic_t<std::uintptr_t> m_thread{0};
 
-	// Thread internals
-	atomic_t<internal*> m_data{};
+	// Thread mutex
+	mutable semaphore<> m_mutex;
+
+	// Thread condition variable
+	cond_variable m_cond;
+
+	// Thread flags
+	atomic_t<u32> m_signal{0};
+
+	// Thread joining condition variable
+	cond_variable m_jcv;
+
+	// Remotely set or caught exception
+	std::exception_ptr m_exception;
+
+	// Thread initial task or atexit task
+	task_stack m_task;
 
 	// Fixed name
 	std::string m_name;
@@ -107,19 +122,19 @@ private:
 	void initialize();
 
 	// Called at the thread end
-	void finalize() noexcept;
+	void finalize(std::exception_ptr) noexcept;
 
-	// Get atexit function
-	void push_atexit(task_stack);
+	// Add task (atexit)
+	static void _push(task_stack);
 
-	// Start waiting
-	void wait_start(u64 timeout);
+	// Internal waiting function, may throw. Infinite value is -1.
+	static bool _wait_for(u64 usec);
 
-	// Proceed waiting
-	bool wait_wait(u64 timeout);
+	// Internal throwing function. Mutex must be locked and will be unlocked.
+	[[noreturn]] void _throw();
 
-	// Check exception
-	void test();
+	// Internal notification function
+	void _notify(cond_variable thread_ctrl::*);
 
 public:
 	thread_ctrl(std::string&& name);
@@ -134,120 +149,57 @@ public:
 		return m_name;
 	}
 
-	// Initialize internal data
-	void initialize_once();
+	// Get exception
+	std::exception_ptr get_exception() const;
+
+	// Set exception
+	void set_exception(std::exception_ptr ptr);
 
 	// Get thread result (may throw, simultaneous joining allowed)
 	void join();
 
-	// Lock thread mutex
-	void lock();
-
-	// Lock conditionally (double-checked)
-	template<typename F>
-	bool lock_if(F&& pred)
-	{
-		if (pred())
-		{
-			lock();
-
-			try
-			{
-				if (LIKELY(pred()))
-				{
-					return true;
-				}
-				else
-				{
-					unlock();
-					return false;
-				}
-			}
-			catch (...)
-			{
-				unlock();
-				throw;
-			}
-		}
-		else
-		{
-			return false;
-		}
-	}
-
-	// Unlock thread mutex (internal data must be initialized)
-	void unlock();
-
-	// Lock, unlock, notify the thread (required if the condition changed locklessly)
-	void lock_notify();
-
-	// Notify the thread (internal data must be initialized)
+	// Notify the thread
 	void notify();
 
-	// Set exception (internal data must be initialized, thread mutex must be locked)
-	void set_exception(std::exception_ptr);
-
-	// Current thread sleeps for specified amount of microseconds.
-	// Wrapper for std::this_thread::sleep, doesn't require valid thread_ctrl.
-	[[deprecated]] static void sleep(u64 useconds);
-
-	// Wait until pred(). Abortable, may throw. Thread must be locked.
-	// Timeout in microseconds (zero means infinite).
-	template<typename F>
-	static inline auto wait(u64 useconds, F&& pred)
+	// Wait once with timeout. Abortable, may throw. May spuriously return false.
+	static inline bool wait_for(u64 usec)
 	{
-		g_tls_this_thread->wait_start(useconds);
-
-		while (true)
-		{
-			g_tls_this_thread->test();
-
-			if (auto&& result = pred())
-			{
-				return result;
-			}
-			else if (!g_tls_this_thread->wait_wait(useconds) && useconds)
-			{
-				return result;
-			}
-		}
+		return _wait_for(usec);
 	}
 
-	// Wait until pred(). Abortable, may throw. Thread must be locked.
-	template<typename F>
-	static inline auto wait(F&& pred)
-	{
-		while (true)
-		{
-			g_tls_this_thread->test();
-
-			if (auto&& result = pred())
-			{
-				return result;
-			}
-
-			g_tls_this_thread->wait_wait(0);
-		}
-	}
-
-	// Wait once. Thread must be locked.
+	// Wait. Abortable, may throw.
 	static inline void wait()
 	{
-		g_tls_this_thread->test();
-		g_tls_this_thread->wait_wait(0);
-		g_tls_this_thread->test();
+		_wait_for(-1);
 	}
 
-	// Wait unconditionally until aborted. Thread must be locked.
+	// Wait until pred(). Abortable, may throw.
+	template<typename F, typename RT = std::result_of_t<F()>>
+	static inline RT wait(F&& pred)
+	{
+		while (true)
+		{
+			if (RT result = pred())
+			{
+				return result;
+			}
+
+			_wait_for(-1);
+		}
+	}
+
+	// Wait eternally until aborted.
 	[[noreturn]] static inline void eternalize()
 	{
 		while (true)
 		{
-			g_tls_this_thread->test();
-			g_tls_this_thread->wait_wait(0);
+			_wait_for(-1);
 		}
 	}
 
+	// Test exception (may throw).
+	static void test();
+
 	// Get current thread (may be nullptr)
 	static thread_ctrl* get_current()
 	{
@@ -258,22 +210,29 @@ public:
 	template<typename F>
 	static inline void atexit(F&& func)
 	{
-		return g_tls_this_thread->push_atexit(std::forward<F>(func));
+		_push(std::forward<F>(func));
+	}
+
+	// Create detached named thread
+	template<typename N, typename F>
+	static inline void spawn(N&& name, F&& func)
+	{
+		auto out = std::make_shared<thread_ctrl>(std::forward<N>(name));
+
+		thread_ctrl::start(out, std::forward<F>(func));
 	}
 
 	// Named thread factory
 	template<typename N, typename F>
-	static inline std::shared_ptr<thread_ctrl> spawn(N&& name, F&& func)
+	static inline void spawn(std::shared_ptr<thread_ctrl>& out, N&& name, F&& func)
 	{
-		auto ctrl = std::make_shared<thread_ctrl>(std::forward<N>(name));
+		out = std::make_shared<thread_ctrl>(std::forward<N>(name));
 
-		thread_ctrl::start(ctrl, std::forward<F>(func));
-
-		return ctrl;
+		thread_ctrl::start(out, std::forward<F>(func));
 	}
 };
 
-class named_thread : public std::enable_shared_from_this<named_thread>
+class named_thread
 {
 	// Pointer to managed resource (shared with actual thread)
 	std::shared_ptr<thread_ctrl> m_thread;
@@ -290,8 +249,8 @@ public:
 	virtual std::string get_name() const;
 
 protected:
-	// Start thread (cannot be called from the constructor: should throw bad_weak_ptr in such case)
-	void start();
+	// Start thread (cannot be called from the constructor: should throw in such case)
+	void start_thread(const std::shared_ptr<void>& _this);
 
 	// Thread task (called in the thread)
 	virtual void on_task() = 0;
@@ -301,9 +260,9 @@ protected:
 
 public:
 	// ID initialization
-	virtual void on_init()
+	virtual void on_init(const std::shared_ptr<void>& _this)
 	{
-		start();
+		return start_thread(_this);
 	}
 
 	// ID finalization
@@ -313,42 +272,19 @@ public:
 	}
 
 	// Access thread_ctrl
-	thread_ctrl* operator->() const
+	thread_ctrl* get() const
 	{
 		return m_thread.get();
 	}
-};
 
-// Simple thread mutex locker
-class thread_lock final
-{
-	thread_ctrl* m_thread;
-
-public:
-	thread_lock(const thread_lock&) = delete;
-
-	// Lock specified thread
-	thread_lock(thread_ctrl* thread)
-		: m_thread(thread)
+	void join() const
 	{
-		m_thread->lock();
+		return m_thread->join();
 	}
 
-	// Lock specified named_thread
-	thread_lock(named_thread& thread)
-		: thread_lock(thread.operator->())
+	void notify() const
 	{
-	}
-
-	// Lock current thread
-	thread_lock()
-		: thread_lock(thread_ctrl::get_current())
-	{
-	}
-
-	~thread_lock()
-	{
-		m_thread->unlock();
+		return m_thread->notify();
 	}
 };
 
@@ -360,8 +296,8 @@ class scope_thread final
 public:
 	template<typename N, typename F>
 	scope_thread(N&& name, F&& func)
-		: m_thread(thread_ctrl::spawn(std::forward<N>(name), std::forward<F>(func)))
 	{
+		thread_ctrl::spawn(m_thread, std::forward<N>(name), std::forward<F>(func));
 	}
 
 	// Deleted copy/move constructors + copy/move operators
@@ -372,4 +308,10 @@ public:
 	{
 		m_thread->join();
 	}
+
+	// Access thread_ctrl
+	thread_ctrl* get() const
+	{
+		return m_thread.get();
+	}
 };

Utilities/Timer.h

@@ -6,8 +6,8 @@ class Timer
 {
 private:
 	bool m_stopped;
-	std::chrono::high_resolution_clock::time_point m_start;
-	std::chrono::high_resolution_clock::time_point m_end;
+	std::chrono::steady_clock::time_point m_start;
+	std::chrono::steady_clock::time_point m_end;
 
 public:
 	Timer() : m_stopped(false)
@@ -17,13 +17,13 @@ public:
 	void Start()
 	{
 		m_stopped = false;
-		m_start = std::chrono::high_resolution_clock::now();
+		m_start = std::chrono::steady_clock::now();
 	}
 
 	void Stop()
 	{
 		m_stopped = true;
-		m_end = std::chrono::high_resolution_clock::now();
+		m_end = std::chrono::steady_clock::now();
 	}
 
 	double GetElapsedTimeInSec() const
@@ -38,14 +38,14 @@ public:
 
 	u64 GetElapsedTimeInMicroSec() const
 	{
-		std::chrono::high_resolution_clock::time_point now = m_stopped ? m_end : std::chrono::high_resolution_clock::now();
+		std::chrono::steady_clock::time_point now = m_stopped ? m_end : std::chrono::steady_clock::now();
 
 		return std::chrono::duration_cast<std::chrono::microseconds>(now - m_start).count();
 	}
 
 	u64 GetElapsedTimeInNanoSec() const
 	{
-		std::chrono::high_resolution_clock::time_point now = m_stopped ? m_end : std::chrono::high_resolution_clock::now();
+		std::chrono::steady_clock::time_point now = m_stopped ? m_end : std::chrono::steady_clock::now();
 
 		return std::chrono::duration_cast<std::chrono::nanoseconds>(now - m_start).count();
 	}

Utilities/VirtualMemory.cpp

@@ -13,33 +13,30 @@
 
 namespace memory_helper
 {
-	void* reserve_memory(size_t size)
+	void* reserve_memory(std::size_t size)
 	{
 #ifdef _WIN32
-		void* ret = VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS);
-		ENSURES(ret != NULL);
+		return verify("reserve_memory" HERE, VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS));
 #else
-		void* ret = mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
-		ENSURES(ret != 0);
-#endif
-		return ret;
-	}
-
-	void commit_page_memory(void* pointer, size_t size)
-	{
-#ifdef _WIN32
-		VERIFY(VirtualAlloc(pointer, size, MEM_COMMIT, PAGE_READWRITE) != NULL);
-#else
-		VERIFY(mprotect((void*)((u64)pointer & -4096), size, PROT_READ | PROT_WRITE) != -1);
+		return verify("reserve_memory" HERE, ::mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0));
 #endif
 	}
 
-	void free_reserved_memory(void* pointer, size_t size)
+	void commit_page_memory(void* pointer, std::size_t size)
 	{
 #ifdef _WIN32
-		VERIFY(VirtualFree(pointer, 0, MEM_DECOMMIT) != 0);
+		verify(HERE), VirtualAlloc(pointer, size, MEM_COMMIT, PAGE_READWRITE);
 #else
-		VERIFY(mprotect(pointer, size, PROT_NONE) != -1);
+		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), ::align(size, 4096), PROT_READ | PROT_WRITE) != -1;
+#endif
+	}
+
+	void free_reserved_memory(void* pointer, std::size_t size)
+	{
+#ifdef _WIN32
+		verify(HERE), VirtualFree(pointer, 0, MEM_DECOMMIT);
+#else
+		verify(HERE), ::mmap(pointer, size, PROT_NONE, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
 #endif
 	}
 }

Utilities/bit_set.h

@@ -0,0 +1,732 @@
+#pragma once
+
+/*
+This header helps to extend scoped enum types (enum class) in two possible ways:
+1) Enabling bitwise operators for enums
+2) Advanced bs_t<> template (this converts enum type to another "bitset" enum type)
+
+To enable bitwise operators, enum scope must contain `__bitwise_ops` entry.
+
+enum class flags
+{
+	__bitwise_ops, // Not essential, but recommended to put it first
+
+	flag1 = 1 << 0,
+	flag2 = 1 << 1,
+};
+
+Examples:
+`flags::flag1 | flags::flag2` - bitwise OR
+`flags::flag1 & flags::flag2` - bitwise AND
+`flags::flag1 ^ flags::flag2` - bitwise XOR
+`~flags::flag1` - bitwise NEG
+
+To enable bs_t<> template, enum scope must contain `__bitset_enum_max` entry.
+
+enum class flagzz : u32
+{
+	flag1, // Bit indices start from zero
+	flag2,
+
+	__bitset_enum_max // It must be the last value
+};
+
+Now some operators are enabled for two enum types: `flagzz` and `bs_t<flagzz>`.
+These are very different from previously described bitwise operators.
+
+Examples:
+`+flagzz::flag1` - unary `+` operator convert flagzz value to bs_t<flagzz>
+`flagzz::flag1 + flagzz::flag2` - bitset union
+`flagzz::flag1 - flagzz::flag2` - bitset difference
+Intersection (&) and symmetric difference (^) is also available.
+
+*/
+
+#include "types.h"
+
+// Helper template
+template<typename T>
+struct bs_base
+{
+	// Underlying type
+	using under = std::underlying_type_t<T>;
+
+	// Actual bitset type
+	enum class type : under
+	{
+		null = 0, // Empty bitset
+
+		__bitset_set_type = 0 // SFINAE marker
+	};
+
+	static constexpr std::size_t bitmax = sizeof(T) * 8;
+	static constexpr std::size_t bitsize = static_cast<under>(T::__bitset_enum_max);
+
+	static_assert(std::is_enum<T>::value, "bs_t<> error: invalid type (must be enum)");
+	static_assert(!bitsize || bitsize <= bitmax, "bs_t<> error: invalid __bitset_enum_max");
+
+	// Helper function
+	static constexpr under shift(T value)
+	{
+		return static_cast<under>(1) << static_cast<under>(value);
+	}
+
+	friend type& operator +=(type& lhs, type rhs)
+	{
+		reinterpret_cast<under&>(lhs) |= static_cast<under>(rhs);
+		return lhs;
+	}
+
+	friend type& operator -=(type& lhs, type rhs)
+	{
+		reinterpret_cast<under&>(lhs) &= ~static_cast<under>(rhs);
+		return lhs;
+	}
+
+	friend type& operator &=(type& lhs, type rhs)
+	{
+		reinterpret_cast<under&>(lhs) &= static_cast<under>(rhs);
+		return lhs;
+	}
+
+	friend type& operator ^=(type& lhs, type rhs)
+	{
+		reinterpret_cast<under&>(lhs) ^= static_cast<under>(rhs);
+		return lhs;
+	}
+
+	friend type& operator +=(type& lhs, T rhs)
+	{
+		reinterpret_cast<under&>(lhs) |= shift(rhs);
+		return lhs;
+	}
+
+	friend type& operator -=(type& lhs, T rhs)
+	{
+		reinterpret_cast<under&>(lhs) &= ~shift(rhs);
+		return lhs;
+	}
+
+	friend type& operator &=(type& lhs, T rhs)
+	{
+		reinterpret_cast<under&>(lhs) &= shift(rhs);
+		return lhs;
+	}
+
+	friend type& operator ^=(type& lhs, T rhs)
+	{
+		reinterpret_cast<under&>(lhs) ^= shift(rhs);
+		return lhs;
+	}
+
+	friend constexpr type operator +(type lhs, type rhs)
+	{
+		return static_cast<type>(static_cast<under>(lhs) | static_cast<under>(rhs));
+	}
+
+	friend constexpr type operator -(type lhs, type rhs)
+	{
+		return static_cast<type>(static_cast<under>(lhs) & ~static_cast<under>(rhs));
+	}
+
+	friend constexpr type operator &(type lhs, type rhs)
+	{
+		return static_cast<type>(static_cast<under>(lhs) & static_cast<under>(rhs));
+	}
+
+	friend constexpr type operator ^(type lhs, type rhs)
+	{
+		return static_cast<type>(static_cast<under>(lhs) ^ static_cast<under>(rhs));
+	}
+
+	friend constexpr type operator &(type lhs, T rhs)
+	{
+		return static_cast<type>(static_cast<under>(lhs) & shift(rhs));
+	}
+
+	friend constexpr type operator ^(type lhs, T rhs)
+	{
+		return static_cast<type>(static_cast<under>(lhs) ^ shift(rhs));
+	}
+
+	friend constexpr type operator &(T lhs, type rhs)
+	{
+		return static_cast<type>(shift(lhs) & static_cast<under>(rhs));
+	}
+
+	friend constexpr type operator ^(T lhs, type rhs)
+	{
+		return static_cast<type>(shift(lhs) ^ static_cast<under>(rhs));
+	}
+
+	friend constexpr bool operator ==(T lhs, type rhs)
+	{
+		return shift(lhs) == rhs;
+	}
+
+	friend constexpr bool operator ==(type lhs, T rhs)
+	{
+		return lhs == shift(rhs);
+	}
+
+	friend constexpr bool operator !=(T lhs, type rhs)
+	{
+		return shift(lhs) != rhs;
+	}
+
+	friend constexpr bool operator !=(type lhs, T rhs)
+	{
+		return lhs != shift(rhs);
+	}
+
+	friend constexpr bool test(type value)
+	{
+		return static_cast<under>(value) != 0;
+	}
+
+	friend constexpr bool test(type lhs, type rhs)
+	{
+		return (static_cast<under>(lhs) & static_cast<under>(rhs)) != 0;
+	}
+
+	friend constexpr bool test(type lhs, T rhs)
+	{
+		return (static_cast<under>(lhs) & shift(rhs)) != 0;
+	}
+
+	friend constexpr bool test(T lhs, type rhs)
+	{
+		return (shift(lhs) & static_cast<under>(rhs)) != 0;
+	}
+
+	friend bool test_and_set(type& lhs, type rhs)
+	{
+		return test_and_set(reinterpret_cast<under&>(lhs), static_cast<under>(rhs));
+	}
+
+	friend bool test_and_set(type& lhs, T rhs)
+	{
+		return test_and_set(reinterpret_cast<under&>(lhs), shift(rhs));
+	}
+
+	friend bool test_and_reset(type& lhs, type rhs)
+	{
+		return test_and_reset(reinterpret_cast<under&>(lhs), static_cast<under>(rhs));
+	}
+
+	friend bool test_and_reset(type& lhs, T rhs)
+	{
+		return test_and_reset(reinterpret_cast<under&>(lhs), shift(rhs));
+	}
+
+	friend bool test_and_complement(type& lhs, type rhs)
+	{
+		return test_and_complement(reinterpret_cast<under&>(lhs), static_cast<under>(rhs));
+	}
+
+	friend bool test_and_complement(type& lhs, T rhs)
+	{
+		return test_and_complement(reinterpret_cast<under&>(lhs), shift(rhs));
+	}
+};
+
+// Bitset type for enum class with available bits [0, T::__bitset_enum_max)
+template<typename T>
+using bs_t = typename bs_base<T>::type;
+
+// Unary '+' operator: promote plain enum value to bitset value
+template<typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator +(T value)
+{
+	return static_cast<bs_t<T>>(bs_base<T>::shift(value));
+}
+
+// Binary '+' operator: bitset union
+template<typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator +(T lhs, T rhs)
+{
+	return static_cast<bs_t<T>>(bs_base<T>::shift(lhs) | bs_base<T>::shift(rhs));
+}
+
+// Binary '+' operator: bitset union
+template<typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator +(typename bs_base<T>::type lhs, T rhs)
+{
+	return static_cast<bs_t<T>>(static_cast<typename bs_base<T>::under>(lhs) | bs_base<T>::shift(rhs));
+}
+
+// Binary '+' operator: bitset union
+template<typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator +(T lhs, typename bs_base<T>::type rhs)
+{
+	return static_cast<bs_t<T>>(bs_base<T>::shift(lhs) | static_cast<typename bs_base<T>::under>(rhs));
+}
+
+// Binary '-' operator: bitset difference
+template<typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator -(T lhs, T rhs)
+{
+	return static_cast<bs_t<T>>(bs_base<T>::shift(lhs) & ~bs_base<T>::shift(rhs));
+}
+
+// Binary '-' operator: bitset difference
+template<typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator -(typename bs_base<T>::type lhs, T rhs)
+{
+	return static_cast<bs_t<T>>(static_cast<typename bs_base<T>::under>(lhs) & ~bs_base<T>::shift(rhs));
+}
+
+// Binary '-' operator: bitset difference
+template<typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator -(T lhs, typename bs_base<T>::type rhs)
+{
+	return static_cast<bs_t<T>>(bs_base<T>::shift(lhs) & ~static_cast<typename bs_base<T>::under>(rhs));
+}
+
+template<typename BS, typename T>
+struct atomic_add<BS, T, void_t<decltype(T::__bitset_enum_max), std::enable_if_t<std::is_same<BS, bs_t<T>>::value>>>
+{
+	using under = typename bs_base<T>::under;
+
+	static inline bs_t<T> op1(bs_t<T>& left, T right)
+	{
+		return static_cast<bs_t<T>>(atomic_storage<under>::fetch_or(reinterpret_cast<under&>(left), bs_base<T>::shift(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline bs_t<T> op2(bs_t<T>& left, T right)
+	{
+		return static_cast<bs_t<T>>(atomic_storage<under>::or_fetch(reinterpret_cast<under&>(left), bs_base<T>::shift(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename BS, typename T>
+struct atomic_sub<BS, T, void_t<decltype(T::__bitset_enum_max), std::enable_if_t<std::is_same<BS, bs_t<T>>::value>>>
+{
+	using under = typename bs_base<T>::under;
+
+	static inline bs_t<T> op1(bs_t<T>& left, T right)
+	{
+		return static_cast<bs_t<T>>(atomic_storage<under>::fetch_and(reinterpret_cast<under&>(left), ~bs_base<T>::shift(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline bs_t<T> op2(bs_t<T>& left, T right)
+	{
+		return static_cast<bs_t<T>>(atomic_storage<under>::and_fetch(reinterpret_cast<under&>(left), ~bs_base<T>::shift(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename BS, typename T>
+struct atomic_and<BS, T, void_t<decltype(T::__bitset_enum_max), std::enable_if_t<std::is_same<BS, bs_t<T>>::value>>>
+{
+	using under = typename bs_base<T>::under;
+
+	static inline bs_t<T> op1(bs_t<T>& left, T right)
+	{
+		return static_cast<bs_t<T>>(atomic_storage<under>::fetch_and(reinterpret_cast<under&>(left), bs_base<T>::shift(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline bs_t<T> op2(bs_t<T>& left, T right)
+	{
+		return static_cast<bs_t<T>>(atomic_storage<under>::and_fetch(reinterpret_cast<under&>(left), bs_base<T>::shift(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename BS, typename T>
+struct atomic_xor<BS, T, void_t<decltype(T::__bitset_enum_max), std::enable_if_t<std::is_same<BS, bs_t<T>>::value>>>
+{
+	using under = typename bs_base<T>::under;
+
+	static inline bs_t<T> op1(bs_t<T>& left, T right)
+	{
+		return static_cast<bs_t<T>>(atomic_storage<under>::fetch_xor(reinterpret_cast<under&>(left), bs_base<T>::shift(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline bs_t<T> op2(bs_t<T>& left, T right)
+	{
+		return static_cast<bs_t<T>>(atomic_storage<under>::xor_fetch(reinterpret_cast<under&>(left), bs_base<T>::shift(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename T>
+struct atomic_add<T, T, void_t<decltype(T::__bitset_set_type)>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline T op1(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::fetch_or(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline T op2(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::or_fetch(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename T>
+struct atomic_sub<T, T, void_t<decltype(T::__bitset_set_type)>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline T op1(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::fetch_and(reinterpret_cast<under&>(left), ~static_cast<under>(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline T op2(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::and_fetch(reinterpret_cast<under&>(left), ~static_cast<under>(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename T>
+struct atomic_and<T, T, void_t<decltype(T::__bitset_set_type)>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline T op1(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::fetch_and(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline T op2(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::and_fetch(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename T>
+struct atomic_xor<T, T, void_t<decltype(T::__bitset_set_type)>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline T op1(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::fetch_xor(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline T op2(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::xor_fetch(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename BS, typename T>
+struct atomic_test_and_set<BS, T, void_t<decltype(T::__bitset_enum_max), std::enable_if_t<std::is_same<BS, bs_t<T>>::value>>>
+{
+	using under = typename bs_base<T>::under;
+
+	static inline bool _op(bs_t<T>& left, T value)
+	{
+		return atomic_storage<under>::bts(reinterpret_cast<under&>(left), static_cast<uint>(static_cast<under>(value)));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};
+
+template<typename BS, typename T>
+struct atomic_test_and_reset<BS, T, void_t<decltype(T::__bitset_enum_max), std::enable_if_t<std::is_same<BS, bs_t<T>>::value>>>
+{
+	using under = typename bs_base<T>::under;
+
+	static inline bool _op(bs_t<T>& left, T value)
+	{
+		return atomic_storage<under>::btr(reinterpret_cast<under&>(left), static_cast<uint>(static_cast<under>(value)));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};
+
+template<typename BS, typename T>
+struct atomic_test_and_complement<BS, T, void_t<decltype(T::__bitset_enum_max), std::enable_if_t<std::is_same<BS, bs_t<T>>::value>>>
+{
+	using under = typename bs_base<T>::under;
+
+	static inline bool _op(bs_t<T>& left, T value)
+	{
+		return atomic_storage<under>::btc(reinterpret_cast<under&>(left), static_cast<uint>(static_cast<under>(value)));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};
+
+template<typename T>
+struct atomic_test_and_set<T, T, void_t<decltype(T::__bitset_set_type)>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline bool _op(T& left, T value)
+	{
+		return atomic_storage<under>::test_and_set(reinterpret_cast<under&>(left), static_cast<under>(value));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};
+
+template<typename T>
+struct atomic_test_and_reset<T, T, void_t<decltype(T::__bitset_set_type)>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline bool _op(T& left, T value)
+	{
+		return atomic_storage<under>::test_and_reset(reinterpret_cast<under&>(left), static_cast<under>(value));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};
+
+template<typename T>
+struct atomic_test_and_complement<T, T, void_t<decltype(T::__bitset_set_type)>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline bool _op(T& left, T value)
+	{
+		return atomic_storage<under>::test_and_complement(reinterpret_cast<under&>(left), static_cast<under>(value));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};
+
+// Binary '|' operator: bitwise OR
+template<typename T, typename = decltype(T::__bitwise_ops)>
+constexpr T operator |(T lhs, T rhs)
+{
+	return static_cast<T>(std::underlying_type_t<T>(lhs) | std::underlying_type_t<T>(rhs));
+}
+
+// Binary '&' operator: bitwise AND
+template<typename T, typename = decltype(T::__bitwise_ops)>
+constexpr T operator &(T lhs, T rhs)
+{
+	return static_cast<T>(std::underlying_type_t<T>(lhs) & std::underlying_type_t<T>(rhs));
+}
+
+// Binary '^' operator: bitwise XOR
+template<typename T, typename = decltype(T::__bitwise_ops)>
+constexpr T operator ^(T lhs, T rhs)
+{
+	return static_cast<T>(std::underlying_type_t<T>(lhs) ^ std::underlying_type_t<T>(rhs));
+}
+
+// Unary '~' operator: bitwise NEG
+template<typename T, typename = decltype(T::__bitwise_ops)>
+constexpr T operator ~(T value)
+{
+	return static_cast<T>(~std::underlying_type_t<T>(value));
+}
+
+// Bitwise OR assignment
+template<typename T, typename = decltype(T::__bitwise_ops)>
+inline T& operator |=(T& lhs, T rhs)
+{
+	reinterpret_cast<std::underlying_type_t<T>&>(lhs) |= std::underlying_type_t<T>(rhs);
+	return lhs;
+}
+
+// Bitwise AND assignment
+template<typename T, typename = decltype(T::__bitwise_ops)>
+inline T& operator &=(T& lhs, T rhs)
+{
+	reinterpret_cast<std::underlying_type_t<T>&>(lhs) &= std::underlying_type_t<T>(rhs);
+	return lhs;
+}
+
+// Bitwise XOR assignment
+template<typename T, typename = decltype(T::__bitwise_ops)>
+inline T& operator ^=(T& lhs, T rhs)
+{
+	reinterpret_cast<std::underlying_type_t<T>&>(lhs) ^= std::underlying_type_t<T>(rhs);
+	return lhs;
+}
+
+template<typename T, typename = decltype(T::__bitwise_ops)>
+constexpr bool test(T value)
+{
+	return std::underlying_type_t<T>(value) != 0;
+}
+
+template<typename T, typename = decltype(T::__bitwise_ops)>
+constexpr bool test(T lhs, T rhs)
+{
+	return (std::underlying_type_t<T>(lhs) & std::underlying_type_t<T>(rhs)) != 0;
+}
+
+template<typename T, typename = decltype(T::__bitwise_ops)>
+inline bool test_and_set(T& lhs, T rhs)
+{
+	return test_and_set(reinterpret_cast<std::underlying_type_t<T>&>(lhs), std::underlying_type_t<T>(rhs));
+}
+
+template<typename T, typename = decltype(T::__bitwise_ops)>
+inline bool test_and_reset(T& lhs, T rhs)
+{
+	return test_and_reset(reinterpret_cast<std::underlying_type_t<T>&>(lhs), std::underlying_type_t<T>(rhs));
+}
+
+template<typename T, typename = decltype(T::__bitwise_ops)>
+inline bool test_and_complement(T& lhs, T rhs)
+{
+	return test_and_complement(reinterpret_cast<std::underlying_type_t<T>&>(lhs), std::underlying_type_t<T>(rhs));
+}
+
+template<typename T>
+struct atomic_or<T, T, void_t<decltype(T::__bitwise_ops), std::enable_if_t<std::is_enum<T>::value>>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline T op1(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::fetch_or(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline T op2(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::or_fetch(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename T>
+struct atomic_and<T, T, void_t<decltype(T::__bitwise_ops), std::enable_if_t<std::is_enum<T>::value>>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline T op1(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::fetch_and(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline T op2(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::and_fetch(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename T>
+struct atomic_xor<T, T, void_t<decltype(T::__bitwise_ops), std::enable_if_t<std::is_enum<T>::value>>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline T op1(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::fetch_xor(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto fetch_op = &op1;
+
+	static inline T op2(T& left, T right)
+	{
+		return static_cast<T>(atomic_storage<under>::xor_fetch(reinterpret_cast<under&>(left), static_cast<under>(right)));
+	}
+
+	static constexpr auto op_fetch = &op2;
+	static constexpr auto atomic_op = &op2;
+};
+
+template<typename T>
+struct atomic_test_and_set<T, T, void_t<decltype(T::__bitwise_ops), std::enable_if_t<std::is_enum<T>::value>>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline bool _op(T& left, T value)
+	{
+		return atomic_storage<under>::test_and_set(reinterpret_cast<under&>(left), static_cast<under>(value));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};
+
+template<typename T>
+struct atomic_test_and_reset<T, T, void_t<decltype(T::__bitwise_ops), std::enable_if_t<std::is_enum<T>::value>>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline bool _op(T& left, T value)
+	{
+		return atomic_storage<under>::test_and_reset(reinterpret_cast<under&>(left), static_cast<under>(value));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};
+
+template<typename T>
+struct atomic_test_and_complement<T, T, void_t<decltype(T::__bitwise_ops), std::enable_if_t<std::is_enum<T>::value>>>
+{
+	using under = std::underlying_type_t<T>;
+
+	static inline bool _op(T& left, T value)
+	{
+		return atomic_storage<under>::test_and_complement(reinterpret_cast<under&>(left), static_cast<under>(value));
+	}
+
+	static constexpr auto fetch_op = &_op;
+	static constexpr auto op_fetch = &_op;
+	static constexpr auto atomic_op = &_op;
+};

Utilities/cfmt.h

@@ -0,0 +1,614 @@
+#pragma once
+
+#include "types.h"
+#include <climits>
+#include <string>
+#include <vector>
+#include <algorithm>
+
+/*
+C-style format parser. Appends formatted string to `out`, returns number of characters written.
+`out`: mutable reference to std::string, std::vector<char> or other compatible container
+`fmt`: null-terminated string of `Char` type (char or constructible from char)
+`src`: rvalue reference to argument provider.
+*/
+template<typename Dst, typename Char, typename Src>
+std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
+{
+	const std::size_t start_pos = out.size();
+
+	struct cfmt_context
+	{
+		std::size_t size; // Size of current format sequence
+
+		u8 args; // Number of extra args used
+		u8 type; // Integral type bytesize
+		bool dot; // Precision enabled
+		bool left;
+		bool sign;
+		bool space;
+		bool alter;
+		bool zeros;
+
+		uint width;
+		uint prec;
+	};
+
+	cfmt_context ctx{0};
+
+	// Error handling: print untouched sequence, stop further formatting
+	const auto drop_sequence = [&]
+	{
+		out.insert(out.end(), fmt - ctx.size, fmt);
+		ctx.size = -1;
+	};
+
+	const auto read_decimal = [&](uint result) -> uint
+	{
+		while (fmt[0] >= '0' && fmt[0] <= '9' && result <= (UINT_MAX / 10))
+		{
+			result = result * 10 + (fmt[0] - '0');
+			fmt++, ctx.size++;
+		}
+
+		return result;
+	};
+
+	const auto write_octal = [&](u64 value, u64 min_num)
+	{
+		out.resize(out.size() + std::max<u64>(min_num, 66 / 3 - (cntlz64(value | 1, true) + 2) / 3), '0');
+
+		// Write in reversed order
+		for (auto i = out.rbegin(); value; i++, value /= 8)
+		{
+			*i = value % 8 + '0';
+		}
+	};
+
+	const auto write_hex = [&](u64 value, bool upper, u64 min_num)
+	{
+		out.resize(out.size() + std::max<u64>(min_num, 64 / 4 - cntlz64(value | 1, true) / 4), '0');
+		
+		// Write in reversed order
+		for (auto i = out.rbegin(); value; i++, value /= 16)
+		{
+			*i = (upper ? "0123456789ABCDEF" : "0123456789abcdef")[value % 16];
+		}
+	};
+
+	const auto write_decimal = [&](u64 value, s64 min_size)
+	{
+		const std::size_t start = out.size();
+
+		do
+		{
+			out.push_back(value % 10 + '0');
+			value /= 10;
+		}
+		while (0 < --min_size || value);
+
+		// Revert written characters
+		for (std::size_t i = start, j = out.size() - 1; i < j; i++, j--)
+		{
+			std::swap(out[i], out[j]);
+		}
+	};
+
+	// Single pass over fmt string (null-terminated), TODO: check correct order
+	while (const Char ch = *fmt++) if (ctx.size == 0)
+	{
+		if (ch == '%')
+		{
+			ctx.size = 1;
+		}
+		else
+		{
+			out.push_back(ch);
+		}
+	}
+	else if (ctx.size == 1 && ch == '%')
+	{
+		ctx = {0};
+		out.push_back(ch);
+	}
+	else if (ctx.size == -1)
+	{
+		out.push_back(ch);
+	}
+	else switch (ctx.size++, ch)
+	{
+	case '-': ctx.left = true; break;
+	case '+': ctx.sign = true; break;
+	case ' ': ctx.space = true; break;
+	case '#': ctx.alter = true; break;
+	case '0': ctx.zeros = true; break;
+
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	{
+		if (UNLIKELY(ctx.width))
+		{
+			drop_sequence();
+		}
+		else
+		{
+			ctx.width = read_decimal(ch - '0');
+		}
+		
+		break;
+	}
+
+	case '*':
+	{
+		if (UNLIKELY(ctx.width || !src.test(ctx.args)))
+		{
+			drop_sequence();
+		}
+		else
+		{
+			const int warg = src.template get<int>(ctx.args++);
+			ctx.width = std::abs(warg);
+			ctx.left |= warg < 0;
+		}
+		
+		break;
+	}
+
+	case '.':
+	{
+		if (UNLIKELY(ctx.dot || ctx.prec))
+		{
+			drop_sequence();
+		}
+		else if (*fmt >= '0' && *fmt <= '9') // TODO: does it allow '0'?
+		{
+			ctx.prec = read_decimal(0);
+			ctx.dot = true;
+		}
+		else if (*fmt == '*')
+		{
+			if (UNLIKELY(!src.test(ctx.args)))
+			{
+				drop_sequence();
+			}
+			else
+			{
+				fmt++, ctx.size++;
+				const int parg = src.template get<int>(ctx.args++);
+				ctx.prec = std::max(parg, 0);
+				ctx.dot = parg >= 0;
+			}
+		}
+		else
+		{
+			ctx.prec = 0;
+			ctx.dot = true;
+		}
+
+		break;
+	}
+
+	case 'h':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else if (fmt[0] == 'h')
+		{
+			fmt++, ctx.size++;
+			ctx.type = sizeof(char);
+		}
+		else
+		{
+			ctx.type = sizeof(short);
+		}
+
+		break;
+	}
+
+	case 'l':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else if (fmt[0] == 'l')
+		{
+			fmt++, ctx.size++;
+			ctx.type = sizeof(llong);
+		}
+		else
+		{
+			ctx.type = sizeof(long);
+		}
+
+		break;
+	}
+
+	case 'z':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else
+		{
+			ctx.type = sizeof(std::size_t);
+		}
+
+		break;
+	}
+
+	case 'j':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else
+		{
+			ctx.type = sizeof(std::intmax_t);
+		}
+
+		break;
+	}
+
+	case 't':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else
+		{
+			ctx.type = sizeof(std::ptrdiff_t);
+		}
+
+		break;
+	}
+
+	case 'c':
+	{
+		if (UNLIKELY(ctx.type || !src.test(ctx.args)))
+		{
+			drop_sequence();
+			break;
+		}
+
+		const std::size_t start = out.size();
+		out.push_back(src.template get<Char>(ctx.args));
+
+		if (1 < ctx.width)
+		{
+			// Add spaces if necessary
+			out.insert(out.begin() + start + ctx.left, ctx.width - 1, ' ');
+		}
+
+		src.skip(ctx.args);
+		ctx = {0};
+		break;
+	}
+
+	case 's':
+	{
+		if (UNLIKELY(ctx.type || !src.test(ctx.args)))
+		{
+			drop_sequence();
+			break;
+		}
+
+		const std::size_t start = out.size();
+		const std::size_t size1 = src.fmt_string(out, ctx.args);
+		
+		if (ctx.dot && size1 > ctx.prec)
+		{
+			// Shrink if necessary
+			out.resize(start + ctx.prec);
+		}
+
+		const std::size_t size2 = out.size() - start;
+
+		if (size2 < ctx.width)
+		{
+			// Add spaces if necessary
+			out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
+		}
+
+		src.skip(ctx.args);
+		ctx = {0};
+		break;
+	}
+
+	case 'd':
+	case 'i':
+	{
+		if (UNLIKELY(!src.test(ctx.args)))
+		{
+			drop_sequence();
+			break;
+		}
+
+		if (!ctx.type)
+		{
+			ctx.type = (u8)src.type(ctx.args);
+		}
+
+		// Sign-extended argument expected
+		const u64 val = src.template get<u64>(ctx.args);
+		const bool negative = ctx.type && static_cast<s64>(val) < 0;
+
+		const std::size_t start = out.size();
+
+		if (!ctx.dot || ctx.prec)
+		{
+			if (negative)
+			{
+				out.push_back('-');
+			}
+			else if (ctx.sign)
+			{
+				out.push_back('+');
+			}
+			else if (ctx.space)
+			{
+				out.push_back(' ');
+			}
+
+			write_decimal(negative ? 0 - val : val, ctx.prec);
+		}
+
+		const std::size_t size2 = out.size() - start;
+
+		if (size2 < ctx.width)
+		{
+			// Add padding if necessary
+			if (ctx.zeros && !ctx.left && !ctx.dot)
+			{
+				out.insert(out.begin() + start + (negative || ctx.sign || ctx.space), ctx.width - size2, '0');
+			}
+			else
+			{
+				out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
+			}
+		}
+
+		src.skip(ctx.args);
+		ctx = {0};
+		break;
+	}
+
+	case 'o':
+	{
+		if (UNLIKELY(!src.test(ctx.args)))
+		{
+			drop_sequence();
+			break;
+		}
+
+		if (!ctx.type)
+		{
+			ctx.type = (u8)src.type(ctx.args);
+		}
+
+		const u64 mask =
+			ctx.type == 1 ? 0xffull :
+			ctx.type == 2 ? 0xffffull :
+			ctx.type == 4 ? 0xffffffffull : 0xffffffffffffffffull;
+
+		// Trunc sign-extended signed types
+		const u64 val = src.template get<u64>(ctx.args) & mask;
+
+		const std::size_t start = out.size();
+
+		if (ctx.alter)
+		{
+			out.push_back('0');
+
+			if (val)
+			{
+				write_octal(val, ctx.prec ? ctx.prec - 1 : 0);
+			}
+		}
+		else if (!ctx.dot || ctx.prec)
+		{
+			write_octal(val, ctx.prec);
+		}
+
+		const std::size_t size2 = out.size() - start;
+
+		if (size2 < ctx.width)
+		{
+			// Add padding if necessary
+			out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ctx.zeros && !ctx.left && !ctx.dot ? '0' : ' ');
+		}
+
+		src.skip(ctx.args);
+		ctx = {0};
+		break;
+	}
+
+	case 'x':
+	case 'X':
+	{
+		if (UNLIKELY(!src.test(ctx.args)))
+		{
+			drop_sequence();
+			break;
+		}
+
+		if (!ctx.type)
+		{
+			ctx.type = (u8)src.type(ctx.args);
+		}
+
+		const u64 mask =
+			ctx.type == 1 ? 0xffull :
+			ctx.type == 2 ? 0xffffull :
+			ctx.type == 4 ? 0xffffffffull : 0xffffffffffffffffull;
+
+		// Trunc sign-extended signed types
+		const u64 val = src.template get<u64>(ctx.args) & mask;
+
+		const std::size_t start = out.size();
+
+		if (ctx.alter)
+		{
+			out.push_back('0');
+
+			if (val)
+			{
+				out.push_back(ch); // Prepend 0x or 0X
+				write_hex(val, ch == 'X', ctx.prec);
+			}
+		}
+		else if (!ctx.dot || ctx.prec)
+		{
+			write_hex(val, ch == 'X', ctx.prec);
+		}
+
+		const std::size_t size2 = out.size() - start;
+
+		if (size2 < ctx.width)
+		{
+			// Add padding if necessary
+			if (ctx.zeros && !ctx.left && !ctx.dot)
+			{
+				out.insert(out.begin() + start + (ctx.alter && val ? 2 : 0), ctx.width - size2, '0');
+			}
+			else
+			{
+				out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
+			}
+		}
+
+		src.skip(ctx.args);
+		ctx = {0};
+		break;
+	}
+
+	case 'u':
+	{
+		if (UNLIKELY(!src.test(ctx.args)))
+		{
+			drop_sequence();
+			break;
+		}
+
+		if (!ctx.type)
+		{
+			ctx.type = (u8)src.type(ctx.args);
+		}
+
+		const u64 mask =
+			ctx.type == 1 ? 0xffull :
+			ctx.type == 2 ? 0xffffull :
+			ctx.type == 4 ? 0xffffffffull : 0xffffffffffffffffull;
+
+		// Trunc sign-extended signed types
+		const u64 val = src.template get<u64>(ctx.args) & mask;
+
+		const std::size_t start = out.size();
+
+		if (!ctx.dot || ctx.prec)
+		{
+			write_decimal(val, ctx.prec);
+		}
+
+		const std::size_t size2 = out.size() - start;
+
+		if (size2 < ctx.width)
+		{
+			// Add padding if necessary
+			out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ctx.zeros && !ctx.left && !ctx.dot ? '0' : ' ');
+		}
+
+		src.skip(ctx.args);
+		ctx = {0};
+		break;
+	}
+
+	case 'p':
+	{
+		if (UNLIKELY(!src.test(ctx.args) || ctx.type))
+		{
+			drop_sequence();
+			break;
+		}
+
+		const u64 val = src.template get<u64>(ctx.args);
+
+		const std::size_t start = out.size();
+
+		write_hex(val, false, sizeof(void*) * 2);
+
+		const std::size_t size2 = out.size() - start;
+
+		if (size2 < ctx.width)
+		{
+			// Add padding if necessary
+			out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
+		}
+		
+		src.skip(ctx.args);
+		ctx = {0};
+		break;
+	}
+
+	case 'f':
+	case 'F':
+	case 'e':
+	case 'E':
+	case 'a':
+	case 'A':
+	case 'g':
+	case 'G':
+	{
+		if (UNLIKELY(!src.test(ctx.args) || ctx.type))
+		{
+			drop_sequence();
+			break;
+		}
+
+		// Fallback (TODO)
+
+		const std::string _fmt(fmt - ctx.size, fmt);
+
+		const f64 arg0 = src.template get<f64>(0);
+		const u64 arg1 = ctx.args >= 1 ? src.template get<u64>(1) : 0;
+		const u64 arg2 = ctx.args >= 2 ? src.template get<u64>(2) : 0;
+
+		if (const std::size_t _size = std::snprintf(0, 0, _fmt.c_str(), arg0, arg1, arg2))
+		{
+			out.resize(out.size() + _size);
+			std::snprintf(&out.front() + out.size() - _size, _size + 1, _fmt.c_str(), arg0, arg1, arg2);
+		}
+
+		src.skip(ctx.args);
+		ctx = {0};
+		break;
+	}
+
+	case 'L': // long double, not supported
+	case 'n': // writeback, not supported
+	default:
+	{
+		drop_sequence();
+	}
+	}
+
+	// Handle unfinished sequence
+	if (ctx.size && ctx.size != -1)
+	{
+		fmt--, drop_sequence();
+	}
+
+	return out.size() - start_pos;
+}

Utilities/cond.cpp

@@ -0,0 +1,105 @@
+#include "cond.h"
+#include "sync.h"
+
+#ifndef _WIN32
+#include <thread>
+#endif
+
+bool cond_variable::imp_wait(u32 _old, u64 _timeout) noexcept
+{
+	verify(HERE), _old != -1; // Very unlikely: it requires 2^32 distinct threads to wait simultaneously
+
+#ifdef _WIN32
+	LARGE_INTEGER timeout;
+	timeout.QuadPart = _timeout * -10;
+
+	if (HRESULT rc = NtWaitForKeyedEvent(nullptr, &m_value, false, _timeout == -1 ? nullptr : &timeout))
+	{
+		verify(HERE), rc == WAIT_TIMEOUT;
+
+		// Retire
+		if (!m_value.fetch_op([](u32& value) { if (value) value--; }))
+		{
+			NtWaitForKeyedEvent(nullptr, &m_value, false, nullptr);
+			return true;
+		}
+
+		return false;
+	}
+
+	return true;
+#else
+	timespec timeout;
+	timeout.tv_sec  = _timeout / 1000000;
+	timeout.tv_nsec = (_timeout % 1000000) * 1000;
+
+	for (u32 value = _old + 1;; value = m_value)
+	{
+		const int err = futex((int*)&m_value.raw(), FUTEX_WAIT_PRIVATE, value, _timeout == -1 ? nullptr : &timeout, nullptr, 0) == 0
+			? 0
+			: errno;
+
+		// Normal or timeout wakeup
+		if (!err || (_timeout != -1 && err == ETIMEDOUT))
+		{
+			// Cleanup (remove waiter)
+			verify(HERE), m_value--;
+			return !err;
+		}
+
+		// Not a wakeup
+		verify(HERE), err == EAGAIN;
+	}
+#endif
+}
+
+void cond_variable::imp_wake(u32 _count) noexcept
+{
+#ifdef _WIN32
+	// Try to subtract required amount of waiters
+	const u32 count = m_value.atomic_op([=](u32& value)
+	{
+		if (value > _count)
+		{
+			value -= _count;
+			return _count;
+		}
+
+		return std::exchange(value, 0);
+	});
+
+	for (u32 i = count; i > 0; i--)
+	{
+		NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
+	}
+#else
+	for (u32 i = _count; i > 0; std::this_thread::yield())
+	{
+		const u32 value = m_value;
+
+		// Constrain remaining amount with imaginary waiter count
+		if (i > value)
+		{
+			i = value;
+		}
+
+		if (!value || i == 0)
+		{
+			// Nothing to do
+			return;
+		}
+
+		if (const int res = futex((int*)&m_value.raw(), FUTEX_WAKE_PRIVATE, i > INT_MAX ? INT_MAX : i, nullptr, nullptr, 0))
+		{
+			verify(HERE), res >= 0 && (u32)res <= i;
+			i -= res;
+		}
+
+		if (!m_value || i == 0)
+		{
+			// Escape
+			return;
+		}
+	}
+#endif
+}

Utilities/cond.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "types.h"
+#include "Atomic.h"
+
+// Lightweight condition variable
+class cond_variable
+{
+	// Internal waiter counter
+	atomic_t<u32> m_value{0};
+
+protected:
+	// Internal waiting function
+	bool imp_wait(u32 _old, u64 _timeout) noexcept;
+
+	// Try to notify up to _count threads
+	void imp_wake(u32 _count) noexcept;
+
+public:
+	constexpr cond_variable() = default;
+
+	// Intrusive wait algorithm for lockable objects
+	template <typename T>
+	explicit_bool_t wait(T& object, u64 usec_timeout = -1)
+	{
+		const u32 _old = m_value.fetch_add(1); // Increment waiter counter
+		object.unlock();
+		const bool res = imp_wait(_old, usec_timeout);
+		object.lock();
+		return res;
+	}
+
+	// Wake one thread
+	void notify_one() noexcept
+	{
+		if (m_value)
+		{
+			imp_wake(1);
+		}
+	}
+
+	// Wake all threads
+	void notify_all() noexcept
+	{
+		if (m_value)
+		{
+			imp_wake(-1);
+		}
+	}
+};

Utilities/copyright.txt

@@ -0,0 +1,10 @@
+Copyright (C) 2011-2012 Andrzej Krzemienski
+
+Distributed under the Boost Software License, Version 1.0
+(see accompanying file LICENSE_1_0.txt or a copy at
+http://www.boost.org/LICENSE_1_0.txt)
+
+The idea and interface is based on Boost.Optional library
+authored by Fernando Luis Cacciola Carballal
+
+Home at https://github.com/akrzemi1/Optional

Utilities/dynamic_library.cpp

@@ -57,4 +57,13 @@ namespace utils
 	{
 		return loaded();
 	}
+
+	void* get_proc_address(const char* lib, const char* name)
+	{
+#ifdef _WIN32
+		return reinterpret_cast<void*>(GetProcAddress(GetModuleHandleA(lib), name));
+#else
+		return dlsym(dlopen(lib, RTLD_NOLOAD), name);
+#endif
+	}
 }

Utilities/dynamic_library.h

@@ -38,4 +38,43 @@ namespace utils
 		bool loaded() const;
 		explicit operator bool() const;
 	};
+
+	// (assume the lib is always loaded)
+	void* get_proc_address(const char* lib, const char* name);
+
+	template <typename F>
+	struct dynamic_import
+	{
+		static_assert(sizeof(F) == 0, "Invalid function type");
+	};
+
+	template <typename R, typename... Args>
+	struct dynamic_import<R(Args...)>
+	{
+		R(*ptr)(Args...);
+		const char* const lib;
+		const char* const name;
+
+		// Constant initialization
+		constexpr dynamic_import(const char* lib, const char* name)
+			: ptr(nullptr)
+			, lib(lib)
+			, name(name)
+		{
+		}
+
+		// Caller
+		R operator()(Args... args)
+		{
+			if (!ptr)
+			{
+				// TODO: atomic
+				ptr = reinterpret_cast<R(*)(Args...)>(get_proc_address(lib, name));
+			}
+
+			return ptr(args...);
+		}
+	};
 }
+
+#define DYNAMIC_IMPORT(lib, name, ...) static utils::dynamic_import<__VA_ARGS__> name(lib, #name);

Utilities/event.h

@@ -1,8 +1,193 @@
 #pragma once
+
 #include <functional>
 #include <deque>
 #include <list>
 
+#include "Atomic.h"
+
+template <typename T, T Mod = T::__state_enum_max, typename Under = std::underlying_type_t<T>>
+T operator ++(T& value, int)
+{
+	return std::exchange(value, static_cast<T>(value < T{} || value >= Mod ? static_cast<Under>(0) : static_cast<Under>(value) + 1));
+}
+
+template <typename T, T Mod = T::__state_enum_max, typename Under = std::underlying_type_t<T>>
+T operator --(T& value, int)
+{
+	return std::exchange(value, static_cast<T>(value <= T{} || value >= static_cast<Under>(Mod) - 1 ? static_cast<Under>(Mod) - 1 : static_cast<Under>(value) - 1));
+}
+
+template <typename T, typename CRT, std::size_t Size = static_cast<std::underlying_type_t<T>>(T::__state_enum_max)>
+class state_machine
+{
+	using under = std::underlying_type_t<T>;
+	using ftype = void(CRT::*)(T);
+
+	atomic_t<T> m_value;
+
+	template <std::size_t... Ind>
+	static inline ftype transition_map(std::integer_sequence<std::size_t, Ind...>, T state)
+	{
+		// Constantly initialized list of functions
+		static constexpr ftype map[Size]{&CRT::template transition<static_cast<T>(Ind)>...};
+
+		// Unsafe table lookup (TODO)
+		return map[static_cast<under>(state)];
+	}
+
+	// "Convert" variable argument to template argument
+	static inline ftype transition_get(T state)
+	{
+		return transition_map(std::make_index_sequence<Size>(), state);
+	}
+
+public:
+	constexpr state_machine()
+		: m_value{T{}}
+	{
+	}
+
+	constexpr state_machine(T state)
+		: m_value{state}
+	{
+	}
+
+	// Get current state
+	T state_get() const
+	{
+		return m_value;
+	}
+
+	// Unconditionally set state
+	void state_set(T state)
+	{
+		T _old = m_value.exchange(state);
+
+		if (_old != state)
+		{
+			(static_cast<CRT*>(this)->*transition_get(state))(_old);
+		}
+	}
+
+	// Conditionally set state (optimized)
+	explicit_bool_t state_test_and_set(T expected, T state)
+	{
+		if (m_value == expected && m_value.compare_and_swap_test(expected, state))
+		{
+			(static_cast<CRT*>(this)->*transition_get(state))(expected);
+			return true;
+		}
+
+		return false;
+	}
+
+	// Conditionally set state (list version)
+	explicit_bool_t state_test_and_set(std::initializer_list<T> expected, T state)
+	{
+		T _old;
+
+		if (m_value.atomic_op([&](T& value)
+		{
+			for (T x : expected)
+			{
+				if (value == x)
+				{
+					_old = std::exchange(value, state);
+					return true;
+				}
+			}
+
+			return false;
+		}))
+		{
+			(static_cast<CRT*>(this)->*transition_get(state))(_old);
+			return true;
+		}
+
+		return false;
+	}
+
+	// Unconditionally set next state
+	void state_next()
+	{
+		T _old, state = m_value.op_fetch([&](T& value)
+		{
+			_old = value++;
+		});
+
+		(static_cast<CRT*>(this)->*transition_get(state))(_old);
+	}
+
+	// Unconditionally set previous state
+	void state_prev()
+	{
+		T _old, state = m_value.op_fetch([&](T& value)
+		{
+			_old = value--;
+		});
+
+		(static_cast<CRT*>(this)->*transition_get(state))(_old);
+	}
+
+	// Get number of states
+	static constexpr std::size_t size()
+	{
+		return Size;
+	}
+};
+
+//enum class test_state
+//{
+//	on,
+//	off,
+//	la,
+//
+//	__state_enum_max // 3
+//};
+//
+//struct test_machine final : state_machine<test_state, test_machine>
+//{
+//	template <test_state>
+//	void transition(test_state old_state);
+//
+//	void on()
+//	{
+//		state_set(test_state::on);
+//	}
+//
+//	void off()
+//	{
+//		state_set(test_state::off);
+//	}
+//
+//	void test()
+//	{
+//		state_next();
+//	}
+//};
+//
+//template <>
+//void test_machine::transition<test_state::on>(test_state)
+//{
+//	LOG_SUCCESS(GENERAL, "ON");
+//}
+//
+//template <>
+//void test_machine::transition<test_state::off>(test_state)
+//{
+//	LOG_SUCCESS(GENERAL, "OFF");
+//}
+//
+//
+//template <>
+//void test_machine::transition<test_state::la>(test_state)
+//{
+//	on();
+//	off();
+//	test();
+//}
+
 enum class event_result
 {
 	skip,

Utilities/lockless.h

@@ -2,7 +2,6 @@
 
 #include "types.h"
 #include "Atomic.h"
-#include "Platform.h"
 
 //! Simple sizeless array base for concurrent access. Cannot shrink, only growths automatically.
 //! There is no way to know the current size. The smaller index is, the faster it's accessed.
@@ -67,9 +66,9 @@ public:
 	constexpr lf_fifo() = default;
 
 	// Get current "push" position
-	u32 size()
+	u32 size() const
 	{
-		return reinterpret_cast<atomic_t<u32>&>(m_ctrl).load(); // Hack
+		return reinterpret_cast<const atomic_t<u32>&>(m_ctrl).load(); // Hack
 	}
 	
 	// Acquire the place for one or more elements.
@@ -79,7 +78,7 @@ public:
 	}
 
 	// Get current "pop" position
-	u32 peek()
+	u32 peek() const
 	{
 		return m_ctrl.load().pop;
 	}
@@ -103,3 +102,229 @@ public:
 		});
 	}
 };
+
+//! Simple lock-free map. Based on lf_array<>. All elements are accessible, implicitly initialized.
+template<typename K, typename T, typename Hash = value_hash<K>, std::size_t Size = 256>
+class lf_hashmap
+{
+	struct pair_t
+	{
+		// Default-constructed key means "no key"
+		atomic_t<K> key{};
+		T value{};
+	};
+
+	//
+	lf_array<pair_t, Size> m_data{};
+
+	// Value for default-constructed key
+	T m_default_key_data{};
+
+public:
+	constexpr lf_hashmap() = default;
+
+	// Access element (added implicitly)
+	T& operator [](const K& key)
+	{
+		if (UNLIKELY(key == K{}))
+		{
+			return m_default_key_data;
+		}
+		
+		// Calculate hash and array position
+		for (std::size_t pos = Hash{}(key) % Size;; pos += Size)
+		{
+			// Access the array
+			auto& pair = m_data[pos];
+
+			// Check the key value (optimistic)
+			if (LIKELY(pair.key == key) || pair.key.compare_and_swap_test(K{}, key))
+			{
+				return pair.value;
+			}
+		}
+	}
+};
+
+// Fixed-size single-producer single-consumer queue
+template <typename T, std::uint32_t N>
+class lf_spsc
+{
+	// If N is a power of 2, m_push/m_pop can safely overflow and the algorithm is simplified
+	static_assert(N && (1u << 31) % N == 0, "lf_spsc<> error: size must be power of 2");
+
+protected:
+	volatile std::uint32_t m_push{0};
+	volatile std::uint32_t m_pop{0};
+	T m_data[N]{};
+
+public:
+	constexpr lf_spsc() = default;
+
+	// Try to push (producer only)
+	template <typename T2>
+	bool try_push(T2&& data)
+	{
+		const std::uint32_t pos = m_push;
+
+		if (pos - m_pop >= N)
+		{
+			return false;
+		}
+
+		_mm_lfence();
+		m_data[pos % N] = std::forward<T2>(data);
+		_mm_sfence();
+		m_push = pos + 1;
+		return true;
+	}
+
+	// Try to get push pointer (producer only)
+	operator T*()
+	{
+		const std::uint32_t pos = m_push;
+
+		if (pos - m_pop >= N)
+		{
+			return nullptr;
+		}
+
+		_mm_lfence();
+		return m_data + (pos % N);
+	}
+
+	// Increment push counter (producer only)
+	void end_push()
+	{
+		const std::uint32_t pos = m_push;
+
+		if (pos - m_pop < N)
+		{
+			_mm_sfence();
+			m_push = pos + 1;
+		}
+	}
+
+	// Unsafe access
+	T& get_push(std::size_t i)
+	{
+		_mm_lfence();
+		return m_data[(m_push + i) % N];
+	}
+
+	// Try to pop (consumer only)
+	template <typename T2>
+	bool try_pop(T2& out)
+	{
+		const std::uint32_t pos = m_pop;
+
+		if (m_push - pos <= 0)
+		{
+			return false;
+		}
+
+		_mm_lfence();
+		out = std::move(m_data[pos % N]);
+		_mm_sfence();
+		m_pop = pos + 1;
+		return true;
+	}
+
+	// Increment pop counter (consumer only)
+	void end_pop()
+	{
+		const std::uint32_t pos = m_pop;
+
+		if (m_push - pos > 0)
+		{
+			_mm_sfence();
+			m_pop = pos + 1;
+		}
+	}
+
+	// Get size (consumer only)
+	std::uint32_t size() const
+	{
+		return m_push - m_pop;
+	}
+
+	// Direct access (consumer only)
+	T& operator [](std::size_t i)
+	{
+		_mm_lfence();
+		return m_data[(m_pop + i) % N];
+	}
+};
+
+// Fixed-size multi-producer single-consumer queue
+template <typename T, std::uint32_t N>
+class lf_mpsc : lf_spsc<T, N>
+{
+protected:
+	using lf_spsc<T, N>::m_push;
+	using lf_spsc<T, N>::m_pop;
+	using lf_spsc<T, N>::m_data;
+
+	enum : std::uint64_t
+	{
+		c_ack = 1ull << 0,
+		c_rel = 1ull << 32,
+	};
+
+	atomic_t<std::uint64_t> m_lock{0};
+
+	void release(std::uint64_t value)
+	{
+		// Push all pending elements at once when possible
+		if (value && value % c_rel == value / c_rel)
+		{
+			_mm_sfence();
+			m_push += value % c_rel;
+			m_lock.compare_and_swap_test(value, 0);
+		}
+	}
+
+public:
+	constexpr lf_mpsc() = default;
+
+	// Try to get push pointer
+	operator T*()
+	{
+		const std::uint64_t old = m_lock.fetch_add(c_ack);
+		const std::uint32_t pos = m_push;
+
+		if (old % N >= N || pos - m_pop >= N - (old % N))
+		{
+			release(m_lock.sub_fetch(c_ack));
+			return nullptr;
+		}
+
+		return m_data + ((pos + old) % N);
+	}
+
+	// Increment push counter (producer only)
+	void end_push()
+	{
+		release(m_lock.add_fetch(c_rel));
+	}
+
+	// Try to push
+	template <typename T2>
+	bool try_push(T2&& data)
+	{
+		if (T* ptr = *this)
+		{
+			*ptr = std::forward<T2>(data);
+			end_push();
+			return true;
+		}
+
+		return false;
+	}
+
+	// Enable consumer methods
+	using lf_spsc<T, N>::try_pop;
+	using lf_spsc<T, N>::end_pop;
+	using lf_spsc<T, N>::size;
+	using lf_spsc<T, N>::operator [];
+};

Utilities/mutex.cpp

@@ -0,0 +1,238 @@
+#include "mutex.h"
+#include "sync.h"
+
+void shared_mutex::imp_lock_shared(s64 _old)
+{
+	verify("shared_mutex overflow" HERE), _old <= c_max;
+
+	for (int i = 0; i < 10; i++)
+	{
+		busy_wait();
+
+		const s64 value = m_value.load();
+
+		if (value >= c_min && m_value.compare_and_swap_test(value, value - c_min))
+		{
+			return;
+		}
+	}
+
+#ifdef _WIN32
+	// Acquire writer lock
+	imp_wait(m_value.load());
+
+	// Convert value
+	s64 value = m_value.fetch_add(c_one - c_min);
+
+	if (value != 0)
+	{
+		imp_unlock(value);
+	}
+
+	// Wait as a reader if necessary
+	if (value + c_one - c_min < 0)
+	{
+		NtWaitForKeyedEvent(nullptr, (int*)&m_value + 1, false, nullptr);
+	}
+#else
+	while (true)
+	{
+		const s64 value0 = m_value.fetch_op([](s64& value)
+		{
+			if (value >= c_min)
+			{
+				value -= c_min;
+			}
+		});
+
+		if (value0 >= c_min)
+		{
+			return;	
+		}
+
+		// Acquire writer lock
+		imp_wait(value0);
+
+		// Convert to reader lock
+		s64 value1 = m_value.fetch_add(c_one - c_min);
+
+		if (value1 != 0)
+		{
+			imp_unlock(value1);
+		}
+
+		value1 += c_one - c_min;
+		
+		if (value1 >= 0)
+		{
+			return;
+		}
+
+		// Wait as a reader if necessary
+		while (futex((int*)&m_value.raw() + IS_LE_MACHINE, FUTEX_WAIT_PRIVATE, int(value1 >> 32), nullptr, nullptr, 0))
+		{
+			value1 = m_value.load();
+
+			if (value1 >= 0)
+			{
+				return;
+			}
+		}
+
+		// If blocked by writers, release the reader lock and try again
+		const s64 value2 = m_value.fetch_op([](s64& value)
+		{
+			if (value < 0)
+			{
+				value += c_min;
+			}
+		});
+
+		if (value2 >= 0)
+		{
+			return;
+		}
+		
+		imp_unlock_shared(value2);
+	}
+#endif
+}
+
+void shared_mutex::imp_unlock_shared(s64 _old)
+{
+	verify("shared_mutex overflow" HERE), _old + c_min <= c_max;
+
+	// Check reader count, notify the writer if necessary
+	if ((_old + c_min) % c_one == 0)
+	{
+#ifdef _WIN32
+		NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
+#else
+		m_value -= c_sig;
+
+		futex((int*)&m_value.raw() + IS_BE_MACHINE, FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
+#endif
+	}
+}
+
+void shared_mutex::imp_wait(s64)
+{
+#ifdef _WIN32
+	if (m_value.sub_fetch(c_one))
+	{
+		NtWaitForKeyedEvent(nullptr, &m_value, false, nullptr);
+	}
+#else
+	if (!m_value.sub_fetch(c_one))
+	{
+		// Return immediately if locked
+		return;
+	}
+
+	while (true)
+	{
+		// Load new value, try to acquire c_sig
+		const s64 value = m_value.fetch_op([](s64& value)
+		{
+			if (value <= c_one - c_sig)
+			{
+				value += c_sig;
+			}
+		});
+
+		if (value <= c_one - c_sig)
+		{
+			return;
+		}
+
+		futex((int*)&m_value.raw() + IS_BE_MACHINE, FUTEX_WAIT_PRIVATE, int(value), nullptr, nullptr, 0);
+	}
+#endif
+}
+
+void shared_mutex::imp_lock(s64 _old)
+{
+	verify("shared_mutex overflow" HERE), _old <= c_max;
+
+	for (int i = 0; i < 10; i++)
+	{
+		busy_wait();
+
+		const s64 value = m_value.load();
+
+		if (value == c_one && m_value.compare_and_swap_test(c_one, 0))
+		{
+			return;
+		}
+	}
+
+	imp_wait(m_value.load());
+}
+
+void shared_mutex::imp_unlock(s64 _old)
+{
+	verify("shared_mutex overflow" HERE), _old + c_one <= c_max;
+
+	// 1) Notify the next writer if necessary
+	// 2) Notify all readers otherwise if necessary
+#ifdef _WIN32
+	if (_old + c_one <= 0)
+	{
+		NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
+	}
+	else if (s64 count = -_old / c_min)
+	{
+		while (count--)
+		{
+			NtReleaseKeyedEvent(nullptr, (int*)&m_value + 1, false, nullptr);
+		}
+	}
+#else
+	if (_old + c_one <= 0)
+	{
+		m_value -= c_sig;
+
+		futex((int*)&m_value.raw() + IS_BE_MACHINE, FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
+	}
+	else if (s64 count = -_old / c_min)
+	{
+		futex((int*)&m_value.raw() + IS_LE_MACHINE, FUTEX_WAKE_PRIVATE, INT_MAX, nullptr, nullptr, 0);
+	}
+#endif
+}
+
+void shared_mutex::imp_lock_upgrade()
+{
+	unlock_shared();
+	lock();
+}
+
+void shared_mutex::imp_lock_degrade()
+{
+	unlock();
+	lock_shared();
+}
+
+bool shared_mutex::try_lock_shared()
+{
+	// Conditional decrement
+	return m_value.fetch_op([](s64& value) { if (value >= c_min) value -= c_min; }) >= c_min;
+}
+
+bool shared_mutex::try_lock()
+{
+	// Conditional decrement (TODO: obtain c_sig)
+	return m_value.compare_and_swap_test(c_one, 0);
+}
+
+bool shared_mutex::try_lock_upgrade()
+{
+	// TODO
+	return m_value.compare_and_swap_test(c_one - c_min, 0);
+}
+
+bool shared_mutex::try_lock_degrade()
+{
+	// TODO
+	return m_value.compare_and_swap_test(0, c_one - c_min);
+}

Utilities/mutex.h

@@ -0,0 +1,173 @@
+#pragma once
+
+#include "types.h"
+#include "Atomic.h"
+
+// Shared mutex.
+class shared_mutex final
+{
+	enum : s64
+	{
+		c_one = 1ull << 31, // Fixed-point 1.0 value (one writer)
+		c_min = 0x00000001, // Fixed-point 1.0/max_readers value
+		c_sig = 1ull << 62,
+		c_max = c_one
+	};
+
+	atomic_t<s64> m_value{c_one}; // Semaphore-alike counter
+
+	void imp_lock_shared(s64 _old);
+	void imp_unlock_shared(s64 _old);
+	void imp_wait(s64 _old);
+	void imp_lock(s64 _old);
+	void imp_unlock(s64 _old);
+
+	void imp_lock_upgrade();
+	void imp_lock_degrade();
+
+public:
+	constexpr shared_mutex() = default;
+
+	bool try_lock_shared();
+
+	void lock_shared()
+	{
+		const s64 value = m_value.load();
+
+		// Fast path: decrement if positive
+		if (UNLIKELY(value < c_min || value > c_one || !m_value.compare_and_swap_test(value, value - c_min)))
+		{
+			imp_lock_shared(value);
+		}
+	}
+
+	void unlock_shared()
+	{
+		// Unconditional increment
+		const s64 value = m_value.fetch_add(c_min);
+
+		if (value < 0 || value > c_one - c_min)
+		{
+			imp_unlock_shared(value);
+		}
+	}
+
+	bool try_lock();
+
+	void lock()
+	{
+		// Try to lock
+		const s64 value = m_value.compare_and_swap(c_one, 0);
+
+		if (value != c_one)
+		{
+			imp_lock(value);
+		}
+	}
+
+	void unlock()
+	{
+		// Unconditional increment
+		const s64 value = m_value.fetch_add(c_one);
+
+		if (value != 0)
+		{
+			imp_unlock(value);
+		}
+	}
+
+	bool try_lock_upgrade();
+
+	void lock_upgrade()
+	{
+		if (!m_value.compare_and_swap_test(c_one - c_min, 0))
+		{
+			imp_lock_upgrade();
+		}
+	}
+
+	bool try_lock_degrade();
+
+	void lock_degrade()
+	{
+		if (!m_value.compare_and_swap_test(0, c_one - c_min))
+		{
+			imp_lock_degrade();
+		}
+	}
+};
+
+// Simplified shared (reader) lock implementation.
+class reader_lock final
+{
+	shared_mutex& m_mutex;
+	bool m_upgraded = false;
+
+	void lock()
+	{
+		m_upgraded ? m_mutex.lock() : m_mutex.lock_shared();
+	}
+
+	void unlock()
+	{
+		m_upgraded ? m_mutex.unlock() : m_mutex.unlock_shared();
+	}
+
+	friend class cond_variable;
+
+public:
+	reader_lock(const reader_lock&) = delete;
+
+	explicit reader_lock(shared_mutex& mutex)
+		: m_mutex(mutex)
+	{
+		lock();
+	}
+
+	// One-way lock upgrade
+	void upgrade()
+	{
+		if (!m_upgraded)
+		{
+			m_mutex.lock_upgrade();
+			m_upgraded = true;
+		}
+	}
+
+	~reader_lock()
+	{
+		unlock();
+	}
+};
+
+// Simplified exclusive (writer) lock implementation.
+class writer_lock final
+{
+	shared_mutex& m_mutex;
+
+	void lock()
+	{
+		m_mutex.lock();
+	}
+
+	void unlock()
+	{
+		m_mutex.unlock();
+	}
+
+	friend class cond_variable;
+
+public:
+	writer_lock(const writer_lock&) = delete;
+
+	explicit writer_lock(shared_mutex& mutex)
+		: m_mutex(mutex)
+	{
+		lock();
+	}
+
+	~writer_lock()
+	{
+		unlock();
+	}
+};

Utilities/rXml.cpp

@@ -1,5 +1,7 @@
 #include "stdafx.h"
+#include "restore_new.h"
 #include "Utilities/rXml.h"
+#include "define_new_memleakdetect.h"
 
 rXmlNode::rXmlNode() : handle()
 {

Utilities/recursive_wrapper.hpp

@@ -0,0 +1,124 @@
+#ifndef MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
+#define MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
+
+// Based on variant/recursive_wrapper.hpp from boost.
+//
+// Original license:
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cassert>
+#include <utility>
+
+//namespace mapbox {
+//namespace util {
+namespace std {
+
+template <typename T>
+class recursive_wrapper
+{
+
+    T* p_;
+
+    void assign(T const& rhs)
+    {
+        this->get() = rhs;
+    }
+
+public:
+    using type = T;
+
+    /**
+     * Default constructor default initializes the internally stored value.
+     * For POD types this means nothing is done and the storage is
+     * uninitialized.
+     *
+     * @throws std::bad_alloc if there is insufficient memory for an object
+     *         of type T.
+     * @throws any exception thrown by the default constructur of T.
+     */
+    recursive_wrapper()
+        : p_(new T){}
+
+    ~recursive_wrapper() noexcept { delete p_; }
+
+    recursive_wrapper(recursive_wrapper const& operand)
+        : p_(new T(operand.get())) {}
+
+    recursive_wrapper(T const& operand)
+        : p_(new T(operand)) {}
+
+    recursive_wrapper(recursive_wrapper&& operand)
+        : p_(new T(std::move(operand.get()))) {}
+
+    recursive_wrapper(T&& operand)
+        : p_(new T(std::move(operand))) {}
+
+    inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
+    {
+        assign(rhs.get());
+        return *this;
+    }
+
+    inline recursive_wrapper& operator=(T const& rhs)
+    {
+        assign(rhs);
+        return *this;
+    }
+
+    inline void swap(recursive_wrapper& operand) noexcept
+    {
+        T* temp = operand.p_;
+        operand.p_ = p_;
+        p_ = temp;
+    }
+
+    recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
+    {
+        swap(rhs);
+        return *this;
+    }
+
+    recursive_wrapper& operator=(T&& rhs)
+    {
+        get() = std::move(rhs);
+        return *this;
+    }
+
+    T& get()
+    {
+        assert(p_);
+        return *get_pointer();
+    }
+
+    T const& get() const
+    {
+        assert(p_);
+        return *get_pointer();
+    }
+
+    T* get_pointer() { return p_; }
+
+    const T* get_pointer() const { return p_; }
+
+    operator T const&() const { return this->get(); }
+
+    operator T&() { return this->get(); }
+
+}; // class recursive_wrapper
+
+template <typename T>
+inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+}
+//} // namespace util
+//} // namespace mapbox
+
+#endif // MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP

Utilities/sema.cpp

@@ -0,0 +1,103 @@
+#include "sema.h"
+#include "sync.h"
+
+void semaphore_base::imp_wait()
+{
+	for (int i = 0; i < 10; i++)
+	{
+		busy_wait();
+
+		const s32 value = m_value.load();
+
+		if (value > 0 && m_value.compare_and_swap_test(value, value - 1))
+		{
+			return;
+		}
+	}
+
+#ifdef _WIN32
+	const s32 value = m_value.fetch_sub(1);
+
+	if (value <= 0)
+	{
+		NtWaitForKeyedEvent(nullptr, &m_value, false, nullptr);
+	}
+#else
+	while (true)
+	{
+		// Try hard way
+		const s32 value = m_value.op_fetch([](s32& value)
+		{
+			// Use sign bit to acknowledge waiter presence
+			if (value && value > INT32_MIN)
+			{
+				value--;
+
+				if (value < 0)
+				{
+					// Remove sign bit
+					value -= INT32_MIN;
+				}
+			}
+			else
+			{
+				// Set sign bit
+				value = INT32_MIN;
+			}
+		});
+
+		if (value >= 0)
+		{
+			// Signal other waiter to wake up or to restore sign bit
+			futex(&m_value.raw(), FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
+			return;
+		}
+
+		futex(&m_value.raw(), FUTEX_WAIT_PRIVATE, value, nullptr, nullptr, 0);
+	}
+#endif
+}
+
+void semaphore_base::imp_post(s32 _old)
+{
+	verify("semaphore_base: overflow" HERE), _old < 0;
+
+#ifdef _WIN32
+	NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
+#else
+	futex(&m_value.raw(), FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
+#endif
+}
+
+bool semaphore_base::try_wait()
+{
+	// Conditional decrement
+	const s32 value = m_value.fetch_op([](s32& value)
+	{
+		if (value > 0)
+		{
+			value -= 1;
+		}
+	});
+
+	return value > 0;
+}
+
+bool semaphore_base::try_post(s32 _max)
+{
+	// Conditional increment
+	const s32 value = m_value.fetch_op([&](s32& value)
+	{
+		if (value < _max)
+		{
+			value += 1;
+		}
+	});
+
+	if (value < 0)
+	{
+		imp_post(value);
+	}
+
+	return value < _max;
+}

Utilities/sema.h

@@ -0,0 +1,146 @@
+#pragma once
+
+#include "types.h"
+#include "Atomic.h"
+
+// Lightweight semaphore helper class
+class semaphore_base
+{
+	// Semaphore value
+	atomic_t<s32> m_value;
+
+	void imp_wait();
+
+	void imp_post(s32 _old);
+
+	friend class semaphore_lock;
+
+protected:
+	explicit constexpr semaphore_base(s32 value)
+		: m_value{value}
+	{
+	}
+
+	void wait()
+	{
+		// Load value
+		const s32 value = m_value.load();
+
+		// Conditional decrement
+		if (UNLIKELY(value <= 0 || !m_value.compare_and_swap_test(value, value - 1)))
+		{
+			imp_wait();
+		}
+	}
+
+	bool try_wait();
+
+	void post(s32 _max)
+	{
+		// Unconditional increment
+		const s32 value = m_value.fetch_add(1);
+
+		if (UNLIKELY(value < 0 || value >= _max))
+		{
+			imp_post(value);
+		}
+	}
+
+	bool try_post(s32 _max);
+
+public:
+	// Get current semaphore value
+	s32 get() const
+	{
+		// Load value
+		const s32 value = m_value;
+
+		// Return only positive value
+		return value < 0 ? 0 : value;
+	}
+};
+
+// Lightweight semaphore template (default arguments define binary semaphore and Def == Max)
+template <s32 Max = 1, s32 Def = Max>
+class semaphore final : public semaphore_base
+{
+	static_assert(Max >= 0, "semaphore<>: Max is out of bounds");
+	static_assert(Def >= 0, "semaphore<>: Def is out of bounds");
+	static_assert(Def <= Max, "semaphore<>: Def is too big");
+
+	using base = semaphore_base;
+
+public:
+	// Default constructor (recommended)
+	constexpr semaphore()
+		: base{Def}
+	{
+	}
+
+	// Explicit value constructor (not recommended)
+	explicit constexpr semaphore(s32 value)
+		: base{value}
+	{
+	}
+
+	// Obtain a semaphore
+	void wait()
+	{
+		return base::wait();
+	}
+
+	// Try to obtain a semaphore
+	explicit_bool_t try_wait()
+	{
+		return base::try_wait();
+	}
+
+	// Return a semaphore
+	void post()
+	{
+		return base::post(Max);
+	}
+
+	// Try to return a semaphore
+	explicit_bool_t try_post()
+	{
+		return base::try_post(Max);
+	}
+
+	// Get max semaphore value
+	static constexpr s32 size()
+	{
+		return Max;
+	}
+};
+
+class semaphore_lock
+{
+	semaphore_base& m_base;
+
+	void lock()
+	{
+		m_base.wait();
+	}
+
+	void unlock()
+	{
+		m_base.post(INT32_MAX);
+	}
+
+	friend class cond_variable;
+
+public:
+	explicit semaphore_lock(const semaphore_lock&) = delete;
+
+	semaphore_lock(semaphore_base& sema)
+		: m_base(sema)
+	{
+		lock();
+	}
+
+	~semaphore_lock()
+	{
+		unlock();
+	}
+};

Utilities/sync.h

@@ -3,187 +3,146 @@
 /* For internal use. Don't include. */
 
 #include "types.h"
-#include "Macro.h"
 #include "Atomic.h"
+#include "dynamic_library.h"
 
 #ifdef _WIN32
-
 #include <Windows.h>
-
-#define DYNAMIC_IMPORT(handle, name) do { name = reinterpret_cast<decltype(name)>(GetProcAddress(handle, #name)); } while (0)
-
-static NTSTATUS(*NtSetTimerResolution)(ULONG DesiredResolution, BOOLEAN SetResolution, PULONG CurrentResolution);
-static NTSTATUS(*NtWaitForKeyedEvent)(HANDLE Handle, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout);
-static NTSTATUS(*NtReleaseKeyedEvent)(HANDLE Handle, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout);
-
-namespace util
-{
-	static const bool keyed_init = []
-	{
-		const auto handle = LoadLibraryA("ntdll.dll");
-		DYNAMIC_IMPORT(handle, NtSetTimerResolution);
-		DYNAMIC_IMPORT(handle, NtWaitForKeyedEvent);
-		DYNAMIC_IMPORT(handle, NtReleaseKeyedEvent);
-		FreeLibrary(handle);
-
-		ULONG res = 100;
-		NtSetTimerResolution(100, TRUE, &res);
-
-		return NtWaitForKeyedEvent && NtReleaseKeyedEvent;
-	}();
-
-	// Wait for specified condition. func() acknowledges success by value modification.
-	template<typename F>
-	inline void keyed_wait(atomic_t<u32>& key, F&& func)
-	{
-		while (true)
-		{
-			u32 read = key.load();
-			u32 copy = read;
-
-			while (func(read), read != copy)
-			{
-				read = key.compare_and_swap(copy, read);
-				
-				if (copy == read)
-				{
-					return;
-				}
-				
-				copy = read;
-			}
-
-			NtWaitForKeyedEvent(NULL, &key, FALSE, NULL);
-		}
-	}
-
-	// Try to wake up a thread.
-	inline bool keyed_post(atomic_t<u32>& key, u32 acknowledged_value)
-	{
-		LARGE_INTEGER timeout;
-		timeout.QuadPart = -50;
-
-		while (UNLIKELY(NtReleaseKeyedEvent(NULL, &key, FALSE, &timeout) != ERROR_SUCCESS))
-		{
-			if (key.load() != acknowledged_value)
-				return false;
-		}
-
-		return true;
-	}
-
-	struct native_rwlock
-	{
-		SRWLOCK rwlock = SRWLOCK_INIT;
-
-		constexpr native_rwlock() = default;
-
-		native_rwlock(const native_rwlock&) = delete;
-
-		void lock()
-		{
-			AcquireSRWLockExclusive(&rwlock);
-		}
-
-		bool try_lock()
-		{
-			return TryAcquireSRWLockExclusive(&rwlock) != 0;
-		}
-
-		void unlock()
-		{
-			ReleaseSRWLockExclusive(&rwlock);
-		}
-
-		void lock_shared()
-		{
-			AcquireSRWLockShared(&rwlock);
-		}
-
-		bool try_lock_shared()
-		{
-			return TryAcquireSRWLockShared(&rwlock) != 0;
-		}
-
-		void unlock_shared()
-		{
-			ReleaseSRWLockShared(&rwlock);
-		}
-	};
-
-	struct native_cond
-	{
-		CONDITION_VARIABLE cond = CONDITION_VARIABLE_INIT;
-
-		constexpr native_cond() = default;
-
-		native_cond(const native_cond&) = delete;
-
-		void notify_one()
-		{
-			WakeConditionVariable(&cond);
-		}
-
-		void notify_all()
-		{
-			WakeAllConditionVariable(&cond);
-		}
-
-		void wait(native_rwlock& rwlock)
-		{
-			SleepConditionVariableSRW(&cond, &rwlock.rwlock, INFINITE, 0);
-		}
-
-		void wait_shared(native_rwlock& rwlock)
-		{
-			SleepConditionVariableSRW(&cond, &rwlock.rwlock, INFINITE, CONDITION_VARIABLE_LOCKMODE_SHARED);
-		}
-	};
-
-	class exclusive_lock
-	{
-		native_rwlock& m_rwlock;
-
-	public:
-		exclusive_lock(native_rwlock& rwlock)
-			: m_rwlock(rwlock)
-		{
-			m_rwlock.lock();
-		}
-
-		~exclusive_lock()
-		{
-			m_rwlock.unlock();
-		}
-	};
-
-	class shared_lock
-	{
-		native_rwlock& m_rwlock;
-
-	public:
-		shared_lock(native_rwlock& rwlock)
-			: m_rwlock(rwlock)
-		{
-			m_rwlock.lock_shared();
-		}
-
-		~shared_lock()
-		{
-			m_rwlock.unlock_shared();
-		}
-	};
-}
-
+#include <time.h>
+#elif __linux__
+#include <errno.h>
+#include <sys/syscall.h>
+#include <linux/futex.h>
+#include <sys/time.h>
+#include <unistd.h>
 #else
+#endif
+#include <ctime>
+#include <chrono>
+#include <mutex>
+#include <condition_variable>
+#include <unordered_map>
 
-namespace util
-{
-	struct native_rwlock;
-	struct native_cond;
-}
-
+#ifdef _WIN32
+DYNAMIC_IMPORT("ntdll.dll", NtSetTimerResolution, NTSTATUS(ULONG DesiredResolution, BOOLEAN SetResolution, PULONG CurrentResolution));
+DYNAMIC_IMPORT("ntdll.dll", NtWaitForKeyedEvent, NTSTATUS(HANDLE Handle, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout));
+DYNAMIC_IMPORT("ntdll.dll", NtReleaseKeyedEvent, NTSTATUS(HANDLE Handle, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout));
+DYNAMIC_IMPORT("ntdll.dll", NtDelayExecution, NTSTATUS(BOOLEAN Alertable, PLARGE_INTEGER DelayInterval));
 #endif
 
-CHECK_SIZE_ALIGN(util::native_rwlock, sizeof(void*), alignof(void*));
-CHECK_SIZE_ALIGN(util::native_cond, sizeof(void*), alignof(void*));
+#ifndef __linux__
+enum
+{
+	FUTEX_PRIVATE_FLAG = 0,
+	FUTEX_WAIT = 0,
+	FUTEX_WAIT_PRIVATE = FUTEX_WAIT,
+	FUTEX_WAKE = 1,
+	FUTEX_WAKE_PRIVATE = FUTEX_WAKE,
+	FUTEX_BITSET = 2,
+	FUTEX_WAIT_BITSET = FUTEX_WAIT | FUTEX_BITSET,
+	FUTEX_WAIT_BITSET_PRIVATE = FUTEX_WAIT_BITSET,
+	FUTEX_WAKE_BITSET = FUTEX_WAKE | FUTEX_BITSET,
+	FUTEX_WAKE_BITSET_PRIVATE = FUTEX_WAKE_BITSET,
+};
+#endif
+
+inline int futex(int* uaddr, int futex_op, int val, const timespec* timeout, int* uaddr2, int val3)
+{
+#ifdef __linux__
+	return syscall(SYS_futex, uaddr, futex_op, val, timeout, uaddr, val3);
+#else
+	static struct futex_map
+	{
+		struct waiter
+		{
+			 int val;
+			 uint mask;
+			 std::condition_variable cv;
+		};
+
+		std::mutex mutex;
+		std::unordered_multimap<int*, waiter*, pointer_hash<int>> map;
+
+		int operator()(int* uaddr, int futex_op, int val, const timespec* timeout, int*, uint val3)
+		{
+			std::unique_lock<std::mutex> lock(mutex);
+
+			switch (futex_op)
+			{
+			case FUTEX_WAIT:
+			{
+				val3 = -1;
+				// Fallthrough
+			}
+			case FUTEX_WAIT_BITSET:
+			{
+				if (*(volatile int*)uaddr != val)
+				{
+					errno = EAGAIN;
+					return -1;
+				}
+
+				waiter rec;
+				rec.val = val;
+				rec.mask = val3;
+				const auto& ref = *map.emplace(uaddr, &rec);
+
+				int res = 0;
+
+				if (!timeout)
+				{
+					rec.cv.wait(lock, [&] { return !rec.mask; });
+				}
+				else if (futex_op == FUTEX_WAIT)
+				{
+					const auto nsec = std::chrono::nanoseconds(timeout->tv_nsec + timeout->tv_sec * 1000000000ull);
+
+					if (!rec.cv.wait_for(lock, nsec, [&] { return !rec.mask; }))
+					{
+						res = -1;
+						errno = ETIMEDOUT;
+					}
+				}
+				else
+				{
+					// TODO
+				}
+				
+				map.erase(std::find(map.find(uaddr), map.end(), ref));
+				return res;
+			}
+
+			case FUTEX_WAKE:
+			{
+				val3 = -1;
+				// Fallthrough
+			}
+			case FUTEX_WAKE_BITSET:
+			{
+				int res = 0;
+
+				for (auto range = map.equal_range(uaddr); val && range.first != range.second; range.first++)
+				{
+					auto& entry = *range.first->second;
+					
+					if (entry.mask & val3)
+					{
+						entry.cv.notify_one();
+						entry.mask = 0;
+						res++;
+						val--;
+					}
+				}
+
+				return res;
+			}
+			}
+
+			errno = EINVAL;
+			return -1;
+		}
+	} g_futex;
+
+	return g_futex(uaddr, futex_op, val, timeout, uaddr2, val3);
+#endif
+}

Utilities/variant.hpp

@@ -0,0 +1,963 @@
+#ifndef MAPBOX_UTIL_VARIANT_HPP
+#define MAPBOX_UTIL_VARIANT_HPP
+
+#include <cassert>
+#include <cstddef>   // size_t
+#include <new>       // operator new
+#include <stdexcept> // runtime_error
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+#include "recursive_wrapper.hpp"
+
+// clang-format off
+// [[deprecated]] is only available in C++14, use this for the time being
+#if __cplusplus <= 201103L
+# ifdef __GNUC__
+#  define MAPBOX_VARIANT_DEPRECATED __attribute__((deprecated))
+# elif defined(_MSC_VER)
+#  define MAPBOX_VARIANT_DEPRECATED __declspec(deprecated)
+# else
+#  define MAPBOX_VARIANT_DEPRECATED
+# endif
+#else
+#  define MAPBOX_VARIANT_DEPRECATED [[deprecated]]
+#endif
+
+
+#ifdef _MSC_VER
+// https://msdn.microsoft.com/en-us/library/bw1hbe6y.aspx
+# ifdef NDEBUG
+#  define VARIANT_INLINE __forceinline
+# else
+#  define VARIANT_INLINE //__declspec(noinline)
+# endif
+#else
+# ifdef NDEBUG
+#  define VARIANT_INLINE //inline __attribute__((always_inline))
+# else
+#  define VARIANT_INLINE __attribute__((noinline))
+# endif
+#endif
+// clang-format on
+
+// Exceptions
+#if defined( __EXCEPTIONS) || defined( _MSC_VER)
+#define HAS_EXCEPTIONS
+#endif
+
+#define VARIANT_MAJOR_VERSION 1
+#define VARIANT_MINOR_VERSION 1
+#define VARIANT_PATCH_VERSION 0
+
+#define VARIANT_VERSION (VARIANT_MAJOR_VERSION * 100000) + (VARIANT_MINOR_VERSION * 100) + (VARIANT_PATCH_VERSION)
+
+//namespace mapbox {
+//	namespace util {
+namespace std {
+
+		// XXX This should derive from std::logic_error instead of std::runtime_error.
+		//     See https://github.com/mapbox/variant/issues/48 for details.
+		class bad_variant_access : public std::runtime_error
+		{
+
+		public:
+			explicit bad_variant_access(const std::string& what_arg)
+				: runtime_error(what_arg) {}
+
+			explicit bad_variant_access(const char* what_arg)
+				: runtime_error(what_arg) {}
+
+		}; // class bad_variant_access
+
+		namespace detail {
+
+			static constexpr std::size_t invalid_value = std::size_t(-1);
+
+			template <typename T, typename... Types>
+			struct direct_type;
+
+			template <typename T, typename First, typename... Types>
+			struct direct_type<T, First, Types...>
+			{
+				static constexpr std::size_t index = std::is_same<T, First>::value
+					? sizeof...(Types)
+					: direct_type<T, Types...>::index;
+			};
+
+			template <typename T>
+			struct direct_type<T>
+			{
+				static constexpr std::size_t index = invalid_value;
+			};
+
+#if __cpp_lib_logical_traits >= 201510L
+
+			using std::disjunction;
+
+#else
+
+			template <typename...>
+			struct disjunction : std::false_type {};
+
+			template <typename B1>
+			struct disjunction<B1> : B1 {};
+
+			template <typename B1, typename B2>
+			struct disjunction<B1, B2> : std::conditional<B1::value, B1, B2>::type {};
+
+			template <typename B1, typename... Bs>
+			struct disjunction<B1, Bs...> : std::conditional<B1::value, B1, disjunction<Bs...>>::type {};
+
+#endif
+
+			template <typename T, typename... Types>
+			struct convertible_type;
+
+			template <typename T, typename First, typename... Types>
+			struct convertible_type<T, First, Types...>
+			{
+				static constexpr std::size_t index = std::is_convertible<T, First>::value
+					? disjunction<std::is_convertible<T, Types>...>::value ? invalid_value : sizeof...(Types)
+					: convertible_type<T, Types...>::index;
+			};
+
+			template <typename T>
+			struct convertible_type<T>
+			{
+				static constexpr std::size_t index = invalid_value;
+			};
+
+			template <typename T, typename... Types>
+			struct value_traits
+			{
+				using value_type = typename std::remove_const<typename std::remove_reference<T>::type>::type;
+				static constexpr std::size_t direct_index = direct_type<value_type, Types...>::index;
+				static constexpr bool is_direct = direct_index != invalid_value;
+				static constexpr std::size_t index = is_direct ? direct_index : convertible_type<value_type, Types...>::index;
+				static constexpr bool is_valid = index != invalid_value;
+				static constexpr std::size_t tindex = is_valid ? sizeof...(Types)-index : 0;
+				using target_type = typename std::tuple_element<tindex, std::tuple<void, Types...>>::type;
+			};
+
+			template <typename T, typename R = void>
+			struct enable_if_type
+			{
+				using type = R;
+			};
+
+			template <typename F, typename V, typename Enable = void>
+			struct result_of_unary_visit
+			{
+				using type = typename std::result_of<F(V&)>::type;
+			};
+
+			template <typename F, typename V>
+			struct result_of_unary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
+			{
+				using type = typename F::result_type;
+			};
+
+			template <typename F, typename V, typename Enable = void>
+			struct result_of_binary_visit
+			{
+				using type = typename std::result_of<F(V&, V&)>::type;
+			};
+
+			template <typename F, typename V>
+			struct result_of_binary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
+			{
+				using type = typename F::result_type;
+			};
+
+			template <std::size_t arg1, std::size_t... others>
+			struct static_max;
+
+			template <std::size_t arg>
+			struct static_max<arg>
+			{
+				static const std::size_t value = arg;
+			};
+
+			template <std::size_t arg1, std::size_t arg2, std::size_t... others>
+			struct static_max<arg1, arg2, others...>
+			{
+				static const std::size_t value = arg1 >= arg2 ? static_max<arg1, others...>::value : static_max<arg2, others...>::value;
+			};
+
+			template <typename... Types>
+			struct variant_helper;
+
+			template <typename T, typename... Types>
+			struct variant_helper<T, Types...>
+			{
+				VARIANT_INLINE static void destroy(const std::size_t type_index, void* data)
+				{
+					if (type_index == sizeof...(Types))
+					{
+						reinterpret_cast<T*>(data)->~T();
+					}
+					else
+					{
+						variant_helper<Types...>::destroy(type_index, data);
+					}
+				}
+
+				VARIANT_INLINE static void move(const std::size_t old_type_index, void* old_value, void* new_value)
+				{
+					if (old_type_index == sizeof...(Types))
+					{
+						new (new_value) T(std::move(*reinterpret_cast<T*>(old_value)));
+					}
+					else
+					{
+						variant_helper<Types...>::move(old_type_index, old_value, new_value);
+					}
+				}
+
+				VARIANT_INLINE static void copy(const std::size_t old_type_index, const void* old_value, void* new_value)
+				{
+					if (old_type_index == sizeof...(Types))
+					{
+						new (new_value) T(*reinterpret_cast<const T*>(old_value));
+					}
+					else
+					{
+						variant_helper<Types...>::copy(old_type_index, old_value, new_value);
+					}
+				}
+			};
+
+			template <>
+			struct variant_helper<>
+			{
+				VARIANT_INLINE static void destroy(const std::size_t, void*) {}
+				VARIANT_INLINE static void move(const std::size_t, void*, void*) {}
+				VARIANT_INLINE static void copy(const std::size_t, const void*, void*) {}
+			};
+
+			template <typename T>
+			struct unwrapper
+			{
+				static T const& apply_const(T const& obj) { return obj; }
+				static T& apply(T& obj) { return obj; }
+			};
+
+			template <typename T>
+			struct unwrapper<recursive_wrapper<T>>
+			{
+				static auto apply_const(recursive_wrapper<T> const& obj)
+					-> typename recursive_wrapper<T>::type const&
+				{
+					return obj.get();
+				}
+				static auto apply(recursive_wrapper<T>& obj)
+					-> typename recursive_wrapper<T>::type&
+				{
+					return obj.get();
+				}
+			};
+
+			template <typename T>
+			struct unwrapper<std::reference_wrapper<T>>
+			{
+				static auto apply_const(std::reference_wrapper<T> const& obj)
+					-> typename std::reference_wrapper<T>::type const&
+				{
+					return obj.get();
+				}
+				static auto apply(std::reference_wrapper<T>& obj)
+					-> typename std::reference_wrapper<T>::type&
+				{
+					return obj.get();
+				}
+			};
+
+			template <typename F, typename V, typename R, typename... Types>
+			struct dispatcher;
+
+			template <typename F, typename V, typename R, typename T, typename... Types>
+			struct dispatcher<F, V, R, T, Types...>
+			{
+				VARIANT_INLINE static R apply_const(V const& v, F&& f)
+				{
+					if (v.template is<T>())
+					{
+						return f(unwrapper<T>::apply_const(v.template get_unchecked<T>()));
+					}
+					else
+					{
+						return dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
+					}
+				}
+
+				VARIANT_INLINE static R apply(V& v, F&& f)
+				{
+					if (v.template is<T>())
+					{
+						return f(unwrapper<T>::apply(v.template get_unchecked<T>()));
+					}
+					else
+					{
+						return dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
+					}
+				}
+			};
+
+			template <typename F, typename V, typename R, typename T>
+			struct dispatcher<F, V, R, T>
+			{
+				VARIANT_INLINE static R apply_const(V const& v, F&& f)
+				{
+					return f(unwrapper<T>::apply_const(v.template get_unchecked<T>()));
+				}
+
+				VARIANT_INLINE static R apply(V& v, F&& f)
+				{
+					return f(unwrapper<T>::apply(v.template get_unchecked<T>()));
+				}
+			};
+
+			template <typename F, typename V, typename R, typename T, typename... Types>
+			struct binary_dispatcher_rhs;
+
+			template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
+			struct binary_dispatcher_rhs<F, V, R, T0, T1, Types...>
+			{
+				VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
+				{
+					if (rhs.template is<T1>()) // call binary functor
+					{
+						return f(unwrapper<T0>::apply_const(lhs.template get_unchecked<T0>()),
+							unwrapper<T1>::apply_const(rhs.template get_unchecked<T1>()));
+					}
+					else
+					{
+						return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
+					}
+				}
+
+				VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
+				{
+					if (rhs.template is<T1>()) // call binary functor
+					{
+						return f(unwrapper<T0>::apply(lhs.template get_unchecked<T0>()),
+							unwrapper<T1>::apply(rhs.template get_unchecked<T1>()));
+					}
+					else
+					{
+						return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
+					}
+				}
+			};
+
+			template <typename F, typename V, typename R, typename T0, typename T1>
+			struct binary_dispatcher_rhs<F, V, R, T0, T1>
+			{
+				VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
+				{
+					return f(unwrapper<T0>::apply_const(lhs.template get_unchecked<T0>()),
+						unwrapper<T1>::apply_const(rhs.template get_unchecked<T1>()));
+				}
+
+				VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
+				{
+					return f(unwrapper<T0>::apply(lhs.template get_unchecked<T0>()),
+						unwrapper<T1>::apply(rhs.template get_unchecked<T1>()));
+				}
+			};
+
+			template <typename F, typename V, typename R, typename T, typename... Types>
+			struct binary_dispatcher_lhs;
+
+			template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
+			struct binary_dispatcher_lhs<F, V, R, T0, T1, Types...>
+			{
+				VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
+				{
+					if (lhs.template is<T1>()) // call binary functor
+					{
+						return f(unwrapper<T1>::apply_const(lhs.template get_unchecked<T1>()),
+							unwrapper<T0>::apply_const(rhs.template get_unchecked<T0>()));
+					}
+					else
+					{
+						return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
+					}
+				}
+
+				VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
+				{
+					if (lhs.template is<T1>()) // call binary functor
+					{
+						return f(unwrapper<T1>::apply(lhs.template get_unchecked<T1>()),
+							unwrapper<T0>::apply(rhs.template get_unchecked<T0>()));
+					}
+					else
+					{
+						return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
+					}
+				}
+			};
+
+			template <typename F, typename V, typename R, typename T0, typename T1>
+			struct binary_dispatcher_lhs<F, V, R, T0, T1>
+			{
+				VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
+				{
+					return f(unwrapper<T1>::apply_const(lhs.template get_unchecked<T1>()),
+						unwrapper<T0>::apply_const(rhs.template get_unchecked<T0>()));
+				}
+
+				VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
+				{
+					return f(unwrapper<T1>::apply(lhs.template get_unchecked<T1>()),
+						unwrapper<T0>::apply(rhs.template get_unchecked<T0>()));
+				}
+			};
+
+			template <typename F, typename V, typename R, typename... Types>
+			struct binary_dispatcher;
+
+			template <typename F, typename V, typename R, typename T, typename... Types>
+			struct binary_dispatcher<F, V, R, T, Types...>
+			{
+				VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
+				{
+					if (v0.template is<T>())
+					{
+						if (v1.template is<T>())
+						{
+							return f(unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
+								unwrapper<T>::apply_const(v1.template get_unchecked<T>())); // call binary functor
+						}
+						else
+						{
+							return binary_dispatcher_rhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
+						}
+					}
+					else if (v1.template is<T>())
+					{
+						return binary_dispatcher_lhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
+					}
+					return binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
+				}
+
+				VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
+				{
+					if (v0.template is<T>())
+					{
+						if (v1.template is<T>())
+						{
+							return f(unwrapper<T>::apply(v0.template get_unchecked<T>()),
+								unwrapper<T>::apply(v1.template get_unchecked<T>())); // call binary functor
+						}
+						else
+						{
+							return binary_dispatcher_rhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
+						}
+					}
+					else if (v1.template is<T>())
+					{
+						return binary_dispatcher_lhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
+					}
+					return binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
+				}
+			};
+
+			template <typename F, typename V, typename R, typename T>
+			struct binary_dispatcher<F, V, R, T>
+			{
+				VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
+				{
+					return f(unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
+						unwrapper<T>::apply_const(v1.template get_unchecked<T>())); // call binary functor
+				}
+
+				VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
+				{
+					return f(unwrapper<T>::apply(v0.template get_unchecked<T>()),
+						unwrapper<T>::apply(v1.template get_unchecked<T>())); // call binary functor
+				}
+			};
+
+			// comparator functors
+			struct equal_comp
+			{
+				template <typename T>
+				bool operator()(T const& lhs, T const& rhs) const
+				{
+					return lhs == rhs;
+				}
+			};
+
+			struct less_comp
+			{
+				template <typename T>
+				bool operator()(T const& lhs, T const& rhs) const
+				{
+					return lhs < rhs;
+				}
+			};
+
+			template <typename Variant, typename Comp>
+			class comparer
+			{
+			public:
+				explicit comparer(Variant const& lhs) noexcept
+					: lhs_(lhs) {}
+				comparer& operator=(comparer const&) = delete;
+				// visitor
+				template <typename T>
+				bool operator()(T const& rhs_content) const
+				{
+					T const& lhs_content = lhs_.template get_unchecked<T>();
+					return Comp()(lhs_content, rhs_content);
+				}
+
+			private:
+				Variant const& lhs_;
+			};
+
+		} // namespace detail
+
+		struct no_init
+		{
+		};
+
+		template <typename... Types>
+		class variant
+		{
+			static_assert(sizeof...(Types) > 0, "Template parameter type list of variant can not be empty");
+			static_assert(!detail::disjunction<std::is_reference<Types>...>::value, "Variant can not hold reference types. Maybe use std::reference_wrapper?");
+
+		private:
+			static const std::size_t data_size = detail::static_max<sizeof(Types)...>::value;
+			static const std::size_t data_align = detail::static_max<alignof(Types)...>::value;
+
+			using first_type = typename std::tuple_element<0, std::tuple<Types...>>::type;
+			using data_type = typename std::aligned_storage<data_size, data_align>::type;
+			using helper_type = detail::variant_helper<Types...>;
+
+			std::size_t type_index;
+			data_type data;
+
+		public:
+			VARIANT_INLINE variant() noexcept(std::is_nothrow_default_constructible<first_type>::value)
+				: type_index(sizeof...(Types)-1)
+			{
+				static_assert(std::is_default_constructible<first_type>::value, "First type in variant must be default constructible to allow default construction of variant");
+				new (&data) first_type();
+			}
+
+			VARIANT_INLINE variant(no_init) noexcept
+				: type_index(detail::invalid_value) {}
+
+			// http://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers
+			template <typename T, typename Traits = detail::value_traits<T, Types...>,
+				typename Enable = typename std::enable_if<Traits::is_valid>::type>
+				VARIANT_INLINE variant(T&& val) noexcept(std::is_nothrow_constructible<typename Traits::target_type, T&&>::value)
+				: type_index(Traits::index)
+			{
+				new (&data) typename Traits::target_type(std::forward<T>(val));
+			}
+
+			VARIANT_INLINE variant(variant<Types...> const& old)
+				: type_index(old.type_index)
+			{
+				helper_type::copy(old.type_index, &old.data, &data);
+			}
+
+			VARIANT_INLINE variant(variant<Types...>&& old) noexcept(std::is_nothrow_move_constructible<std::tuple<Types...>>::value)
+				: type_index(old.type_index)
+			{
+				helper_type::move(old.type_index, &old.data, &data);
+			}
+
+		private:
+			VARIANT_INLINE void copy_assign(variant<Types...> const& rhs)
+			{
+				helper_type::destroy(type_index, &data);
+				type_index = detail::invalid_value;
+				helper_type::copy(rhs.type_index, &rhs.data, &data);
+				type_index = rhs.type_index;
+			}
+
+			VARIANT_INLINE void move_assign(variant<Types...>&& rhs)
+			{
+				helper_type::destroy(type_index, &data);
+				type_index = detail::invalid_value;
+				helper_type::move(rhs.type_index, &rhs.data, &data);
+				type_index = rhs.type_index;
+			}
+
+		public:
+			VARIANT_INLINE variant<Types...>& operator=(variant<Types...>&& other)
+			{
+				move_assign(std::move(other));
+				return *this;
+			}
+
+			VARIANT_INLINE variant<Types...>& operator=(variant<Types...> const& other)
+			{
+				copy_assign(other);
+				return *this;
+			}
+
+			// conversions
+			// move-assign
+			template <typename T>
+			VARIANT_INLINE variant<Types...>& operator=(T&& rhs) noexcept
+			{
+				variant<Types...> temp(std::forward<T>(rhs));
+				move_assign(std::move(temp));
+				return *this;
+			}
+
+			// copy-assign
+			template <typename T>
+			VARIANT_INLINE variant<Types...>& operator=(T const& rhs)
+			{
+				variant<Types...> temp(rhs);
+				copy_assign(temp);
+				return *this;
+			}
+
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE bool is() const
+			{
+				return type_index == detail::direct_type<T, Types...>::index;
+			}
+
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE bool is() const
+			{
+				return type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index;
+			}
+
+			VARIANT_INLINE bool valid() const
+			{
+				return type_index != detail::invalid_value;
+			}
+
+			template <typename T, typename... Args>
+			VARIANT_INLINE void set(Args&&... args)
+			{
+				helper_type::destroy(type_index, &data);
+				type_index = detail::invalid_value;
+				new (&data) T(std::forward<Args>(args)...);
+				type_index = detail::direct_type<T, Types...>::index;
+			}
+
+			// get_unchecked<T>()
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T& get_unchecked()
+			{
+				return *reinterpret_cast<T*>(&data);
+			}
+
+#ifdef HAS_EXCEPTIONS
+			// get<T>()
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T& get()
+			{
+				if (type_index == detail::direct_type<T, Types...>::index)
+				{
+					return *reinterpret_cast<T*>(&data);
+				}
+				else
+				{
+					throw bad_variant_access("in get<T>()");
+				}
+			}
+#endif
+
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T const& get_unchecked() const
+			{
+				return *reinterpret_cast<T const*>(&data);
+			}
+
+#ifdef HAS_EXCEPTIONS
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T const& get() const
+			{
+				if (type_index == detail::direct_type<T, Types...>::index)
+				{
+					return *reinterpret_cast<T const*>(&data);
+				}
+				else
+				{
+					throw bad_variant_access("in get<T>()");
+				}
+			}
+#endif
+
+			// get_unchecked<T>() - T stored as recursive_wrapper<T>
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T& get_unchecked()
+			{
+				return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
+			}
+
+#ifdef HAS_EXCEPTIONS
+			// get<T>() - T stored as recursive_wrapper<T>
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T& get()
+			{
+				if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
+				{
+					return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
+				}
+				else
+				{
+					throw bad_variant_access("in get<T>()");
+				}
+			}
+#endif
+
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T const& get_unchecked() const
+			{
+				return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
+			}
+
+#ifdef HAS_EXCEPTIONS
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T const& get() const
+			{
+				if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
+				{
+					return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
+				}
+				else
+				{
+					throw bad_variant_access("in get<T>()");
+				}
+			}
+#endif
+
+			// get_unchecked<T>() - T stored as std::reference_wrapper<T>
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T& get_unchecked()
+			{
+				return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
+			}
+
+#ifdef HAS_EXCEPTIONS
+			// get<T>() - T stored as std::reference_wrapper<T>
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T& get()
+			{
+				if (type_index == detail::direct_type<std::reference_wrapper<T>, Types...>::index)
+				{
+					return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
+				}
+				else
+				{
+					throw bad_variant_access("in get<T>()");
+				}
+			}
+#endif
+
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T const& get_unchecked() const
+			{
+				return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
+			}
+
+#ifdef HAS_EXCEPTIONS
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE T const& get() const
+			{
+				if (type_index == detail::direct_type<std::reference_wrapper<T const>, Types...>::index)
+				{
+					return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
+				}
+				else
+				{
+					throw bad_variant_access("in get<T>()");
+				}
+			}
+#endif
+
+			// This function is deprecated because it returns an internal index field.
+			// Use which() instead.
+			MAPBOX_VARIANT_DEPRECATED VARIANT_INLINE std::size_t get_type_index() const
+			{
+				return type_index;
+			}
+
+			VARIANT_INLINE int which() const noexcept
+			{
+				return static_cast<int>(sizeof...(Types)-type_index - 1);
+			}
+
+			template <typename T, typename std::enable_if<
+				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+				VARIANT_INLINE static constexpr int which() noexcept
+			{
+				return static_cast<int>(sizeof...(Types)-detail::direct_type<T, Types...>::index - 1);
+			}
+
+			// visitor
+			// unary
+			template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
+			auto VARIANT_INLINE static visit(V const& v, F&& f)
+				-> decltype(detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f)))
+			{
+				return detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
+			}
+			// non-const
+			template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
+			auto VARIANT_INLINE static visit(V& v, F&& f)
+				-> decltype(detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f)))
+			{
+				return detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
+			}
+
+			// binary
+			// const
+			template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
+			auto VARIANT_INLINE static binary_visit(V const& v0, V const& v1, F&& f)
+				-> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f)))
+			{
+				return detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
+			}
+			// non-const
+			template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
+			auto VARIANT_INLINE static binary_visit(V& v0, V& v1, F&& f)
+				-> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f)))
+			{
+				return detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
+			}
+
+			~variant() noexcept // no-throw destructor
+			{
+				helper_type::destroy(type_index, &data);
+			}
+
+			// comparison operators
+			// equality
+			VARIANT_INLINE bool operator==(variant const& rhs) const
+			{
+				assert(valid() && rhs.valid());
+				if (this->which() != rhs.which())
+				{
+					return false;
+				}
+				detail::comparer<variant, detail::equal_comp> visitor(*this);
+				return visit(rhs, visitor);
+			}
+
+			VARIANT_INLINE bool operator!=(variant const& rhs) const
+			{
+				return !(*this == rhs);
+			}
+
+			// less than
+			VARIANT_INLINE bool operator<(variant const& rhs) const
+			{
+				assert(valid() && rhs.valid());
+				if (this->which() != rhs.which())
+				{
+					return this->which() < rhs.which();
+				}
+				detail::comparer<variant, detail::less_comp> visitor(*this);
+				return visit(rhs, visitor);
+			}
+			VARIANT_INLINE bool operator>(variant const& rhs) const
+			{
+				return rhs < *this;
+			}
+			VARIANT_INLINE bool operator<=(variant const& rhs) const
+			{
+				return !(*this > rhs);
+			}
+			VARIANT_INLINE bool operator>=(variant const& rhs) const
+			{
+				return !(*this < rhs);
+			}
+		};
+
+		// unary visitor interface
+		// const
+		template <typename F, typename V>
+		auto VARIANT_INLINE apply_visitor(F&& f, V const& v) -> decltype(V::visit(v, std::forward<F>(f)))
+		{
+			return V::visit(v, std::forward<F>(f));
+		}
+
+		// non-const
+		template <typename F, typename V>
+		auto VARIANT_INLINE apply_visitor(F&& f, V& v) -> decltype(V::visit(v, std::forward<F>(f)))
+		{
+			return V::visit(v, std::forward<F>(f));
+		}
+
+		// binary visitor interface
+		// const
+		template <typename F, typename V>
+		auto VARIANT_INLINE apply_visitor(F&& f, V const& v0, V const& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
+		{
+			return V::binary_visit(v0, v1, std::forward<F>(f));
+		}
+
+		// non-const
+		template <typename F, typename V>
+		auto VARIANT_INLINE apply_visitor(F&& f, V& v0, V& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
+		{
+			return V::binary_visit(v0, v1, std::forward<F>(f));
+		}
+
+		// getter interface
+
+#ifdef HAS_EXCEPTIONS
+		template <typename ResultType, typename T>
+		auto get(T& var)->decltype(var.template get<ResultType>())
+		{
+			return var.template get<ResultType>();
+		}
+#endif
+
+		template <typename ResultType, typename T>
+		ResultType& get_unchecked(T& var)
+		{
+			return var.template get_unchecked<ResultType>();
+		}
+
+#ifdef HAS_EXCEPTIONS
+		template <typename ResultType, typename T>
+		auto get(T const& var)->decltype(var.template get<ResultType>())
+		{
+			return var.template get<ResultType>();
+		}
+#endif
+
+		template <typename ResultType, typename T>
+		ResultType const& get_unchecked(T const& var)
+		{
+			return var.template get_unchecked<ResultType>();
+		}
+	}
+//	} // namespace util
+//} // namespace mapbox
+
+#endif // MAPBOX_UTIL_VARIANT_HPP

Utilities/version.cpp

@@ -14,26 +14,12 @@ namespace utils
 		case version_type::release: return "Release";
 		}
 
-		throw;
+		return "Unknown";
 	}
 
-	version::version(std::uint8_t hi, std::uint8_t mid, std::uint8_t lo)
-		: m_hi(hi)
-		, m_mid(mid)
-		, m_lo(lo)
+	uint version::to_hex() const
 	{
-	}
-
-	version& version::type(version_type type, std::uint8_t type_index)
-	{
-		m_type = type;
-		m_type_index = type_index;
-		return *this;
-	}
-
-	std::uint16_t version::to_hex() const
-	{
-		return (m_hi << 24) | (m_mid << 16) | (m_lo << 8) | ((std::uint8_t(m_type) & 0xf) << 4) | (m_type_index & 0xf);
+		return (m_hi << 24) | (m_mid << 16) | (m_lo << 8) | ((uint(m_type) & 0xf) << 4) | (m_type_index & 0xf);
 	}
 
 	std::string version::to_string() const

Utilities/version.h

@@ -1,10 +1,11 @@
 #pragma once
+
+#include "types.h"
 #include <string>
-#include <cstdint>
 
 namespace utils
 {
-	enum class version_type : std::uint8_t
+	enum class version_type : uint
 	{
 		pre_alpha,
 		alpha,
@@ -17,29 +18,35 @@ namespace utils
 
 	class version
 	{
-		std::uint8_t m_hi;
-		std::uint8_t m_mid;
-		std::uint8_t m_lo;
+		uint m_hi;
+		uint m_mid;
+		uint m_lo;
 		version_type m_type = version_type::release;
-		std::uint8_t m_type_index = 1;
-		std::string m_postfix;
+		uint m_type_index = 1;
+		const char* m_postfix;
 
 	public:
-		version(std::uint8_t hi, std::uint8_t mid, std::uint8_t lo = 0);
+		constexpr version(uint hi, uint mid, uint lo, version_type type, uint type_index, const char* postfix)
+			: m_hi(hi)
+			, m_mid(mid)
+			, m_lo(lo)
+			, m_type(type)
+			, m_type_index(type_index)
+			, m_postfix(postfix)
+		{
+		}
 
-		version& type(version_type type, std::uint8_t type_index = 1);
-
-		std::uint8_t hi() const
+		uint hi() const
 		{
 			return m_hi;
 		}
 
-		std::uint8_t mid() const
+		uint mid() const
 		{
 			return m_mid;
 		}
 
-		std::uint8_t lo() const
+		uint lo() const
 		{
 			return m_lo;
 		}
@@ -54,18 +61,12 @@ namespace utils
 			return m_postfix;
 		}
 
-		version& postfix(const std::string& value)
-		{
-			m_postfix = value;
-			return *this;
-		}
-
-		std::uint8_t type_index() const
+		uint type_index() const
 		{
 			return m_type_index;
 		}
 
-		std::uint16_t to_hex() const;
+		uint to_hex() const;
 		std::string to_string() const;
 	};
 }

Vulkan/CMakeLists.txt

@@ -1,8 +1,6 @@
-if(APPLE)
-else()
+if(WIN32 AND NOT VULKAN_PREBUILT)
 set(BUILD_TESTS OFF CACHE BOOL "Build tests" FORCE)
 set(BUILD_DEMOS OFF CACHE BOOL "Build demos" FORCE)
-# TravisCI break build with layers and vkjson
 set(BUILD_LAYERS OFF CACHE BOOL "Build demos" FORCE)
 set(BUILD_VKJSON OFF CACHE BOOL "Build demos" FORCE)
 add_subdirectory( Vulkan-LoaderAndValidationLayers )

Vulkan/Vulkan-build/Vulkan-build.vcxproj

@@ -39,23 +39,20 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Release
-    </NMakeBuildCommandLine>
-    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF ../Vulkan-LoaderAndValidationLayers
+    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
+msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Release</NMakeBuildCommandLine>
+    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Release</NMakeCleanCommandLine>
-    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF ../Vulkan-LoaderAndValidationLayers
+    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Release
     </NMakeReBuildCommandLine>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Debug
-    </NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Debug
-    </NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF ../Vulkan-LoaderAndValidationLayers
+    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
+msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Debug</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
+msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Debug</NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Debug</NMakeCleanCommandLine>
   </PropertyGroup>
   <ItemDefinitionGroup>

appveyor.yml

@@ -1,29 +1,32 @@
-version: 1.0.{build}
+version: '0.0.2-{build}'
+
 os: Visual Studio 2015
-configuration:
-# - Release
- - ReleaseLLVM
 platform: x64
-clone_folder: c:\rpcs3
+clone_folder: C:\rpcs3
 clone_depth: 3
 test: off
 
+configuration:
+# Release
+ - ReleaseLLVM
+
 before_build:
- # until git for win 2.5 release with commit checkout
- - git submodule update --init 3rdparty/ffmpeg 3rdparty/pugixml asmjit 3rdparty/GSL 3rdparty/libpng Vulkan/glslang Vulkan/Vulkan-LoaderAndValidationLayers Utilities/yaml-cpp rsx_program_decompiler
+ - ps: $env:Date="$(git show -s --date=short --format='%ad')"
+ - git submodule update --init 3rdparty/ffmpeg 3rdparty/pugixml asmjit 3rdparty/GSL 3rdparty/libpng Vulkan/glslang Vulkan/Vulkan-LoaderAndValidationLayers Utilities/yaml-cpp rsx_program_decompiler 3rdparty/cereal
  - 7z x wxWidgets.7z -aos -oC:\rpcs3\wxWidgets > null
  - 7z x zlib.7z -aos -oC:\rpcs3\ > null
- - if %configuration%==Release (cmake -G "Visual Studio 14 Win64" -DZLIB_ROOT=C:/rpcs3/zlib/)
-   else (7z x llvmlibs.7z -aos -oC:\rpcs3 > null && cmake -G "Visual Studio 14 Win64" -DLLVM_DIR=C:/rpcs3/llvm_build/share/llvm/cmake -DZLIB_ROOT=C:/rpcs3/zlib/)
+ - 7z x vulkan.7z -aos -oC:\rpcs3\Vulkan > null
+ - if %configuration%==Release (cmake -G "Visual Studio 14 Win64" -DZLIB_ROOT=C:/rpcs3/zlib/ -DVULKAN_PREBUILT=ON)
+   else (7z x llvmlibs.7z -aos -oC:\rpcs3 > null && cmake -G "Visual Studio 14 Win64" -DLLVM_DIR=C:/rpcs3/llvm_build/share/llvm/cmake -DZLIB_ROOT=C:/rpcs3/zlib/ -DVULKAN_PREBUILT=ON)
 
 build_script:
  - cmake --build . --config Release -- /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
 
 install:
- - ps: Start-FileDownload 'https://402331b94f8e4b87ae2ef4677347f7956cf3861f.googledrive.com/host/0B6v_qtb9hkicfmt0NG0wTTRtUmF4X3VTQk5Oc2JidEVKVnUteDA1dXdrYlNsVW9kREpsSHc/wxWidgets.7z'
-# - ps: Start-FileDownload 'https://402331b94f8e4b87ae2ef4677347f7956cf3861f.googledrive.com/host/0B6v_qtb9hkicfmt0NG0wTTRtUmF4X3VTQk5Oc2JidEVKVnUteDA1dXdrYlNsVW9kREpsSHc/llvmlibs.7z'
- - ps: Start-FileDownload 'https://drive.google.com/uc?export=download&id=0B-98fOyaZKJ5YWVnb29JZXFQWkU' -FileName llvmlibs.7z
- - ps: Start-FileDownload 'https://402331b94f8e4b87ae2ef4677347f7956cf3861f.googledrive.com/host/0B6v_qtb9hkicfmt0NG0wTTRtUmF4X3VTQk5Oc2JidEVKVnUteDA1dXdrYlNsVW9kREpsSHc/zlib.7z'
+ - appveyor DownloadFile "https://dl.dropboxusercontent.com/s/c1by0uulee6g8th/wxWidgets.7z?dl=0" -FileName wxWidgets.7z
+ - appveyor DownloadFile "https://drive.google.com/uc?export=download&id=0B-98fOyaZKJ5YWVnb29JZXFQWkU" -FileName llvmlibs.7z
+ - appveyor DownloadFile "https://drive.google.com/uc?export=download&id=0B8A6NaxhQAGRa21fbDQteTN1dGs" -FileName vulkan.7z
+ - appveyor DownloadFile "https://drive.google.com/uc?export=download&id=0B6v_qtb9hkicQ2hHa2dRbF83cE0" -FileName zlib.7z
  - set WXWIN=C:\rpcs3\wxWidgets
  - set OPENALDIR=C:\rpcs3\3rdparty\OpenAL
  - set PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;C:\wxWidgets;%PATH%
@@ -31,4 +34,5 @@ install:
 
 artifacts:
  - path: bin
-   name: rpcs3-$(configuration)-$(COMMIT_SHA)
+   name: 'rpcs3-v0.0.2-$(Date)-$(COMMIT_SHA)_win64'
+   type: zip

bin/dev_hdd1/.gitignore

@@ -2,5 +2,3 @@
 *
 # Except this file
 !.gitignore
-!cache
-!cache/README.txt

bin/dev_hdd1/cache/README.txt

@@ -1 +0,0 @@
-This directory is used for cache functionality, so don't store any data here.

bin/dev_hdd1/game/README.txt

@@ -1 +0,0 @@
-This directory is used for temporary gamedata functionality, so don't store any data here.

bin/dev_usb000/.gitignore

@@ -1,4 +1,4 @@
 # Ignore everything in this directory
 *
 # Except this file
-!.gitignore
+!.gitignore

git-clang-format

@@ -0,0 +1,485 @@
+#!/usr/bin/env python
+#
+#===- git-clang-format - ClangFormat Git Integration ---------*- python -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+r"""                                                                             
+clang-format git integration                                                     
+============================                                                     
+                                                                                 
+This file provides a clang-format integration for git. Put it somewhere in your  
+path and ensure that it is executable. Then, "git clang-format" will invoke      
+clang-format on the changes in current files or a specific commit.               
+                                                                                 
+For further details, run:                                                        
+git clang-format -h                                                              
+                                                                                 
+Requires Python 2.7                                                              
+"""               
+
+import argparse
+import collections
+import contextlib
+import errno
+import os
+import re
+import subprocess
+import sys
+
+usage = 'git clang-format [OPTIONS] [<commit>] [--] [<file>...]'
+
+desc = '''
+Run clang-format on all lines that differ between the working directory
+and <commit>, which defaults to HEAD.  Changes are only applied to the working
+directory.
+
+The following git-config settings set the default of the corresponding option:
+  clangFormat.binary
+  clangFormat.commit
+  clangFormat.extension
+  clangFormat.style
+'''
+
+# Name of the temporary index file in which save the output of clang-format.
+# This file is created within the .git directory.
+temp_index_basename = 'clang-format-index'
+
+
+Range = collections.namedtuple('Range', 'start, count')
+
+
+def main():
+  config = load_git_config()
+
+  # In order to keep '--' yet allow options after positionals, we need to
+  # check for '--' ourselves.  (Setting nargs='*' throws away the '--', while
+  # nargs=argparse.REMAINDER disallows options after positionals.)
+  argv = sys.argv[1:]
+  try:
+    idx = argv.index('--')
+  except ValueError:
+    dash_dash = []
+  else:
+    dash_dash = argv[idx:]
+    argv = argv[:idx]
+
+  default_extensions = ','.join([
+      # From clang/lib/Frontend/FrontendOptions.cpp, all lower case
+      'c', 'h',  # C
+      'm',  # ObjC
+      'mm',  # ObjC++
+      'cc', 'cp', 'cpp', 'c++', 'cxx', 'hpp',  # C++
+      # Other languages that clang-format supports
+      'proto', 'protodevel',  # Protocol Buffers
+      'js',  # JavaScript
+      'ts',  # TypeScript
+      ])
+
+  p = argparse.ArgumentParser(
+    usage=usage, formatter_class=argparse.RawDescriptionHelpFormatter,
+    description=desc)
+  p.add_argument('--binary',
+                 default=config.get('clangformat.binary', 'clang-format'),
+                 help='path to clang-format'),
+  p.add_argument('--commit',
+                 default=config.get('clangformat.commit', 'HEAD'),
+                 help='default commit to use if none is specified'),
+  p.add_argument('--diff', action='store_true',
+                 help='print a diff instead of applying the changes')
+  p.add_argument('--extensions',
+                 default=config.get('clangformat.extensions',
+                                    default_extensions),
+                 help=('comma-separated list of file extensions to format, '
+                       'excluding the period and case-insensitive')),
+  p.add_argument('-f', '--force', action='store_true',
+                 help='allow changes to unstaged files')
+  p.add_argument('-p', '--patch', action='store_true',
+                 help='select hunks interactively')
+  p.add_argument('-q', '--quiet', action='count', default=0,
+                 help='print less information')
+  p.add_argument('--style',
+                 default=config.get('clangformat.style', None),
+                 help='passed to clang-format'),
+  p.add_argument('-v', '--verbose', action='count', default=0,
+                 help='print extra information')
+  # We gather all the remaining positional arguments into 'args' since we need
+  # to use some heuristics to determine whether or not <commit> was present.
+  # However, to print pretty messages, we make use of metavar and help.
+  p.add_argument('args', nargs='*', metavar='<commit>',
+                 help='revision from which to compute the diff')
+  p.add_argument('ignored', nargs='*', metavar='<file>...',
+                 help='if specified, only consider differences in these files')
+  opts = p.parse_args(argv)
+
+  opts.verbose -= opts.quiet
+  del opts.quiet
+
+  commit, files = interpret_args(opts.args, dash_dash, opts.commit)
+  changed_lines = compute_diff_and_extract_lines(commit, files)
+  if opts.verbose >= 1:
+    ignored_files = set(changed_lines)
+  filter_by_extension(changed_lines, opts.extensions.lower().split(','))
+  if opts.verbose >= 1:
+    ignored_files.difference_update(changed_lines)
+    if ignored_files:
+      print 'Ignoring changes in the following files (wrong extension):'
+      for filename in ignored_files:
+        print '   ', filename
+    if changed_lines:
+      print 'Running clang-format on the following files:'
+      for filename in changed_lines:
+        print '   ', filename
+  if not changed_lines:
+    print 'no modified files to format'
+    return
+  # The computed diff outputs absolute paths, so we must cd before accessing
+  # those files.
+  cd_to_toplevel()
+  old_tree = create_tree_from_workdir(changed_lines)
+  new_tree = run_clang_format_and_save_to_tree(changed_lines,
+                                               binary=opts.binary,
+                                               style=opts.style)
+  if opts.verbose >= 1:
+    print 'old tree:', old_tree
+    print 'new tree:', new_tree
+  if old_tree == new_tree:
+    if opts.verbose >= 0:
+      print 'clang-format did not modify any files'
+  elif opts.diff:
+    print_diff(old_tree, new_tree)
+  else:
+    changed_files = apply_changes(old_tree, new_tree, force=opts.force,
+                                  patch_mode=opts.patch)
+    if (opts.verbose >= 0 and not opts.patch) or opts.verbose >= 1:
+      print 'changed files:'
+      for filename in changed_files:
+        print '   ', filename
+
+
+def load_git_config(non_string_options=None):
+  """Return the git configuration as a dictionary.
+
+  All options are assumed to be strings unless in `non_string_options`, in which
+  is a dictionary mapping option name (in lower case) to either "--bool" or
+  "--int"."""
+  if non_string_options is None:
+    non_string_options = {}
+  out = {}
+  for entry in run('git', 'config', '--list', '--null').split('\0'):
+    if entry:
+      name, value = entry.split('\n', 1)
+      if name in non_string_options:
+        value = run('git', 'config', non_string_options[name], name)
+      out[name] = value
+  return out
+
+
+def interpret_args(args, dash_dash, default_commit):
+  """Interpret `args` as "[commit] [--] [files...]" and return (commit, files).
+
+  It is assumed that "--" and everything that follows has been removed from
+  args and placed in `dash_dash`.
+
+  If "--" is present (i.e., `dash_dash` is non-empty), the argument to its
+  left (if present) is taken as commit.  Otherwise, the first argument is
+  checked if it is a commit or a file.  If commit is not given,
+  `default_commit` is used."""
+  if dash_dash:
+    if len(args) == 0:
+      commit = default_commit
+    elif len(args) > 1:
+      die('at most one commit allowed; %d given' % len(args))
+    else:
+      commit = args[0]
+    object_type = get_object_type(commit)
+    if object_type not in ('commit', 'tag'):
+      if object_type is None:
+        die("'%s' is not a commit" % commit)
+      else:
+        die("'%s' is a %s, but a commit was expected" % (commit, object_type))
+    files = dash_dash[1:]
+  elif args:
+    if disambiguate_revision(args[0]):
+      commit = args[0]
+      files = args[1:]
+    else:
+      commit = default_commit
+      files = args
+  else:
+    commit = default_commit
+    files = []
+  return commit, files
+
+
+def disambiguate_revision(value):
+  """Returns True if `value` is a revision, False if it is a file, or dies."""
+  # If `value` is ambiguous (neither a commit nor a file), the following
+  # command will die with an appropriate error message.
+  run('git', 'rev-parse', value, verbose=False)
+  object_type = get_object_type(value)
+  if object_type is None:
+    return False
+  if object_type in ('commit', 'tag'):
+    return True
+  die('`%s` is a %s, but a commit or filename was expected' %
+      (value, object_type))
+
+
+def get_object_type(value):
+  """Returns a string description of an object's type, or None if it is not
+  a valid git object."""
+  cmd = ['git', 'cat-file', '-t', value]
+  p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+  stdout, stderr = p.communicate()
+  if p.returncode != 0:
+    return None
+  return stdout.strip()
+
+
+def compute_diff_and_extract_lines(commit, files):
+  """Calls compute_diff() followed by extract_lines()."""
+  diff_process = compute_diff(commit, files)
+  changed_lines = extract_lines(diff_process.stdout)
+  diff_process.stdout.close()
+  diff_process.wait()
+  if diff_process.returncode != 0:
+    # Assume error was already printed to stderr.
+    sys.exit(2)
+  return changed_lines
+
+
+def compute_diff(commit, files):
+  """Return a subprocess object producing the diff from `commit`.
+
+  The return value's `stdin` file object will produce a patch with the
+  differences between the working directory and `commit`, filtered on `files`
+  (if non-empty).  Zero context lines are used in the patch."""
+  cmd = ['git', 'diff-index', '-p', '-U0', commit, '--']
+  cmd.extend(files)
+  p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+  p.stdin.close()
+  return p
+
+
+def extract_lines(patch_file):
+  """Extract the changed lines in `patch_file`.
+
+  The return value is a dictionary mapping filename to a list of (start_line,
+  line_count) pairs.
+
+  The input must have been produced with ``-U0``, meaning unidiff format with
+  zero lines of context.  The return value is a dict mapping filename to a
+  list of line `Range`s."""
+  matches = {}
+  for line in patch_file:
+    match = re.search(r'^\+\+\+\ [^/]+/(.*)', line)
+    if match:
+      filename = match.group(1).rstrip('\r\n')
+    match = re.search(r'^@@ -[0-9,]+ \+(\d+)(,(\d+))?', line)
+    if match:
+      start_line = int(match.group(1))
+      line_count = 1
+      if match.group(3):
+        line_count = int(match.group(3))
+      if line_count > 0:
+        matches.setdefault(filename, []).append(Range(start_line, line_count))
+  return matches
+
+
+def filter_by_extension(dictionary, allowed_extensions):
+  """Delete every key in `dictionary` that doesn't have an allowed extension.
+
+  `allowed_extensions` must be a collection of lowercase file extensions,
+  excluding the period."""
+  allowed_extensions = frozenset(allowed_extensions)
+  for filename in dictionary.keys():
+    base_ext = filename.rsplit('.', 1)
+    if len(base_ext) == 1 or base_ext[1].lower() not in allowed_extensions:
+      del dictionary[filename]
+
+
+def cd_to_toplevel():
+  """Change to the top level of the git repository."""
+  toplevel = run('git', 'rev-parse', '--show-toplevel')
+  os.chdir(toplevel)
+
+
+def create_tree_from_workdir(filenames):
+  """Create a new git tree with the given files from the working directory.
+
+  Returns the object ID (SHA-1) of the created tree."""
+  return create_tree(filenames, '--stdin')
+
+
+def run_clang_format_and_save_to_tree(changed_lines, binary='clang-format',
+                                      style=None):
+  """Run clang-format on each file and save the result to a git tree.
+
+  Returns the object ID (SHA-1) of the created tree."""
+  def index_info_generator():
+    for filename, line_ranges in changed_lines.iteritems():
+      mode = oct(os.stat(filename).st_mode)
+      blob_id = clang_format_to_blob(filename, line_ranges, binary=binary,
+                                     style=style)
+      yield '%s %s\t%s' % (mode, blob_id, filename)
+  return create_tree(index_info_generator(), '--index-info')
+
+
+def create_tree(input_lines, mode):
+  """Create a tree object from the given input.
+
+  If mode is '--stdin', it must be a list of filenames.  If mode is
+  '--index-info' is must be a list of values suitable for "git update-index
+  --index-info", such as "<mode> <SP> <sha1> <TAB> <filename>".  Any other mode
+  is invalid."""
+  assert mode in ('--stdin', '--index-info')
+  cmd = ['git', 'update-index', '--add', '-z', mode]
+  with temporary_index_file():
+    p = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+    for line in input_lines:
+      p.stdin.write('%s\0' % line)
+    p.stdin.close()
+    if p.wait() != 0:
+      die('`%s` failed' % ' '.join(cmd))
+    tree_id = run('git', 'write-tree')
+    return tree_id
+
+
+def clang_format_to_blob(filename, line_ranges, binary='clang-format',
+                         style=None):
+  """Run clang-format on the given file and save the result to a git blob.
+
+  Returns the object ID (SHA-1) of the created blob."""
+  clang_format_cmd = [binary, filename]
+  if style:
+    clang_format_cmd.extend(['-style='+style])
+  clang_format_cmd.extend([
+      '-lines=%s:%s' % (start_line, start_line+line_count-1)
+      for start_line, line_count in line_ranges])
+  try:
+    clang_format = subprocess.Popen(clang_format_cmd, stdin=subprocess.PIPE,
+                                    stdout=subprocess.PIPE)
+  except OSError as e:
+    if e.errno == errno.ENOENT:
+      die('cannot find executable "%s"' % binary)
+    else:
+      raise
+  clang_format.stdin.close()
+  hash_object_cmd = ['git', 'hash-object', '-w', '--path='+filename, '--stdin']
+  hash_object = subprocess.Popen(hash_object_cmd, stdin=clang_format.stdout,
+                                 stdout=subprocess.PIPE)
+  clang_format.stdout.close()
+  stdout = hash_object.communicate()[0]
+  if hash_object.returncode != 0:
+    die('`%s` failed' % ' '.join(hash_object_cmd))
+  if clang_format.wait() != 0:
+    die('`%s` failed' % ' '.join(clang_format_cmd))
+  return stdout.rstrip('\r\n')
+
+
+@contextlib.contextmanager
+def temporary_index_file(tree=None):
+  """Context manager for setting GIT_INDEX_FILE to a temporary file and deleting
+  the file afterward."""
+  index_path = create_temporary_index(tree)
+  old_index_path = os.environ.get('GIT_INDEX_FILE')
+  os.environ['GIT_INDEX_FILE'] = index_path
+  try:
+    yield
+  finally:
+    if old_index_path is None:
+      del os.environ['GIT_INDEX_FILE']
+    else:
+      os.environ['GIT_INDEX_FILE'] = old_index_path
+    os.remove(index_path)
+
+
+def create_temporary_index(tree=None):
+  """Create a temporary index file and return the created file's path.
+
+  If `tree` is not None, use that as the tree to read in.  Otherwise, an
+  empty index is created."""
+  gitdir = run('git', 'rev-parse', '--git-dir')
+  path = os.path.join(gitdir, temp_index_basename)
+  if tree is None:
+    tree = '--empty'
+  run('git', 'read-tree', '--index-output='+path, tree)
+  return path
+
+
+def print_diff(old_tree, new_tree):
+  """Print the diff between the two trees to stdout."""
+  # We use the porcelain 'diff' and not plumbing 'diff-tree' because the output
+  # is expected to be viewed by the user, and only the former does nice things
+  # like color and pagination.
+  subprocess.check_call(['git', 'diff', old_tree, new_tree, '--'])
+
+
+def apply_changes(old_tree, new_tree, force=False, patch_mode=False):
+  """Apply the changes in `new_tree` to the working directory.
+
+  Bails if there are local changes in those files and not `force`.  If
+  `patch_mode`, runs `git checkout --patch` to select hunks interactively."""
+  changed_files = run('git', 'diff-tree', '-r', '-z', '--name-only', old_tree,
+                      new_tree).rstrip('\0').split('\0')
+  if not force:
+    unstaged_files = run('git', 'diff-files', '--name-status', *changed_files)
+    if unstaged_files:
+      print >>sys.stderr, ('The following files would be modified but '
+                           'have unstaged changes:')
+      print >>sys.stderr, unstaged_files
+      print >>sys.stderr, 'Please commit, stage, or stash them first.'
+      sys.exit(2)
+  if patch_mode:
+    # In patch mode, we could just as well create an index from the new tree
+    # and checkout from that, but then the user will be presented with a
+    # message saying "Discard ... from worktree".  Instead, we use the old
+    # tree as the index and checkout from new_tree, which gives the slightly
+    # better message, "Apply ... to index and worktree".  This is not quite
+    # right, since it won't be applied to the user's index, but oh well.
+    with temporary_index_file(old_tree):
+      subprocess.check_call(['git', 'checkout', '--patch', new_tree])
+    index_tree = old_tree
+  else:
+    with temporary_index_file(new_tree):
+      run('git', 'checkout-index', '-a', '-f')
+  return changed_files
+
+
+def run(*args, **kwargs):
+  stdin = kwargs.pop('stdin', '')
+  verbose = kwargs.pop('verbose', True)
+  strip = kwargs.pop('strip', True)
+  for name in kwargs:
+    raise TypeError("run() got an unexpected keyword argument '%s'" % name)
+  p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                       stdin=subprocess.PIPE)
+  stdout, stderr = p.communicate(input=stdin)
+  if p.returncode == 0:
+    if stderr:
+      if verbose:
+        print >>sys.stderr, '`%s` printed to stderr:' % ' '.join(args)
+      print >>sys.stderr, stderr.rstrip()
+    if strip:
+      stdout = stdout.rstrip('\r\n')
+    return stdout
+  if verbose:
+    print >>sys.stderr, '`%s` returned %s' % (' '.join(args), p.returncode)
+  if stderr:
+    print >>sys.stderr, stderr.rstrip()
+  sys.exit(2)
+
+
+def die(message):
+  print >>sys.stderr, 'error:', message
+  sys.exit(2)
+
+
+if __name__ == '__main__':
+  main()

pre-commit.readme

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# git pre-commit hook that run git-clang-format when committing.
+# To use it install clang-format and python 2.7 then copy this
+# file to .git/hooks/ and remove the extension
+
+git clang-format --style=file --diff > style.patch
+git apply --index style.patch
+rm style.patch
+exit 0

rpcs3/CMakeLists.txt

@@ -1,6 +1,7 @@
 cmake_minimum_required(VERSION 2.8.12)
 
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake_modules")
+set(RES_FILES "")
 include(cotire)
 
 project(rpcs3)
@@ -12,25 +13,19 @@ add_custom_command(OUTPUT something_that_never_exists
 	COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}
 		-P ${CMAKE_CURRENT_SOURCE_DIR}/git-version.cmake)
 
-if(CMAKE_COMPILER_IS_GNUCXX)
-	if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9.0) # TODO: the same for (apple) clang
-		message(FATAL_ERROR "GCC ${CMAKE_CXX_COMPILER_VERSION} is too old.")
-	endif()
-	# Warnings
-	add_compile_options(-Wno-attributes -Wno-enum-compare -Wno-invalid-offsetof)
-elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-	add_compile_options(-ftemplate-depth=1024)
-	if(APPLE)
-		add_compile_options(-stdlib=libc++)
-	endif()
-	if(WIN32)
-		add_compile_options(-pthread)
-	endif()
-endif()
+# Check for a sufficient compiler and set build options
+include(ConfigureCompiler)
+
 
 if(WIN32)
 	add_definitions(-DUNICODE)
 	add_definitions(-D_WIN32_WINNT=0x0601)
+	set(RES_FILES "rpcs3_.rc")
+	if(NOT MSVC)
+		set(CMAKE_RC_COMPILER_INIT windres)
+		enable_language(RC)
+		set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> <FLAGS> -O coff <DEFINES> -i <SOURCE> -o <OBJECT>")
+	endif()
 endif()
 
 if(NOT MSVC)
@@ -39,7 +34,7 @@ if(NOT MSVC)
 		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O1") # fix for travis gcc OoM crash. Might be fixed with the move to containers.
 	endif()
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fexceptions")
-	add_compile_options(-msse -msse2 -mcx16 -mssse3 -march=native)
+	add_compile_options(-msse -msse2 -mcx16 -mssse3)
 else()
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:throwingNew /D _CRT_SECURE_NO_DEPRECATE=1 /D _CRT_NON_CONFORMING_SWPRINTFS=1 /D _SCL_SECURE_NO_WARNINGS=1")
 endif()
@@ -148,6 +143,7 @@ ${LLVM_INCLUDE_DIRS}
 "${RPCS3_SRC_DIR}/../3rdparty/stblib"
 "${RPCS3_SRC_DIR}/../rsx_program_decompiler/rsx_decompiler"
 "${RPCS3_SRC_DIR}/../rsx_program_decompiler/shader_code"
+"${RPCS3_SRC_DIR}/../3rdparty/cereal/include"
 )
 if(WIN32)
 	include_directories(BEFORE "${RPCS3_SRC_DIR}/../3rdparty/XAudio2_7") # Slimmed down version of minidx9 for XAudio2_7 only
@@ -171,6 +167,7 @@ endif()
 
 link_directories(
 "${RPCS3_SRC_DIR}/../3rdparty/minidx12/"
+"${RPCS3_SRC_DIR}/../Vulkan"
 )
 
 if(NOT USE_SYSTEM_FFMPEG)
@@ -194,7 +191,7 @@ RPCS3_SRC
 "${RPCS3_SRC_DIR}/../asmjit/src/asmjit/*.cpp"
 )
 
-if(APPLE)
+if(NOT WIN32)
 	set (EXCLUDE_DIR "/RSX/VK/")
 	foreach (TMP_PATH ${RPCS3_SRC})
 		string (FIND ${TMP_PATH} ${EXCLUDE_DIR} EXCLUDE_DIR_FOUND)
@@ -204,7 +201,7 @@ if(APPLE)
 	endforeach(TMP_PATH)
 endif()
 
-add_executable(rpcs3 ${RPCS3_SRC})
+add_executable(rpcs3 ${RPCS3_SRC} ${RES_FILES})
 
 
 if(MSVC)
@@ -212,7 +209,7 @@ if(MSVC)
 	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS /DYNAMICBASE:NO /BASE:0x10000 /FIXED")
 endif()
 if(WIN32)
-	target_link_libraries(rpcs3  ws2_32.lib Winmm.lib VKstatic.1 glslang OSDependent OGLCompiler SPIRV)
+	target_link_libraries(rpcs3  ws2_32.lib Winmm.lib Psapi.lib VKstatic.1 glslang OSDependent OGLCompiler SPIRV HLSL)
 	if(NOT MSVC)
 		target_link_libraries(rpcs3  ${OPENGL_LIBRARIES} ${GLEW_LIBRARY} opengl32.lib glu32.lib libpthread)
 	else()
@@ -221,7 +218,7 @@ if(WIN32)
 	target_link_libraries(rpcs3  avformat.lib avcodec.lib avutil.lib swresample.lib swscale.lib png16_static ${wxWidgets_LIBRARIES} ${OPENAL_LIBRARY} ${ADDITIONAL_LIBS})
 else()
 	target_link_libraries(rpcs3  ${wxWidgets_LIBRARIES} ${OPENAL_LIBRARY} ${GLEW_LIBRARY} ${OPENGL_LIBRARIES})
-	target_link_libraries(rpcs3  ${ZLIB_LIBRARIES} ${ADDITIONAL_LIBS})
+	target_link_libraries(rpcs3  -ldl ${ZLIB_LIBRARIES} ${ADDITIONAL_LIBS})
 	if (USE_SYSTEM_FFMPEG)
 		link_libraries(${FFMPEG_LIBRARY_DIR})
 		target_link_libraries(rpcs3  libavformat.so libavcodec.so libavutil.so libswresample.so libswscale.so)
@@ -233,9 +230,6 @@ else()
 	else()
 		target_link_libraries(rpcs3  png16_static)
 	endif()
-	if (NOT APPLE)
-		target_link_libraries(rpcs3  vulkan glslang OSDependent OGLCompiler SPIRV)
-	endif()
 endif()
 if(LLVM_FOUND)
 	target_link_libraries(rpcs3  ${LLVM_LIBS})

rpcs3/Crypto/aes.h

@@ -1,5 +1,5 @@
 #pragma once
-
+#define POLARSSL_AES_ROM_TABLES
 /**
  * \file aes.h
  *

rpcs3/Crypto/key_vault.h

@@ -140,6 +140,15 @@ static u8 VSH_PUB[0x28] = {
 	0x6E, 0x73, 0x6A, 0xBF, 0x81, 0xF7, 0x0E, 0xE9, 0x16, 0x1B, 0x0D, 0xDE, 0xB0, 0x26, 0x76, 0x1A, 0xFF, 0x7B, 0xC8, 0x5B
 };
 
+static u8 SCEPKG_RIV[0x10] = { 
+	0x4A, 0xCE, 0xF0, 0x12, 0x24, 0xFB, 0xEE, 0xDF, 0x82, 0x45, 0xF8, 0xFF, 0x10, 0x21, 0x1E, 0x6E 
+};
+
+static u8 SCEPKG_ERK[0x20] = { 
+	0xA9, 0x78, 0x18, 0xBD, 0x19, 0x3A, 0x67, 0xA1, 0x6F, 0xE8, 0x3A, 0x85, 0x5E, 0x1B, 0xE9, 0xFB, 0x56, 0x40, 0x93, 0x8D,
+	0x4D, 0xBC, 0xB2, 0xCB, 0x52, 0xC5, 0xA2, 0xF8, 0xB0, 0x2B, 0x10, 0x31 
+};
+
 class KeyVault
 {
 	std::vector<SELF_KEY> sk_LV0_arr;

rpcs3/Crypto/lz.cpp

@@ -140,8 +140,7 @@ int decompress(unsigned char *out, unsigned char *in, unsigned int size)
 	unsigned int range = 0xFFFFFFFF;
 	unsigned int code = (in[1] << 24) | (in[2] << 16) | (in[3] << 8) | in[4];
 
-	// TODO:: Syphurith: There was a check against the unsigned char head. if (head < 0) would always be false.. I don't know are you tried to if (head > 0x80)?
-	if (head < 0) // Check if we have a valid starting byte.
+	if (head > 0x80) // Check if we have a valid starting byte.
 	{
 		// The dictionary header is invalid, the data is not compressed.
 		result = -1;

rpcs3/Crypto/unedat.h

@@ -2,35 +2,118 @@
 
 #include <stdio.h>
 #include <string.h>
+#include <array>
+
 #include "utils.h"
 
-#define SDAT_FLAG 0x01000000
-#define EDAT_COMPRESSED_FLAG 0x00000001
-#define EDAT_FLAG_0x02 0x00000002
-#define EDAT_ENCRYPTED_KEY_FLAG 0x00000008
-#define EDAT_FLAG_0x10 0x00000010
-#define EDAT_FLAG_0x20 0x00000020
-#define EDAT_DEBUG_DATA_FLAG 0x80000000
+constexpr u32 SDAT_FLAG = 0x01000000;
+constexpr u32 EDAT_COMPRESSED_FLAG = 0x00000001;
+constexpr u32 EDAT_FLAG_0x02 = 0x00000002;
+constexpr u32 EDAT_ENCRYPTED_KEY_FLAG = 0x00000008;
+constexpr u32 EDAT_FLAG_0x10 = 0x00000010;
+constexpr u32 EDAT_FLAG_0x20 = 0x00000020;
+constexpr u32 EDAT_DEBUG_DATA_FLAG = 0x80000000;
 
-typedef struct 
+struct EdatKeys_t
 {
-	unsigned char magic[4];
-    int version;
-    int license;
-    int type;
-    unsigned char content_id[0x30];
-    unsigned char digest[0x10];
-    unsigned char title_hash[0x10];
-    unsigned char dev_hash[0x10];
-    unsigned long long unk1;
-    unsigned long long unk2;
-} NPD_HEADER;
+	std::array<u8, 0x10> devKlic{};
+	std::array<u8, 0x10> rifKey{};
+};
 
-typedef struct 
+struct NPD_HEADER
 {
-	int flags;
-	int block_size;
-	unsigned long long file_size;
-} EDAT_HEADER;
+	u32 magic;
+	s32 version;
+	s32 license;
+	s32 type;
+	u8 content_id[0x30];
+	u8 digest[0x10];
+	u8 title_hash[0x10];
+	u8 dev_hash[0x10];
+	u64 unk1;
+	u64 unk2;
+};
 
-int DecryptEDAT(const std::string& input_file_name, const std::string& output_file_name, int mode, const std::string& rap_file_name, unsigned char *custom_klic, bool verbose);
+struct EDAT_HEADER
+{
+	s32 flags;
+	s32 block_size;
+	u64 file_size;
+};
+
+// Decrypts full file, or null/empty file
+extern fs::file DecryptEDAT(const fs::file& input, const std::string& input_file_name, int mode, const std::string& rap_file_name, u8 *custom_klic, bool verbose);
+
+extern bool VerifyEDATHeaderWithKLicense(const fs::file& input, const std::string& input_file_name, const std::array<u8,0x10>& custom_klic);
+
+extern std::array<u8, 0x10> GetEdatRifKeyFromRapFile(const fs::file& rap_file);
+
+struct EDATADecrypter final : fs::file_base
+{
+	// file stream
+	const fs::file edata_file;
+	u64 file_size{0};
+	u32 total_blocks{0};
+	u64 pos{0};
+
+	NPD_HEADER npdHeader;
+	EDAT_HEADER edatHeader;
+
+	// Internal data buffers.
+	std::unique_ptr<u8[]> data_buf;
+	u64 data_buf_size{0};
+
+	std::array<u8, 0x10> dec_key{};
+
+	// edat usage
+	std::array<u8, 0x10> rif_key{};
+	std::array<u8, 0x10> dev_key{};
+public:
+	// SdataByFd usage
+	EDATADecrypter(fs::file&& input)
+		: edata_file(std::move(input)) {}
+	// Edat usage
+	EDATADecrypter(fs::file&& input, const std::array<u8, 0x10>& dev_key, const std::array<u8, 0x10>& rif_key)
+		: edata_file(std::move(input)), rif_key(rif_key), dev_key(dev_key) {}
+
+	~EDATADecrypter() override {}
+	// false if invalid 
+	bool ReadHeader();
+	u64 ReadData(u64 pos, u8* data, u64 size);
+
+	fs::stat_t stat() override
+	{
+		fs::stat_t stats;
+		stats.is_directory = false;
+		stats.is_writable = false;
+		stats.size = file_size;
+		stats.atime = -1;
+		stats.ctime = -1;
+		stats.mtime = -1;
+		return stats;
+	}
+	bool trunc(u64 length) override 
+	{
+		return true;
+	};
+	u64 read(void* buffer, u64 size) override
+	{
+		u64 bytesRead = ReadData(pos, (u8*)buffer, size);
+		pos += bytesRead;
+		return bytesRead;
+	}
+	u64 write(const void* buffer, u64 size) override
+	{
+		return 0;
+	}
+
+	u64 seek(s64 offset, fs::seek_mode whence) override
+	{
+		return
+			whence == fs::seek_set ? pos = offset :
+			whence == fs::seek_cur ? pos = offset + pos :
+			whence == fs::seek_end ? pos = offset + size() :
+			(fmt::raw_error("EDATADecrypter::seek(): invalid whence"), 0);
+	}
+	u64 size() override { return file_size; }
+};

rpcs3/Crypto/unpkg.cpp

@@ -49,12 +49,6 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 	}
 	}
 
-	if (header.header_size != PKG_HEADER_SIZE && header.header_size != PKG_HEADER_SIZE2)
-	{
-		LOG_ERROR(LOADER, "Wrong PKG header size (0x%x)", header.header_size);
-		return false;
-	}
-
 	if (header.pkg_size > pkg_f.size())
 	{
 		LOG_ERROR(LOADER, "PKG file size mismatch (pkg_size=0x%llx)", header.pkg_size);
@@ -67,11 +61,54 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		return false;
 	}
 
+	be_t<u32> drm_type{0};
+	be_t<u32> content_type{0};
+
+	pkg_f.seek(header.pkg_info_off);
+
+	for (u32 i = 0; i < header.pkg_info_num; i++)
+	{
+		struct packet_T
+		{
+			be_t<u32> id;
+			be_t<u32> size;
+		} packet;
+		
+		pkg_f.read(packet);
+
+		// TODO
+		switch (+packet.id)
+		{
+		case 0x1:
+		{
+			if (packet.size == sizeof(drm_type))
+			{
+				pkg_f.read(drm_type);
+				continue;
+			}
+
+			break;
+		}
+		case 0x2:
+		{
+			if (packet.size == sizeof(content_type))
+			{
+				pkg_f.read(content_type);
+				continue;
+			}
+
+			break;
+		}
+		}
+
+		pkg_f.seek(packet.size, fs::seek_cur);
+	}
+
 	// Allocate buffer with BUF_SIZE size or more if required
 	const std::unique_ptr<u128[]> buf(new u128[std::max<u64>(BUF_SIZE, sizeof(PKGEntry) * header.file_count) / sizeof(u128)]);
 
 	// Define decryption subfunction (`psp` arg selects the key for specific block)
-	auto decrypt = [&](u64 offset, u64 size, bool psp) -> u64
+	auto decrypt = [&](u64 offset, u64 size, const uchar* key) -> u64
 	{
 		pkg_f.seek(start_offset + header.data_offset + offset);
 
@@ -94,14 +131,18 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 
 			for (u64 i = 0; i < blocks; i++)
 			{
-				// Initialize "debug key" for current position
+				// Initialize stream cipher for current position
 				input[7] = offset / 16 + i;
 
-				u128 key;
+				union sha1_hash
+				{
+					u8 data[20];
+					u128 _v128;
+				} hash;
 				
-				sha1(reinterpret_cast<const u8*>(input), sizeof(input), reinterpret_cast<u8*>(&key));
+				sha1(reinterpret_cast<const u8*>(input), sizeof(input), hash.data);
 
-				buf[i] ^= key;
+				buf[i] ^= hash._v128;
 			}
 		}
 
@@ -109,13 +150,13 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		{
 			aes_context ctx;
 
-			// Set decryption key
-			aes_setkey_enc(&ctx, psp ? PKG_AES_KEY2 : PKG_AES_KEY, 128);
+			// Set encryption key for stream cipher
+			aes_setkey_enc(&ctx, key, 128);
 
-			// Initialize "release key" for start position
+			// Initialize stream cipher for start position
 			be_t<u128> input = header.klicensee.value() + offset / 16;
 
-			// Increment "release key" for every block
+			// Increment stream position for every block
 			for (u64 i = 0; i < blocks; i++, input++)
 			{
 				u128 key;
@@ -130,7 +171,24 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		return read;
 	};
 
-	decrypt(0, header.file_count * sizeof(PKGEntry), header.pkg_platform == PKG_PLATFORM_TYPE_PSP);
+	std::array<uchar, 16> dec_key;
+
+	if (header.pkg_platform == PKG_PLATFORM_TYPE_PSP && content_type >= 0x15 && content_type <= 0x17)
+	{
+		const uchar psp2t1[] = {0xE3, 0x1A, 0x70, 0xC9, 0xCE, 0x1D, 0xD7, 0x2B, 0xF3, 0xC0, 0x62, 0x29, 0x63, 0xF2, 0xEC, 0xCB};
+		const uchar psp2t2[] = {0x42, 0x3A, 0xCA, 0x3A, 0x2B, 0xD5, 0x64, 0x9F, 0x96, 0x86, 0xAB, 0xAD, 0x6F, 0xD8, 0x80, 0x1F};
+		const uchar psp2t3[] = {0xAF, 0x07, 0xFD, 0x59, 0x65, 0x25, 0x27, 0xBA, 0xF1, 0x33, 0x89, 0x66, 0x8B, 0x17, 0xD9, 0xEA};
+
+		aes_context ctx;
+		aes_setkey_enc(&ctx, content_type == 0x15 ? psp2t1 : content_type == 0x16 ? psp2t2 : psp2t3, 128);
+		aes_crypt_ecb(&ctx, AES_ENCRYPT, reinterpret_cast<const uchar*>(&header.klicensee), dec_key.data());
+		decrypt(0, header.file_count * sizeof(PKGEntry), dec_key.data());
+	}
+	else
+	{
+		std::memcpy(dec_key.data(), PKG_AES_KEY, dec_key.size());
+		decrypt(0, header.file_count * sizeof(PKGEntry), header.pkg_platform == PKG_PLATFORM_TYPE_PSP ? PKG_AES_KEY2 : dec_key.data());
+	}
 
 	std::vector<PKGEntry> entries(header.file_count);
 
@@ -146,10 +204,12 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 			continue;
 		}
 
-		decrypt(entry.name_offset, entry.name_size, is_psp);
+		decrypt(entry.name_offset, entry.name_size, is_psp ? PKG_AES_KEY2 : dec_key.data());
 
 		const std::string name(reinterpret_cast<char*>(buf.get()), entry.name_size);
 
+		LOG_NOTICE(LOADER, "Entry 0x%08x: %s", entry.type, name);
+
 		switch (entry.type & 0xff)
 		{
 		case PKG_FILE_ENTRY_NPDRM:
@@ -157,6 +217,12 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		case PKG_FILE_ENTRY_SDAT:
 		case PKG_FILE_ENTRY_REGULAR:
 		case PKG_FILE_ENTRY_UNK1:
+		case 0xe:
+		case 0x10:
+		case 0x11:
+		case 0x13:
+		case 0x15:
+		case 0x16:
 		{
 			const std::string path = dir + name;
 
@@ -168,7 +234,7 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 				{
 					const u64 block_size = std::min<u64>(BUF_SIZE, entry.file_size - pos);
 
-					if (decrypt(entry.file_offset + pos, block_size, is_psp) != block_size)
+					if (decrypt(entry.file_offset + pos, block_size, is_psp ? PKG_AES_KEY2 : dec_key.data()) != block_size)
 					{
 						LOG_ERROR(LOADER, "Failed to extract file %s", path);
 						break;
@@ -205,6 +271,7 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		}
 
 		case PKG_FILE_ENTRY_FOLDER:
+		case 0x12:
 		{
 			const std::string path = dir + name;
 

rpcs3/Crypto/unpkg.h

@@ -35,9 +35,9 @@ struct PKGHeader
 	nse_t<u32> pkg_magic;   // Magic (0x7f504b47)
 	be_t<u16> pkg_type;     // Release type (Retail:0x8000, Debug:0x0000)
 	be_t<u16> pkg_platform; // Platform type (PS3:0x0001, PSP:0x0002)
-	be_t<u32> header_size;  // Header size (0xc0)
-	be_t<u32> unk1;         // Some PKG version maybe?
-	be_t<u32> meta_size;    // Size of metadata (block after header & hashes) 
+	be_t<u32> pkg_info_off;
+	be_t<u32> pkg_info_num;
+	be_t<u32> header_size;  // Header size
 	be_t<u32> file_count;   // Number of files
 	be_t<u64> pkg_size;     // PKG size in bytes
 	be_t<u64> data_offset;  // Encrypted data offset

rpcs3/Crypto/unself.cpp

@@ -3,90 +3,91 @@
 #include "sha1.h"
 #include "utils.h"
 #include "unself.h"
+#include "Emu/VFS.h"
 
 // TODO: Still reliant on wxWidgets for zlib functions. Alternative solutions?
 #include <zlib.h>
 
-force_inline u8 Read8(const fs::file& f)
+inline u8 Read8(const fs::file& f)
 {
 	u8 ret;
 	f.read(&ret, sizeof(ret));
 	return ret;
 }
 
-force_inline u16 Read16(const fs::file& f)
+inline u16 Read16(const fs::file& f)
 {
 	be_t<u16> ret;
 	f.read(&ret, sizeof(ret));
 	return ret;
 }
 
-force_inline u32 Read32(const fs::file& f)
+inline u32 Read32(const fs::file& f)
 {
 	be_t<u32> ret;
 	f.read(&ret, sizeof(ret));
 	return ret;
 }
 
-force_inline u64 Read64(const fs::file& f)
+inline u64 Read64(const fs::file& f)
 {
 	be_t<u64> ret;
 	f.read(&ret, sizeof(ret));
 	return ret;
 }
 
-force_inline u16 Read16LE(const fs::file& f)
+inline u16 Read16LE(const fs::file& f)
 {
 	u16 ret;
 	f.read(&ret, sizeof(ret));
 	return ret;
 }
 
-force_inline u32 Read32LE(const fs::file& f)
+inline u32 Read32LE(const fs::file& f)
 {
 	u32 ret;
 	f.read(&ret, sizeof(ret));
 	return ret;
 }
 
-force_inline u64 Read64LE(const fs::file& f)
+inline u64 Read64LE(const fs::file& f)
 {
 	u64 ret;
 	f.read(&ret, sizeof(ret));
 	return ret;
 }
 
-force_inline void Write8(const fs::file& f, const u8 data)
+inline void Write8(const fs::file& f, const u8 data)
 {
 	f.write(&data, sizeof(data));
 }
 
-force_inline void Write16LE(const fs::file& f, const u16 data)
+inline void Write16LE(const fs::file& f, const u16 data)
 {
 	f.write(&data, sizeof(data));
 }
 
-force_inline void Write32LE(const fs::file& f, const u32 data)
+inline void Write32LE(const fs::file& f, const u32 data)
 {
 	f.write(&data, sizeof(data));
 }
 
-force_inline void Write64LE(const fs::file& f, const u64 data)
+inline void Write64LE(const fs::file& f, const u64 data)
 {
 	f.write(&data, sizeof(data));
 }
 
-force_inline void Write16(const fs::file& f, const be_t<u16> data)
+inline void Write16(const fs::file& f, const be_t<u16> data)
 {
 	f.write(&data, sizeof(data));
 }
 
-force_inline void Write32(const fs::file& f, const be_t<u32> data)
+inline void Write32(const fs::file& f, const be_t<u32> data)
 {
 	f.write(&data, sizeof(data));
 }
 
-force_inline void Write64(const fs::file& f, const be_t<u64> data)
+inline void Write64(const fs::file& f, const be_t<u64> data)
 {
 	f.write(&data, sizeof(data));
 }
@@ -647,6 +648,236 @@ void SelfHeader::Load(const fs::file& f)
 	pad = Read64(f);
 }
 
+SCEDecrypter::SCEDecrypter(const fs::file& s)
+	: sce_f(s)
+	, data_buf_length(0)
+{
+}
+
+bool SCEDecrypter::LoadHeaders()
+{
+	// Read SCE header.
+	sce_f.seek(0);
+	sce_hdr.Load(sce_f);
+
+	// Check SCE magic.
+	if (!sce_hdr.CheckMagic())
+	{
+		LOG_ERROR(LOADER, "SELF: Not a SELF file!");
+		return false;
+	}
+
+	return true;
+}
+
+bool SCEDecrypter::LoadMetadata(const u8 erk[32], const u8 riv[16])
+{
+	aes_context aes;
+	u32 metadata_info_size = SIZE_32(meta_info);
+	auto metadata_info = std::make_unique<u8[]>(metadata_info_size);
+	u32 metadata_headers_size = sce_hdr.se_hsize - (SIZE_32(sce_hdr) + sce_hdr.se_meta + SIZE_32(meta_info));
+	auto metadata_headers = std::make_unique<u8[]>(metadata_headers_size);
+
+	// Locate and read the encrypted metadata info.
+	sce_f.seek(sce_hdr.se_meta + sizeof(sce_hdr));
+	sce_f.read(metadata_info.get(), metadata_info_size);
+
+	// Locate and read the encrypted metadata header and section header.
+	sce_f.seek(sce_hdr.se_meta + sizeof(sce_hdr) + metadata_info_size);
+	sce_f.read(metadata_headers.get(), metadata_headers_size);
+
+	// Copy the necessary parameters.
+	u8 metadata_key[0x20];
+	u8 metadata_iv[0x10];
+	memcpy(metadata_key, erk, 0x20);
+	memcpy(metadata_iv, riv, 0x10);
+
+	// Check DEBUG flag.
+	if ((sce_hdr.se_flags & 0x8000) != 0x8000)
+	{
+		// Decrypt the metadata info.
+		aes_setkey_dec(&aes, metadata_key, 256);  // AES-256
+		aes_crypt_cbc(&aes, AES_DECRYPT, metadata_info_size, metadata_iv, metadata_info.get(), metadata_info.get());
+	}
+
+	// Load the metadata info.
+	meta_info.Load(metadata_info.get());
+
+	// If the padding is not NULL for the key or iv fields, the metadata info
+	// is not properly decrypted.
+	if ((meta_info.key_pad[0] != 0x00) ||
+		(meta_info.iv_pad[0] != 0x00))
+	{
+		LOG_ERROR(LOADER, "SELF: Failed to decrypt metadata info!");
+		return false;
+	}
+
+	// Perform AES-CTR encryption on the metadata headers.
+	size_t ctr_nc_off = 0;
+	u8 ctr_stream_block[0x10];
+	aes_setkey_enc(&aes, meta_info.key, 128);
+	aes_crypt_ctr(&aes, metadata_headers_size, &ctr_nc_off, meta_info.iv, ctr_stream_block, metadata_headers.get(), metadata_headers.get());
+
+	// Load the metadata header.
+	meta_hdr.Load(metadata_headers.get());
+
+	// Load the metadata section headers.
+	meta_shdr.clear();
+	for (unsigned int i = 0; i < meta_hdr.section_count; i++)
+	{
+		meta_shdr.emplace_back();
+		meta_shdr.back().Load(metadata_headers.get() + sizeof(meta_hdr) + sizeof(MetadataSectionHeader) * i);
+	}
+
+	// Copy the decrypted data keys.
+	data_keys_length = meta_hdr.key_count * 0x10;
+	data_keys = std::make_unique<u8[]>(data_keys_length);
+	memcpy(data_keys.get(), metadata_headers.get() + sizeof(meta_hdr) + meta_hdr.section_count * sizeof(MetadataSectionHeader), data_keys_length);
+
+	return true;
+}
+
+bool SCEDecrypter::DecryptData()
+{
+	aes_context aes;
+
+	// Calculate the total data size.
+	for (unsigned int i = 0; i < meta_hdr.section_count; i++)
+	{
+		data_buf_length += meta_shdr[i].data_size;
+	}
+
+	// Allocate a buffer to store decrypted data.
+	data_buf = std::make_unique<u8[]>(data_buf_length);
+
+	// Set initial offset.
+	u32 data_buf_offset = 0;
+
+	// Parse the metadata section headers to find the offsets of encrypted data.
+	for (unsigned int i = 0; i < meta_hdr.section_count; i++)
+	{
+		size_t ctr_nc_off = 0;
+		u8 ctr_stream_block[0x10];
+		u8 data_key[0x10];
+		u8 data_iv[0x10];
+
+		// Check if this is an encrypted section.
+		if (meta_shdr[i].encrypted == 3)
+		{
+			// Make sure the key and iv are not out of boundaries.
+			if ((meta_shdr[i].key_idx <= meta_hdr.key_count - 1) && (meta_shdr[i].iv_idx <= meta_hdr.key_count))
+			{
+				// Get the key and iv from the previously stored key buffer.
+				memcpy(data_key, data_keys.get() + meta_shdr[i].key_idx * 0x10, 0x10);
+				memcpy(data_iv, data_keys.get() + meta_shdr[i].iv_idx * 0x10, 0x10);
+
+				// Allocate a buffer to hold the data.
+				auto buf = std::make_unique<u8[]>(meta_shdr[i].data_size);
+
+				// Seek to the section data offset and read the encrypted data.
+				sce_f.seek(meta_shdr[i].data_offset);
+				sce_f.read(buf.get(), meta_shdr[i].data_size);
+
+				// Zero out our ctr nonce.
+				memset(ctr_stream_block, 0, sizeof(ctr_stream_block));
+
+				// Perform AES-CTR encryption on the data blocks.
+				aes_setkey_enc(&aes, data_key, 128);
+				aes_crypt_ctr(&aes, meta_shdr[i].data_size, &ctr_nc_off, data_iv, ctr_stream_block, buf.get(), buf.get());
+
+				// Copy the decrypted data.
+				memcpy(data_buf.get() + data_buf_offset, buf.get(), meta_shdr[i].data_size);
+			}
+		}
+		else
+		{
+			auto buf = std::make_unique<u8[]>(meta_shdr[i].data_size);
+			sce_f.seek(meta_shdr[i].data_offset);
+			sce_f.read(buf.get(), meta_shdr[i].data_size);
+			memcpy(data_buf.get() + data_buf_offset, buf.get(), meta_shdr[i].data_size);
+		}
+
+		// Advance the buffer's offset.
+		data_buf_offset += meta_shdr[i].data_size;
+	}
+
+	return true;
+}
+
+// Each section gets put into its own file.
+std::vector<fs::file> SCEDecrypter::MakeFile()
+{
+	std::vector<fs::file> vec;
+
+	// Set initial offset.
+	u32 data_buf_offset = 0;
+
+	// Write data.
+	for (unsigned int i = 0; i < meta_hdr.section_count; i++)
+	{
+		fs::file out_f = fs::make_stream<std::vector<u8>>();
+
+		bool isValid = true;
+
+		// Decompress if necessary.
+		if (meta_shdr[i].compressed == 2)
+		{
+			const size_t BUFSIZE = 32 * 1024;
+			u8 tempbuf[BUFSIZE];
+			z_stream strm;
+			strm.zalloc = Z_NULL;
+			strm.zfree = Z_NULL;
+			strm.opaque = Z_NULL;
+			strm.avail_in = meta_shdr[i].data_size;
+			strm.avail_out = BUFSIZE;
+			strm.next_in = data_buf.get()+data_buf_offset;
+			strm.next_out = tempbuf;
+			int ret = inflateInit(&strm);
+
+			while (strm.avail_in)
+			{
+				ret = inflate(&strm, Z_NO_FLUSH);
+				if (ret == Z_STREAM_END)
+					break;
+				if (ret != Z_OK)
+					isValid = false;
+
+				if (!strm.avail_out) {
+					out_f.write(tempbuf, BUFSIZE);
+					strm.next_out = tempbuf;
+					strm.avail_out = BUFSIZE;
+				}
+				else
+					break;
+			}
+
+			int inflate_res = Z_OK;
+			inflate_res = inflate(&strm, Z_FINISH);
+
+			if (inflate_res != Z_STREAM_END)
+				isValid = false;
+
+			out_f.write(tempbuf, BUFSIZE - strm.avail_out);
+			inflateEnd(&strm);
+		}
+		else
+		{
+			// Write the data.
+			out_f.write(data_buf.get()+data_buf_offset, meta_shdr[i].data_size);
+		}
+
+		// Advance the data buffer offset by data size.
+		data_buf_offset += meta_shdr[i].data_size;
+
+		if (out_f.pos() != out_f.size())
+			fmt::throw_exception("MakeELF written bytes (%llu) does not equal buffer size (%llu).", out_f.pos(), out_f.size());
+
+		if (isValid) vec.push_back(std::move(out_f));
+	}
+
+	return vec;
+}
+
 SELFDecrypter::SELFDecrypter(const fs::file& s)
 	: self_f(s)
 	, key_v()
@@ -904,17 +1135,17 @@ bool SELFDecrypter::LoadMetadata()
 {
 	aes_context aes;
 	u32 metadata_info_size = SIZE_32(meta_info);
-	u8 *metadata_info = (u8 *)malloc(metadata_info_size);
+	auto metadata_info = std::make_unique<u8[]>(metadata_info_size);
 	u32 metadata_headers_size = sce_hdr.se_hsize - (SIZE_32(sce_hdr) + sce_hdr.se_meta + SIZE_32(meta_info));
-	u8 *metadata_headers = (u8 *)malloc(metadata_headers_size);
+	auto metadata_headers = std::make_unique<u8[]>(metadata_headers_size);
 
 	// Locate and read the encrypted metadata info.
 	self_f.seek(sce_hdr.se_meta + sizeof(sce_hdr));
-	self_f.read(metadata_info, metadata_info_size);
+	self_f.read(metadata_info.get(), metadata_info_size);
 
 	// Locate and read the encrypted metadata header and section header.
 	self_f.seek(sce_hdr.se_meta + sizeof(sce_hdr) + metadata_info_size);
-	self_f.read(metadata_headers, metadata_headers_size);
+	self_f.read(metadata_headers.get(), metadata_headers_size);
 
 	// Find the right keyset from the key vault.
 	SELF_KEY keyset = key_v.FindSelfKey(app_info.self_type, sce_hdr.se_flags, app_info.version);
@@ -929,16 +1160,16 @@ bool SELFDecrypter::LoadMetadata()
 	if ((sce_hdr.se_flags & 0x8000) != 0x8000)
 	{
 		// Decrypt the NPDRM layer.
-		if (!DecryptNPDRM(metadata_info, metadata_info_size))
+		if (!DecryptNPDRM(metadata_info.get(), metadata_info_size))
 			return false;
 
 		// Decrypt the metadata info.
 		aes_setkey_dec(&aes, metadata_key, 256);  // AES-256
-		aes_crypt_cbc(&aes, AES_DECRYPT, metadata_info_size, metadata_iv, metadata_info, metadata_info);
+		aes_crypt_cbc(&aes, AES_DECRYPT, metadata_info_size, metadata_iv, metadata_info.get(), metadata_info.get());
 	}
 
 	// Load the metadata info.
-	meta_info.Load(metadata_info);
+	meta_info.Load(metadata_info.get());
 
 	// If the padding is not NULL for the key or iv fields, the metadata info
 	// is not properly decrypted.
@@ -953,23 +1184,23 @@ bool SELFDecrypter::LoadMetadata()
 	size_t ctr_nc_off = 0;
 	u8 ctr_stream_block[0x10];
 	aes_setkey_enc(&aes, meta_info.key, 128);
-	aes_crypt_ctr(&aes, metadata_headers_size, &ctr_nc_off, meta_info.iv, ctr_stream_block, metadata_headers, metadata_headers);
+	aes_crypt_ctr(&aes, metadata_headers_size, &ctr_nc_off, meta_info.iv, ctr_stream_block, metadata_headers.get(), metadata_headers.get());
 
 	// Load the metadata header.
-	meta_hdr.Load(metadata_headers);
+	meta_hdr.Load(metadata_headers.get());
 
 	// Load the metadata section headers.
 	meta_shdr.clear();
 	for (unsigned int i = 0; i < meta_hdr.section_count; i++)
 	{
 		meta_shdr.emplace_back();
-		meta_shdr.back().Load(metadata_headers + sizeof(meta_hdr) + sizeof(MetadataSectionHeader) * i);
+		meta_shdr.back().Load(metadata_headers.get() + sizeof(meta_hdr) + sizeof(MetadataSectionHeader) * i);
 	}
 
 	// Copy the decrypted data keys.
 	data_keys_length = meta_hdr.key_count * 0x10;
-	data_keys = (u8 *) malloc (data_keys_length);
-	memcpy(data_keys, metadata_headers + sizeof(meta_hdr) + meta_hdr.section_count * sizeof(MetadataSectionHeader), data_keys_length);
+	data_keys = std::make_unique<u8[]>(data_keys_length);
+	memcpy(data_keys.get(), metadata_headers.get() + sizeof(meta_hdr) + meta_hdr.section_count * sizeof(MetadataSectionHeader), data_keys_length);
 
 	return true;
 }
@@ -989,7 +1220,7 @@ bool SELFDecrypter::DecryptData()
 	}
 
 	// Allocate a buffer to store decrypted data.
-	data_buf = (u8*)malloc(data_buf_length);
+	data_buf = std::make_unique<u8[]>(data_buf_length);
 
 	// Set initial offset.
 	u32 data_buf_offset = 0;
@@ -1009,31 +1240,28 @@ bool SELFDecrypter::DecryptData()
 			if((meta_shdr[i].key_idx <= meta_hdr.key_count - 1) && (meta_shdr[i].iv_idx <= meta_hdr.key_count))
 			{
 				// Get the key and iv from the previously stored key buffer.
-				memcpy(data_key, data_keys + meta_shdr[i].key_idx * 0x10, 0x10);
-				memcpy(data_iv, data_keys + meta_shdr[i].iv_idx * 0x10, 0x10);
+				memcpy(data_key, data_keys.get() + meta_shdr[i].key_idx * 0x10, 0x10);
+				memcpy(data_iv, data_keys.get() + meta_shdr[i].iv_idx * 0x10, 0x10);
 
 				// Allocate a buffer to hold the data.
-				u8 *buf = (u8 *)malloc(meta_shdr[i].data_size);
+				auto buf = std::make_unique<u8[]>(meta_shdr[i].data_size);
 
 				// Seek to the section data offset and read the encrypted data.
 				self_f.seek(meta_shdr[i].data_offset);
-				self_f.read(buf, meta_shdr[i].data_size);
+				self_f.read(buf.get(), meta_shdr[i].data_size);
 
 				// Zero out our ctr nonce.
 				memset(ctr_stream_block, 0, sizeof(ctr_stream_block));
 
 				// Perform AES-CTR encryption on the data blocks.
 				aes_setkey_enc(&aes, data_key, 128);
-				aes_crypt_ctr(&aes, meta_shdr[i].data_size, &ctr_nc_off, data_iv, ctr_stream_block, buf, buf);
+				aes_crypt_ctr(&aes, meta_shdr[i].data_size, &ctr_nc_off, data_iv, ctr_stream_block, buf.get(), buf.get());
 
 				// Copy the decrypted data.
-				memcpy(data_buf + data_buf_offset, buf, meta_shdr[i].data_size);
+				memcpy(data_buf.get() + data_buf_offset, buf.get(), meta_shdr[i].data_size);
 
 				// Advance the buffer's offset.
 				data_buf_offset += meta_shdr[i].data_size;
-
-				// Release the temporary buffer.
-				free(buf);
 			}
 		}
 	}
@@ -1041,15 +1269,10 @@ bool SELFDecrypter::DecryptData()
 	return true;
 }
 
-bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32)
+fs::file SELFDecrypter::MakeElf(bool isElf32)
 {
 	// Create a new ELF file.
-	fs::file e(elf, fs::rewrite);
-	if(!e)
-	{
-		LOG_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str());
-		return false;
-	}
+	fs::file e = fs::make_stream<std::vector<u8>>();
 
 	// Set initial offset.
 	u32 data_buf_offset = 0;
@@ -1072,7 +1295,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32)
 			{
 				// Seek to the program header data offset and write the data.
 				e.seek(phdr32_arr[meta_shdr[i].program_idx].p_offset);
-				e.write(data_buf + data_buf_offset, meta_shdr[i].data_size);
+				e.write(data_buf.get() + data_buf_offset, meta_shdr[i].data_size);
 
 				// Advance the data buffer offset by data size.
 				data_buf_offset += meta_shdr[i].data_size;
@@ -1122,7 +1345,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32)
 
 					// Create a buffer separate from data_buf to uncompress.
 					std::unique_ptr<u8[]> zlib_buf(new u8[data_buf_length]);
-					memcpy(zlib_buf.get(), data_buf, data_buf_length);
+					memcpy(zlib_buf.get(), data_buf.get(), data_buf_length);
 
 					// Use zlib uncompress on the new buffer.
 					// decomp_buf_length changes inside the call to uncompress, so it must be a pointer to correct type (in writeable mem space).
@@ -1145,7 +1368,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32)
 				{
 					// Seek to the program header data offset and write the data.
 					e.seek(phdr64_arr[meta_shdr[i].program_idx].p_offset);
-					e.write(data_buf + data_buf_offset, meta_shdr[i].data_size);
+					e.write(data_buf.get() + data_buf_offset, meta_shdr[i].data_size);
 				}
 
 				// Advance the data buffer offset by data size.
@@ -1165,33 +1388,25 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32)
 		}
 	}
 
-	return true;
+	return e;
 }
 
-bool SELFDecrypter::GetKeyFromRap(u8 *content_id, u8 *npdrm_key)
+bool SELFDecrypter::GetKeyFromRap(u8* content_id, u8* npdrm_key)
 {
 	// Set empty RAP key.
 	u8 rap_key[0x10];
 	memset(rap_key, 0, 0x10);
 
 	// Try to find a matching RAP file under exdata folder.
-	std::string ci_str((const char *)content_id);
-	std::string pf_str("00000001");  // TODO: Allow multiple profiles. Use default for now.
-	std::string rap_path("dev_hdd0/home/" + pf_str + "/exdata/" + ci_str + ".rap");
-
-	// Check if we have a valid RAP file.
-	if (!fs::is_file(rap_path))
-	{
-		LOG_ERROR(LOADER, "This application requires a valid RAP file for decryption!");
-		return false;
-	}
+	const std::string ci_str = reinterpret_cast<const char*>(content_id);
+	const std::string rap_path = "/dev_hdd0/home/00000001/exdata/" + ci_str + ".rap";
 
 	// Open the RAP file and read the key.
-	fs::file rap_file(rap_path);
+	const fs::file rap_file(vfs::get(rap_path));
 
 	if (!rap_file)
 	{
-		LOG_ERROR(LOADER, "Failed to load RAP file!");
+		LOG_FATAL(LOADER, "Failed to load RAP file: %s", rap_path);
 		return false;
 	}
 
@@ -1204,23 +1419,11 @@ bool SELFDecrypter::GetKeyFromRap(u8 *content_id, u8 *npdrm_key)
 	return true;
 }
 
-bool IsSelf(const std::string& path)
+static bool IsSelfElf32(const fs::file& f)
 {
-	fs::file f(path);
-
 	if (!f) return false;
 
-	SceHeader hdr;
-	hdr.Load(f);
-
-	return hdr.CheckMagic();
-}
-
-bool IsSelfElf32(const std::string& path)
-{
-	fs::file f(path);
-
-	if (!f) return false;
+	f.seek(0);
 
 	SceHeader hdr;
 	SelfHeader sh;
@@ -1236,46 +1439,31 @@ bool IsSelfElf32(const std::string& path)
 	return (elf_class[4] == 1);
 }
 
-bool CheckDebugSelf(const std::string& self, const std::string& elf)
+static bool CheckDebugSelf(fs::file& s)
 {
-	// Open the SELF file.
-	fs::file s(self);
-
-	if (!s)
+	if (s.size() < 0x18)
 	{
-		LOG_ERROR(LOADER, "Could not open SELF file! (%s)", self.c_str());
 		return false;
 	}
 
 	// Get the key version.
 	s.seek(0x08);
 
-	u16 key_version;
-	s.read(&key_version, sizeof(key_version));
+	const u16 key_version = s.read<le_t<u16>>();
 
 	// Check for DEBUG version.
-	if (swap16(key_version) == 0x8000)
+	if (key_version == 0x80 || key_version == 0xc0)
 	{
 		LOG_WARNING(LOADER, "Debug SELF detected! Removing fake header...");
 
 		// Get the real elf offset.
 		s.seek(0x10);
 
-		u64 elf_offset;
-		s.read(&elf_offset, sizeof(elf_offset));
-
 		// Start at the real elf offset.
-		elf_offset = swap64(elf_offset);
-
-		s.seek(elf_offset);
+		s.seek(key_version == 0x80 ? +s.read<be_t<u64>>() : +s.read<le_t<u64>>());
 
 		// Write the real ELF file back.
-		fs::file e(elf, fs::rewrite);
-		if (!e)
-		{
-			LOG_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str());
-			return false;
-		}
+		fs::file e = fs::make_stream<std::vector<u8>>();
 
 		// Copy the data.
 		char buf[2048];
@@ -1284,6 +1472,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
 			e.write(buf, size);
 		}
 
+		s = std::move(e);
 		return true;
 	}
 
@@ -1291,53 +1480,48 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
 	return false;
 }
 
-bool DecryptSelf(const std::string& elf, const std::string& self)
-{
-	LOG_NOTICE(LOADER, "Decrypting %s", self);
-
-	// Check for a debug SELF first.
-	if (!CheckDebugSelf(self, elf))
+extern fs::file decrypt_self(fs::file elf_or_self)
+{	
+	if (!elf_or_self) 
 	{
-		// Set a virtual pointer to the SELF file.
-		fs::file self_vf(self);
-
-		if (!self_vf)
-			return false;
+		return fs::file{};
+	}
+	
+	elf_or_self.seek(0);
 
+	// Check SELF header first. Check for a debug SELF.
+	if (elf_or_self.size() >= 4 && elf_or_self.read<u32>() == "SCE\0"_u32 && !CheckDebugSelf(elf_or_self))
+	{
 		// Check the ELF file class (32 or 64 bit).
-		bool isElf32 = IsSelfElf32(self);
+		bool isElf32 = IsSelfElf32(elf_or_self);
 
 		// Start the decrypter on this SELF file.
-		SELFDecrypter self_dec(self_vf);
+		SELFDecrypter self_dec(elf_or_self);
 
 		// Load the SELF file headers.
 		if (!self_dec.LoadHeaders(isElf32))
 		{
 			LOG_ERROR(LOADER, "SELF: Failed to load SELF file headers!");
-			return false;
+			return fs::file{};
 		}
 		
 		// Load and decrypt the SELF file metadata.
 		if (!self_dec.LoadMetadata())
 		{
 			LOG_ERROR(LOADER, "SELF: Failed to load SELF file metadata!");
-			return false;
+			return fs::file{};
 		}
 		
 		// Decrypt the SELF file data.
 		if (!self_dec.DecryptData())
 		{
 			LOG_ERROR(LOADER, "SELF: Failed to decrypt SELF file data!");
-			return false;
+			return fs::file{};
 		}
 		
 		// Make a new ELF file from this SELF.
-		if (!self_dec.MakeElf(elf, isElf32))
-		{
-			LOG_ERROR(LOADER, "SELF: Failed to make ELF file from SELF!");
-			return false;
-		}
+		return self_dec.MakeElf(isElf32);
 	}
 
-	return true;
+	return elf_or_self;
 }

rpcs3/Crypto/unself.h

@@ -338,6 +338,34 @@ struct SelfHeader
 	void Show(){}
 };
 
+class SCEDecrypter
+{
+protected:
+	// Main SELF file stream.
+	const fs::file& sce_f;
+
+	// SCE headers.
+	SceHeader sce_hdr;
+
+	// Metadata structs.
+	MetadataInfo meta_info;
+	MetadataHeader meta_hdr;
+	std::vector<MetadataSectionHeader> meta_shdr;
+
+	// Internal data buffers.
+	std::unique_ptr<u8[]> data_keys;
+	u32 data_keys_length;
+	std::unique_ptr<u8[]> data_buf;
+	u32 data_buf_length;
+
+public:
+	SCEDecrypter(const fs::file& s);
+	std::vector<fs::file> MakeFile();
+	bool LoadHeaders();
+	bool LoadMetadata(const u8 erk[32], const u8 riv[16]);
+	bool DecryptData();
+};
+
 class SELFDecrypter
 {
 	// Main SELF file stream.
@@ -369,9 +397,9 @@ class SELFDecrypter
 	std::vector<MetadataSectionHeader> meta_shdr;
 
 	// Internal data buffers.
-	u8 *data_keys;
+	std::unique_ptr<u8[]> data_keys;
 	u32 data_keys_length;
-	u8 *data_buf;
+	std::unique_ptr<u8[]> data_buf;
 	u32 data_buf_length;
 
 	// Main key vault instance.
@@ -379,7 +407,7 @@ class SELFDecrypter
 
 public:
 	SELFDecrypter(const fs::file& s);
-	bool MakeElf(const std::string& elf, bool isElf32);
+	fs::file MakeElf(bool isElf32);
 	bool LoadHeaders(bool isElf32);
 	void ShowHeaders(bool isElf32);
 	bool LoadMetadata();
@@ -388,7 +416,4 @@ public:
 	bool GetKeyFromRap(u8 *content_id, u8 *npdrm_key);
 };
 
-extern bool IsSelf(const std::string& path);
-extern bool IsSelfElf32(const std::string& path);
-extern bool CheckDebugSelf(const std::string& self, const std::string& elf);
-extern bool DecryptSelf(const std::string& elf, const std::string& self);
+extern fs::file decrypt_self(fs::file elf_or_self);

rpcs3/Crypto/utils.cpp

@@ -6,29 +6,13 @@
 #include <stdio.h>
 #include <time.h>
 
+#include <memory>
+
 // Auxiliary functions (endian swap, xor and prng).
-u16 swap16(u16 i)
-{
-	return ((i & 0xFF00) >>  8) | ((i & 0xFF) << 8);
-}
 
-u32 swap32(u32 i)
+void xor_key(unsigned char *dest, const u8* src1, const u8* src2)
 {
-	return ((i & 0xFF000000) >> 24) | ((i & 0xFF0000) >>  8) | ((i & 0xFF00) <<  8) | ((i & 0xFF) << 24);
-}
-
-u64 swap64(u64 i)
-{
-	return ((i & 0x00000000000000ff) << 56) | ((i & 0x000000000000ff00) << 40) |
-		((i & 0x0000000000ff0000) << 24) | ((i & 0x00000000ff000000) <<  8) |
-		((i & 0x000000ff00000000) >>  8) | ((i & 0x0000ff0000000000) >> 24) |
-		((i & 0x00ff000000000000) >> 40) | ((i & 0xff00000000000000) >> 56);
-}
-
-void xor_key(unsigned char *dest, unsigned char *src1, unsigned char *src2, int size)
-{
-	int i;
-	for(i = 0; i < size; i++)
+	for(int i = 0; i < 0x10; i++)
 	{
 		dest[i] = src1[i] ^ src2[i];
 	}
@@ -36,16 +20,10 @@ void xor_key(unsigned char *dest, unsigned char *src1, unsigned char *src2, int
 
 void prng(unsigned char *dest, int size)
 {
-    unsigned char *buffer = new unsigned char[size];
 	srand((u32)time(0));
 
-	int i;
-	for(i = 0; i < size; i++)
-      buffer[i] = (unsigned char)(rand() & 0xFF);
-
-	memcpy(dest, buffer, size);
-
-	delete[] buffer;
+	for(int i = 0; i < size; i++)
+		dest[i] = (unsigned char)(rand() & 0xFF);
 }
 
 // Hex string conversion auxiliary functions.
@@ -82,8 +60,8 @@ void hex_to_bytes(unsigned char *data, const char *hex_str, unsigned int str_len
 	// Don't convert if the string length is odd.
 	if (!(strn_length % 2))
 	{
-		u8 *out = (u8 *)malloc(strn_length * sizeof(u8));
-		u8 *pos = out;
+		auto out = std::make_unique<u8[]>(strn_length * sizeof(u8));
+		u8 *pos = out.get();
 
 		while (strn_length--)
 		{
@@ -94,26 +72,25 @@ void hex_to_bytes(unsigned char *data, const char *hex_str, unsigned int str_len
 		}
 
 		// Copy back to our array.
-		memcpy(data, out, data_length);
-		free(out);
+		memcpy(data, out.get(), data_length);
 	}
 }
 
 bool is_hex(const char* hex_str, unsigned int str_length)
 {
-    static const char hex_chars[] = "0123456789abcdefABCDEF";
+	static const char hex_chars[] = "0123456789abcdefABCDEF";
 
-    if (hex_str == NULL)
-        return false;
+	if (hex_str == NULL)
+		return false;
 
-    unsigned int i;
-    for (i = 0; i < str_length; i++)
+	unsigned int i;
+	for (i = 0; i < str_length; i++)
 	{
 		if (strchr(hex_chars, hex_str[i]) == 0)
 			return false;
 	}
 
-    return true;
+	return true;
 }
 
 // Crypto functions (AES128-CBC, AES128-ECB, SHA1-HMAC and AES-CMAC).
@@ -146,22 +123,11 @@ void aesecb128_encrypt(unsigned char *key, unsigned char *in, unsigned char *out
 
 bool hmac_hash_compare(unsigned char *key, int key_len, unsigned char *in, int in_len, unsigned char *hash, int hash_len)
 {
-	unsigned char *out = new unsigned char[key_len];
+	std::unique_ptr<u8> out(new u8[key_len]);
 
-	sha1_hmac(key, key_len, in, in_len, out);
+	sha1_hmac(key, key_len, in, in_len, out.get());
 
-	for (int i = 0; i < hash_len; i++)
-	{
-		if (out[i] != hash[i])
-		{
-			delete[] out;
-			return false;
-		}
-	}
-
-	delete[] out;
-
-	return true;
+	return std::memcmp(out.get(), hash, hash_len) == 0;
 }
 
 void hmac_hash_forge(unsigned char *key, int key_len, unsigned char *in, int in_len, unsigned char *hash)
@@ -171,24 +137,13 @@ void hmac_hash_forge(unsigned char *key, int key_len, unsigned char *in, int in_
 
 bool cmac_hash_compare(unsigned char *key, int key_len, unsigned char *in, int in_len, unsigned char *hash, int hash_len)
 {
-	unsigned char *out = new unsigned char[key_len];
+	std::unique_ptr<u8> out(new u8[key_len]);
 
 	aes_context ctx;
 	aes_setkey_enc(&ctx, key, 128);
-	aes_cmac(&ctx, in_len, in, out);
+	aes_cmac(&ctx, in_len, in, out.get());
 
-	for (int i = 0; i < hash_len; i++)
-	{
-		if (out[i] != hash[i])
-		{
-			delete[] out;
-			return false;
-		}
-	}
-
-	delete[] out;
-
-	return true;
+	return std::memcmp(out.get(), hash, hash_len) == 0;
 }
 
 void cmac_hash_forge(unsigned char *key, int key_len, unsigned char *in, int in_len, unsigned char *hash)

rpcs3/Crypto/utils.h

@@ -15,10 +15,40 @@
 #include "ec.h"
 
 // Auxiliary functions (endian swap, xor, prng and file name).
-u16 swap16(u16 i);
-u32 swap32(u32 i);
-u64 swap64(u64 i);
-void xor_key(unsigned char *dest, unsigned char *src1, unsigned char *src2, int size);
+inline u16 swap16(u16 i)
+{
+#if defined(__GNUG__)
+	return __builtin_bswap16(i);
+#else
+	return _byteswap_ushort(i);
+#endif
+}
+
+inline u32 swap32(u32 i)
+{
+#if defined(__GNUG__)
+	return __builtin_bswap32(i);
+#else
+	return _byteswap_ulong(i);
+#endif
+}
+
+inline u64 swap64(u64 i)
+{
+#if defined(__GNUG__)
+	return __builtin_bswap64(i);
+#else
+	return _byteswap_uint64(i);
+#endif
+}
+
+void xor_key(unsigned char *dest, const u8* src1, const u8* src2);
+inline void xor_key_sse(u8* dest, const u8* src1, const u8* src2)
+{
+	_mm_storeu_si128(&(((__m128i*)dest)[0]),
+		_mm_xor_si128(_mm_loadu_si128((__m128i*)src1), _mm_loadu_si128((__m128i*)src2)));
+}
+
 void prng(unsigned char *dest, int size);
 char* extract_file_name(const char* file_path, char real_file_name[MAX_PATH]);
 

rpcs3/Emu/Audio/AudioDumper.cpp

@@ -1,5 +1,10 @@
 #include "stdafx.h"
 #include "AudioDumper.h"
+#include "AudioThread.h"
+
+AudioThread::~AudioThread()
+{
+}
 
 AudioDumper::AudioDumper(u16 ch)
 	: m_header(ch)
@@ -24,7 +29,7 @@ void AudioDumper::WriteData(const void* buffer, u32 size)
 {
 	if (GetCh())
 	{
-		VERIFY(m_output.write(buffer, size) == size);
+		verify(HERE), size, m_output.write(buffer, size) == size;
 		m_header.Size += size;
 		m_header.RIFF.Size += size;
 	}

rpcs3/Emu/Audio/AudioThread.h

@@ -3,7 +3,7 @@
 class AudioThread
 {
 public:
-	virtual ~AudioThread() = default;
+	virtual ~AudioThread();
 
 	virtual void Play() = 0;
 	virtual void Open(const void* src, int size) = 0;

rpcs3/Emu/Audio/XAudio2/XAudio27Thread.cpp

@@ -0,0 +1,163 @@
+#ifdef _WIN32
+
+#include "Utilities/Log.h"
+#include "Utilities/StrFmt.h"
+#include "Utilities/Config.h"
+#include "Emu/System.h"
+
+#include "XAudio2Thread.h"
+#include "3rdparty/XAudio2_7/XAudio2.h"
+
+extern cfg::bool_entry g_cfg_audio_convert_to_u16;
+
+static thread_local HMODULE s_tls_xaudio2_lib{};
+static thread_local IXAudio2* s_tls_xaudio2_instance{};
+static thread_local IXAudio2MasteringVoice* s_tls_master_voice{};
+static thread_local IXAudio2SourceVoice* s_tls_source_voice{};
+
+void XAudio2Thread::xa27_init(void* lib2_7)
+{
+	s_tls_xaudio2_lib = (HMODULE)lib2_7;
+
+	HRESULT hr = S_OK;
+
+	hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : CoInitializeEx() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+		return;
+	}	
+
+	hr = XAudio2Create(&s_tls_xaudio2_instance, 0, XAUDIO2_DEFAULT_PROCESSOR);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : XAudio2Create() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+		return;
+	}
+
+	hr = s_tls_xaudio2_instance->CreateMasteringVoice(&s_tls_master_voice, 8, 48000);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : CreateMasteringVoice() failed(0x%08x)", (u32)hr);
+		s_tls_xaudio2_instance->Release();
+		Emu.Pause();
+	}
+}
+
+void XAudio2Thread::xa27_destroy()
+{
+	if (s_tls_source_voice != nullptr)
+	{
+		s_tls_source_voice->Stop();
+		s_tls_source_voice->DestroyVoice();
+	}
+
+	if (s_tls_master_voice != nullptr)
+	{
+		s_tls_master_voice->DestroyVoice();
+	}
+
+	if (s_tls_xaudio2_instance != nullptr)
+	{
+		s_tls_xaudio2_instance->StopEngine();
+		s_tls_xaudio2_instance->Release();
+	}
+
+	CoUninitialize();
+
+	FreeLibrary(s_tls_xaudio2_lib);
+}
+
+void XAudio2Thread::xa27_play()
+{
+	HRESULT hr = s_tls_source_voice->Start();
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : Start() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+	}
+}
+
+void XAudio2Thread::xa27_flush()
+{
+	HRESULT hr = s_tls_source_voice->FlushSourceBuffers();
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : FlushSourceBuffers() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+	}
+}
+
+void XAudio2Thread::xa27_stop()
+{
+	HRESULT hr = s_tls_source_voice->Stop();
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : Stop() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+	}
+}
+
+void XAudio2Thread::xa27_open()
+{
+	HRESULT hr;
+
+	WORD sample_size = g_cfg_audio_convert_to_u16 ? sizeof(u16) : sizeof(float);
+	WORD channels = 8;
+
+	WAVEFORMATEX waveformatex;
+	waveformatex.wFormatTag = g_cfg_audio_convert_to_u16 ? WAVE_FORMAT_PCM : WAVE_FORMAT_IEEE_FLOAT;
+	waveformatex.nChannels = channels;
+	waveformatex.nSamplesPerSec = 48000;
+	waveformatex.nAvgBytesPerSec = 48000 * (DWORD)channels * (DWORD)sample_size;
+	waveformatex.nBlockAlign = channels * sample_size;
+	waveformatex.wBitsPerSample = sample_size * 8;
+	waveformatex.cbSize = 0;
+
+	hr = s_tls_xaudio2_instance->CreateSourceVoice(&s_tls_source_voice, &waveformatex, 0, XAUDIO2_DEFAULT_FREQ_RATIO);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : CreateSourceVoice() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+		return;
+	}
+
+	s_tls_source_voice->SetVolume(4.0);
+}
+
+void XAudio2Thread::xa27_add(const void* src, int size)
+{
+	XAUDIO2_VOICE_STATE state;
+	s_tls_source_voice->GetState(&state);
+
+	// XAudio 2.7 bug workaround, when it says "SimpList: non-growable list ran out of room for new elements" and hits int 3
+	if (state.BuffersQueued > 32)
+	{
+		LOG_WARNING(GENERAL, "XAudio2Thread : too many buffers enqueued (%d, pos=%u)", state.BuffersQueued, state.SamplesPlayed);
+
+		return xa27_flush();
+	}
+
+	XAUDIO2_BUFFER buffer;
+
+	buffer.AudioBytes = size;
+	buffer.Flags = 0;
+	buffer.LoopBegin = XAUDIO2_NO_LOOP_REGION;
+	buffer.LoopCount = 0;
+	buffer.LoopLength = 0;
+	buffer.pAudioData = (const BYTE*)src;
+	buffer.pContext = 0;
+	buffer.PlayBegin = 0;
+	buffer.PlayLength = 256;
+
+	HRESULT hr = s_tls_source_voice->SubmitSourceBuffer(&buffer);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : AddData() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+	}
+}
+
+#endif

rpcs3/Emu/Audio/XAudio2/XAudio28Thread.cpp

@@ -0,0 +1,164 @@
+#ifdef _WIN32
+
+#include "Utilities/Log.h"
+#include "Utilities/StrFmt.h"
+#include "Utilities/Config.h"
+#include "Emu/System.h"
+
+#include "XAudio2Thread.h"
+#include "3rdparty/minidx12/Include/xaudio2.h"
+
+extern cfg::bool_entry g_cfg_audio_convert_to_u16;
+
+static thread_local HMODULE s_tls_xaudio2_lib{};
+static thread_local IXAudio2* s_tls_xaudio2_instance{};
+static thread_local IXAudio2MasteringVoice* s_tls_master_voice{};
+static thread_local IXAudio2SourceVoice* s_tls_source_voice{};
+
+void XAudio2Thread::xa28_init(void* lib)
+{
+	s_tls_xaudio2_lib = (HMODULE)lib;
+
+	const auto create = (XAudio2Create)GetProcAddress(s_tls_xaudio2_lib, "XAudio2Create");
+
+	HRESULT hr = S_OK;
+
+	hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : CoInitializeEx() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+		return;
+	}	
+
+	hr = create(&s_tls_xaudio2_instance, 0, XAUDIO2_DEFAULT_PROCESSOR);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : XAudio2Create() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+		return;
+	}
+
+	hr = s_tls_xaudio2_instance->CreateMasteringVoice(&s_tls_master_voice, 8, 48000);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : CreateMasteringVoice() failed(0x%08x)", (u32)hr);
+		s_tls_xaudio2_instance->Release();
+		Emu.Pause();
+	}
+}
+
+void XAudio2Thread::xa28_destroy()
+{
+	if (s_tls_source_voice != nullptr)
+	{
+		s_tls_source_voice->Stop();
+		s_tls_source_voice->DestroyVoice();
+	}
+
+	if (s_tls_master_voice != nullptr)
+	{
+		s_tls_master_voice->DestroyVoice();
+	}
+
+	if (s_tls_xaudio2_instance != nullptr)
+	{
+		s_tls_xaudio2_instance->StopEngine();
+		s_tls_xaudio2_instance->Release();
+	}
+
+	CoUninitialize();
+
+	FreeLibrary(s_tls_xaudio2_lib);
+}
+
+void XAudio2Thread::xa28_play()
+{
+	HRESULT hr = s_tls_source_voice->Start();
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : Start() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+	}
+}
+
+void XAudio2Thread::xa28_flush()
+{
+	HRESULT hr = s_tls_source_voice->FlushSourceBuffers();
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : FlushSourceBuffers() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+	}
+}
+
+void XAudio2Thread::xa28_stop()
+{
+	HRESULT hr = s_tls_source_voice->Stop();
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : Stop() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+	}
+}
+
+void XAudio2Thread::xa28_open()
+{
+	HRESULT hr;
+
+	WORD sample_size = g_cfg_audio_convert_to_u16 ? sizeof(u16) : sizeof(float);
+	WORD channels = 8;
+
+	WAVEFORMATEX waveformatex;
+	waveformatex.wFormatTag = g_cfg_audio_convert_to_u16 ? WAVE_FORMAT_PCM : WAVE_FORMAT_IEEE_FLOAT;
+	waveformatex.nChannels = channels;
+	waveformatex.nSamplesPerSec = 48000;
+	waveformatex.nAvgBytesPerSec = 48000 * (DWORD)channels * (DWORD)sample_size;
+	waveformatex.nBlockAlign = channels * sample_size;
+	waveformatex.wBitsPerSample = sample_size * 8;
+	waveformatex.cbSize = 0;
+
+	hr = s_tls_xaudio2_instance->CreateSourceVoice(&s_tls_source_voice, &waveformatex, 0, XAUDIO2_DEFAULT_FREQ_RATIO);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : CreateSourceVoice() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+		return;
+	}
+
+	s_tls_source_voice->SetVolume(4.0);
+}
+
+void XAudio2Thread::xa28_add(const void* src, int size)
+{
+	XAUDIO2_VOICE_STATE state;
+	s_tls_source_voice->GetState(&state);
+
+	if (state.BuffersQueued > 32)
+	{
+		LOG_WARNING(GENERAL, "XAudio2Thread : too many buffers enqueued (%d, pos=%u)", state.BuffersQueued, state.SamplesPlayed);
+
+		return xa28_flush();
+	}
+
+	XAUDIO2_BUFFER buffer;
+
+	buffer.AudioBytes = size;
+	buffer.Flags = 0;
+	buffer.LoopBegin = XAUDIO2_NO_LOOP_REGION;
+	buffer.LoopCount = 0;
+	buffer.LoopLength = 0;
+	buffer.pAudioData = (const BYTE*)src;
+	buffer.pContext = 0;
+	buffer.PlayBegin = 0;
+	buffer.PlayLength = 256;
+
+	HRESULT hr = s_tls_source_voice->SubmitSourceBuffer(&buffer);
+	if (FAILED(hr))
+	{
+		LOG_ERROR(GENERAL, "XAudio2Thread : AddData() failed(0x%08x)", (u32)hr);
+		Emu.Pause();
+	}
+}
+
+#endif

rpcs3/Emu/Audio/XAudio2/XAudio2Thread.cpp

@@ -1,148 +1,98 @@
 #ifdef _WIN32
+
 #include "Utilities/Log.h"
 #include "Utilities/StrFmt.h"
-#include "Utilities/Config.h"
-#include "Emu/System.h"
 
 #include "XAudio2Thread.h"
-
-extern cfg::bool_entry g_cfg_audio_convert_to_u16;
+#include <Windows.h>
 
 XAudio2Thread::XAudio2Thread()
-	: m_xaudio2_instance(nullptr)
-	, m_master_voice(nullptr)
-	, m_source_voice(nullptr)
 {
-	HRESULT hr = S_OK;
-
-	hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-	if (FAILED(hr))
+	if (!SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL))
 	{
-		LOG_ERROR(GENERAL, "XAudio2Thread : CoInitializeEx() failed(0x%08x)", (u32)hr);
-		Emu.Pause();
+		LOG_ERROR(GENERAL, "XAudio: failed to increase thread priority");
+	}
+
+	if (auto lib2_9 = LoadLibraryExW(L"XAudio2_9.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32))
+	{
+		// xa28* implementation is fully compatible with library 2.9
+		xa28_init(lib2_9);
+
+		m_funcs.destroy = &xa28_destroy;
+		m_funcs.play    = &xa28_play;
+		m_funcs.flush   = &xa28_flush;
+		m_funcs.stop    = &xa28_stop;
+		m_funcs.open    = &xa28_open;
+		m_funcs.add     = &xa28_add;
+
+		LOG_SUCCESS(GENERAL, "XAudio 2.9 initialized");
 		return;
 	}
 
-	hr = XAudio2Create(&m_xaudio2_instance, 0, XAUDIO2_DEFAULT_PROCESSOR);
-	if (FAILED(hr))
+	if (auto lib2_7 = LoadLibraryExW(L"XAudio2_7.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32))
 	{
-		LOG_ERROR(GENERAL, "XAudio2Thread : XAudio2Create() failed(0x%08x)", (u32)hr);
-		Emu.Pause();
+		xa27_init(lib2_7);
+
+		m_funcs.destroy = &xa27_destroy;
+		m_funcs.play    = &xa27_play;
+		m_funcs.flush   = &xa27_flush;
+		m_funcs.stop    = &xa27_stop;
+		m_funcs.open    = &xa27_open;
+		m_funcs.add     = &xa27_add;
+
+		LOG_SUCCESS(GENERAL, "XAudio 2.7 initialized");
+		return;
+	}
+	
+	if (auto lib2_8 = LoadLibraryExW(L"XAudio2_8.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32))
+	{
+		xa28_init(lib2_8);
+
+		m_funcs.destroy = &xa28_destroy;
+		m_funcs.play    = &xa28_play;
+		m_funcs.flush   = &xa28_flush;
+		m_funcs.stop    = &xa28_stop;
+		m_funcs.open    = &xa28_open;
+		m_funcs.add     = &xa28_add;
+
+		LOG_SUCCESS(GENERAL, "XAudio 2.8 initialized");
 		return;
 	}
 
-	hr = m_xaudio2_instance->CreateMasteringVoice(&m_master_voice);
-	if (FAILED(hr))
-	{
-		LOG_ERROR(GENERAL, "XAudio2Thread : CreateMasteringVoice() failed(0x%08x)", (u32)hr);
-		m_xaudio2_instance->Release();
-		Emu.Pause();
-	}
+	fmt::throw_exception("No supported XAudio2 library found");
 }
 
 XAudio2Thread::~XAudio2Thread()
 {
-	if (m_source_voice != nullptr)
-	{
-		m_source_voice->Stop();
-		m_source_voice->DestroyVoice();
-	}
-
-	if (m_master_voice != nullptr)
-	{
-		m_master_voice->DestroyVoice();
-	}
-
-	if (m_xaudio2_instance != nullptr)
-	{
-		m_xaudio2_instance->StopEngine();
-		m_xaudio2_instance->Release();
-	}
-
-	CoUninitialize();
+	m_funcs.destroy();
 }
 
 void XAudio2Thread::Play()
 {
-	HRESULT hr = m_source_voice->Start();
-	if (FAILED(hr))
-	{
-		LOG_ERROR(GENERAL, "XAudio2Thread : Start() failed(0x%08x)", (u32)hr);
-		Emu.Pause();
-	}
+	m_funcs.play();
 }
 
 void XAudio2Thread::Close()
 {
-	Stop();
-	HRESULT hr = m_source_voice->FlushSourceBuffers();
-	if (FAILED(hr))
-	{
-		LOG_ERROR(GENERAL, "XAudio2Thread : FlushSourceBuffers() failed(0x%08x)", (u32)hr);
-		Emu.Pause();
-	}
+	m_funcs.stop();
+	m_funcs.flush();
 }
 
 void XAudio2Thread::Stop()
 {
-	HRESULT hr = m_source_voice->Stop();
-	if (FAILED(hr))
-	{
-		LOG_ERROR(GENERAL, "XAudio2Thread : Stop() failed(0x%08x)", (u32)hr);
-		Emu.Pause();
-	}
+	m_funcs.stop();
 }
 
 void XAudio2Thread::Open(const void* src, int size)
 {
-	HRESULT hr;
-
-	WORD sample_size = g_cfg_audio_convert_to_u16 ? sizeof(u16) : sizeof(float);
-	WORD channels = 8;
-
-	WAVEFORMATEX waveformatex;
-	waveformatex.wFormatTag = g_cfg_audio_convert_to_u16 ? WAVE_FORMAT_PCM : WAVE_FORMAT_IEEE_FLOAT;
-	waveformatex.nChannels = channels;
-	waveformatex.nSamplesPerSec = 48000;
-	waveformatex.nAvgBytesPerSec = 48000 * (DWORD)channels * (DWORD)sample_size;
-	waveformatex.nBlockAlign = channels * sample_size;
-	waveformatex.wBitsPerSample = sample_size * 8;
-	waveformatex.cbSize = 0;
-
-	hr = m_xaudio2_instance->CreateSourceVoice(&m_source_voice, &waveformatex, 0, XAUDIO2_DEFAULT_FREQ_RATIO);
-	if (FAILED(hr))
-	{
-		LOG_ERROR(GENERAL, "XAudio2Thread : CreateSourceVoice() failed(0x%08x)", (u32)hr);
-		Emu.Pause();
-		return;
-	}
-
-	m_source_voice->SetVolume(4.0);
-
-	AddData(src, size);
-	Play();
+	m_funcs.open();
+	m_funcs.add(src, size);
+	m_funcs.play();
 }
 
 void XAudio2Thread::AddData(const void* src, int size)
 {
-	XAUDIO2_BUFFER buffer;
-
-	buffer.AudioBytes = size;
-	buffer.Flags = 0;
-	buffer.LoopBegin = XAUDIO2_NO_LOOP_REGION;
-	buffer.LoopCount = 0;
-	buffer.LoopLength = 0;
-	buffer.pAudioData = (const BYTE*)src;
-	buffer.pContext = 0;
-	buffer.PlayBegin = 0;
-	buffer.PlayLength = 256;
-
-	HRESULT hr = m_source_voice->SubmitSourceBuffer(&buffer);
-	if (FAILED(hr))
-	{
-		LOG_ERROR(GENERAL, "XAudio2Thread : AddData() failed(0x%08x)", (u32)hr);
-		Emu.Pause();
-	}
+	m_funcs.add(src, size);
 }
 
 #endif

rpcs3/Emu/Audio/XAudio2/XAudio2Thread.h

@@ -4,13 +4,35 @@
 
 #include "Emu/Audio/AudioThread.h"
 
-#include "3rdparty/XAudio2_7/XAudio2.h"
-
 class XAudio2Thread : public AudioThread
 {
-	IXAudio2* m_xaudio2_instance;
-	IXAudio2MasteringVoice* m_master_voice;
-	IXAudio2SourceVoice* m_source_voice;
+	struct vtable
+	{
+		void(*destroy)();
+		void(*play)();
+		void(*flush)();
+		void(*stop)();
+		void(*open)();
+		void(*add)(const void*, int);
+	};
+
+	vtable m_funcs;
+
+	static void xa27_init(void*);
+	static void xa27_destroy();
+	static void xa27_play();
+	static void xa27_flush();
+	static void xa27_stop();
+	static void xa27_open();
+	static void xa27_add(const void*, int);
+
+	static void xa28_init(void*);
+	static void xa28_destroy();
+	static void xa28_play();
+	static void xa28_flush();
+	static void xa28_stop();
+	static void xa28_open();
+	static void xa28_add(const void*, int);
 
 public:
 	XAudio2Thread();

rpcs3/Emu/CPU/CPUThread.cpp

@@ -1,40 +1,60 @@
 #include "stdafx.h"
 #include "Emu/System.h"
+#include "Emu/Memory/vm.h"
 #include "CPUThread.h"
 
-#include <mutex>
-#include <condition_variable>
+DECLARE(cpu_thread::g_threads_created){0};
+DECLARE(cpu_thread::g_threads_deleted){0};
+
+template <>
+void fmt_class_string<cpu_flag>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](cpu_flag f)
+	{
+		switch (f)
+		{
+		case cpu_flag::stop: return "STOP";
+		case cpu_flag::exit: return "EXIT";
+		case cpu_flag::suspend: return "s";
+		case cpu_flag::ret: return "ret";
+		case cpu_flag::signal: return "sig";
+		case cpu_flag::memory: return "mem";
+		case cpu_flag::dbg_global_pause: return "G-PAUSE";
+		case cpu_flag::dbg_global_stop: return "G-EXIT";
+		case cpu_flag::dbg_pause: return "PAUSE";
+		case cpu_flag::dbg_step: return "STEP";
+		case cpu_flag::__bitset_enum_max: break;
+		}
+
+		return unknown;
+	});
+}
+
+template<>
+void fmt_class_string<bs_t<cpu_flag>>::format(std::string& out, u64 arg)
+{
+	format_bitset(out, arg, "[", "|", "]", &fmt_class_string<cpu_flag>::format);
+}
 
 thread_local cpu_thread* g_tls_current_cpu_thread = nullptr;
 
-extern std::mutex& get_current_thread_mutex();
-extern std::condition_variable& get_current_thread_cv();
-
 void cpu_thread::on_task()
 {
-	state -= cpu_state::exit;
+	state -= cpu_flag::exit;
 
 	g_tls_current_cpu_thread = this;
 
-	Emu.SendDbgCommand(DID_CREATE_THREAD, this);
-
-	std::unique_lock<std::mutex> lock(get_current_thread_mutex());
-
 	// Check thread status
-	while (!(state & cpu_state::exit))
+	while (!test(state, cpu_flag::exit + cpu_flag::dbg_global_stop))
 	{
-		CHECK_EMU_STATUS;
-
-		// check stop status
-		if (!(state & cpu_state::stop))
+		// Check stop status
+		if (!test(state & cpu_flag::stop))
 		{
-			if (lock) lock.unlock();
-
 			try
 			{
 				cpu_task();
 			}
-			catch (cpu_state _s)
+			catch (cpu_flag _s)
 			{
 				state += _s;
 			}
@@ -44,79 +64,109 @@ void cpu_thread::on_task()
 				throw;
 			}
 
-			state -= cpu_state::ret;
+			state -= cpu_flag::ret;
 			continue;
 		}
 
-		if (!lock)
-		{
-			lock.lock();
-			continue;
-		}
-
-		get_current_thread_cv().wait(lock);
+		thread_ctrl::wait();
 	}
 }
 
 void cpu_thread::on_stop()
 {
-	state += cpu_state::exit;
-	(*this)->lock_notify();
+	state += cpu_flag::exit;
+	notify();
 }
 
 cpu_thread::~cpu_thread()
 {
+	vm::cleanup_unlock(*this);
+	g_threads_deleted++;
 }
 
-cpu_thread::cpu_thread(cpu_type type)
-	: type(type)
+cpu_thread::cpu_thread(u32 id)
+	: id(id)
 {
+	g_threads_created++;
 }
 
-bool cpu_thread::check_status()
+bool cpu_thread::check_state()
 {
-	std::unique_lock<std::mutex> lock(get_current_thread_mutex(), std::defer_lock);
+	bool cpu_sleep_called = false;
+	bool cpu_flag_memory = false;
 
 	while (true)
 	{
-		CHECK_EMU_STATUS; // check at least once
+		if (test(state, cpu_flag::memory) && state.test_and_reset(cpu_flag::memory))
+		{
+			cpu_flag_memory = true;
 
-		if (state & cpu_state::exit)
+			if (auto& ptr = vm::g_tls_locked)
+			{
+				ptr->compare_and_swap(this, nullptr);
+				ptr = nullptr;
+			}
+		}
+
+		if (test(state, cpu_flag::exit + cpu_flag::dbg_global_stop))
 		{
 			return true;
 		}
 
-		if (!state.test(cpu_state_pause) && !state.test(cpu_state::interrupt))
+		if (test(state & cpu_flag::signal) && state.test_and_reset(cpu_flag::signal))
 		{
+			cpu_sleep_called = false;
+		}
+
+		if (!test(state, cpu_state_pause))
+		{
+			if (cpu_flag_memory) vm::passive_lock(*this);
 			break;
 		}
-
-		if (!lock)
+		else if (!cpu_sleep_called)
 		{
-			lock.lock();
+			cpu_sleep();
+			cpu_sleep_called = true;
 			continue;
 		}
 
-		if (!state.test(cpu_state_pause) && state & cpu_state::interrupt && handle_interrupt())
-		{
-			continue;
-		}
-
-		get_current_thread_cv().wait(lock);
+		thread_ctrl::wait();
 	}
 
 	const auto state_ = state.load();
 
-	if (state_ & make_bitset(cpu_state::ret, cpu_state::stop))
+	if (test(state_, cpu_flag::ret + cpu_flag::stop))
 	{
 		return true;
 	}
 
-	if (state_ & cpu_state::dbg_step)
+	if (test(state_, cpu_flag::dbg_step))
 	{
-		state += cpu_state::dbg_pause;
-		state -= cpu_state::dbg_step;
+		state += cpu_flag::dbg_pause;
+		state -= cpu_flag::dbg_step;
 	}
 
 	return false;
 }
+
+void cpu_thread::test_state()
+{
+	if (UNLIKELY(test(state)))
+	{
+		if (check_state())
+		{
+			throw cpu_flag::ret;
+		}
+	}
+}
+
+void cpu_thread::run()
+{
+	state -= cpu_flag::stop;
+	notify();
+}
+
+std::string cpu_thread::dump() const
+{
+	return fmt::format("Type: %s\n" "State: %s\n", typeid(*this).name(), state.load());
+}

rpcs3/Emu/CPU/CPUThread.h

@@ -1,77 +1,70 @@
 #pragma once
 
 #include "../Utilities/Thread.h"
-#include "../Utilities/BitSet.h"
+#include "../Utilities/bit_set.h"
 
-// CPU Thread Type
-enum class cpu_type : u8
-{
-	ppu, // PPU Thread
-	spu, // SPU Thread
-	arm, // ARMv7 Thread
-};
-
-// CPU Thread State flags
-enum struct cpu_state : u16
+// Thread state flags
+enum class cpu_flag : u32
 {
 	stop, // Thread not running (HLE, initial state)
 	exit, // Irreversible exit
-	suspend, // Thread paused
+	suspend, // Thread suspended
 	ret, // Callback return requested
 	signal, // Thread received a signal (HLE)
-	interrupt, // Thread interrupted
+	memory, // Thread must unlock memory mutex
 
 	dbg_global_pause, // Emulation paused
 	dbg_global_stop, // Emulation stopped
 	dbg_pause, // Thread paused
 	dbg_step, // Thread forced to pause after one step (one instruction, etc)
+
+	__bitset_enum_max
 };
 
-// CPU Thread State flags: pause state union
-constexpr bitset_t<cpu_state> cpu_state_pause = make_bitset(cpu_state::suspend, cpu_state::dbg_global_pause, cpu_state::dbg_pause);
+// Flag set for pause state
+constexpr bs_t<cpu_flag> cpu_state_pause = cpu_flag::suspend + cpu_flag::dbg_global_pause + cpu_flag::dbg_pause;
 
 class cpu_thread : public named_thread
 {
-	void on_task() override;
+	void on_task() override final;
 
 public:
 	virtual void on_stop() override;
 	virtual ~cpu_thread() override;
 
-	const id_value<> id{};
-	const cpu_type type;
+	const u32 id;
 
-	cpu_thread(cpu_type type);
-
-	// Public recursive sleep state counter
-	atomic_t<u8> sleep_counter{};
+	cpu_thread(u32 id);
 
 	// Public thread state
-	atomic_t<bitset_t<cpu_state>> state{ cpu_state::stop };
-
-	// Object associated with sleep state, possibly synchronization primitive (mutex, semaphore, etc.)
-	atomic_t<void*> owner{};
+	atomic_t<bs_t<cpu_flag>> state{+cpu_flag::stop};
 
 	// Process thread state, return true if the checker must return
-	bool check_status();
+	bool check_state();
 
-	// Increse sleep counter
-	void sleep()
+	// Process thread state
+	void test_state();
+
+	// Run thread
+	void run();
+
+	// Check thread type
+	u32 id_type()
 	{
-		if (!sleep_counter++) return; //handle_interrupt();
+		return id >> 24;
 	}
 
-	// Decrese sleep counter
-	void awake()
-	{
-		if (!--sleep_counter) owner = nullptr;
-	}
+	// Thread stats for external observation
+	static atomic_t<u64> g_threads_created, g_threads_deleted;
 
 	// Print CPU state
-	virtual std::string dump() const = 0;
-	virtual void cpu_init() {}
+	virtual std::string dump() const;
+
+	// Thread entry point function
 	virtual void cpu_task() = 0;
-	virtual bool handle_interrupt() { return false; }
+
+	// Callback for cpu_flag::suspend
+	virtual void cpu_sleep() {}
 };
 
 inline cpu_thread* get_current_cpu_thread() noexcept
@@ -80,27 +73,3 @@ inline cpu_thread* get_current_cpu_thread() noexcept
 
 	return g_tls_current_cpu_thread;
 }
-
-// Helper for cpu_thread.
-// 1) Calls sleep() and locks the thread in the constructor.
-// 2) Calls awake() and unlocks the thread in the destructor.
-class cpu_thread_lock final
-{
-	cpu_thread& m_thread;
-
-public:
-	cpu_thread_lock(const cpu_thread_lock&) = delete;
-
-	cpu_thread_lock(cpu_thread& thread)
-		: m_thread(thread)
-	{
-		m_thread.sleep();
-		m_thread->lock();
-	}
-
-	~cpu_thread_lock()
-	{
-		m_thread.awake();
-		m_thread->unlock();
-	}
-};

rpcs3/Emu/Cell/ErrorCodes.h

@@ -1,215 +1,80 @@
 #pragma once
 
-#define ERROR_CODE(code) static_cast<s32>(code)
-
-enum CellOk : s32
+struct CellOk
 {
-	CELL_OK = 0,
+	enum : s32
+	{
+		__not_an_error,
+
+		CELL_OK = 0
+	};
 };
 
-enum CellError : s32
+// Temporary workaround
+constexpr auto CELL_OK = CellOk::CELL_OK;
+
+enum CellError : u32
 {
-	CELL_EAGAIN        = ERROR_CODE(0x80010001), // The resource is temporarily unavailable
-	CELL_EINVAL        = ERROR_CODE(0x80010002), // An invalid argument value is specified
-	CELL_ENOSYS        = ERROR_CODE(0x80010003), // The feature is not yet implemented
-	CELL_ENOMEM        = ERROR_CODE(0x80010004), // Memory allocation failure
-	CELL_ESRCH         = ERROR_CODE(0x80010005), // The resource with the specified identifier does not exist
-	CELL_ENOENT        = ERROR_CODE(0x80010006), // The file does not exist
-	CELL_ENOEXEC       = ERROR_CODE(0x80010007), // The file is in unrecognized format
-	CELL_EDEADLK       = ERROR_CODE(0x80010008), // Resource deadlock is avoided
-	CELL_EPERM         = ERROR_CODE(0x80010009), // The operation is not permitted
-	CELL_EBUSY         = ERROR_CODE(0x8001000A), // The device or resource is busy
-	CELL_ETIMEDOUT     = ERROR_CODE(0x8001000B), // The operation is timed out
-	CELL_EABORT        = ERROR_CODE(0x8001000C), // The operation is aborted
-	CELL_EFAULT        = ERROR_CODE(0x8001000D), // Invalid memory access
-	CELL_ESTAT         = ERROR_CODE(0x8001000F), // State of the target thread is invalid
-	CELL_EALIGN        = ERROR_CODE(0x80010010), // Alignment is invalid.
-	CELL_EKRESOURCE    = ERROR_CODE(0x80010011), // Shortage of the kernel resources
-	CELL_EISDIR        = ERROR_CODE(0x80010012), // The file is a directory
-	CELL_ECANCELED     = ERROR_CODE(0x80010013), // Operation canceled
-	CELL_EEXIST        = ERROR_CODE(0x80010014), // Entry already exists
-	CELL_EISCONN       = ERROR_CODE(0x80010015), // Port is already connected
-	CELL_ENOTCONN      = ERROR_CODE(0x80010016), // Port is not connected
-	CELL_EAUTHFAIL     = ERROR_CODE(0x80010017), // Program authentication fail
-	CELL_ENOTMSELF     = ERROR_CODE(0x80010018), // The file is not a MSELF
-	CELL_ESYSVER       = ERROR_CODE(0x80010019), // System version error
-	CELL_EAUTHFATAL    = ERROR_CODE(0x8001001A), // Fatal system error
-	CELL_EDOM          = ERROR_CODE(0x8001001B),
-	CELL_ERANGE        = ERROR_CODE(0x8001001C),
-	CELL_EILSEQ        = ERROR_CODE(0x8001001D),
-	CELL_EFPOS         = ERROR_CODE(0x8001001E),
-	CELL_EINTR         = ERROR_CODE(0x8001001F),
-	CELL_EFBIG         = ERROR_CODE(0x80010020),
-	CELL_EMLINK        = ERROR_CODE(0x80010021),
-	CELL_ENFILE        = ERROR_CODE(0x80010022),
-	CELL_ENOSPC        = ERROR_CODE(0x80010023),
-	CELL_ENOTTY        = ERROR_CODE(0x80010024),
-	CELL_EPIPE         = ERROR_CODE(0x80010025),
-	CELL_EROFS         = ERROR_CODE(0x80010026),
-	CELL_ESPIPE        = ERROR_CODE(0x80010027),
-	CELL_E2BIG         = ERROR_CODE(0x80010028),
-	CELL_EACCES        = ERROR_CODE(0x80010029),
-	CELL_EBADF         = ERROR_CODE(0x8001002A),
-	CELL_EIO           = ERROR_CODE(0x8001002B),
-	CELL_EMFILE        = ERROR_CODE(0x8001002C),
-	CELL_ENODEV        = ERROR_CODE(0x8001002D),
-	CELL_ENOTDIR       = ERROR_CODE(0x8001002E),
-	CELL_ENXIO         = ERROR_CODE(0x8001002F),
-	CELL_EXDEV         = ERROR_CODE(0x80010030),
-	CELL_EBADMSG       = ERROR_CODE(0x80010031),
-	CELL_EINPROGRESS   = ERROR_CODE(0x80010032),
-	CELL_EMSGSIZE      = ERROR_CODE(0x80010033),
-	CELL_ENAMETOOLONG  = ERROR_CODE(0x80010034),
-	CELL_ENOLCK        = ERROR_CODE(0x80010035),
-	CELL_ENOTEMPTY     = ERROR_CODE(0x80010036),
-	CELL_ENOTSUP       = ERROR_CODE(0x80010037),
-	CELL_EFSSPECIFIC   = ERROR_CODE(0x80010038),
-	CELL_EOVERFLOW     = ERROR_CODE(0x80010039),
-	CELL_ENOTMOUNTED   = ERROR_CODE(0x8001003A),
-	CELL_ENOTSDATA     = ERROR_CODE(0x8001003B),
+	CELL_EAGAIN        = 0x80010001, // The resource is temporarily unavailable
+	CELL_EINVAL        = 0x80010002, // An invalid argument value is specified
+	CELL_ENOSYS        = 0x80010003, // The feature is not yet implemented
+	CELL_ENOMEM        = 0x80010004, // Memory allocation failure
+	CELL_ESRCH         = 0x80010005, // The resource with the specified identifier does not exist
+	CELL_ENOENT        = 0x80010006, // The file does not exist
+	CELL_ENOEXEC       = 0x80010007, // The file is in unrecognized format
+	CELL_EDEADLK       = 0x80010008, // Resource deadlock is avoided
+	CELL_EPERM         = 0x80010009, // The operation is not permitted
+	CELL_EBUSY         = 0x8001000A, // The device or resource is busy
+	CELL_ETIMEDOUT     = 0x8001000B, // The operation is timed out
+	CELL_EABORT        = 0x8001000C, // The operation is aborted
+	CELL_EFAULT        = 0x8001000D, // Invalid memory access
+	CELL_ENOCHILD      = 0x8001000E, // Process has no child(s)
+	CELL_ESTAT         = 0x8001000F, // State of the target thread is invalid
+	CELL_EALIGN        = 0x80010010, // Alignment is invalid.
+	CELL_EKRESOURCE    = 0x80010011, // Shortage of the kernel resources
+	CELL_EISDIR        = 0x80010012, // The file is a directory
+	CELL_ECANCELED     = 0x80010013, // Operation canceled
+	CELL_EEXIST        = 0x80010014, // Entry already exists
+	CELL_EISCONN       = 0x80010015, // Port is already connected
+	CELL_ENOTCONN      = 0x80010016, // Port is not connected
+	CELL_EAUTHFAIL     = 0x80010017, // Program authentication fail
+	CELL_ENOTMSELF     = 0x80010018, // The file is not a MSELF
+	CELL_ESYSVER       = 0x80010019, // System version error
+	CELL_EAUTHFATAL    = 0x8001001A, // Fatal system error
+	CELL_EDOM          = 0x8001001B, // Math domain violation 
+	CELL_ERANGE        = 0x8001001C, // Math range violation 
+	CELL_EILSEQ        = 0x8001001D, // Illegal multi-byte sequence in input 
+	CELL_EFPOS         = 0x8001001E, // File position error
+	CELL_EINTR         = 0x8001001F, // Syscall was interrupted
+	CELL_EFBIG         = 0x80010020, // File too large
+	CELL_EMLINK        = 0x80010021, // Too many links
+	CELL_ENFILE        = 0x80010022, // File table overflow
+	CELL_ENOSPC        = 0x80010023, // No space left on device
+	CELL_ENOTTY        = 0x80010024, // Not a TTY
+	CELL_EPIPE         = 0x80010025, // Broken pipe
+	CELL_EROFS         = 0x80010026, // Read-only filesystem (write fail)
+	CELL_ESPIPE        = 0x80010027, // Illegal seek (e.g. seek on pipe)
+	CELL_E2BIG         = 0x80010028, // Arg list too long
+	CELL_EACCES        = 0x80010029, // Access violation
+	CELL_EBADF         = 0x8001002A, // Invalid file descriptor
+	CELL_EIO           = 0x8001002B, // Filesystem mounting failed (actually IO error...EIO)
+	CELL_EMFILE        = 0x8001002C, // Too many files open
+	CELL_ENODEV        = 0x8001002D, // No device
+	CELL_ENOTDIR       = 0x8001002E, // Not a directory
+	CELL_ENXIO         = 0x8001002F, // No such device or IO
+	CELL_EXDEV         = 0x80010030, // Cross-device link error
+	CELL_EBADMSG       = 0x80010031, // Bad Message
+	CELL_EINPROGRESS   = 0x80010032, // In progress
+	CELL_EMSGSIZE      = 0x80010033, // Message size error
+	CELL_ENAMETOOLONG  = 0x80010034, // Name too long
+	CELL_ENOLCK        = 0x80010035, // No lock
+	CELL_ENOTEMPTY     = 0x80010036, // Not empty
+	CELL_ENOTSUP       = 0x80010037, // Not supported
+	CELL_EFSSPECIFIC   = 0x80010038, // File-system specific error
+	CELL_EOVERFLOW     = 0x80010039, // Overflow occured
+	CELL_ENOTMOUNTED   = 0x8001003A, // Filesystem not mounted
+	CELL_ENOTSDATA     = 0x8001003B, // Not SData
+	CELL_ESDKVER       = 0x8001003C, // Incorrect version in sys_load_param 
+	CELL_ENOLICDISC    = 0x8001003D, // Pointer is null. Similar than 0x8001003E but with some PARAM.SFO parameter (TITLE_ID?) embedded.
+	CELL_ENOLICENT     = 0x8001003E, // Pointer is null
 };
-
-// Special return type signaling on errors
-struct ppu_error_code
-{
-	s32 value;
-
-	// Print error message, error code is returned
-	static s32 report(s32 error, const char* text);
-
-	// Must be specialized for specific tag type T
-	template<typename T>
-	static const char* print(T code)
-	{
-		return nullptr;
-	}
-
-	template<typename T>
-	s32 error_check(T code)
-	{
-		if (const auto text = print(code))
-		{
-			return report(code, text);
-		}
-
-		return code;
-	}
-
-	ppu_error_code() = default;
-
-	// General error check
-	template<typename T, typename = std::enable_if_t<std::is_enum<T>::value>>
-	ppu_error_code(T value)
-		: value(error_check(value))
-	{
-	}
-
-	// Force error reporting with a message specified
-	ppu_error_code(s32 value, const char* text)
-		: value(report(value, text))
-	{
-	}
-
-	// Helper
-	enum class not_an_error : s32 {};
-
-	// Silence any error
-	constexpr ppu_error_code(not_an_error value)
-		: value(static_cast<s32>(value))
-	{
-	}
-
-	// Conversion
-	constexpr operator s32() const
-	{
-		return value;
-	}
-};
-
-// Helper macro for silencing possible error checks on returning ppu_error_code values
-#define NOT_AN_ERROR(...) static_cast<ppu_error_code::not_an_error>(__VA_ARGS__)
-
-template<typename T, typename>
-struct ppu_gpr_cast_impl;
-
-template<>
-struct ppu_gpr_cast_impl<ppu_error_code, void>
-{
-	static inline u64 to(const ppu_error_code& code)
-	{
-		return code;
-	}
-
-	static inline ppu_error_code from(const u64 reg)
-	{
-		return NOT_AN_ERROR(reg);
-	}
-};
-
-template<>
-inline const char* ppu_error_code::print(CellError error)
-{
-	switch (error)
-	{
-		STR_CASE(CELL_EAGAIN);
-		STR_CASE(CELL_EINVAL);
-		STR_CASE(CELL_ENOSYS);
-		STR_CASE(CELL_ENOMEM);
-		STR_CASE(CELL_ESRCH);
-		STR_CASE(CELL_ENOENT);
-		STR_CASE(CELL_ENOEXEC);
-		STR_CASE(CELL_EDEADLK);
-		STR_CASE(CELL_EPERM);
-		STR_CASE(CELL_EBUSY);
-		STR_CASE(CELL_ETIMEDOUT);
-		STR_CASE(CELL_EABORT);
-		STR_CASE(CELL_EFAULT);
-		STR_CASE(CELL_ESTAT);
-		STR_CASE(CELL_EALIGN);
-		STR_CASE(CELL_EKRESOURCE);
-		STR_CASE(CELL_EISDIR);
-		STR_CASE(CELL_ECANCELED);
-		STR_CASE(CELL_EEXIST);
-		STR_CASE(CELL_EISCONN);
-		STR_CASE(CELL_ENOTCONN);
-		STR_CASE(CELL_EAUTHFAIL);
-		STR_CASE(CELL_ENOTMSELF);
-		STR_CASE(CELL_ESYSVER);
-		STR_CASE(CELL_EAUTHFATAL);
-		STR_CASE(CELL_EDOM);
-		STR_CASE(CELL_ERANGE);
-		STR_CASE(CELL_EILSEQ);
-		STR_CASE(CELL_EFPOS);
-		STR_CASE(CELL_EINTR);
-		STR_CASE(CELL_EFBIG);
-		STR_CASE(CELL_EMLINK);
-		STR_CASE(CELL_ENFILE);
-		STR_CASE(CELL_ENOSPC);
-		STR_CASE(CELL_ENOTTY);
-		STR_CASE(CELL_EPIPE);
-		STR_CASE(CELL_EROFS);
-		STR_CASE(CELL_ESPIPE);
-		STR_CASE(CELL_E2BIG);
-		STR_CASE(CELL_EACCES);
-		STR_CASE(CELL_EBADF);
-		STR_CASE(CELL_EIO);
-		STR_CASE(CELL_EMFILE);
-		STR_CASE(CELL_ENODEV);
-		STR_CASE(CELL_ENOTDIR);
-		STR_CASE(CELL_ENXIO);
-		STR_CASE(CELL_EXDEV);
-		STR_CASE(CELL_EBADMSG);
-		STR_CASE(CELL_EINPROGRESS);
-		STR_CASE(CELL_EMSGSIZE);
-		STR_CASE(CELL_ENAMETOOLONG);
-		STR_CASE(CELL_ENOLCK);
-		STR_CASE(CELL_ENOTEMPTY);
-		STR_CASE(CELL_ENOTSUP);
-		STR_CASE(CELL_EFSSPECIFIC);
-		STR_CASE(CELL_EOVERFLOW);
-		STR_CASE(CELL_ENOTMOUNTED);
-		STR_CASE(CELL_ENOTSDATA);
-	}
-
-	return nullptr;
-}

rpcs3/Emu/Cell/MFC.cpp

@@ -1,47 +1,321 @@
 #include "stdafx.h"
+#include "Emu/Memory/vm.h"
+#include "Emu/Cell/SPUThread.h"
+#include "Emu/Cell/lv2/sys_sync.h"
 #include "MFC.h"
 
-const char* get_mfc_cmd_name(u32 cmd)
+template <>
+void fmt_class_string<MFC>::format(std::string& out, u64 arg)
 {
-	switch (cmd)
+	format_enum(out, arg, [](MFC cmd)
 	{
-	case MFC_PUT_CMD: return "PUT";
-	case MFC_PUTB_CMD: return "PUTB";
-	case MFC_PUTF_CMD: return "PUTF";
-	case MFC_PUTS_CMD: return "PUTS";
-	case MFC_PUTBS_CMD: return "PUTBS";
-	case MFC_PUTFS_CMD: return "PUTFS";
-	case MFC_PUTR_CMD: return "PUTR";
-	case MFC_PUTRB_CMD: return "PUTRB";
-	case MFC_PUTRF_CMD: return "PUTRF";
-	case MFC_GET_CMD: return "GET";
-	case MFC_GETB_CMD: return "GETB";
-	case MFC_GETF_CMD: return "GETF";
-	case MFC_GETS_CMD: return "GETS";
-	case MFC_GETBS_CMD: return "GETBS";
-	case MFC_GETFS_CMD: return "GETFS";
-	case MFC_PUTL_CMD: return "PUTL";
-	case MFC_PUTLB_CMD: return "PUTLB";
-	case MFC_PUTLF_CMD: return "PUTLF";
-	case MFC_PUTRL_CMD: return "PUTRL";
-	case MFC_PUTRLB_CMD: return "PUTRLB";
-	case MFC_PUTRLF_CMD: return "PUTRLF";
-	case MFC_GETL_CMD: return "GETL";
-	case MFC_GETLB_CMD: return "GETLB";
-	case MFC_GETLF_CMD: return "GETLF";
+		switch (cmd)
+		{
+		case MFC_PUT_CMD: return "PUT";
+		case MFC_PUTB_CMD: return "PUTB";
+		case MFC_PUTF_CMD: return "PUTF";
+		case MFC_PUTS_CMD: return "PUTS";
+		case MFC_PUTBS_CMD: return "PUTBS";
+		case MFC_PUTFS_CMD: return "PUTFS";
+		case MFC_PUTR_CMD: return "PUTR";
+		case MFC_PUTRB_CMD: return "PUTRB";
+		case MFC_PUTRF_CMD: return "PUTRF";
+		case MFC_GET_CMD: return "GET";
+		case MFC_GETB_CMD: return "GETB";
+		case MFC_GETF_CMD: return "GETF";
+		case MFC_GETS_CMD: return "GETS";
+		case MFC_GETBS_CMD: return "GETBS";
+		case MFC_GETFS_CMD: return "GETFS";
+		case MFC_PUTL_CMD: return "PUTL";
+		case MFC_PUTLB_CMD: return "PUTLB";
+		case MFC_PUTLF_CMD: return "PUTLF";
+		case MFC_PUTRL_CMD: return "PUTRL";
+		case MFC_PUTRLB_CMD: return "PUTRLB";
+		case MFC_PUTRLF_CMD: return "PUTRLF";
+		case MFC_GETL_CMD: return "GETL";
+		case MFC_GETLB_CMD: return "GETLB";
+		case MFC_GETLF_CMD: return "GETLF";
 
-	case MFC_GETLLAR_CMD: return "GETLLAR";
-	case MFC_PUTLLC_CMD: return "PUTLLC";
-	case MFC_PUTLLUC_CMD: return "PUTLLUC";
-	case MFC_PUTQLLUC_CMD: return "PUTQLLUC";
+		case MFC_GETLLAR_CMD: return "GETLLAR";
+		case MFC_PUTLLC_CMD: return "PUTLLC";
+		case MFC_PUTLLUC_CMD: return "PUTLLUC";
+		case MFC_PUTQLLUC_CMD: return "PUTQLLUC";
 
-	case MFC_SNDSIG_CMD: return "SNDSIG";
-	case MFC_SNDSIGB_CMD: return "SNDSIGB";
-	case MFC_SNDSIGF_CMD: return "SNDSIGF";
-	case MFC_BARRIER_CMD: return "BARRIER";
-	case MFC_EIEIO_CMD: return "EIEIO";
-	case MFC_SYNC_CMD: return "SYNC";
+		case MFC_SNDSIG_CMD: return "SNDSIG";
+		case MFC_SNDSIGB_CMD: return "SNDSIGB";
+		case MFC_SNDSIGF_CMD: return "SNDSIGF";
+		case MFC_BARRIER_CMD: return "BARRIER";
+		case MFC_EIEIO_CMD: return "EIEIO";
+		case MFC_SYNC_CMD: return "SYNC";
+		}
+
+		return unknown;
+	});
+}
+
+mfc_thread::mfc_thread()
+	: cpu_thread(0)
+{
+}
+
+mfc_thread::~mfc_thread()
+{
+}
+
+std::string mfc_thread::get_name() const
+{
+	return "MFC Thread";
+}
+
+void mfc_thread::cpu_task()
+{
+	vm::passive_lock(*this);
+
+	u32 no_updates = 0;
+
+	while (!m_spus.empty() || m_spuq.size() != 0)
+	{
+		// Add or remove destroyed SPU threads
+		while (m_spuq.size())
+		{
+			auto& thread_ptr = m_spuq[0];
+
+			// Look for deleted threads if nullptr received
+			for (auto it = m_spus.cbegin(); !thread_ptr && it != m_spus.cend();)
+			{
+				if (test(it->get()->state, cpu_flag::exit))
+				{
+					it = m_spus.erase(it);
+				}
+				else
+				{
+					it++;
+				}
+			}
+
+			// Add thread
+			if (thread_ptr)
+			{
+				m_spus.emplace_back(std::move(thread_ptr));
+			}
+
+			m_spuq.end_pop();
+			no_updates = 0;
+		}
+
+		test_state();
+
+		// Process SPU threads
+		for (const auto& thread_ptr : m_spus)
+		{
+			SPUThread& spu = *thread_ptr;
+
+			const auto proxy_size = spu.mfc_proxy.size();
+			const auto queue_size = spu.mfc_queue.size();
+
+			if (proxy_size)
+			{
+				const auto& cmd = spu.mfc_proxy[0];
+
+				spu.do_dma_transfer(cmd);
+
+				if (cmd.cmd & MFC_START_MASK && !spu.status.test_and_set(SPU_STATUS_RUNNING))
+				{
+					spu.run();
+				}
+
+				spu.mfc_proxy.end_pop();
+				no_updates = 0;
+			}
+
+			test_state();
+
+			if (queue_size)
+			{
+				auto& cmd = spu.mfc_queue[0];
+
+				if ((cmd.cmd & ~(MFC_BARRIER_MASK | MFC_FENCE_MASK)) == MFC_PUTQLLUC_CMD)
+				{
+					auto& data = vm::ps3::_ref<decltype(spu.rdata)>(cmd.eal);
+					const auto to_write = spu._ref<decltype(spu.rdata)>(cmd.lsa & 0x3ffff);
+
+					cmd.size = 0;
+					no_updates = 0;
+
+					// Store unconditionally
+					vm::writer_lock lock(0);
+					data = to_write;
+					vm::reservation_update(cmd.eal, 128);
+					vm::notify(cmd.eal, 128);
+				}
+				else if (cmd.cmd & MFC_LIST_MASK)
+				{
+					struct list_element
+					{
+						be_t<u16> sb; // Stall-and-Notify bit (0x8000)
+						be_t<u16> ts; // List Transfer Size
+						be_t<u32> ea; // External Address Low
+					};
+
+					if (cmd.size && (spu.ch_stall_mask & (1u << cmd.tag)) == 0)
+					{
+						cmd.lsa &= 0x3fff0;
+
+						const list_element item = spu._ref<list_element>(cmd.eal & 0x3fff8);
+
+						const u32 size = item.ts;
+						const u32 addr = item.ea;
+
+						if (size)
+						{
+							spu_mfc_cmd transfer;
+							transfer.eal = addr;
+							transfer.eah = 0;
+							transfer.lsa = cmd.lsa | (addr & 0xf);
+							transfer.tag = cmd.tag;
+							transfer.cmd = MFC(cmd.cmd & ~MFC_LIST_MASK);
+							transfer.size = size;
+
+							spu.do_dma_transfer(transfer);
+							cmd.lsa += std::max<u32>(size, 16);
+						}
+
+						cmd.eal += 8;
+						cmd.size -= 8;
+						no_updates = 0;
+
+						if (item.sb & 0x8000)
+						{
+							spu.ch_stall_stat.push_or(spu, 1 << cmd.tag);
+
+							const u32 evt = spu.ch_event_stat.fetch_or(SPU_EVENT_SN);
+
+							if (evt & SPU_EVENT_WAITING)
+							{
+								spu.notify();
+							}
+							else if (evt & SPU_EVENT_INTR_ENABLED)
+							{
+								spu.state += cpu_flag::suspend;
+							}
+						}
+					}
+				}
+				else if (LIKELY(cmd.size))
+				{
+					spu.do_dma_transfer(cmd);
+					cmd.size = 0;
+				}
+				else if (UNLIKELY((cmd.cmd & ~0xc) == MFC_BARRIER_CMD))
+				{
+					// TODO (MFC_BARRIER_CMD, MFC_EIEIO_CMD, MFC_SYNC_CMD)
+					_mm_mfence();
+				}
+
+				if (!cmd.size)
+				{
+					spu.mfc_queue.end_pop();
+					no_updates = 0;
+				}
+			}
+
+			test_state();
+
+			if (spu.ch_tag_upd)
+			{
+				// Mask incomplete transfers
+				u32 completed = spu.ch_tag_mask;
+
+				for (u32 i = 0; i < spu.mfc_queue.size(); i++)
+				{
+					const auto& _cmd = spu.mfc_queue[i];
+
+					if (_cmd.size)
+					{
+						if (spu.ch_tag_upd == 1)
+						{
+							completed &= ~(1u << _cmd.tag);
+						}
+						else
+						{
+							completed = 0;
+							break;
+						}
+					}
+				}
+
+				if (completed && spu.ch_tag_upd.exchange(0))
+				{
+					spu.ch_tag_stat.push(spu, completed);
+					no_updates = 0;
+				}
+			}
+
+			test_state();
+		}
+
+		if (no_updates++)
+		{
+			if (no_updates >= 3)
+			{
+				if (m_spuq.size())
+				{
+					no_updates = 0;
+				}
+
+				for (const auto& thread_ptr : m_spus)
+				{
+					SPUThread& spu = *thread_ptr;
+
+					if (spu.mfc_proxy.size())
+					{
+						no_updates = 0;
+						break;
+					}
+
+					if (spu.mfc_queue.size())
+					{
+						auto& cmd = spu.mfc_queue[0];
+
+						if ((cmd.cmd & MFC_LIST_MASK) == 0 || (spu.ch_stall_mask & (1u << cmd.tag)) == 0)
+						{
+							no_updates = 0;
+							break;
+						}
+					}
+
+					if (spu.ch_tag_upd)
+					{
+						no_updates = 0;
+						break;
+					}
+				}
+
+				if (no_updates)
+				{
+					vm::temporary_unlock(*this);
+					thread_ctrl::wait_for(100);
+				}
+			}
+			else
+			{
+				vm::reader_lock lock;
+				vm::notify_all();
+			}
+		}
 	}
 
-	return "UNKNOWN";
+	vm::passive_unlock(*this);
+	state += cpu_flag::stop;
+}
+
+void mfc_thread::add_spu(spu_ptr _spu)
+{
+	while (!m_spuq.try_push(std::move(_spu)))
+	{
+		busy_wait();
+		continue;
+	}
+
+	run();
 }

rpcs3/Emu/Cell/MFC.h

@@ -1,8 +1,11 @@
 #pragma once
 
-const char* get_mfc_cmd_name(u32 cmd);
+#include "Emu/CPU/CPUThread.h"
+#include "Utilities/lockless.h"
 
-enum : u32
+#include <deque>
+
+enum MFC : u8
 {
 	MFC_PUT_CMD      = 0x20, MFC_PUTB_CMD     = 0x21, MFC_PUTF_CMD     = 0x22,
 	MFC_PUTS_CMD     = 0x28, MFC_PUTBS_CMD    = 0x29, MFC_PUTFS_CMD    = 0x2a,
@@ -64,29 +67,50 @@ enum : u32
 	MFC_SPU_MAX_QUEUE_SPACE                 = 0x10,
 };
 
-struct spu_mfc_arg_t
+enum : u32
 {
-	union
-	{
-		u64 ea;
+	MFC_DMA_TAG_STATUS_UPDATE_EVENT    = 0x00000001,
+	MFC_DMA_TAG_CMD_STALL_NOTIFY_EVENT = 0x00000002,
+	MFC_DMA_QUEUE_VACANCY_EVENT        = 0x00000008,
+	MFC_SPU_MAILBOX_WRITTEN_EVENT      = 0x00000010,
+	MFC_DECREMENTER_EVENT              = 0x00000020,
+	MFC_PU_INT_MAILBOX_AVAIL_EVENT     = 0x00000040,
+	MFC_PU_MAILBOX_AVAIL_EVENT         = 0x00000080,
+	MFC_SIGNAL_2_EVENT                 = 0x00000100,
+	MFC_SIGNAL_1_EVENT                 = 0x00000200,
+	MFC_LLR_LOST_EVENT                 = 0x00000400,
+	MFC_PRIV_ATTN_EVENT                = 0x00000800,
+	MFG_MULTISOURCE_SYNC_EVENT         = 0x00001000,
+};
 
-		struct
-		{
-			u32 eal;
-			u32 eah;
-		};
-	};
+struct alignas(16) spu_mfc_cmd
+{
+	MFC cmd;
+	u8 tag;
+	u16 size;
+	u32 lsa;
+	u32 eal;
+	u32 eah;
+};
+
+class mfc_thread : public cpu_thread
+{
+	using spu_ptr = std::shared_ptr<class SPUThread>;
+
+	// SPU threads to poll
+	std::vector<spu_ptr> m_spus;
+
+	// SPU threads to enqueue
+	lf_mpsc<spu_ptr, 128> m_spuq;
 
-	u32 lsa;
+public:
+	mfc_thread();
+
+	virtual ~mfc_thread() override;
+
+	virtual std::string get_name() const override;
 
-	union
-	{
-		struct
-		{
-			u16 tag;
-			u16 size;
-		};
+	virtual void cpu_task() override;
 
-		u32 size_tag;
-	};
+	virtual void add_spu(spu_ptr _spu);
 };

rpcs3/Emu/Cell/Modules/cellAdec.cpp

@@ -2,8 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/IdManager.h"
 #include "Emu/Cell/PPUModule.h"
-
-extern std::mutex g_mutex_avcodec_open2;
+#include "Emu/Cell/lv2/sys_sync.h"
 
 extern "C"
 {
@@ -15,97 +14,394 @@ extern "C"
 #include "cellPamf.h"
 #include "cellAdec.h"
 
+#include <mutex>
 #include <thread>
 
+extern std::mutex g_mutex_avcodec_open2;
+
 logs::channel cellAdec("cellAdec", logs::level::notice);
 
-AudioDecoder::AudioDecoder(s32 type, u32 addr, u32 size, vm::ptr<CellAdecCbMsg> func, u32 arg)
-	: type(type)
-	, memAddr(addr)
-	, memSize(size)
-	, memBias(0)
-	, cbFunc(func)
-	, cbArg(arg)
-	, is_closed(false)
-	, is_finished(false)
-	, just_started(false)
-	, just_finished(false)
-	, codec(nullptr)
-	, input_format(nullptr)
-	, ctx(nullptr)
-	, fmt(nullptr)
+class AudioDecoder : public ppu_thread
 {
-	av_register_all();
-	avcodec_register_all();
+public:
+	squeue_t<AdecTask> job;
+	volatile bool is_closed;
+	volatile bool is_finished;
+	bool just_started;
+	bool just_finished;
 
-	switch (type)
-	{
-	case CELL_ADEC_TYPE_ATRACX:
-	case CELL_ADEC_TYPE_ATRACX_2CH:
-	case CELL_ADEC_TYPE_ATRACX_6CH:
-	case CELL_ADEC_TYPE_ATRACX_8CH:
-	{
-		codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P);
-		input_format = av_find_input_format("oma");
-		break;
-	}
-	case CELL_ADEC_TYPE_MP3:
-	{
-		codec = avcodec_find_decoder(AV_CODEC_ID_MP3);
-		input_format = av_find_input_format("mp3");
-		break;
-	}
-	default:
-	{
-		throw EXCEPTION("Unknown type (0x%x)", type);
-	}
-	}
-	
-	if (!codec)
-	{
-		throw EXCEPTION("avcodec_find_decoder() failed");
-	}
-	if (!input_format)
-	{
-		throw EXCEPTION("av_find_input_format() failed");
-	}
-	fmt = avformat_alloc_context();
-	if (!fmt)
-	{
-		throw EXCEPTION("avformat_alloc_context() failed");
-	}
-	io_buf = (u8*)av_malloc(4096);
-	fmt->pb = avio_alloc_context(io_buf, 256, 0, this, adecRead, NULL, NULL);
-	if (!fmt->pb)
-	{
-		throw EXCEPTION("avio_alloc_context() failed");
-	}
-}
+	AVCodec* codec;
+	AVInputFormat* input_format;
+	AVCodecContext* ctx;
+	AVFormatContext* fmt;
+	u8* io_buf;
 
-AudioDecoder::~AudioDecoder()
-{
-	// TODO: check finalization
-	AdecFrame af;
-	while (frames.try_pop(af))
+	struct AudioReader
 	{
-		av_frame_unref(af.data);
-		av_frame_free(&af.data);
-	}
-	if (ctx)
-	{
-		avcodec_close(ctx);
-		avformat_close_input(&fmt);
-	}
-	if (fmt)
-	{
-		if (io_buf)
+		u32 addr;
+		u32 size;
+		bool init;
+		bool has_ats;
+
+		AudioReader()
+			: init(false)
 		{
-			av_free(io_buf);
 		}
-		if (fmt->pb) av_free(fmt->pb);
-		avformat_free_context(fmt);
+
+	} reader;
+
+	squeue_t<AdecFrame> frames;
+
+	const s32 type;
+	const u32 memAddr;
+	const u32 memSize;
+	const vm::ptr<CellAdecCbMsg> cbFunc;
+	const u32 cbArg;
+	u32 memBias;
+
+	AdecTask task;
+	u64 last_pts, first_pts;
+
+	u32 ch_out;
+	u32 ch_cfg;
+	u32 frame_size;
+	u32 sample_rate;
+	bool use_ats_headers;
+
+	AudioDecoder(s32 type, u32 addr, u32 size, vm::ptr<CellAdecCbMsg> func, u32 arg)
+		: ppu_thread("HLE Audio Decoder")
+		, type(type)
+		, memAddr(addr)
+		, memSize(size)
+		, memBias(0)
+		, cbFunc(func)
+		, cbArg(arg)
+		, is_closed(false)
+		, is_finished(false)
+		, just_started(false)
+		, just_finished(false)
+		, codec(nullptr)
+		, input_format(nullptr)
+		, ctx(nullptr)
+		, fmt(nullptr)
+	{
+		av_register_all();
+		avcodec_register_all();
+
+		switch (type)
+		{
+		case CELL_ADEC_TYPE_ATRACX:
+		case CELL_ADEC_TYPE_ATRACX_2CH:
+		case CELL_ADEC_TYPE_ATRACX_6CH:
+		case CELL_ADEC_TYPE_ATRACX_8CH:
+		{
+			codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P);
+			input_format = av_find_input_format("oma");
+			break;
+		}
+		case CELL_ADEC_TYPE_MP3:
+		{
+			codec = avcodec_find_decoder(AV_CODEC_ID_MP3);
+			input_format = av_find_input_format("mp3");
+			break;
+		}
+		default:
+		{
+			fmt::throw_exception("Unknown type (0x%x)" HERE, type);
+		}
+		}
+
+		if (!codec)
+		{
+			fmt::throw_exception("avcodec_find_decoder() failed" HERE);
+		}
+		if (!input_format)
+		{
+			fmt::throw_exception("av_find_input_format() failed" HERE);
+		}
+		fmt = avformat_alloc_context();
+		if (!fmt)
+		{
+			fmt::throw_exception("avformat_alloc_context() failed" HERE);
+		}
+		io_buf = (u8*)av_malloc(4096);
+		fmt->pb = avio_alloc_context(io_buf, 256, 0, this, adecRead, NULL, NULL);
+		if (!fmt->pb)
+		{
+			fmt::throw_exception("avio_alloc_context() failed" HERE);
+		}
 	}
-}
+
+	~AudioDecoder()
+	{
+		// TODO: check finalization
+		AdecFrame af;
+		while (frames.try_pop(af))
+		{
+			av_frame_unref(af.data);
+			av_frame_free(&af.data);
+		}
+		if (ctx)
+		{
+			avcodec_close(ctx);
+			avformat_close_input(&fmt);
+		}
+		if (fmt)
+		{
+			if (io_buf)
+			{
+				av_free(io_buf);
+			}
+			if (fmt->pb) av_free(fmt->pb);
+			avformat_free_context(fmt);
+		}
+	}
+
+	virtual void cpu_task() override
+	{
+		while (true)
+		{
+			if (Emu.IsStopped() || is_closed)
+			{
+				break;
+			}
+
+			if (!job.pop(task, &is_closed))
+			{
+				break;
+			}
+
+			switch (task.type)
+			{
+			case adecStartSeq:
+			{
+				// TODO: reset data
+				cellAdec.warning("adecStartSeq:");
+
+				reader.addr = 0;
+				reader.size = 0;
+				reader.init = false;
+				reader.has_ats = false;
+				just_started = true;
+
+				if (adecIsAtracX(type))
+				{
+					ch_cfg = task.at3p.channel_config;
+					ch_out = task.at3p.channels;
+					frame_size = task.at3p.frame_size;
+					sample_rate = task.at3p.sample_rate;
+					use_ats_headers = task.at3p.ats_header == 1;
+				}
+				break;
+			}
+
+			case adecEndSeq:
+			{
+				// TODO: finalize
+				cellAdec.warning("adecEndSeq:");
+				cbFunc(*this, id, CELL_ADEC_MSG_TYPE_SEQDONE, CELL_OK, cbArg);
+				lv2_obj::sleep(*this);
+
+				just_finished = true;
+				break;
+			}
+
+			case adecDecodeAu:
+			{
+				int err = 0;
+
+				reader.addr = task.au.addr;
+				reader.size = task.au.size;
+				reader.has_ats = use_ats_headers;
+				//LOG_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", task.au.size, task.au.pts);
+
+				if (just_started)
+				{
+					first_pts = task.au.pts;
+					last_pts = task.au.pts;
+					if (adecIsAtracX(type)) last_pts -= 0x10000; // hack
+				}
+
+				struct AVPacketHolder : AVPacket
+				{
+					AVPacketHolder(u32 size)
+					{
+						av_init_packet(this);
+
+						if (size)
+						{
+							data = (u8*)av_calloc(1, size + FF_INPUT_BUFFER_PADDING_SIZE);
+							this->size = size + FF_INPUT_BUFFER_PADDING_SIZE;
+						}
+						else
+						{
+							data = NULL;
+							size = 0;
+						}
+					}
+
+					~AVPacketHolder()
+					{
+						av_free(data);
+					}
+
+				} au(0);
+
+				if (just_started && just_finished)
+				{
+					avcodec_flush_buffers(ctx);
+					
+					reader.init = true; // wrong
+					just_finished = false;
+					just_started = false;
+				}
+				else if (just_started) // deferred initialization
+				{
+					AVDictionary* opts = nullptr;
+					av_dict_set(&opts, "probesize", "96", 0);
+					err = avformat_open_input(&fmt, NULL, input_format, &opts);
+					if (err || opts)
+					{
+						fmt::throw_exception("avformat_open_input() failed (err=0x%x, opts=%d)" HERE, err, opts ? 1 : 0);
+					}
+					//err = avformat_find_stream_info(fmt, NULL);
+					//if (err || !fmt->nb_streams)
+					//{
+					//	ADEC_ERROR("adecDecodeAu: avformat_find_stream_info() failed (err=0x%x, nb_streams=%d)", err, fmt->nb_streams);
+					//}
+					if (!avformat_new_stream(fmt, codec))
+					{
+						fmt::throw_exception("avformat_new_stream() failed" HERE);
+					}
+					ctx = fmt->streams[0]->codec; // TODO: check data
+
+					opts = nullptr;
+					av_dict_set(&opts, "refcounted_frames", "1", 0);
+					{
+						std::lock_guard<std::mutex> lock(g_mutex_avcodec_open2);
+						// not multithread-safe (???)
+						err = avcodec_open2(ctx, codec, &opts);
+					}
+					if (err || opts)
+					{
+						fmt::throw_exception("avcodec_open2() failed (err=0x%x, opts=%d)" HERE, err, opts ? 1 : 0);
+					}
+					just_started = false;
+				}
+
+				bool last_frame = false;
+
+				while (true)
+				{
+					if (Emu.IsStopped() || is_closed)
+					{
+						if (Emu.IsStopped()) cellAdec.warning("adecDecodeAu: aborted");
+						break;
+					}
+
+					last_frame = av_read_frame(fmt, &au) < 0;
+					if (last_frame)
+					{
+						//break;
+						av_free(au.data);
+						au.data = NULL;
+						au.size = 0;
+					}
+
+					struct AdecFrameHolder : AdecFrame
+					{
+						AdecFrameHolder()
+						{
+							data = av_frame_alloc();
+						}
+
+						~AdecFrameHolder()
+						{
+							if (data)
+							{
+								av_frame_unref(data);
+								av_frame_free(&data);
+							}
+						}
+
+					} frame;
+
+					if (!frame.data)
+					{
+						fmt::throw_exception("av_frame_alloc() failed" HERE);
+					}
+
+					int got_frame = 0;
+
+					int decode = avcodec_decode_audio4(ctx, frame.data, &got_frame, &au);
+
+					if (decode <= 0)
+					{
+						if (decode < 0)
+						{
+							cellAdec.error("adecDecodeAu: AU decoding error(0x%x)", decode);
+						}
+						if (!got_frame && reader.size == 0) break;
+					}
+
+					if (got_frame)
+					{
+						//u64 ts = av_frame_get_best_effort_timestamp(frame.data);
+						//if (ts != AV_NOPTS_VALUE)
+						//{
+						//	frame.pts = ts/* - first_pts*/;
+						//	last_pts = frame.pts;
+						//}
+						last_pts += ((u64)frame.data->nb_samples) * 90000 / frame.data->sample_rate;
+						frame.pts = last_pts;
+
+						s32 nbps = av_get_bytes_per_sample((AVSampleFormat)frame.data->format);
+						switch (frame.data->format)
+						{
+						case AV_SAMPLE_FMT_FLTP: break;
+						case AV_SAMPLE_FMT_S16P: break;
+						default:
+						{
+							fmt::throw_exception("Unsupported frame format(%d)" HERE, frame.data->format);
+						}
+						}
+						frame.auAddr = task.au.addr;
+						frame.auSize = task.au.size;
+						frame.userdata = task.au.userdata;
+						frame.size = frame.data->nb_samples * frame.data->channels * nbps;
+
+						//LOG_NOTICE(HLE, "got audio frame (pts=0x%llx, nb_samples=%d, ch=%d, sample_rate=%d, nbps=%d)",
+							//frame.pts, frame.data->nb_samples, frame.data->channels, frame.data->sample_rate, nbps);
+
+						if (frames.push(frame, &is_closed))
+						{
+							frame.data = nullptr; // to prevent destruction
+							cbFunc(*this, id, CELL_ADEC_MSG_TYPE_PCMOUT, CELL_OK, cbArg);
+							lv2_obj::sleep(*this);
+						}
+					}
+				}
+
+				cbFunc(*this, id, CELL_ADEC_MSG_TYPE_AUDONE, task.au.auInfo_addr, cbArg);
+				lv2_obj::sleep(*this);
+				break;
+			}
+
+			case adecClose:
+			{
+				break;
+			}
+
+			default:
+			{
+				fmt::throw_exception("Unknown task(%d)" HERE, (u32)task.type);
+			}
+			}
+		}
+
+		is_finished = true;
+	}
+};
 
 int adecRead(void* opaque, u8* buf, int buf_size)
 {
@@ -162,16 +458,16 @@ next:
 			buf_size = adec.reader.size;
 		}
 		break;
-		
+
 		case adecDecodeAu:
 		{
 			std::memcpy(buf, vm::base(adec.reader.addr), adec.reader.size);
-			
+
 			buf += adec.reader.size;
 			buf_size -= adec.reader.size;
 			res += adec.reader.size;
 
-			adec.cbFunc(*adec.adecCb, adec.id, CELL_ADEC_MSG_TYPE_AUDONE, adec.task.au.auInfo_addr, adec.cbArg);
+			adec.cbFunc(adec, adec.id, CELL_ADEC_MSG_TYPE_AUDONE, adec.task.au.auInfo_addr, adec.cbArg);
 
 			adec.job.pop(adec.task);
 
@@ -181,10 +477,10 @@ next:
 			//LOG_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", adec.task.au.size, adec.task.au.pts);
 		}
 		break;
-		
+
 		default:
 		{
-			cellAdec.error("adecRawRead(): unknown task (%d)", task.type);
+			cellAdec.error("adecRawRead(): unknown task (%d)", (u32)task.type);
 			Emu.Pause();
 			return -1;
 		}
@@ -212,267 +508,6 @@ next:
 	}
 }
 
-void adecOpen(u32 adec_id) // TODO: call from the constructor
-{
-	const auto sptr = idm::get<AudioDecoder>(adec_id);
-	AudioDecoder& adec = *sptr;
-
-	adec.id = adec_id;
-
-	adec.adecCb = idm::make_ptr<PPUThread>(fmt::format("Demuxer[0x%x] Thread", adec_id));
-	adec.adecCb->prio = 1001;
-	adec.adecCb->stack_size = 0x10000;
-	adec.adecCb->custom_task = [sptr](PPUThread& CPU)
-	{
-		AudioDecoder& adec = *sptr;
-		AdecTask& task = adec.task;
-
-		while (true)
-		{
-			if (Emu.IsStopped() || adec.is_closed)
-			{
-				break;
-			}
-
-			if (!adec.job.pop(task, &adec.is_closed))
-			{
-				break;
-			}
-
-			switch (task.type)
-			{
-			case adecStartSeq:
-			{
-				// TODO: reset data
-				cellAdec.warning("adecStartSeq:");
-
-				adec.reader.addr = 0;
-				adec.reader.size = 0;
-				adec.reader.init = false;
-				adec.reader.has_ats = false;
-				adec.just_started = true;
-
-				if (adecIsAtracX(adec.type))
-				{
-					adec.ch_cfg = task.at3p.channel_config;
-					adec.ch_out = task.at3p.channels;
-					adec.frame_size = task.at3p.frame_size;
-					adec.sample_rate = task.at3p.sample_rate;
-					adec.use_ats_headers = task.at3p.ats_header == 1;
-				}
-				break;
-			}
-
-			case adecEndSeq:
-			{
-				// TODO: finalize
-				cellAdec.warning("adecEndSeq:");
-				adec.cbFunc(CPU, adec.id, CELL_ADEC_MSG_TYPE_SEQDONE, CELL_OK, adec.cbArg);
-
-				adec.just_finished = true;
-				break;
-			}
-
-			case adecDecodeAu:
-			{
-				int err = 0;
-
-				adec.reader.addr = task.au.addr;
-				adec.reader.size = task.au.size;
-				adec.reader.has_ats = adec.use_ats_headers;
-				//LOG_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", task.au.size, task.au.pts);
-
-				if (adec.just_started)
-				{
-					adec.first_pts = task.au.pts;
-					adec.last_pts = task.au.pts;
-					if (adecIsAtracX(adec.type)) adec.last_pts -= 0x10000; // hack
-				}
-
-				struct AVPacketHolder : AVPacket
-				{
-					AVPacketHolder(u32 size)
-					{
-						av_init_packet(this);
-
-						if (size)
-						{
-							data = (u8*)av_calloc(1, size + FF_INPUT_BUFFER_PADDING_SIZE);
-							this->size = size + FF_INPUT_BUFFER_PADDING_SIZE;
-						}
-						else
-						{
-							data = NULL;
-							size = 0;
-						}
-					}
-
-					~AVPacketHolder()
-					{
-						av_free(data);
-					}
-
-				} au(0);
-
-				if (adec.just_started && adec.just_finished)
-				{
-					avcodec_flush_buffers(adec.ctx);
-					
-					adec.reader.init = true; // wrong
-					adec.just_finished = false;
-					adec.just_started = false;
-				}
-				else if (adec.just_started) // deferred initialization
-				{
-					AVDictionary* opts = nullptr;
-					av_dict_set(&opts, "probesize", "96", 0);
-					err = avformat_open_input(&adec.fmt, NULL, adec.input_format, &opts);
-					if (err || opts)
-					{
-						throw EXCEPTION("avformat_open_input() failed (err=0x%x, opts=%d)", err, opts ? 1 : 0);
-					}
-					//err = avformat_find_stream_info(adec.fmt, NULL);
-					//if (err || !adec.fmt->nb_streams)
-					//{
-					//	ADEC_ERROR("adecDecodeAu: avformat_find_stream_info() failed (err=0x%x, nb_streams=%d)", err, adec.fmt->nb_streams);
-					//}
-					if (!avformat_new_stream(adec.fmt, adec.codec))
-					{
-						throw EXCEPTION("avformat_new_stream() failed");
-					}
-					adec.ctx = adec.fmt->streams[0]->codec; // TODO: check data
-
-					opts = nullptr;
-					av_dict_set(&opts, "refcounted_frames", "1", 0);
-					{
-						std::lock_guard<std::mutex> lock(g_mutex_avcodec_open2);
-						// not multithread-safe (???)
-						err = avcodec_open2(adec.ctx, adec.codec, &opts);
-					}
-					if (err || opts)
-					{
-						throw EXCEPTION("avcodec_open2() failed (err=0x%x, opts=%d)", err, opts ? 1 : 0);
-					}
-					adec.just_started = false;
-				}
-
-				bool last_frame = false;
-
-				while (true)
-				{
-					if (Emu.IsStopped() || adec.is_closed)
-					{
-						if (Emu.IsStopped()) cellAdec.warning("adecDecodeAu: aborted");
-						break;
-					}
-
-					last_frame = av_read_frame(adec.fmt, &au) < 0;
-					if (last_frame)
-					{
-						//break;
-						av_free(au.data);
-						au.data = NULL;
-						au.size = 0;
-					}
-
-					struct AdecFrameHolder : AdecFrame
-					{
-						AdecFrameHolder()
-						{
-							data = av_frame_alloc();
-						}
-
-						~AdecFrameHolder()
-						{
-							if (data)
-							{
-								av_frame_unref(data);
-								av_frame_free(&data);
-							}
-						}
-
-					} frame;
-
-					if (!frame.data)
-					{
-						throw EXCEPTION("av_frame_alloc() failed");
-					}
-
-					int got_frame = 0;
-
-					int decode = avcodec_decode_audio4(adec.ctx, frame.data, &got_frame, &au);
-
-					if (decode <= 0)
-					{
-						if (decode < 0)
-						{
-							cellAdec.error("adecDecodeAu: AU decoding error(0x%x)", decode);
-						}
-						if (!got_frame && adec.reader.size == 0) break;
-					}
-
-					if (got_frame)
-					{
-						//u64 ts = av_frame_get_best_effort_timestamp(frame.data);
-						//if (ts != AV_NOPTS_VALUE)
-						//{
-						//	frame.pts = ts/* - adec.first_pts*/;
-						//	adec.last_pts = frame.pts;
-						//}
-						adec.last_pts += ((u64)frame.data->nb_samples) * 90000 / frame.data->sample_rate;
-						frame.pts = adec.last_pts;
-
-						s32 nbps = av_get_bytes_per_sample((AVSampleFormat)frame.data->format);
-						switch (frame.data->format)
-						{
-						case AV_SAMPLE_FMT_FLTP: break;
-						case AV_SAMPLE_FMT_S16P: break;
-						default:
-						{
-							throw EXCEPTION("Unsupported frame format(%d)", frame.data->format);
-						}
-						}
-						frame.auAddr = task.au.addr;
-						frame.auSize = task.au.size;
-						frame.userdata = task.au.userdata;
-						frame.size = frame.data->nb_samples * frame.data->channels * nbps;
-
-						//LOG_NOTICE(HLE, "got audio frame (pts=0x%llx, nb_samples=%d, ch=%d, sample_rate=%d, nbps=%d)",
-							//frame.pts, frame.data->nb_samples, frame.data->channels, frame.data->sample_rate, nbps);
-
-						if (adec.frames.push(frame, &adec.is_closed))
-						{
-							frame.data = nullptr; // to prevent destruction
-							adec.cbFunc(CPU, adec.id, CELL_ADEC_MSG_TYPE_PCMOUT, CELL_OK, adec.cbArg);
-						}
-					}
-				}
-
-				adec.cbFunc(CPU, adec.id, CELL_ADEC_MSG_TYPE_AUDONE, task.au.auInfo_addr, adec.cbArg);
-				break;
-			}
-
-			case adecClose:
-			{
-				break;
-			}
-
-			default:
-			{
-				throw EXCEPTION("Unknown task(%d)", task.type);
-			}
-			}
-		}
-
-		adec.is_finished = true;
-
-	};
-
-	adec.adecCb->cpu_init();
-	adec.adecCb->state -= cpu_state::stop;
-	(*adec.adecCb)->lock_notify();
-}
-
 bool adecCheckType(s32 type)
 {
 	switch (type)
@@ -527,7 +562,11 @@ s32 cellAdecOpen(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResource> res, vm::
 		return CELL_ADEC_ERROR_ARG;
 	}
 
-	adecOpen(*handle = idm::make<AudioDecoder>(type->audioCodecType, res->startAddr, res->totalMemSize, cb->cbFunc, cb->cbArg));
+	auto&& adec = idm::make_ptr<ppu_thread, AudioDecoder>(type->audioCodecType, res->startAddr, res->totalMemSize, cb->cbFunc, cb->cbArg);
+
+	*handle = adec->id;
+
+	adec->run();
 
 	return CELL_OK;
 }
@@ -541,7 +580,11 @@ s32 cellAdecOpenEx(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResourceEx> res,
 		return CELL_ADEC_ERROR_ARG;
 	}
 
-	adecOpen(*handle = idm::make<AudioDecoder>(type->audioCodecType, res->startAddr, res->totalMemSize, cb->cbFunc, cb->cbArg));
+	auto&& adec = idm::make_ptr<ppu_thread, AudioDecoder>(type->audioCodecType, res->startAddr, res->totalMemSize, cb->cbFunc, cb->cbArg);
+
+	*handle = adec->id;
+
+	adec->run();
 
 	return CELL_OK;
 }
@@ -569,13 +612,10 @@ s32 cellAdecClose(u32 handle)
 
 	while (!adec->is_finished)
 	{
-		CHECK_EMU_STATUS;
-
-		std::this_thread::sleep_for(1ms); // hack
+		thread_ctrl::wait_for(1000); // hack
 	}
 
-	idm::remove<PPUThread>(adec->adecCb->id);
-	idm::remove<AudioDecoder>(handle);
+	idm::remove<ppu_thread>(handle);
 	return CELL_OK;
 }
 
@@ -779,7 +819,7 @@ s32 cellAdecGetPcm(u32 handle, vm::ptr<float> outBuffer)
 		}
 		else
 		{
-			throw EXCEPTION("Unsupported frame format (channels=%d, format=%d)", frame->channels, frame->format);
+			fmt::throw_exception("Unsupported frame format (channels=%d, format=%d)" HERE, frame->channels, frame->format);
 		}
 	}
 
@@ -867,6 +907,30 @@ s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
 
 DECLARE(ppu_module_manager::cellAdec)("cellAdec", []()
 {
+	static ppu_static_module cell_libac3dec("cell_libac3dec");
+	static ppu_static_module cellAtrac3dec("cellAtrac3dec");
+	static ppu_static_module cellAtracXdec("cellAtracXdec");
+	static ppu_static_module cellCelpDec("cellCelpDec");
+	static ppu_static_module cellDTSdec("cellDTSdec");
+	static ppu_static_module cellM2AACdec("cellM2AACdec");
+	static ppu_static_module cellM2BCdec("cellM2BCdec");
+	static ppu_static_module cellM4AacDec("cellM4AacDec");
+	static ppu_static_module cellMP3dec("cellMP3dec");
+	static ppu_static_module cellTRHDdec("cellTRHDdec");
+	static ppu_static_module cellWMAdec("cellWMAdec");
+	static ppu_static_module cellDTSLBRdec("cellDTSLBRdec");
+	static ppu_static_module cellDDPdec("cellDDPdec");
+	static ppu_static_module cellM4AacDec2ch("cellM4AacDec2ch");
+	static ppu_static_module cellDTSHDdec("cellDTSHDdec");
+	static ppu_static_module cellMPL1dec("cellMPL1dec");
+	static ppu_static_module cellMP3Sdec("cellMP3Sdec");
+	static ppu_static_module cellM4AacDec2chmod("cellM4AacDec2chmod");
+	static ppu_static_module cellCelp8Dec("cellCelp8Dec");
+	static ppu_static_module cellWMAPROdec("cellWMAPROdec");
+	static ppu_static_module cellWMALSLdec("cellWMALSLdec");
+	static ppu_static_module cellDTSHDCOREdec("cellDTSHDCOREdec");
+	static ppu_static_module cellAtrac3multidec("cellAtrac3multidec");
+
 	REG_FUNC(cellAdec, cellAdecQueryAttr);
 	REG_FUNC(cellAdec, cellAdecOpen);
 	REG_FUNC(cellAdec, cellAdecOpenEx);

rpcs3/Emu/Cell/Modules/cellAdec.h

@@ -1043,7 +1043,7 @@ struct AdecTask
 
 struct AdecFrame
 {
-	AVFrame* data;
+	struct AVFrame* data;
 	u64 pts;
 	u64 userdata;
 	u32 auAddr;
@@ -1096,58 +1096,3 @@ struct OMAHeader // OMA Header
 };
 
 CHECK_SIZE(OMAHeader, 96);
-
-class AudioDecoder
-{
-public:
-	squeue_t<AdecTask> job;
-	u32 id;
-	volatile bool is_closed;
-	volatile bool is_finished;
-	bool just_started;
-	bool just_finished;
-
-	AVCodec* codec;
-	AVInputFormat* input_format;
-	AVCodecContext* ctx;
-	AVFormatContext* fmt;
-	u8* io_buf;
-
-	struct AudioReader
-	{
-		u32 addr;
-		u32 size;
-		bool init;
-		bool has_ats;
-
-		AudioReader()
-			: init(false)
-		{
-		}
-
-	} reader;
-
-	squeue_t<AdecFrame> frames;
-
-	const s32 type;
-	const u32 memAddr;
-	const u32 memSize;
-	const vm::ptr<CellAdecCbMsg> cbFunc;
-	const u32 cbArg;
-	u32 memBias;
-
-	AdecTask task;
-	u64 last_pts, first_pts;
-
-	u32 ch_out;
-	u32 ch_cfg;
-	u32 frame_size;
-	u32 sample_rate;
-	bool use_ats_headers;
-
-	std::shared_ptr<PPUThread> adecCb;
-
-	AudioDecoder(s32 type, u32 addr, u32 size, vm::ptr<CellAdecCbMsg> func, u32 arg);
-
-	~AudioDecoder();
-};

rpcs3/Emu/Cell/Modules/cellAudio.cpp

@@ -16,8 +16,11 @@ logs::channel cellAudio("cellAudio", logs::level::notice);
 cfg::bool_entry g_cfg_audio_dump_to_file(cfg::root.audio, "Dump to file");
 cfg::bool_entry g_cfg_audio_convert_to_u16(cfg::root.audio, "Convert to 16 bit");
 
-void audio_config::on_task()
+void audio_config::on_init(const std::shared_ptr<void>& _this)
 {
+	m_buffer.set(vm::alloc(AUDIO_PORT_OFFSET * AUDIO_PORT_COUNT, vm::main));
+	m_indexes.set(vm::alloc(sizeof(u64) * AUDIO_PORT_COUNT, vm::main));
+
 	for (u32 i = 0; i < AUDIO_PORT_COUNT; i++)
 	{
 		ports[i].number = i;
@@ -25,6 +28,11 @@ void audio_config::on_task()
 		ports[i].index = m_indexes + i;
 	}
 
+	named_thread::on_init(_this);
+}
+
+void audio_config::on_task()
+{
 	AudioDumper m_dump(g_cfg_audio_dump_to_file ? 2 : 0); // Init AudioDumper for 2 channels if enabled
 
 	float buf2ch[2 * BUFFER_SIZE]{}; // intermediate buffer for 2 channels
@@ -208,7 +216,7 @@ void audio_config::on_task()
 			}
 			else
 			{
-				throw EXCEPTION("Unknown channel count (port=%u, channel=%d)", port.number, port.channel);
+				fmt::throw_exception("Unknown channel count (port=%u, channel=%d)" HERE, port.number, port.channel);
 			}
 
 			memset(buf, 0, block_size * sizeof(float));
@@ -281,14 +289,13 @@ void audio_config::on_task()
 
 			// send aftermix event (normal audio event)
 
-			LV2_LOCK;
+			semaphore_lock lock(mutex);
 
 			for (u64 key : keys)
 			{
-				if (auto&& queue = lv2_event_queue_t::find(key))
+				if (auto queue = lv2_event_queue::find(key))
 				{
-					if (queue->events() < queue->size)
-						queue->push(lv2_lock, 0, 0, 0, 0); // TODO: check arguments
+					queue->send(0, 0, 0, 0); // TODO: check arguments	
 				}
 			}
 		}
@@ -461,7 +468,7 @@ s32 cellAudioGetPortConfig(u32 portNum, vm::ptr<CellAudioPortConfig> portConfig)
 	case audio_port_state::closed: portConfig->status = CELL_AUDIO_STATUS_CLOSE; break;
 	case audio_port_state::opened: portConfig->status = CELL_AUDIO_STATUS_READY; break;
 	case audio_port_state::started: portConfig->status = CELL_AUDIO_STATUS_RUN; break;
-	default: throw fmt::exception("Invalid port state (%d: %d)", portNum, state);
+	default: fmt::throw_exception("Invalid port state (%d: %d)", portNum, (u32)state);
 	}
 
 	portConfig->nChannel = port.channel;
@@ -492,7 +499,7 @@ s32 cellAudioPortStart(u32 portNum)
 	case audio_port_state::closed: return CELL_AUDIO_ERROR_PORT_NOT_OPEN;
 	case audio_port_state::started: return CELL_AUDIO_ERROR_PORT_ALREADY_RUN;
 	case audio_port_state::opened: return CELL_OK;
-	default: throw fmt::exception("Invalid port state (%d: %d)", portNum, state);
+	default: fmt::throw_exception("Invalid port state (%d: %d)", portNum, (u32)state);
 	}
 }
 
@@ -517,7 +524,7 @@ s32 cellAudioPortClose(u32 portNum)
 	case audio_port_state::closed: return CELL_AUDIO_ERROR_PORT_NOT_OPEN;
 	case audio_port_state::started: return CELL_OK;
 	case audio_port_state::opened: return CELL_OK;
-	default: throw fmt::exception("Invalid port state (%d: %d)", portNum, state);
+	default: fmt::throw_exception("Invalid port state (%d: %d)", portNum, (u32)state);
 	}
 }
 
@@ -542,7 +549,7 @@ s32 cellAudioPortStop(u32 portNum)
 	case audio_port_state::closed: return CELL_AUDIO_ERROR_PORT_NOT_RUN;
 	case audio_port_state::started: return CELL_OK;
 	case audio_port_state::opened: return CELL_AUDIO_ERROR_PORT_NOT_RUN;
-	default: throw fmt::exception("Invalid port state (%d: %d)", portNum, state);
+	default: fmt::throw_exception("Invalid port state (%d: %d)", portNum, (u32)state);
 	}
 }
 
@@ -658,16 +665,26 @@ s32 cellAudioCreateNotifyEventQueue(vm::ptr<u32> id, vm::ptr<u64> key)
 {
 	cellAudio.warning("cellAudioCreateNotifyEventQueue(id=*0x%x, key=*0x%x)", id, key);
 
-	for (u64 k = 0; k < 100; k++)
+	vm::var<sys_event_queue_attribute_t> attr;
+	attr->protocol = SYS_SYNC_FIFO;
+	attr->type     = SYS_PPU_QUEUE;
+	attr->name_u64 = 0;
+
+	for (u64 i = 0; i < 100; i++)
 	{
-		const u64 key_value = 0x80004d494f323221ull + k;
-
 		// Create an event queue "bruteforcing" an available key
-		if (auto&& queue = lv2_event_queue_t::make(SYS_SYNC_FIFO, SYS_PPU_QUEUE, 0, key_value, 32))
-		{
-			*id = queue->id;
-			*key = key_value;
+		const u64 key_value = 0x80004d494f323221ull + i;
 
+		if (const s32 res = sys_event_queue_create(id, attr, key_value, 32))
+		{
+			if (res != CELL_EEXIST)
+			{
+				return res;
+			}
+		}
+		else
+		{
+			*key = key_value;
 			return CELL_OK;
 		}
 	}
@@ -700,7 +717,7 @@ s32 cellAudioSetNotifyEventQueue(u64 key)
 		return CELL_AUDIO_ERROR_NOT_INIT;
 	}
 
-	LV2_LOCK;
+	semaphore_lock lock(g_audio->mutex);
 
 	for (auto k : g_audio->keys) // check for duplicates
 	{
@@ -735,7 +752,7 @@ s32 cellAudioRemoveNotifyEventQueue(u64 key)
 		return CELL_AUDIO_ERROR_NOT_INIT;
 	}
 
-	LV2_LOCK;
+	semaphore_lock lock(g_audio->mutex);
 
 	for (auto i = g_audio->keys.begin(); i != g_audio->keys.end(); i++)
 	{

rpcs3/Emu/Cell/Modules/cellAudio.h

@@ -125,19 +125,29 @@ class audio_config final : public named_thread
 
 	std::string get_name() const override { return "Audio Thread"; }
 
-	vm::var<char[], vm::page_allocator<vm::main>> m_buffer{ AUDIO_PORT_OFFSET * AUDIO_PORT_COUNT };
-	vm::var<u64[], vm::page_allocator<vm::main>> m_indexes{ AUDIO_PORT_COUNT };
+	vm::ptr<char> m_buffer = vm::null;
+	vm::ptr<u64> m_indexes = vm::null;
 
 	u64 m_counter{};
 
 public:
+	void on_init(const std::shared_ptr<void>&) override;
+
 	const u64 start_time = get_system_time();
 
 	std::array<audio_port, AUDIO_PORT_COUNT> ports;
 
 	std::vector<u64> keys;
 
-	~audio_config() noexcept = default;
+	semaphore<> mutex;
+
+	audio_config() = default;
+
+	~audio_config()
+	{
+		vm::dealloc_verbose_nothrow(m_buffer.addr());
+		vm::dealloc_verbose_nothrow(m_indexes.addr());
+	}
 
 	audio_port* open_port()
 	{

rpcs3/Emu/Cell/Modules/cellAudioOut.cpp

@@ -230,12 +230,12 @@ s32 cellAudioOutSetCopyControl(u32 audioOut, u32 control)
 
 s32 cellAudioOutRegisterCallback()
 {
-	throw EXCEPTION("");
+	fmt::throw_exception("Unimplemented" HERE);
 }
 
 s32 cellAudioOutUnregisterCallback()
 {
-	throw EXCEPTION("");
+	fmt::throw_exception("Unimplemented" HERE);
 }