use "config/custom_configs/" for custom configs (backwards compatible)

vk: Use FIFO mode for vsync
- Avoids tearing and also hides some driver bugs causing fullscreen bugs with mailbox mode
2019-01-31 20:14:52 +00:00 · 2019-01-31 21:53:02 +03:00 · 2019-01-31 21:53:02 +03:00 · 2019-01-31 16:03:38 +03:00 · 2019-01-31 16:03:38 +03:00 · 2019-01-31 01:08:30 +03:00
1063 changed files with 198283 additions and 102154 deletions
@@ -0,0 +1,31 @@
+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: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+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
@@ -0,0 +1,7 @@
+root = true
+
+[*.{h,cpp,hpp}]
+charset = utf-8-bom
+indent_style = tab
+indent_size = 4
+trim_trailing_whitespace = true
@@ -0,0 +1,20 @@
+# Getting Started
+
+Before getting started using the emulator, read the [Quickstart Guide](https://rpcs3.net/quickstart) and the [FAQ](https://rpcs3.net/faq). After reading those, if you need support, visit our [Forums](https://forums.rpcs3.net). 
+
+# Issue Reporting
+
+**The GitHub Issue Tracker is not the place to ask for support or to submit [Game Compatibility](https://rpcs3.net/compatibility) reports.** Requests for support or incorrect reports will be closed. If you are not sure whether the issue you want to report is an actual issue that is not yet known, please use the forums to submit such report.
+
+**Before reporting an issue:**
+- Check if your system matches all the minimum requirements listed in the [Quickstart Guide](https://rpcs3.net/quickstart);
+- Check if the issue is meaningful for the team (e.g. The Last of Us doesn't work is obvious and therefore useless);
+- Search older issues/forum threads to see if your issue was already submitted.
+- Use understandable English. It doesn't need to be perfect, but clear enough to understand your message.
+- While reporting issues, don't forget to include details about your system (OS, CPU, GPU, etc.), as well as the RPCS3.log file.
+
+Submitting your test results for Commercial Games must be done on our forums. Please read the [Game Compatibility](https://github.com/RPCS3/rpcs3/wiki/Game-Compatibility) wiki page before doing so.
+
+# Contributing
+
+Check the [Coding Style Guidelines](https://github.com/RPCS3/rpcs3/wiki/Coding-Style), [Roadmap](https://github.com/RPCS3/rpcs3/wiki/Roadmap) and [Developer Information](https://github.com/RPCS3/rpcs3/wiki/Developer-Information). If you have any questions, hit us up on our [Discord Server](https://discord.me/RPCS3) in the **#development** channel.
@@ -0,0 +1,24 @@
+<!---
+
+THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
+https://forums.rpcs3.net
+or our discord:
+https://discord.me/RPCS3
+
+PLEASE READ THE GUIDELINES BEFORE OPENING AN ISSUE:
+https://github.com/RPCS3/rpcs3/blob/master/.github/CONTRIBUTING.md
+
+====================================================
+
+When submitting an issue, please check the following:
+
+- You have read the above.
+- You have provided the version (commit hash) of RPCS3 you are using.
+- You have provided sufficient detail for the issue to be reproduced.
+- You have provided system specs.
+- Please also provide:
+  - For crashes, a backtrace.
+  - For graphical issues, comparison screenshots with real hardware.
+
+Remember that the GitHub Issue Tracker is not the place to ask for support or to submit Game Compatibility reports. You must use our forums for that.
+--->
@@ -31,7 +31,6 @@
 *.wav

 /build
-/bin
 /lib
 /tmp
 /ipch
@@ -41,40 +40,31 @@
 /Vulkan/Vulkan-build
 /Vulkan/glslang-build

-/wxWidgets/lib
-/bin/rpcs3.ini
-/bin/rpcs3.ipdb
-/bin/rpcs3.iobj
-/bin/FragmentProgram.txt
-/bin/VertexProgram.txt
-/bin/*.hlsl
-/bin/BreakPoints.dat
-/bin/textures
-/bin/*.lib
-/bin/*.exp
-rpcs3/git-version.h
+!/bin
+/bin/*
+
+# Themes
+!/bin/GuiConfigs/
+/bin/GuiConfigs/*.ini
+/bin/GuiConfigs/*.ini.*
+/bin/GuiConfigs/*.dat
+/bin/GuiConfigs/*.dat.*

 # Visual Studio Files
+.vs/*
+.vscode/*
+*.ipch
 *.vspx
 *.psess
 *.VC.*
-
-# Copyrighted files
-/bin/data/
-/bin/dev_flash/data/font
-/bin/dev_flash/sys
-/bin/dev_flash/vsh
-
-# Ignore installed games except test homebrews
-!/bin/dev_hdd0/game/
-/bin/dev_hdd0/game/*
-!/bin/dev_hdd0/game/TEST12345/
+*.vcxproj.user
+enc_temp_folder/*
+CMakeSettings.json

 # Ignore other system generated files
-bin/dev_hdd0/*.txt
 x64/*
 rpcs3/x64/*
-rpcs3-tests/x64/*
+rpcs3/git-version.h

 # cmake
 Makefile
@@ -85,3 +75,25 @@ CMakeCache.txt
 # cotire
 rpcs3/cotire/*
 rpcs3/rpcs3_*_cotire.cmake
+
+# kdevelop
+*.kdev4
+.kdev4/*
+
+# Qt
+moc_*.cpp
+qrc_*.cpp
+rpcs3_automoc.cpp
+ui_*.h
+rpcs3/rpcs3_autogen/*
+
+# QtCreator
+CMakeLists.txt.user
+
+# CLion
+/.idea/*
+/cmake-build-*/
+
+# macOS
+.DS_Store
+
@@ -1,37 +1,50 @@
-[submodule "wxWidgets"]
-	path = wxWidgets
-	url = https://github.com/wxWidgets/wxWidgets
-	ignore = dirty
 [submodule "rpcs3-ffmpeg"]
 	path = 3rdparty/ffmpeg
 	url = https://github.com/hrydgard/ppsspp-ffmpeg
+	ignore = dirty
 [submodule "asmjit"]
 	path = asmjit
 	url = https://github.com/kobalicek/asmjit
 	ignore = dirty
 [submodule "llvm"]
 	path = llvm
-	url = https://github.com/llvm-mirror/llvm
-	branch = release_36
-[submodule "rsx_program_decompiler"]
-	path = rsx_program_decompiler
-	url = https://github.com/RPCS3/rsx_program_decompiler
+	url = https://github.com/RPCS3/llvm
+	branch = release_60
+	ignore = dirty
 [submodule "GSL"]
 	path = 3rdparty/GSL
 	url = https://github.com/Microsoft/GSL.git
-[submodule "libpng"]
-	path = 3rdparty/libpng
-	url = https://github.com/RPCS3/libpng
 	ignore = dirty
 [submodule "Vulkan/glslang"]
 	path = Vulkan/glslang
 	url = https://github.com/KhronosGroup/glslang.git
-[submodule "Vulkan/Vulkan-LoaderAndValidationLayers"]
-	path = Vulkan/Vulkan-LoaderAndValidationLayers
-	url = https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers
-[submodule "Utilities/yaml-cpp"]
-	path = Utilities/yaml-cpp
-	url = https://github.com/RPCS3/yaml-cpp
+	ignore = dirty
+[submodule "3rdparty/cereal"]
+	path = 3rdparty/cereal
+	url = https://github.com/USCiLab/cereal.git
+	ignore = dirty
+[submodule "3rdparty/zlib"]
+	path = 3rdparty/zlib
+	url = https://github.com/madler/zlib
+	ignore = dirty
+[submodule "3rdparty/hidapi"]
+	path = 3rdparty/hidapi
+	url = https://github.com/RPCS3/hidapi
+	branch = master
+	ignore = dirty
 [submodule "3rdparty/pugixml"]
 	path = 3rdparty/pugixml
-	url = https://github.com/RPCS3/pugixml
+	url = https://github.com/zeux/pugixml
+	ignore = dirty
+[submodule "3rdparty/xxHash"]
+	path = 3rdparty/xxHash
+	url = https://github.com/Cyan4973/xxHash
+	ignore = dirty
+[submodule "3rdparty/yaml-cpp"]
+	path = 3rdparty/yaml-cpp
+	url = https://github.com/jbeder/yaml-cpp.git
+	ignore = dirty
+[submodule "3rdparty/libpng"]
+	path = 3rdparty/libpng
+	url = https://github.com/glennrp/libpng.git
+	ignore = dirty
@@ -1,3 +1,3 @@
 {
-  "userBlacklist": ["AlexAltea", "tambry"]
+  "userBlacklist": ["AlexAltea", "tambry", "DHrpcs3"]
 }
@@ -1,90 +1,37 @@
 language: cpp
-sudo: required
-dist: trusty
-
-os:
- - linux
- - osx
-
-osx_image: xcode6.4
-
-compiler:
- - clang
- - gcc
-
-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
-
 matrix:
- exclude:
-  - os: osx
-    compiler: gcc
-
+    include:
+        - os: linux
+          env:
+            - NAME="Linux build"
+            - COMPILER="gcc"
+          dist: trusty
+          services: docker
+          cache: ccache
+          install: "docker pull rpcs3/rpcs3-travis-trusty:1.0"
+          script: 'travis_wait docker run -v $(pwd):/rpcs3 -v "$HOME/.ccache":/root/.ccache --env-file .travis/travis.env rpcs3/rpcs3-travis-trusty:1.0 /bin/bash -ex /rpcs3/.travis/build-linux.bash'
+        - os: linux
+          env:
+            - NAME="Linux build"
+            - COMPILER="clang"
+            - DEPLOY_APPIMAGE="true"
+          dist: trusty
+          services: docker
+          cache: ccache
+          install: "docker pull rpcs3/rpcs3-travis-trusty:1.0"
+          script: 'travis_wait docker run -v $(pwd):/rpcs3 -v "$HOME/.ccache":/root/.ccache --env-file .travis/travis.env rpcs3/rpcs3-travis-trusty:1.0 /bin/bash -ex /rpcs3/.travis/build-linux.bash'
+        - os: osx
+          osx_image: xcode10.1
+          addons:
+            homebrew:
+                packages:
+                    - ccache
+                    - glew
+                    - ninja
+                    - qt
+          script: "/bin/bash -ex .travis/build-mac.bash"
+          cache: ccache
+        
 git:
+  depth: false # Unshallow clone to obtain proper GIT_VERSION
  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.
-  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      sudo pip install cpp-coveralls requests[security];
-    else
-      brew update; brew update;
-      brew install glew wxwidgets llvm36;
-    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
-
-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
-
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-#    - llvm-toolchain-trusty-3.6 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
-  coverity_scan:
-    project:
-      name: $TRAVIS_REPO_SLUG
-      description: "PS3 emulator/debugger"
-    notification_email: raul.tambre@gmail.com
-    build_command: "make -j 4"
-    branch_pattern: coverity_scan
-
-after_success:
- if [ "$COVERITY_SCAN_BRANCH" != 1 ] && [ "$TRAVIS_OS_NAME" = linux ]; then coveralls --extension .c --extension .cpp --extension .h; fi
@@ -0,0 +1,35 @@
+#!/bin/env bash -ex
+shopt -s nocasematch
+
+# Setup Qt variables
+export QT_BASE_DIR=/opt/qt${QTVERMIN}
+export PATH=$QT_BASE_DIR/bin:$PATH
+export LD_LIBRARY_PATH=$QT_BASE_DIR/lib/x86_64-linux-gnu:$QT_BASE_DIR/lib
+
+cd rpcs3
+
+git submodule update --quiet --init asmjit 3rdparty/ffmpeg 3rdparty/pugixml 3rdparty/GSL 3rdparty/libpng 3rdparty/cereal 3rdparty/hidapi 3rdparty/xxHash 3rdparty/yaml-cpp Vulkan/glslang
+
+# Download pre-compiled llvm libs
+curl -sLO https://github.com/RPCS3/llvm/releases/download/continuous-linux-master/llvmlibs-linux.tar.gz
+mkdir llvmlibs
+tar -xzf ./llvmlibs-linux.tar.gz -C llvmlibs
+
+mkdir build ; cd build
+
+if [ $COMPILER = "gcc" ]; then
+	# These are set in the dockerfile
+	export CC=${GCC_BINARY}
+	export CXX=${GXX_BINARY}
+else
+	export CC=${CLANG_BINARY}
+	export CXX=${CLANGXX_BINARY}
+fi
+
+cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_LLVM_SUBMODULE=OFF -DLLVM_DIR=llvmlibs/lib/cmake/llvm/ -DUSE_NATIVE_INSTRUCTIONS=OFF -G Ninja
+
+ninja
+
+cd ..
+# If it compiled succesfully let's deploy
+if [ $? -eq 0 ] && [ -n "$GITHUB_TOKEN" ] && [ "$TRAVIS_BRANCH" = "master" ] && [ "$TRAVIS_PULL_REQUEST" = false ]; then /bin/bash -ex .travis/deploy-linux.bash ; fi
@@ -0,0 +1,26 @@
+export CCACHE_SLOPPINESS=pch_defines,time_macros
+export CMAKE_PREFIX_PATH=/usr/local/opt/qt5/
+export PATH="/usr/local/opt/ccache/libexec:$PATH"
+
+# Allow using optional on 10.13
+sudo perl -pi -e 'BEGIN{undef $/;} s/(_LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS[ ]+\\\n[^\n]+10)\.14/\1.13/;' \
+  $(xcode-select -p)/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/__config
+
+# Setup vulkan and gfx-rs/portability
+curl -sLO https://github.com/gfx-rs/portability/releases/download/latest/gfx-portability-macos-latest.zip
+unzip -: gfx-portability-macos-latest.zip
+curl -sLO https://github.com/KhronosGroup/Vulkan-Headers/archive/sdk-1.1.92.0.zip
+unzip -: sdk-*.zip
+mkdir vulkan-sdk
+ln -s ${PWD}/Vulkan-Headers*/include vulkan-sdk/include
+mkdir vulkan-sdk/lib
+cp target/release/libportability.dylib vulkan-sdk/lib/libVulkan.dylib
+# Let macdeployqt locate and install Vulkan library
+install_name_tool -id ${PWD}/vulkan-sdk/lib/libVulkan.dylib vulkan-sdk/lib/libVulkan.dylib
+export VULKAN_SDK=${PWD}/vulkan-sdk
+
+git submodule update --quiet --init asmjit 3rdparty/ffmpeg 3rdparty/pugixml 3rdparty/GSL 3rdparty/libpng 3rdparty/cereal 3rdparty/hidapi 3rdparty/xxHash 3rdparty/yaml-cpp Vulkan/glslang
+
+mkdir build; cd build
+cmake .. -DWITH_LLVM=OFF -DUSE_NATIVE_INSTRUCTIONS=OFF -G Ninja
+ninja
@@ -0,0 +1,53 @@
+#!/bin/env bash -ex
+shopt -s nocasematch
+cd build
+if [ "$DEPLOY_APPIMAGE" = "true" ]; then
+	DESTDIR=appdir ninja install
+	curl -sLO "https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage"
+	chmod a+x linuxdeployqt*.AppImage
+	./linuxdeployqt*.AppImage --appimage-extract
+	./squashfs-root/AppRun ./appdir/usr/share/applications/*.desktop -bundle-non-qt-libs
+	ls ./appdir/usr/lib/
+	rm -r ./appdir/usr/share/doc
+	rm ./appdir/usr/lib/libxcb*
+	cp $(readlink -f /lib/x86_64-linux-gnu/libnsl.so.1) ./appdir/usr/lib/libnsl.so.1
+	export PATH=/rpcs3/build/squashfs-root/usr/bin/:${PATH}
+
+	# Embed newer libstdc++ for distros that don't come with it (ubuntu 14.04, 16.04)
+	mkdir -p appdir/usr/optional/ ; mkdir -p appdir/usr/optional/libstdc++/
+	cp /usr/lib/x86_64-linux-gnu/libstdc++.so.6 ./appdir/usr/optional/libstdc++/
+	rm ./appdir/AppRun
+	curl -sL https://github.com/RPCS3/AppImageKit-checkrt/releases/download/continuous2/AppRun-patched-x86_64 -o ./appdir/AppRun
+	chmod a+x ./appdir/AppRun
+	curl -sL https://github.com/RPCS3/AppImageKit-checkrt/releases/download/continuous2/exec-x86_64.so -o ./appdir/usr/optional/exec.so
+	
+	# Compile checker binary for AppImageKit-checkrt
+	
+	# This may need updating if you update the compiler or rpcs3 uses newer c++ features
+	# See https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/config/abi/pre/gnu.ver
+	# for which definitions correlate to which CXXABI version.
+	printf "#include <memory>\nint main(){std::make_exception_ptr(0);}" | $CXX -x c++ -o ./appdir/usr/optional/checker -
+	
+	# Package it up and send it off
+	./squashfs-root/usr/bin/appimagetool /rpcs3/build/appdir
+	ls
+	COMM_TAG="$(git describe --tags $(git rev-list --tags --max-count=1))"
+	COMM_COUNT="$(git rev-list --count HEAD)"
+	curl -sLO https://github.com/hcorion/uploadtool/raw/master/upload.sh
+	
+	mv ./RPCS3*.AppImage rpcs3-${COMM_TAG}-${COMM_COUNT}-${TRAVIS_COMMIT:0:8}_linux64.AppImage
+	
+	FILESIZEMB=$(bc <<< "scale=6; $(stat -c %s ./rpcs3*.AppImage)/1000000")
+	SHA256SUM=($(sha256sum ./rpcs3*.AppImage))
+	
+	unset TRAVIS_REPO_SLUG
+	REPO_SLUG=RPCS3/rpcs3-binaries-linux \
+		UPLOADTOOL_BODY="$SHA256SUM;${FILESIZEMB}MB"\
+		RELEASE_NAME=build-${TRAVIS_COMMIT}\
+		RELEASE_TITLE=${COMM_TAG}-${COMM_COUNT}\
+		REPO_COMMIT=d812f1254a1157c80fd402f94446310560f54e5f\
+		bash upload.sh rpcs3*.AppImage
+fi
+if [ "$DEPLOY_PPA" = "true" ]; then
+	export DEBFULLNAME="RPCS3 Build Bot"
+fi
@@ -0,0 +1,9 @@
+# Variables set by Travis CI
+TRAVIS_PULL_REQUEST
+TRAVIS_BRANCH
+TRAVIS_COMMIT
+# Variables for Travis build matrix
+COMPILER
+DEPLOY_APPIMAGE
+# Private Travis CI variables
+GITHUB_TOKEN
@@ -0,0 +1,363 @@
+find_package(PkgConfig)
+include(ExternalProject)
+
+if(APPLE)
+	set(PLATFORM_ARCH "macosx/x86_64")
+elseif(WIN32)
+	set(PLATFORM_ARCH "Windows/x86_64")
+else()
+	set(PLATFORM_ARCH "linux/x86_64")
+endif()
+
+# Dummy target to use when lib isn't available
+add_library(3rdparty_dummy_lib INTERFACE)
+
+
+# ZLib
+if (USE_SYSTEM_ZLIB)
+	find_package(ZLIB QUIET)
+endif()
+
+if (NOT ZLIB_FOUND)
+	message(STATUS "Using builtin ZLIB")
+	set(SKIP_INSTALL_ALL ON)
+	add_subdirectory(zlib EXCLUDE_FROM_ALL)
+	set(ZLIB_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/zlib" "${CMAKE_CURRENT_BINARY_DIR}/zlib")
+	set(ZLIB_LIBRARY zlibstatic)
+endif()
+
+add_library(3rdparty_zlib INTERFACE)
+target_link_libraries(3rdparty_zlib INTERFACE ${ZLIB_LIBRARY})
+target_include_directories(3rdparty_zlib INTERFACE ${ZLIB_INCLUDE_DIR})
+
+# libPNG
+# Select the version of libpng to use, default is builtin
+if (NOT USE_SYSTEM_LIBPNG)
+	# We use libpng's static library and don't need to build the shared library and run the tests
+	set(PNG_SHARED OFF CACHE BOOL "Build shared lib" FORCE)
+	set(PNG_TESTS OFF CACHE BOOL "Build libpng tests" FORCE)
+	set(PNG_BUILD_ZLIB ON CACHE BOOL "ZLIB is already build or package is found" FORCE)
+	set(SKIP_INSTALL_ALL ON)
+	add_subdirectory(libpng EXCLUDE_FROM_ALL)
+
+	set(LIBPNG_TARGET png_static)
+
+	target_include_directories(png_static INTERFACE "${libpng_BINARY_DIR}" "${libpng_SOURCE_DIR}")
+else()
+	find_package(PNG REQUIRED)
+
+	add_library(3rdparty_system_libpng INTERFACE)
+	target_include_directories(3rdparty_system_libpng INTERFACE ${PNG_INCLUDE_DIR})
+	target_link_libraries(3rdparty_system_libpng INTERFACE ${PNG_LIBRARY})
+	target_compile_definitions(3rdparty_system_libpng INTERFACE ${PNG_DEFINITIONS})
+
+	set(LIBPNG_TARGET 3rdparty_system_libpng)
+endif()
+
+
+# pugixml
+add_subdirectory(pugixml EXCLUDE_FROM_ALL)
+
+
+# hidapi
+add_library(3rdparty_hidapi INTERFACE)
+target_include_directories(3rdparty_hidapi INTERFACE hidapi/hidapi)
+
+if(APPLE)
+	add_subdirectory(hidapi/mac EXCLUDE_FROM_ALL)
+	target_include_directories(hidapi-mac PUBLIC hidapi/hidapi)
+
+	target_link_libraries(3rdparty_hidapi INTERFACE hidapi-mac "-framework CoreFoundation" "-framework IOKit")
+elseif(CMAKE_SYSTEM MATCHES "Linux")
+	add_subdirectory(hidapi/linux EXCLUDE_FROM_ALL)
+	target_include_directories(hidapi-hidraw PUBLIC hidapi/hidapi)
+
+	target_link_libraries(3rdparty_hidapi INTERFACE hidapi-hidraw udev)
+elseif(WIN32)
+	add_subdirectory(hidapi/windows EXCLUDE_FROM_ALL)
+	target_include_directories(hidapi-hid PUBLIC hidapi/hidapi)
+
+	target_link_libraries(3rdparty_hidapi INTERFACE hidapi-hid Shlwapi.lib)
+else()
+	add_subdirectory(hidapi/libusb EXCLUDE_FROM_ALL)
+	target_include_directories(hidapi-libusb PUBLIC hidapi/hidapi)
+
+	target_link_libraries(3rdparty_hidapi INTERFACE hidapi-libusb usb)
+endif()
+
+
+# yaml-cpp
+# We don't want to install yaml-cpp but its cmake file doesn't have option
+# to disable it...
+# So we just install it to a different directory
+set(CMAKE_INSTALL_PREFIX_OLD ${CMAKE_INSTALL_PREFIX})
+set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/yaml-cpp_install)
+
+set(YAML_CPP_BUILD_TESTS OFF CACHE BOOL "Enable testing" FORCE)
+set(YAML_CPP_BUILD_TOOLS OFF CACHE BOOL "Enable parse tools" FORCE)
+set(YAML_CPP_BUILD_CONTRIB OFF CACHE BOOL "Enable contrib stuff in library" FORCE)
+add_subdirectory(yaml-cpp EXCLUDE_FROM_ALL)
+
+set(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX_OLD})
+
+
+# xxHash
+set(XXHASH_BUNDLED_MODE ON)
+set(BUILD_SHARED_LIBS OFF CACHE BOOL "Make xxHash build static libs")
+add_subdirectory(xxHash/cmake_unofficial EXCLUDE_FROM_ALL)
+target_include_directories(xxhash INTERFACE xxHash)
+
+
+# cereal
+add_library(3rdparty_cereal INTERFACE)
+target_include_directories(3rdparty_cereal INTERFACE cereal/include)
+
+
+# OpenGL
+
+# Prefer GLVND for OpenGL rather than legacy
+set(OpenGL_GL_PREFERENCE GLVND)
+find_package(OpenGL REQUIRED)
+
+add_library(3rdparty_opengl INTERFACE)
+target_include_directories(3rdparty_opengl INTERFACE GL)
+
+if (WIN32)
+	if(NOT MSVC)
+		target_link_libraries(3rdparty_opengl INTERFACE ${OPENGL_LIBRARIES} opengl32.lib glu32.lib)
+	else()
+		target_link_libraries(3rdparty_opengl INTERFACE dxgi.lib d2d1.lib dwrite.lib)
+	endif()
+else()
+	target_link_libraries(3rdparty_opengl INTERFACE ${OPENGL_LIBRARIES})
+
+	target_compile_definitions(3rdparty_opengl
+		INTERFACE
+			-DGL_GLEXT_PROTOTYPES
+			-DGLX_GLXEXT_PROTOTYPES)
+endif()
+
+
+# GSL
+add_library(3rdparty_gsl INTERFACE)
+target_include_directories(3rdparty_gsl INTERFACE GSL/include)
+
+
+# stblib
+add_library(3rdparty_stblib INTERFACE)
+target_include_directories(3rdparty_stblib INTERFACE stblib)
+
+
+# discord_rpc
+add_library(3rdparty_discord-rpc INTERFACE)
+
+# We don't want Discord Rich Presence on the BSDs and other OSes
+if (USE_DISCORD_RPC AND (WIN32 OR CMAKE_SYSTEM MATCHES "Linux" OR APPLE))
+	if (WIN32 AND NOT MSVC)
+		ExternalProject_Add(discord-rpc
+				GIT_REPOSITORY https://github.com/discordapp/discord-rpc
+				BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/discord-rpc
+				INSTALL_COMMAND ""
+			)
+
+	endif()
+
+	target_include_directories(3rdparty_discord-rpc INTERFACE discord-rpc/include)
+	target_compile_definitions(3rdparty_discord-rpc INTERFACE -DWITH_DISCORD_RPC)
+
+	set(DISCORD_RPC_LIB NOTFOUND)
+	if (WIN32)
+		if (NOT MSVC)
+			set(DISCORD_RPC_LIB ${CMAKE_CURRENT_BINARY_DIR}/discord-rpc/src/libdiscord-rpc.a)
+		else()
+			find_library(DISCORD_RPC_LIB discord-rpc PATHS discord-rpc/lib/ NO_DEFAULT_PATH)
+		endif()
+	elseif(CMAKE_SYSTEM MATCHES "Linux")
+		find_library(DISCORD_RPC_LIB discord-rpc-linux PATHS discord-rpc/lib/ NO_DEFAULT_PATH)
+	elseif(APPLE)
+		find_library(DISCORD_RPC_LIB discord-rpc-mac PATHS discord-rpc/lib/ NO_DEFAULT_PATH)
+	endif()
+	target_link_libraries(3rdparty_discord-rpc INTERFACE ${DISCORD_RPC_LIB})
+	if(APPLE)
+		target_link_libraries(3rdparty_discord-rpc INTERFACE "objc" "-framework Foundation" "-framework CoreServices")
+	endif()
+endif()
+
+
+# ALSA
+set(ALSA_TARGET 3rdparty_dummy_lib)
+
+if(USE_ALSA)
+	find_package(ALSA)
+	if(ALSA_FOUND)
+		add_library(3rdparty_alsa INTERFACE)
+		target_compile_definitions(3rdparty_alsa INTERFACE -DHAVE_ALSA)
+		target_include_directories(3rdparty_alsa SYSTEM INTERFACE ${ALSA_INCLUDE_DIRS})
+		target_link_libraries(3rdparty_alsa INTERFACE ${ALSA_LIBRARIES})
+
+		set(ALSA_TARGET 3rdparty_alsa)
+	endif()
+endif()
+
+
+# Pulse
+set(PULSE_TARGET 3rdparty_dummy_lib)
+if(USE_PULSE)
+	pkg_check_modules(PULSE libpulse-simple)
+
+	if(PULSE_FOUND)
+		add_library(3rdparty_pulse INTERFACE)
+		target_compile_definitions(3rdparty_pulse INTERFACE -DHAVE_PULSE)
+		target_include_directories(3rdparty_pulse SYSTEM
+			INTERFACE ${PULSE_INCLUDE_DIRS})
+		target_link_libraries(3rdparty_pulse INTERFACE ${PULSE_LDFLAGS})
+
+		set(PULSE_TARGET 3rdparty_pulse)
+	endif()
+endif()
+
+# libevdev
+set(LIBEVDEV_TARGET 3rdparty_dummy_lib)
+if(USE_LIBEVDEV)
+	pkg_check_modules(LIBEVDEV libevdev)
+	if(LIBEVDEV_FOUND)
+		add_library(3rdparty_libevdev INTERFACE)
+		target_compile_definitions(3rdparty_libevdev INTERFACE -DHAVE_LIBEVDEV)
+		target_include_directories(3rdparty_libevdev SYSTEM
+			INTERFACE ${LIBEVDEV_INCLUDE_DIRS})
+		target_link_libraries(3rdparty_libevdev INTERFACE ${LIBEVDEV_LDFLAGS})
+
+		set(LIBEVDEV_TARGET 3rdparty_libevdev)
+	endif()
+endif()
+
+
+# Vulkan
+set(VULKAN_TARGET 3rdparty_dummy_lib)
+if(USE_VULKAN)
+	find_package(Vulkan)
+	if(VULKAN_FOUND)
+		add_library(3rdparty_vulkan INTERFACE)
+		target_compile_definitions(3rdparty_vulkan INTERFACE -DHAVE_VULKAN)
+		target_link_libraries(3rdparty_vulkan INTERFACE SPIRV Vulkan::Vulkan)
+
+		if(UNIX AND NOT APPLE)
+			find_package(Wayland)
+			if (WAYLAND_FOUND)
+				target_include_directories(3rdparty_vulkan
+					INTERFACE ${WAYLAND_INCLUDE_DIR})
+
+				target_compile_definitions(3rdparty_vulkan
+					INTERFACE -DVK_USE_PLATFORM_WAYLAND_KHR)
+			endif()
+		endif()
+
+		set(VULKAN_TARGET 3rdparty_vulkan)
+	else()
+		message("WARNING! USE_VULKAN was enabled, but libvulkan was not found. RPCS3 will be compiled without Vulkan support.")
+	endif()
+endif()
+
+
+# OpenAL
+if (MSVC)
+	find_path(OPENAL_INCLUDE_DIR al.h PATHS OpenAL/include)
+	find_library(OPENAL_LIBRARY OpenAL32 PATHS OpenAL/libs/Win64/)
+else()
+	find_package(OpenAL REQUIRED)
+endif()
+
+add_library(3rdparty_openal INTERFACE)
+target_include_directories(3rdparty_openal INTERFACE ${OPENAL_INCLUDE_DIR})
+target_link_libraries(3rdparty_openal INTERFACE ${OPENAL_LIBRARY})
+
+
+# FFMPEG
+add_library(3rdparty_ffmpeg INTERFACE)
+
+# Select the version of ffmpeg to use, default is builtin
+if(USE_SYSTEM_FFMPEG)
+	message("-- RPCS3: using shared ffmpeg")
+	find_package(FFMPEG REQUIRED)
+
+	target_include_directories(3rdparty_ffmpeg INTERFACE ${FFMPEG_INCLUDE_DIR})
+	target_link_libraries(3rdparty_ffmpeg INTERFACE ${FFMPEG_LIBRARIES})
+else()
+	set(FFMPEG_PLATFORM_DIR "ffmpeg/${PLATFORM_ARCH}")
+
+	if (NOT MSVC AND WIN32)
+		message("-- RPCS3: building ffmpeg submodule")
+
+		ExternalProject_Add(ffmpeg-mingw
+			DOWNLOAD_COMMAND ""
+			SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ffmpeg
+			BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/ffmpeg
+			CONFIGURE_COMMAND  ${CMAKE_CURRENT_SOURCE_DIR}/ffmpeg/configure --prefix=./Windows/x86_64 --arch=x86_64 --disable-avdevice --disable-programs --disable-avfilter --disable-postproc --disable-doc --disable-pthreads --enable-w32threads --disable-network --disable-everything --disable-encoders --disable-muxers --disable-hwaccels --disable-parsers --disable-protocols --enable-dxva2 --enable-static --disable-shared --enable-decoder=aac --enable-decoder=aac_latm --enable-decoder=atrac3 --enable-decoder=atrac3p --enable-decoder=mp3 --enable-decoder=pcm_s16le --enable-decoder=pcm_s8 --enable-decoder=h264 --enable-decoder=mpeg4 --enable-decoder=mpeg2video --enable-decoder=mjpeg --enable-decoder=mjpegb --enable-encoder=pcm_s16le --enable-encoder=ffv1 --enable-encoder=mpeg4 --enable-parser=h264 --enable-parser=mpeg4video --enable-parser=mpegaudio --enable-parser=mpegvideo --enable-parser=mjpeg --enable-parser=aac --enable-parser=aac_latm --enable-muxer=avi --enable-demuxer=h264 --enable-demuxer=m4v --enable-demuxer=mp3 --enable-demuxer=mpegvideo --enable-demuxer=mpegps --enable-demuxer=mjpeg --enable-demuxer=avi --enable-demuxer=aac --enable-demuxer=pmp --enable-demuxer=oma --enable-demuxer=pcm_s16le --enable-demuxer=pcm_s8 --enable-demuxer=wav --enable-hwaccel=h264_dxva2 --enable-indev=dshow --enable-protocol=file
+			BUILD_COMMAND make -j 4
+			INSTALL_COMMAND make install
+		)
+
+		set(FFMPEG_LIB_AVFORMAT "${CMAKE_CURRENT_BINARY_DIR}/ffmpeg/${PLATFORM_ARCH}/lib/libavformat.a")
+		set(FFMPEG_LIB_AVCODEC "${CMAKE_CURRENT_BINARY_DIR}/ffmpeg/${PLATFORM_ARCH}/lib/libavcodec.a")
+		set(FFMPEG_LIB_AVUTIL "${CMAKE_CURRENT_BINARY_DIR}/ffmpeg/${PLATFORM_ARCH}/lib/libavutil.a")
+		set(FFMPEG_LIB_SWSCALE "${CMAKE_CURRENT_BINARY_DIR}/ffmpeg/${PLATFORM_ARCH}/lib/libswscale.a")
+	else()
+		message("-- RPCS3: using builtin ffmpeg")
+
+		set(FFMPEG_LIB_DIR "${FFMPEG_PLATFORM_DIR}/lib")
+		find_library(FFMPEG_LIB_AVFORMAT avformat PATHS ${FFMPEG_LIB_DIR} NO_DEFAULT_PATH)
+		find_library(FFMPEG_LIB_AVCODEC avcodec PATHS ${FFMPEG_LIB_DIR} NO_DEFAULT_PATH)
+		find_library(FFMPEG_LIB_AVUTIL avutil PATHS ${FFMPEG_LIB_DIR} NO_DEFAULT_PATH)
+		find_library(FFMPEG_LIB_SWSCALE swscale PATHS ${FFMPEG_LIB_DIR} NO_DEFAULT_PATH)
+	endif()
+
+	target_include_directories(3rdparty_ffmpeg INTERFACE "${FFMPEG_PLATFORM_DIR}/include")
+
+	target_link_libraries(3rdparty_ffmpeg
+		INTERFACE
+			${FFMPEG_LIB_AVFORMAT}
+			${FFMPEG_LIB_AVCODEC}
+			${FFMPEG_LIB_AVUTIL}
+			${FFMPEG_LIB_SWSCALE})
+endif()
+
+
+# dx12
+add_library(3rdparty_dx12 INTERFACE)
+if (WIN32)
+	target_link_libraries(3rdparty_dx12 INTERFACE dxgi.lib d2d1.lib dwrite.lib)
+endif()
+
+
+# GLEW
+add_library(3rdparty_glew INTERFACE)
+if(NOT MSVC)
+	find_package(GLEW 1.13.0 REQUIRED)
+	target_link_libraries(3rdparty_glew INTERFACE GLEW::GLEW)
+endif()
+
+
+# LLVM
+include(llvm.cmake)
+
+
+# add nice ALIAS targets for ease of use
+add_library(3rdparty::zlib ALIAS 3rdparty_zlib)
+add_library(3rdparty::pugixml ALIAS pugixml)
+add_library(3rdparty::yaml-cpp ALIAS yaml-cpp)
+add_library(3rdparty::xxhash ALIAS xxhash)
+add_library(3rdparty::hidapi ALIAS 3rdparty_hidapi)
+add_library(3rdparty::libpng ALIAS ${LIBPNG_TARGET})
+add_library(3rdparty::cereal ALIAS 3rdparty_cereal)
+add_library(3rdparty::opengl ALIAS 3rdparty_opengl)
+add_library(3rdparty::gsl ALIAS 3rdparty_gsl)
+add_library(3rdparty::stblib ALIAS 3rdparty_stblib)
+add_library(3rdparty::discord-rpc ALIAS 3rdparty_discord-rpc)
+add_library(3rdparty::alsa ALIAS ${ALSA_TARGET})
+add_library(3rdparty::pulse ALIAS ${PULSE_TARGET})
+add_library(3rdparty::libevdev ALIAS ${LIBEVDEV_TARGET})
+add_library(3rdparty::vulkan ALIAS ${VULKAN_TARGET})
+add_library(3rdparty::openal ALIAS 3rdparty_openal)
+add_library(3rdparty::ffmpeg ALIAS 3rdparty_ffmpeg)
+add_library(3rdparty::dx12 ALIAS 3rdparty_dx12)
+add_library(3rdparty::glew ALIAS 3rdparty_glew)
@@ -13,8 +13,8 @@
 *
 * You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 * Or go to http://www.gnu.org/copyleft/lgpl.html
 */

@@ -97,6 +97,31 @@ extern "C" {

 #ifndef AL_EXT_MCFORMATS
 #define AL_EXT_MCFORMATS 1
+/* Provides support for surround sound buffer formats with 8, 16, and 32-bit
+ * samples.
+ *
+ * QUAD8: Unsigned 8-bit, Quadraphonic (Front Left, Front Right, Rear Left,
+ *        Rear Right).
+ * QUAD16: Signed 16-bit, Quadraphonic.
+ * QUAD32: 32-bit float, Quadraphonic.
+ * REAR8: Unsigned 8-bit, Rear Stereo (Rear Left, Rear Right).
+ * REAR16: Signed 16-bit, Rear Stereo.
+ * REAR32: 32-bit float, Rear Stereo.
+ * 51CHN8: Unsigned 8-bit, 5.1 Surround (Front Left, Front Right, Front Center,
+ *         LFE, Side Left, Side Right). Note that some audio systems may label
+ *         5.1's Side channels as Rear or Surround; they are equivalent for the
+ *         purposes of this extension.
+ * 51CHN16: Signed 16-bit, 5.1 Surround.
+ * 51CHN32: 32-bit float, 5.1 Surround.
+ * 61CHN8: Unsigned 8-bit, 6.1 Surround (Front Left, Front Right, Front Center,
+ *         LFE, Rear Center, Side Left, Side Right).
+ * 61CHN16: Signed 16-bit, 6.1 Surround.
+ * 61CHN32: 32-bit float, 6.1 Surround.
+ * 71CHN8: Unsigned 8-bit, 7.1 Surround (Front Left, Front Right, Front Center,
+ *         LFE, Rear Left, Rear Right, Side Left, Side Right).
+ * 71CHN16: Signed 16-bit, 7.1 Surround.
+ * 71CHN32: 32-bit float, 7.1 Surround.
+ */
 #define AL_FORMAT_QUAD8                          0x1204
 #define AL_FORMAT_QUAD16                         0x1205
 #define AL_FORMAT_QUAD32                         0x1206
@@ -393,6 +418,97 @@ ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device);
 #endif
 #endif

+#ifndef AL_EXT_BFORMAT
+#define AL_EXT_BFORMAT 1
+/* Provides support for B-Format ambisonic buffers (first-order, FuMa scaling
+ * and layout).
+ *
+ * BFORMAT2D_8: Unsigned 8-bit, 3-channel non-periphonic (WXY).
+ * BFORMAT2D_16: Signed 16-bit, 3-channel non-periphonic (WXY).
+ * BFORMAT2D_FLOAT32: 32-bit float, 3-channel non-periphonic (WXY).
+ * BFORMAT3D_8: Unsigned 8-bit, 4-channel periphonic (WXYZ).
+ * BFORMAT3D_16: Signed 16-bit, 4-channel periphonic (WXYZ).
+ * BFORMAT3D_FLOAT32: 32-bit float, 4-channel periphonic (WXYZ).
+ */
+#define AL_FORMAT_BFORMAT2D_8                    0x20021
+#define AL_FORMAT_BFORMAT2D_16                   0x20022
+#define AL_FORMAT_BFORMAT2D_FLOAT32              0x20023
+#define AL_FORMAT_BFORMAT3D_8                    0x20031
+#define AL_FORMAT_BFORMAT3D_16                   0x20032
+#define AL_FORMAT_BFORMAT3D_FLOAT32              0x20033
+#endif
+
+#ifndef AL_EXT_MULAW_BFORMAT
+#define AL_EXT_MULAW_BFORMAT 1
+#define AL_FORMAT_BFORMAT2D_MULAW                0x10031
+#define AL_FORMAT_BFORMAT3D_MULAW                0x10032
+#endif
+
+#ifndef ALC_SOFT_HRTF
+#define ALC_SOFT_HRTF 1
+#define ALC_HRTF_SOFT                            0x1992
+#define ALC_DONT_CARE_SOFT                       0x0002
+#define ALC_HRTF_STATUS_SOFT                     0x1993
+#define ALC_HRTF_DISABLED_SOFT                   0x0000
+#define ALC_HRTF_ENABLED_SOFT                    0x0001
+#define ALC_HRTF_DENIED_SOFT                     0x0002
+#define ALC_HRTF_REQUIRED_SOFT                   0x0003
+#define ALC_HRTF_HEADPHONES_DETECTED_SOFT        0x0004
+#define ALC_HRTF_UNSUPPORTED_FORMAT_SOFT         0x0005
+#define ALC_NUM_HRTF_SPECIFIERS_SOFT             0x1994
+#define ALC_HRTF_SPECIFIER_SOFT                  0x1995
+#define ALC_HRTF_ID_SOFT                         0x1996
+typedef const ALCchar* (ALC_APIENTRY*LPALCGETSTRINGISOFT)(ALCdevice *device, ALCenum paramName, ALCsizei index);
+typedef ALCboolean (ALC_APIENTRY*LPALCRESETDEVICESOFT)(ALCdevice *device, const ALCint *attribs);
+#ifdef AL_ALEXT_PROTOTYPES
+ALC_API const ALCchar* ALC_APIENTRY alcGetStringiSOFT(ALCdevice *device, ALCenum paramName, ALCsizei index);
+ALC_API ALCboolean ALC_APIENTRY alcResetDeviceSOFT(ALCdevice *device, const ALCint *attribs);
+#endif
+#endif
+
+#ifndef AL_SOFT_gain_clamp_ex
+#define AL_SOFT_gain_clamp_ex 1
+#define AL_GAIN_LIMIT_SOFT                       0x200E
+#endif
+
+#ifndef AL_SOFT_source_resampler
+#define AL_SOFT_source_resampler
+#define AL_NUM_RESAMPLERS_SOFT                   0x1210
+#define AL_DEFAULT_RESAMPLER_SOFT                0x1211
+#define AL_SOURCE_RESAMPLER_SOFT                 0x1212
+#define AL_RESAMPLER_NAME_SOFT                   0x1213
+typedef const ALchar* (AL_APIENTRY*LPALGETSTRINGISOFT)(ALenum pname, ALsizei index);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index);
+#endif
+#endif
+
+#ifndef AL_SOFT_source_spatialize
+#define AL_SOFT_source_spatialize
+#define AL_SOURCE_SPATIALIZE_SOFT                0x1214
+#define AL_AUTO_SOFT                             0x0002
+#endif
+
+#ifndef ALC_SOFT_output_limiter
+#define ALC_SOFT_output_limiter
+#define ALC_OUTPUT_LIMITER_SOFT                  0x199A
+#endif
+
+#ifndef ALC_SOFT_device_clock
+#define ALC_SOFT_device_clock 1
+typedef int64_t ALCint64SOFT;
+typedef uint64_t ALCuint64SOFT;
+#define ALC_DEVICE_CLOCK_SOFT                    0x1600
+#define ALC_DEVICE_LATENCY_SOFT                  0x1601
+#define ALC_DEVICE_CLOCK_LATENCY_SOFT            0x1602
+#define AL_SAMPLE_OFFSET_CLOCK_SOFT              0x1202
+#define AL_SEC_OFFSET_CLOCK_SOFT                 0x1203
+typedef void (ALC_APIENTRY*LPALCGETINTEGER64VSOFT)(ALCdevice *device, ALCenum pname, ALsizei size, ALCint64SOFT *values);
+#ifdef AL_ALEXT_PROTOTYPES
+ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALsizei size, ALCint64SOFT *values);
+#endif
+#endif
+
 #ifdef __cplusplus
 }
 #endif
@@ -345,7 +345,7 @@ typedef struct {
 /* Driving Presets */

 #define EFX_REVERB_PRESET_DRIVING_COMMENTATOR \
-    { 1.0000f, 0.0000f, 3.1623f, 0.5623f, 0.5012f, 2.4200f, 0.8800f, 0.6800f, 0.1995f, 0.0930f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+    { 1.0000f, 0.0000f, 0.3162f, 0.5623f, 0.5012f, 2.4200f, 0.8800f, 0.6800f, 0.1995f, 0.0930f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }

 #define EFX_REVERB_PRESET_DRIVING_PITGARAGE \
    { 0.4287f, 0.5900f, 0.3162f, 0.7079f, 0.5623f, 1.7200f, 0.9300f, 0.8700f, 0.5623f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
@@ -1,84 +1,35 @@
 EXPORTS
-    alAuxiliaryEffectSlotf
-    alAuxiliaryEffectSlotfv
-    alAuxiliaryEffectSloti
-    alAuxiliaryEffectSlotiv
    alBuffer3f
    alBuffer3i
    alBufferData
-    alBufferSamplesSOFT
-    alBufferSubDataSOFT
-    alBufferSubSamplesSOFT
    alBufferf
    alBufferfv
    alBufferi
    alBufferiv
-    alDeferUpdatesSOFT
-    alDeleteAuxiliaryEffectSlots
    alDeleteBuffers
-    alDeleteEffects
-    alDeleteFilters
-    alDeleteFontsoundsSOFT
-    alDeletePresetsSOFT
-    alDeleteSoundfontsSOFT
    alDeleteSources
    alDisable
    alDistanceModel
    alDopplerFactor
    alDopplerVelocity
-    alEffectf
-    alEffectfv
-    alEffecti
-    alEffectiv
    alEnable
-    alFilterf
-    alFilterfv
-    alFilteri
-    alFilteriv
-    alFontsound2iSOFT
-    alFontsoundModulatoriSOFT
-    alFontsoundiSOFT
-    alFontsoundivSOFT
-    alGenAuxiliaryEffectSlots
    alGenBuffers
-    alGenEffects
-    alGenFilters
-    alGenFontsoundsSOFT
-    alGenPresetsSOFT
-    alGenSoundfontsSOFT
    alGenSources
-    alGetAuxiliaryEffectSlotf
-    alGetAuxiliaryEffectSlotfv
-    alGetAuxiliaryEffectSloti
-    alGetAuxiliaryEffectSlotiv
    alGetBoolean
    alGetBooleanv
    alGetBuffer3f
    alGetBuffer3i
-    alGetBufferSamplesSOFT
    alGetBufferf
    alGetBufferfv
    alGetBufferi
    alGetBufferiv
    alGetDouble
    alGetDoublev
-    alGetEffectf
-    alGetEffectfv
-    alGetEffecti
-    alGetEffectiv
    alGetEnumValue
    alGetError
-    alGetFilterf
-    alGetFilterfv
-    alGetFilteri
-    alGetFilteriv
    alGetFloat
    alGetFloatv
-    alGetFontsoundModulatorivSOFT
-    alGetFontsoundivSOFT
    alGetInteger
-    alGetInteger64SOFT
-    alGetInteger64vSOFT
    alGetIntegerv
    alGetListener3f
    alGetListener3i
@@ -86,32 +37,17 @@ EXPORTS
    alGetListenerfv
    alGetListeneri
    alGetListeneriv
-    alGetPresetivSOFT
    alGetProcAddress
-    alGetSoundfontivSOFT
-    alGetSource3dSOFT
    alGetSource3f
    alGetSource3i
-    alGetSource3i64SOFT
-    alGetSourcedSOFT
-    alGetSourcedvSOFT
    alGetSourcef
    alGetSourcefv
    alGetSourcei
-    alGetSourcei64SOFT
-    alGetSourcei64vSOFT
    alGetSourceiv
    alGetString
-    alIsAuxiliaryEffectSlot
    alIsBuffer
-    alIsBufferFormatSupportedSOFT
-    alIsEffect
    alIsEnabled
    alIsExtensionPresent
-    alIsFilter
-    alIsFontsoundSOFT
-    alIsPresetSOFT
-    alIsSoundfontSOFT
    alIsSource
    alListener3f
    alListener3i
@@ -119,25 +55,8 @@ EXPORTS
    alListenerfv
    alListeneri
    alListeneriv
-    alLoadSoundfontSOFT
-    alMidiEventSOFT
-    alMidiGainSOFT
-    alMidiPauseSOFT
-    alMidiPlaySOFT
-    alMidiResetSOFT
-    alMidiSoundfontSOFT
-    alMidiSoundfontvSOFT
-    alMidiStopSOFT
-    alMidiSysExSOFT
-    alPresetFontsoundsSOFT
-    alPresetiSOFT
-    alPresetivSOFT
-    alProcessUpdatesSOFT
-    alSoundfontPresetsSOFT
-    alSource3dSOFT
    alSource3f
    alSource3i
-    alSource3i64SOFT
    alSourcePause
    alSourcePausev
    alSourcePlay
@@ -148,13 +67,9 @@ EXPORTS
    alSourceStop
    alSourceStopv
    alSourceUnqueueBuffers
-    alSourcedSOFT
-    alSourcedvSOFT
    alSourcef
    alSourcefv
    alSourcei
-    alSourcei64SOFT
-    alSourcei64vSOFT
    alSourceiv
    alSpeedOfSound
    alcCaptureCloseDevice
@@ -165,23 +80,17 @@ EXPORTS
    alcCloseDevice
    alcCreateContext
    alcDestroyContext
-    alcDevicePauseSOFT
-    alcDeviceResumeSOFT
    alcGetContextsDevice
    alcGetCurrentContext
    alcGetEnumValue
    alcGetError
-    alcGetInteger64vSOFT
    alcGetIntegerv
    alcGetProcAddress
    alcGetString
    alcGetThreadContext
    alcIsExtensionPresent
-    alcIsRenderFormatSupportedSOFT
-    alcLoopbackOpenDeviceSOFT
    alcMakeContextCurrent
    alcOpenDevice
    alcProcessContext
-    alcRenderSamplesSOFT
    alcSetThreadContext
    alcSuspendContext
@@ -0,0 +1,26 @@
+#pragma once
+
+#if defined(DISCORD_DYNAMIC_LIB)
+#  if defined(_WIN32)
+#    if defined(DISCORD_BUILDING_SDK)
+#      define DISCORD_EXPORT __declspec(dllexport)
+#    else
+#      define DISCORD_EXPORT __declspec(dllimport)
+#    endif
+#  else
+#    define DISCORD_EXPORT __attribute__((visibility("default")))
+#  endif
+#else
+#  define DISCORD_EXPORT
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DISCORD_EXPORT void Discord_Register(const char* applicationId, const char* command);
+DISCORD_EXPORT void Discord_RegisterSteamGame(const char* applicationId, const char* steamId);
+
+#ifdef __cplusplus
+}
+#endif
@@ -0,0 +1,87 @@
+#pragma once
+#include <stdint.h>
+
+// clang-format off
+
+#if defined(DISCORD_DYNAMIC_LIB)
+#  if defined(_WIN32)
+#    if defined(DISCORD_BUILDING_SDK)
+#      define DISCORD_EXPORT __declspec(dllexport)
+#    else
+#      define DISCORD_EXPORT __declspec(dllimport)
+#    endif
+#  else
+#    define DISCORD_EXPORT __attribute__((visibility("default")))
+#  endif
+#else
+#  define DISCORD_EXPORT
+#endif
+
+// clang-format on
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct DiscordRichPresence {
+    const char* state;   /* max 128 bytes */
+    const char* details; /* max 128 bytes */
+    int64_t startTimestamp;
+    int64_t endTimestamp;
+    const char* largeImageKey;  /* max 32 bytes */
+    const char* largeImageText; /* max 128 bytes */
+    const char* smallImageKey;  /* max 32 bytes */
+    const char* smallImageText; /* max 128 bytes */
+    const char* partyId;        /* max 128 bytes */
+    int partySize;
+    int partyMax;
+    const char* matchSecret;    /* max 128 bytes */
+    const char* joinSecret;     /* max 128 bytes */
+    const char* spectateSecret; /* max 128 bytes */
+    int8_t instance;
+} DiscordRichPresence;
+
+typedef struct DiscordJoinRequest {
+    const char* userId;
+    const char* username;
+    const char* discriminator;
+    const char* avatar;
+} DiscordJoinRequest;
+
+typedef struct DiscordEventHandlers {
+    void (*ready)(void);
+    void (*disconnected)(int errorCode, const char* message);
+    void (*errored)(int errorCode, const char* message);
+    void (*joinGame)(const char* joinSecret);
+    void (*spectateGame)(const char* spectateSecret);
+    void (*joinRequest)(const DiscordJoinRequest* request);
+} DiscordEventHandlers;
+
+#define DISCORD_REPLY_NO 0
+#define DISCORD_REPLY_YES 1
+#define DISCORD_REPLY_IGNORE 2
+
+DISCORD_EXPORT void Discord_Initialize(const char* applicationId,
+                                       DiscordEventHandlers* handlers,
+                                       int autoRegister,
+                                       const char* optionalSteamId);
+DISCORD_EXPORT void Discord_Shutdown(void);
+
+/* checks for incoming messages, dispatches callbacks */
+DISCORD_EXPORT void Discord_RunCallbacks(void);
+
+/* If you disable the lib starting its own io thread, you'll need to call this from your own */
+#ifdef DISCORD_DISABLE_IO_THREAD
+DISCORD_EXPORT void Discord_UpdateConnection(void);
+#endif
+
+DISCORD_EXPORT void Discord_UpdatePresence(const DiscordRichPresence* presence);
+DISCORD_EXPORT void Discord_ClearPresence(void);
+
+DISCORD_EXPORT void Discord_Respond(const char* userid, /* DISCORD_REPLY_ */ int reply);
+
+DISCORD_EXPORT void Discord_UpdateHandlers(DiscordEventHandlers* handlers);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
@@ -0,0 +1,142 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug Library|x64">
+      <Configuration>Debug Library</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release Library|x64">
+      <Configuration>Release Library</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{D6973076-9317-4EF2-A0B8-B7A18AC0713E}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>libpng</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\3rdparty\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <CustomBuildBeforeTargets />
+    <TargetName>$(ProjectName)16</TargetName>
+    <OutDir>$(SolutionDir)lib/</OutDir>
+    <IntDir>$(SolutionDir)tmp\$(ProjectName)-$(Configuration)-$(Platform)/</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <CustomBuildBeforeTargets />
+    <TargetName>$(ProjectName)16</TargetName>
+    <OutDir>$(SolutionDir)lib/</OutDir>
+    <IntDir>$(SolutionDir)tmp\$(ProjectName)-$(Configuration)-$(Platform)/</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|x64'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>$(WarningLevel)</WarningLevel>
+      <MinimalRebuild>false</MinimalRebuild>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <TreatWChar_tAsBuiltInType>false</TreatWChar_tAsBuiltInType>
+      <PrecompiledHeaderFile>pngpriv.h</PrecompiledHeaderFile>
+      <BrowseInformation>true</BrowseInformation>
+      <CompileAs>CompileAsC</CompileAs>
+      <StringPooling>true</StringPooling>
+      <DisableSpecificWarnings>$(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>$(ZLibSrcDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <TreatWarningAsError>$(TreatWarningAsError)</TreatWarningAsError>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|x64'">
+    <ClCompile>
+      <WarningLevel>$(WarningLevel)</WarningLevel>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <TreatWChar_tAsBuiltInType>false</TreatWChar_tAsBuiltInType>
+      <PrecompiledHeaderFile>pngpriv.h</PrecompiledHeaderFile>
+      <BrowseInformation>true</BrowseInformation>
+      <CompileAs>CompileAsC</CompileAs>
+      <StringPooling>true</StringPooling>
+      <MinimalRebuild>false</MinimalRebuild>
+      <DisableSpecificWarnings>$(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>$(ZLibSrcDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <TreatWarningAsError>$(TreatWarningAsError)</TreatWarningAsError>
+      <Optimization>Full</Optimization>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <Lib>
+      <LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include=".\libpng\png.c">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug Library|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release Library|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include=".\libpng\pngerror.c" />
+    <ClCompile Include=".\libpng\pngget.c" />
+    <ClCompile Include=".\libpng\pngmem.c" />
+    <ClCompile Include=".\libpng\pngpread.c" />
+    <ClCompile Include=".\libpng\pngread.c" />
+    <ClCompile Include=".\libpng\pngrio.c" />
+    <ClCompile Include=".\libpng\pngrtran.c" />
+    <ClCompile Include=".\libpng\pngrutil.c" />
+    <ClCompile Include=".\libpng\pngset.c" />
+    <ClCompile Include=".\libpng\pngtrans.c" />
+    <ClCompile Include=".\libpng\pngwio.c" />
+    <ClCompile Include=".\libpng\pngwrite.c" />
+    <ClCompile Include=".\libpng\pngwtran.c" />
+    <ClCompile Include=".\libpng\pngwutil.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include=".\libpng\scripts\pngwin.rc">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug Library|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release Library|x64'">true</ExcludedFromBuild>
+    </ResourceCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
@@ -0,0 +1,65 @@
+if(WITH_LLVM)
+	if(BUILD_LLVM_SUBMODULE)
+		message(STATUS "LLVM will be built from the submodule.")
+
+		set(LLVM_TARGETS_TO_BUILD "X86" CACHE INTERNAL "")
+		option(LLVM_BUILD_RUNTIME OFF)
+		option(LLVM_BUILD_TOOLS OFF)
+		option(LLVM_INCLUDE_DOCS OFF)
+		option(LLVM_INCLUDE_EXAMPLES OFF)
+		option(LLVM_INCLUDE_TESTS OFF)
+		option(LLVM_INCLUDE_TOOLS OFF)
+		option(LLVM_INCLUDE_UTILS OFF)
+		option(WITH_POLLY OFF)
+		option(LLVM_ENABLE_CXX1Z TRUE)
+
+		set(CXX_FLAGS_OLD ${CMAKE_CXX_FLAGS})
+
+		if (MSVC)
+			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS")
+		endif()
+
+		# LLVM needs to be built out-of-tree
+		add_subdirectory(${CMAKE_SOURCE_DIR}/llvm ${CMAKE_CURRENT_BINARY_DIR}/llvm_build EXCLUDE_FROM_ALL)
+		set(LLVM_DIR "${CMAKE_CURRENT_BINARY_DIR}/llvm_build/lib/cmake/llvm/")
+
+		set(CMAKE_CXX_FLAGS ${CXX_FLAGS_OLD})
+
+		# now tries to find LLVM again
+		find_package(LLVM 8.0 CONFIG)
+		if(NOT LLVM_FOUND)
+			message(FATAL_ERROR "Couldn't build LLVM from the submodule. You might need to run `git submodule update --init`")
+		endif()
+
+	else()
+		message(STATUS "Using prebuilt LLVM")
+
+		if (LLVM_DIR AND NOT IS_ABSOLUTE "${LLVM_DIR}")
+			# change relative LLVM_DIR to be relative to the source dir
+			set(LLVM_DIR ${CMAKE_SOURCE_DIR}/${LLVM_DIR})
+		endif()
+
+		find_package(LLVM 8.0 CONFIG)
+
+		if (NOT LLVM_FOUND)
+			if (LLVM_VERSION AND LLVM_VERSION_MAJOR LESS 8)
+				message(FATAL_ERROR "Found LLVM version ${LLVM_VERSION}. Required version 8.0. \
+														 Enable BUILD_LLVM_SUBMODULE option to build LLVM from included as a git submodule.")
+			endif()
+
+			message(FATAL_ERROR "Can't find LLVM libraries from the CMAKE_PREFIX_PATH path or LLVM_DIR. \
+													 Enable BUILD_LLVM_SUBMODULE option to build LLVM from included as a git submodule.")
+		endif()
+	endif()
+
+	set(LLVM_LIBS LLVMMCJIT LLVMX86CodeGen)
+
+	add_library(3rdparty_llvm INTERFACE)
+	target_link_libraries(3rdparty_llvm INTERFACE ${LLVM_LIBS})
+	target_include_directories(3rdparty_llvm INTERFACE ${LLVM_INCLUDE_DIRS})
+	target_compile_definitions(3rdparty_llvm INTERFACE ${LLVM_DEFINITIONS} -DLLVM_AVAILABLE)
+
+	add_library(3rdparty::llvm ALIAS 3rdparty_llvm)
+else()
+	add_library(3rdparty::llvm ALIAS 3rdparty_dummy_lib)
+endif()
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{EB33566E-DA7F-4D28-9077-88C0B7C77E35}</ProjectGuid>
+    <RootNamespace>pnglibconf</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\3rdparty\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <CustomBuildBeforeTargets>Build</CustomBuildBeforeTargets>
+    <IntDir>$(SolutionDir)tmp\$(ProjectName)-$(Configuration)-$(Platform)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>$(WarningLevel)</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <CustomBuildStep>
+      <Command>copy .\libpng\scripts\pnglibconf.h.prebuilt .\libpng\pnglibconf.h</Command>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Message>Generating pnglibconf.h</Message>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Outputs>.\libpng\pnglibconf.h</Outputs>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Inputs>.\libpng\scripts\pnglibconf.h.prebuilt</Inputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
@@ -0,0 +1,49 @@
+add_library(3rdparty_qt5 INTERFACE)
+
+find_package(Qt5 5.10 CONFIG COMPONENTS Widgets Network Qml)
+if(WIN32)
+	find_package(Qt5 5.10 COMPONENTS WinExtras REQUIRED)
+	target_link_libraries(3rdparty_qt5 INTERFACE Qt5::Widgets Qt5::WinExtras Qt5::Network Qt5::Qml)
+else()
+	find_package(Qt5 5.10 COMPONENTS DBus Gui)
+	if(Qt5DBus_FOUND)
+		target_link_libraries(3rdparty_qt5 INTERFACE Qt5::Widgets Qt5::DBus Qt5::Network Qt5::Qml)
+		target_compile_definitions(3rdparty_qt5 INTERFACE -DHAVE_QTDBUS)
+	else()
+		target_link_libraries(3rdparty_qt5 INTERFACE Qt5::Widgets Qt5::Network Qt5::Qml)
+	endif()
+	target_include_directories(3rdparty_qt5 INTERFACE ${Qt5Gui_PRIVATE_INCLUDE_DIRS})
+endif()
+
+if(NOT Qt5Widgets_FOUND)
+	if(Qt5Widgets_VERSION VERSION_LESS 5.10.0)
+		message("Minimum supported Qt5 version is 5.10.0! You have version ${Qt5Widgets_VERSION} installed, please upgrade!")
+		if(CMAKE_SYSTEM MATCHES "Linux")
+			message(FATAL_ERROR "Most distros do not provide an up-to-date version of Qt.
+If you're on Ubuntu or Linux Mint, there are PPAs you can use to install one of the latest qt5 versions.
+		https://launchpad.net/~beineri/+archive/ubuntu/opt-qt-5.11.0-bionic
+		https://launchpad.net/~beineri/+archive/ubuntu/opt-qt-5.11.0-xenial
+		https://launchpad.net/~beineri/+archive/ubuntu/opt-qt-5.10.1-trusty
+just make sure to run
+	source /opt/qt511/bin/qt511-env.sh
+respective
+	source /opt/qt510/bin/qt510-env.sh
+before re-running cmake")
+		elseif(WIN32)
+			message(FATAL_ERROR "You can download the latest version of Qt5 here: https://www.qt.io/download-open-source/")
+		else()
+			message(FATAL_ERROR "Look online for instructions on installing an up-to-date Qt5 on ${CMAKE_SYSTEM}.")
+		endif()
+	endif()
+
+	message("CMake was unable to find Qt5!")
+	if(WIN32)
+		message(FATAL_ERROR "Make sure the QTDIR env variable has been set properly. (for example C:\\Qt\\5.11.1\\msvc2017_64\\)")
+	elseif(CMAKE_SYSTEM MATCHES "Linux")
+		message(FATAL_ERROR "Make sure to install your distro's qt5 package!")
+	else()
+		message(FATAL_ERROR "You need to have Qt5 installed, look online for instructions on installing Qt5 on ${CMAKE_SYSTEM}.")
+	endif()
+endif()
+
+add_library(3rdparty::qt5 ALIAS 3rdparty_qt5)
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{939FE206-1182-ABC3-1234-FEAB88E98404}</ProjectGuid>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\rpcs3_default.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="..\rpcs3_debug.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="..\rpcs3_release.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="xxHash/xxhash.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <Text Include="LICENSE" />
+    <Text Include="CMakeLists.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="xxHash/xxhash.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
@@ -19,7 +19,7 @@
  <PropertyGroup Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
    <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
@@ -54,6 +54,7 @@
    </ClCompile>
    <ClCompile Include="yaml-cpp\src\emitterutils.cpp">
    </ClCompile>
+    <ClCompile Include="yaml-cpp\src\exceptions.cpp" />
    <ClCompile Include="yaml-cpp\src\exp.cpp">
    </ClCompile>
    <ClCompile Include="yaml-cpp\src\memory.cpp">
@@ -7,85 +7,88 @@
    </Filter>
  </ItemGroup>
  <ItemGroup>
-    <ClCompile Include="src\binary.cpp">
+    <ClCompile Include="yaml-cpp\src\binary.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\convert.cpp">
+    <ClCompile Include="yaml-cpp\src\convert.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\directives.cpp">
+    <ClCompile Include="yaml-cpp\src\directives.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\emit.cpp">
+    <ClCompile Include="yaml-cpp\src\emit.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\emitfromevents.cpp">
+    <ClCompile Include="yaml-cpp\src\emitfromevents.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\emitter.cpp">
+    <ClCompile Include="yaml-cpp\src\emitter.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\emitterstate.cpp">
+    <ClCompile Include="yaml-cpp\src\emitterstate.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\emitterutils.cpp">
+    <ClCompile Include="yaml-cpp\src\emitterutils.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\exp.cpp">
+    <ClCompile Include="yaml-cpp\src\exp.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\memory.cpp">
+    <ClCompile Include="yaml-cpp\src\memory.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\node.cpp">
+    <ClCompile Include="yaml-cpp\src\node.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\node_data.cpp">
+    <ClCompile Include="yaml-cpp\src\nodebuilder.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\nodebuilder.cpp">
+    <ClCompile Include="yaml-cpp\src\nodeevents.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\nodeevents.cpp">
+    <ClCompile Include="yaml-cpp\src\node_data.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\null.cpp">
+    <ClCompile Include="yaml-cpp\src\null.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\ostream_wrapper.cpp">
+    <ClCompile Include="yaml-cpp\src\ostream_wrapper.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\parse.cpp">
+    <ClCompile Include="yaml-cpp\src\parse.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\parser.cpp">
+    <ClCompile Include="yaml-cpp\src\parser.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\regex_yaml.cpp">
+    <ClCompile Include="yaml-cpp\src\regex_yaml.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\scanner.cpp">
+    <ClCompile Include="yaml-cpp\src\scanner.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\scanscalar.cpp">
+    <ClCompile Include="yaml-cpp\src\scanscalar.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\scantag.cpp">
+    <ClCompile Include="yaml-cpp\src\scantag.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\scantoken.cpp">
+    <ClCompile Include="yaml-cpp\src\scantoken.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\simplekey.cpp">
+    <ClCompile Include="yaml-cpp\src\simplekey.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\singledocparser.cpp">
+    <ClCompile Include="yaml-cpp\src\singledocparser.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\stream.cpp">
+    <ClCompile Include="yaml-cpp\src\stream.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="src\tag.cpp">
+    <ClCompile Include="yaml-cpp\src\tag.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="yaml-cpp\src\exceptions.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
@@ -2,7 +2,7 @@
 <!--
 * zlib.props - location of zlib source
 *
- * libpng version 1.6.20 - December 3, 2015
+ * libpng version 1.6.34 - September 29, 2017
 *
 * Copyright (c) 1998-2011 Glenn Randers-Pehrson
 *
@@ -32,7 +32,7 @@
 	 versions do not match.  The zlib version used in this build is recorded
 	 below:
     -->
-    <ZLibSrcDir>$(SolutionDir)wxWidgets\src\zlib\</ZLibSrcDir>
+    <ZLibSrcDir>$(SolutionDir)3rdparty\zlib\</ZLibSrcDir>

    <!-- The following line allows compilation for an ARM target with Visual
         Studio 2012.  Notice that this is not supported by the Visual Studio
@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="$(ZLibSrcDir)\adler32.c" />
+    <ClCompile Include="$(ZLibSrcDir)\compress.c" />
+    <ClCompile Include="$(ZLibSrcDir)\crc32.c" />
+    <ClCompile Include="$(ZLibSrcDir)\deflate.c" />
+    <ClCompile Include="$(ZLibSrcDir)\infback.c" />
+    <ClCompile Include="$(ZLibSrcDir)\inffast.c" />
+    <ClCompile Include="$(ZLibSrcDir)\inflate.c" />
+    <ClCompile Include="$(ZLibSrcDir)\inftrees.c" />
+    <ClCompile Include="$(ZLibSrcDir)\trees.c" />
+    <ClCompile Include="$(ZLibSrcDir)\uncompr.c" />
+    <ClCompile Include="$(ZLibSrcDir)\zutil.c" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{60F89955-91C6-3A36-8000-13C592FEC2DF}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>zlib</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\3rdparty\zlib.props" />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)lib\$(Configuration)-$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)tmp\$(ProjectName)-$(Configuration)-$(Platform)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)lib\$(Configuration)-$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)tmp\$(ProjectName)-$(Configuration)-$(Platform)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>$(WarningLevel)</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+      <BrowseInformation>true</BrowseInformation>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <DisableSpecificWarnings>$(DisableSpecificWarnings);4127;4131;4242;4244</DisableSpecificWarnings>
+      <TreatWarningAsError>$(TreatWarningAsError)</TreatWarningAsError>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>$(WarningLevel)</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Full</Optimization>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <BrowseInformation>true</BrowseInformation>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <DisableSpecificWarnings>$(DisableSpecificWarnings);4127;4131;4242;4244</DisableSpecificWarnings>
+      <TreatWarningAsError>$(TreatWarningAsError)</TreatWarningAsError>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <Lib>
+      <LinkTimeCodeGeneration>true</LinkTimeCodeGeneration>
+    </Lib>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
@@ -1,30 +1,68 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.8.2)

-set(ASMJIT_STATIC TRUE)
+project(rpcs3)
+
+option(WITH_GDB "WITH_GDB" OFF)
+option(USE_NATIVE_INSTRUCTIONS "USE_NATIVE_INSTRUCTIONS makes rpcs3 compile with -march=native, which is useful for local builds, but not good for packages." ON)
+
+option(WITH_LLVM "Enable usage of LLVM library" ON)
+option(BUILD_LLVM_SUBMODULE "Build LLVM from git submodule" ON)
+
+option(USE_ALSA "ALSA audio backend" ON)
+option(USE_PULSE "PulseAudio audio backend" ON)
+option(USE_LIBEVDEV "libevdev-based joystick support" ON)
+
+option(USE_DISCORD_RPC "Discord rich presence integration" ON)
+
+option(USE_SYSTEM_ZLIB "Prefer system ZLIB instead of the builtin one" ON)
+
+option(USE_VULKAN "Vulkan render backend" ON)
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/rpcs3/cmake_modules")
+
+set(CMAKE_CXX_STANDARD 17)
+include(CheckCXXCompilerFlag)
+
+if (WITH_GDB)
+	add_definitions(-DWITH_GDB_DEBUGGER)
+endif()

 if (NOT CMAKE_BUILD_TYPE)
 	message(STATUS "No build type selected, default to Release")
 	set(CMAKE_BUILD_TYPE "Release")
 endif()

+if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+	add_definitions(-DNDEBUG)
+endif()
+
 if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
 	message( FATAL_ERROR "RPCS3 can only be compiled on 64-bit platforms." )
 endif()

-add_definitions(-DCMAKE_BUILD)
-
-# We use libpng's static library and don't need to build the shared library and run the tests
-set(PNG_SHARED OFF CACHE BOOL "Build shared lib." FORCE)
-set(PNG_TESTS  OFF CACHE BOOL "Build tests." FORCE)
-
-# Select the version of libpng to use, default is builtin
-if (NOT USE_SYSTEM_LIBPNG)
-	add_subdirectory( 3rdparty/libpng )
+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()

+if(WIN32)
+	add_definitions(-DUNICODE)
+	add_definitions(-D_WIN32_WINNT=0x0602)
+endif()
+
+if(APPLE)
+	include_directories(/opt/local/include)
+	link_directories(/opt/local/lib)
+endif()
+
+add_subdirectory(Vulkan EXCLUDE_FROM_ALL)
+add_subdirectory(asmjitsrc EXCLUDE_FROM_ALL)
+add_subdirectory(3rdparty)
+
 # 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")
-add_subdirectory( Vulkan )
-add_subdirectory( rpcs3 )
-add_subdirectory( rsx_program_decompiler )
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${PROJECT_BINARY_DIR}/bin")
+
+add_subdirectory(rpcs3)
@@ -3,58 +3,94 @@ 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++.
+The world's first free and open-source PlayStation 3 emulator/debugger, written in C++ for Windows and Linux.

-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 on our [**website**](https://rpcs3.net/). Game info is being populated on the [**Wiki**](https://wiki.rpcs3.net/).
+For discussion about this emulator, PS3 emulation, and game compatibility reports, please visit our [**forums**](https://forums.rpcs3.net) and our [**Discord server**](https://discord.me/RPCS3).
+
+[**Support Lead Developers Nekotekina and kd-11 on Patreon**](https://www.patreon.com/Nekotekina)


-### Development
+## Contributing

-If you want to contribute please take a look at the [Coding Style](https://github.com/RPCS3/rpcs3/wiki/Coding-Style), [Roadmap](https://github.com/RPCS3/rpcs3/wiki/Roadmap) and [Developer Information](https://github.com/RPCS3/rpcs3/wiki/Developer-Information) pages. You should as well contact any of the developers in the forum in order to know about the current situation of the emulator.
+If you want to help the project but do not code, the best way to help out is to test games and make bug reports. See:
+* [Quickstart](https://rpcs3.net/quickstart)
+
+If you want to contribute as a developer, please take a look at the following pages:
+
+* [Coding Style](https://github.com/RPCS3/rpcs3/wiki/Coding-Style)
+* [Developer Information](https://github.com/RPCS3/rpcs3/wiki/Developer-Information)
+* [Roadmap](https://rpcs3.net/roadmap)
+
+You should also contact any of the developers in the forums or in the Discord server to learn more about the current state of the emulator.


-### Dependencies
+## Dependencies

-__Windows__
-* [Visual Studio 2015](https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx)
-* [Visual C++ Redistributable Packages for Visual Studio 2015](http://www.microsoft.com/en-us/download/details.aspx?id=48145)
-* [Cmake 3.1.0+](http://www.cmake.org/download/) (required; add to PATH)
-* [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`
-* Arch: `sudo pacman -S glew openal wxgtk cmake llvm`
-
-__Mac OSX__
-* 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
+### Windows
+* [Visual Studio 2017](https://www.visualstudio.com/en/downloads/)
+* [Visual C++ Redistributable Packages for Visual Studio 2017](https://go.microsoft.com/fwlink/?LinkId=746572)
+* [CMake 3.8.2+](https://www.cmake.org/download/) (add to PATH)
+* [Python 3.3+](https://www.python.org/downloads/) (add to PATH)
+* [Vulkan SDK](https://vulkan.lunarg.com/sdk/home) (See "Install the SDK" [here](https://vulkan.lunarg.com/doc/sdk/latest/windows/getting_started.html))
+* [Qt 5.10+](https://www.qt.io/download-open-source/) (Avoid 5.11.1, due to a bug)


-### Building
+**Either add the** `QTDIR` **environment variable, e.g.** `<QtInstallFolder>\5.11.2\msvc2017_64\` **, or use the [Visual Studio Qt Plugin](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.QtVisualStudioTools-19123)**
+
+### Linux
+* [Qt 5.10+](https://www.qt.io/download-open-source/) (Avoid 5.11.1, due to a bug)
+* GCC 7.3+ or Clang 5.0+
+* CMake 3.8.2+
+* Debian & Ubuntu: `sudo apt-get install cmake build-essential libasound2-dev libpulse-dev libopenal-dev libglew-dev zlib1g-dev libedit-dev libvulkan-dev libudev-dev git qt5-default libevdev-dev`
+* Arch: `sudo pacman -S glew openal cmake vulkan-validation-layers qt5-base qt5-declarative`
+* Fedora: `sudo dnf install alsa-lib-devel cmake glew glew-devel libatomic libevdev-devel libudev-devel openal-devel qt5-devel vulkan-devel`
+* OpenSUSE: `sudo zypper install git cmake libasound2 libpulse-devel openal-soft-devel glew-devel zlib-devel libedit-devel vulkan-devel libudev-devel libqt5-qtbase-devel libevdev-devel`
+
+**If you have an NVIDIA GPU, you may need to install the libglvnd package.**
+
+
+## Building
+
+Only Windows and Linux are officially supported for building. However, various other platforms are capable of building RPCS3. Other instructions may be found [here](https://wiki.rpcs3.net/index.php?title=Building).
+
+Clone and initialize the repository:
+
+1) `git clone https://github.com/RPCS3/rpcs3.git`
+2) `cd rpcs3/`
+3) `git submodule update --init`
+
+### Windows
+#### Configuring the Qt plugin (if used)
+
+1) Go to the Qt5 menu and edit Qt5 options.
+2) Add the path to your Qt installation with compiler e.g. `<QtInstallFolder>\5.11.2\msvc2017_64`.
+3) While selecting the rpcs3qt project, go to Qt5->Project Setting and select the version you added.
+
+#### Building the projects
+
+Open `rpcs3.sln`. The recommended build configuration is `Release - LLVM` for all purposes.
+
+You may want to download precompiled [LLVM libs](https://github.com/RPCS3/llvm/releases/download/continuous-master/llvmlibs.7z) and extract to root rpcs3 folder (which contains `rpcs3.sln`), as well as download and extract [additional libs](https://drive.google.com/uc?export=download&id=1A2eOMmCO714i0U7J0qI4aEMKnuWl8l_R) to `lib\%CONFIGURATION%-x64\` to speed up compilation time (unoptimised/debug libs are currently not available precompiled).
+
+If you're not using precompiled libs, build the projects in *__BUILD_BEFORE* folder: right-click on every project > *Build*.
+
+
+`Build > Build Solution`
+
+
+### Linux
+
+While still in the project root:
+
+1) `cd .. && mkdir rpcs3_build && cd rpcs3_build`
+2) `cmake ../rpcs3/ && make GitVersion && make`
+3) Run RPCS3 with `./bin/rpcs3`

-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`.
-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`).
+If desired, use the various build options in [CMakeLists](https://github.com/RPCS3/rpcs3/blob/master/CMakeLists.txt).

-##### CMake Build Options (Linux & Mac OSX)
+## License

- ```-DUSE_SYSTEM_LIBPNG=ON/OFF``` (default = *OFF*) </br>
-Build against the shared libpng instead of using the builtin one. libpng 1.6+ highly recommended. Try this option if you get version conflict errors or only see black game icons.
-
- ```-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)
+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.
@@ -1,73 +0,0 @@
-#include "stdafx.h"
-#include "Config.h"
-#include "Emu/System.h"
-#include "AutoPause.h"
-
-cfg::bool_entry g_cfg_debug_autopause_syscall(cfg::root.misc, "Auto Pause at System Call");
-cfg::bool_entry g_cfg_debug_autopause_func_call(cfg::root.misc, "Auto Pause at Function Call");
-
-debug::autopause& debug::autopause::get_instance()
-{
-	// Use magic static
-	static autopause instance;
-	return instance;
-}
-
-// Load Auto Pause Configuration from file "pause.bin"
-void debug::autopause::reload(void)
-{
-	auto& instance = get_instance();
-
-	instance.m_pause_function.clear();
-	instance.m_pause_syscall.clear();
-
-	// TODO: better format, possibly a config entry
-	if (fs::file list{ fs::get_config_dir() + "pause.bin" })
-	{
-		u32 num;
-		size_t fmax = list.size();
-		size_t fcur = 0;
-		list.seek(0);
-		while (fcur <= fmax - sizeof(u32))
-		{
-			list.read(&num, sizeof(u32));
-			fcur += sizeof(u32);
-			if (num == 0xFFFFFFFF) break;
-			
-			if (num < 1024)
-			{
-				instance.m_pause_syscall.emplace(num);
-				LOG_WARNING(HLE, "Set autopause at syscall %lld", num);
-			}
-			else
-			{
-				instance.m_pause_function.emplace(num);
-				LOG_WARNING(HLE, "Set autopause at function 0x%08x", num);
-			}
-		}
-	}
-}
-
-bool debug::autopause::pause_syscall(u64 code)
-{
-	if (g_cfg_debug_autopause_syscall && get_instance().m_pause_syscall.count(code) != 0)
-	{
-		Emu.Pause();
-		LOG_SUCCESS(HLE, "Autopause triggered at syscall %lld", code);
-		return true;
-	}
-
-	return false;
-}
-
-bool debug::autopause::pause_function(u32 code)
-{
-	if (g_cfg_debug_autopause_func_call && get_instance().m_pause_function.count(code) != 0)
-	{
-		Emu.Pause();
-		LOG_SUCCESS(HLE, "Autopause triggered at function 0x%08x", code);
-		return true;
-	}
-
-	return false;
-}
@@ -1,22 +0,0 @@
-#pragma once
-
-#include <unordered_set>
-
-// Regarded as a Debugger Enchantment
-namespace debug
-{
-	// To store the pause function/call id, and let those pause there.
-	// Would be with a GUI to configure those.
-	class autopause
-	{
-		std::unordered_set<u64> m_pause_syscall;
-		std::unordered_set<u32> m_pause_function;
-
-		static autopause& get_instance();
-	public:
-
-		static void reload();
-		static bool pause_syscall(u64 code);
-		static bool pause_function(u32 code);
-	};
-}
@@ -1,56 +1,59 @@
 #pragma once

 #include "types.h"
-#include "Platform.h"
+#include <cstring>

+// 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 +83,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 +96,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 +111,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 +119,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 +279,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 +300,72 @@ 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)
+template <typename T, std::size_t N, std::size_t M>
+struct offset32_array<v128::masked_array_t<T, N, M>>
+{
+	template <typename Arg>
+	static inline u32 index32(const Arg& arg)
+	{
+		return u32{sizeof(T)} * (static_cast<u32>(arg) ^ static_cast<u32>(M));
+	}
+};
+
+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");
+	struct type
+	{
+		alignas(Align) std::byte data[Size];
+	};
+
+	// 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;
+	}
 };

-template<typename T>
-struct se_storage<T, 2>
+template <typename T>
+struct se_storage<T, 2, 2>
 {
 	using type = u16;

@@ -359,8 +390,8 @@ struct se_storage<T, 2>
 	}
 };

-template<typename T>
-struct se_storage<T, 4>
+template <typename T>
+struct se_storage<T, 4, 4>
 {
 	using type = u32;

@@ -385,8 +416,8 @@ struct se_storage<T, 4>
 	}
 };

-template<typename T>
-struct se_storage<T, 8>
+template <typename T>
+struct se_storage<T, 8, 8>
 {
 	using type = u64;

@@ -411,14 +442,14 @@ struct se_storage<T, 8>
 	}
 };

-template<typename T>
-struct se_storage<T, 16>
+template <typename T>
+struct se_storage<T, 16, 16>
 {
 	using type = v128;

 	static inline v128 swap(const v128& src)
 	{
-		return v128::fromV(_mm_shuffle_epi8(src.vi, _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)));
+		return v128::from64(se_storage<u64>::swap(src._u64[1]), se_storage<u64>::swap(src._u64[0]));
 	}

 	static inline v128 to(const T& src)
@@ -433,41 +464,13 @@ struct se_storage<T, 16>
 	}
 };

-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)
-	{
-		return data;
-	}
-
-	static inline stype_to convert(const stype_from& data, ...)
-	{
-		return storage_to::to(storage_from::from(data));
-	}
-};
-
-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 +479,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 +488,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 +507,137 @@ 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;
+
+	static stype init(type value)
+	{
+		stype result;
+		std::memcpy(&result, &value, sizeof(result));
+		return result;
+	}

 public:
 	se_t() = default;

-	constexpr se_t(type value)
-		: m_data(value)
+	se_t(type value)
+		: m_data(init(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
 	{
+		type result;
+		std::memcpy(&result, &m_data, sizeof(result));
+		return result;
 	}

-	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;
+		std::memcpy(&m_data, &value, sizeof(m_data));
+		return *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 value();
 	}
 };

-// 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 +645,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 +654,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 +767,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
@@ -7,15 +7,19 @@ 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));
+
+	// All ones mask
+	static constexpr utype mask1 = static_cast<utype>(~utype{});

 protected:
 	type m_data;
@@ -27,14 +31,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>(static_cast<utype>(bf_t::mask1 >> (bf_t::bitmax - bf_t::bitsize)) << bitpos);
 	}

 	// Bitfield extraction helper
@@ -50,7 +55,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 +65,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 +78,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 +90,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 +102,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 +120,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 +147,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 +170,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 +248,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);
+	}
+};
@@ -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;
-};
@@ -0,0 +1,243 @@
+#pragma once
+
+#include <Utilities/types.h>
+
+#ifdef _WIN32
+#include "windows.h"
+#include "tlhelp32.h"
+#else
+#include "stdlib.h"
+#include "sys/times.h"
+#include "sys/types.h"
+#include "unistd.h"
+#endif
+
+#ifdef __APPLE__
+# include <mach/mach_init.h>
+# include <mach/task.h>
+# include <mach/vm_map.h>
+#endif
+
+#ifdef __linux__
+# include <dirent.h>
+#endif
+
+#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+# include <sys/sysctl.h>
+# if defined(__DragonFly__) || defined(__FreeBSD__)
+#  include <sys/user.h>
+# endif
+
+# if defined(__NetBSD__)
+#  undef KERN_PROC
+#  define KERN_PROC KERN_PROC2
+#  define kinfo_proc kinfo_proc2
+# endif
+
+# if defined(__DragonFly__)
+#  define KP_NLWP(kp) (kp.kp_nthreads)
+# elif defined(__FreeBSD__)
+#  define KP_NLWP(kp) (kp.ki_numthreads)
+# elif defined(__NetBSD__)
+#  define KP_NLWP(kp) (kp.p_nlwps)
+# endif
+#endif
+
+class CPUStats
+{
+#ifdef _WIN32
+	HANDLE m_self;
+	using time_type = ULARGE_INTEGER;
+#else
+	using time_type = clock_t;
+#endif
+
+private:
+	s32 m_num_processors;
+	time_type m_last_cpu, m_sys_cpu, m_usr_cpu;
+
+public:
+	CPUStats()
+	{
+#ifdef _WIN32
+		SYSTEM_INFO sysInfo;
+		FILETIME ftime, fsys, fuser;
+
+		GetSystemInfo(&sysInfo);
+		m_num_processors = sysInfo.dwNumberOfProcessors;
+
+		GetSystemTimeAsFileTime(&ftime);
+		memcpy(&m_last_cpu, &ftime, sizeof(FILETIME));
+
+		m_self = GetCurrentProcess();
+		GetProcessTimes(m_self, &ftime, &ftime, &fsys, &fuser);
+		memcpy(&m_sys_cpu, &fsys, sizeof(FILETIME));
+		memcpy(&m_usr_cpu, &fuser, sizeof(FILETIME));
+#else
+		struct tms timeSample;
+
+		m_last_cpu = times(&timeSample);
+		m_sys_cpu  = timeSample.tms_stime;
+		m_usr_cpu  = timeSample.tms_utime;
+		m_num_processors = sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+	}
+
+	double get_usage()
+	{
+#ifdef _WIN32
+		FILETIME ftime, fsys, fusr;
+		ULARGE_INTEGER now, sys, usr;
+
+		GetSystemTimeAsFileTime(&ftime);
+		memcpy(&now, &ftime, sizeof(FILETIME));
+
+		GetProcessTimes(m_self, &ftime, &ftime, &fsys, &fusr);
+		memcpy(&sys, &fsys, sizeof(FILETIME));
+		memcpy(&usr, &fusr, sizeof(FILETIME));
+		double percent = double(sys.QuadPart - m_sys_cpu.QuadPart) + (usr.QuadPart - m_usr_cpu.QuadPart);
+		percent /= (now.QuadPart - m_last_cpu.QuadPart);
+		percent /= m_num_processors;
+
+		m_last_cpu = now;
+		m_usr_cpu  = usr;
+		m_sys_cpu  = sys;
+
+		return std::clamp(percent * 100, 0.0, 100.0);
+#else
+		struct tms timeSample;
+		clock_t now;
+		double percent;
+
+		now = times(&timeSample);
+		if (now <= m_last_cpu || timeSample.tms_stime < m_sys_cpu || timeSample.tms_utime < m_usr_cpu)
+		{
+			// Overflow detection. Just skip this value.
+			percent = -1.0;
+		}
+		else
+		{
+			percent = (timeSample.tms_stime - m_sys_cpu) + (timeSample.tms_utime - m_usr_cpu);
+			percent /= (now - m_last_cpu);
+			percent /= m_num_processors;
+			percent *= 100;
+		}
+		m_last_cpu = now;
+		m_sys_cpu  = timeSample.tms_stime;
+		m_usr_cpu  = timeSample.tms_utime;
+
+		return percent;
+#endif
+	}
+
+	static u32 get_thread_count()
+	{
+#ifdef _WIN32
+		// first determine the id of the current process
+		DWORD const id = GetCurrentProcessId();
+
+		// then get a process list snapshot.
+		HANDLE const snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
+
+		// initialize the process entry structure.
+		PROCESSENTRY32 entry = {0};
+		entry.dwSize         = sizeof(entry);
+
+		// get the first process info.
+		BOOL ret = true;
+		ret      = Process32First(snapshot, &entry);
+		while (ret && entry.th32ProcessID != id)
+		{
+			ret = Process32Next(snapshot, &entry);
+		}
+		CloseHandle(snapshot);
+		return ret ? entry.cntThreads : 0;
+#elif defined(__APPLE__)
+		const task_t task = mach_task_self();
+		mach_msg_type_number_t thread_count;
+		thread_act_array_t thread_list;
+		if (task_threads(task, &thread_list, &thread_count) != KERN_SUCCESS)
+		{
+			return 0;
+		}
+		vm_deallocate(task, reinterpret_cast<vm_address_t>(thread_list),
+			      sizeof(thread_t) * thread_count);
+		return static_cast<u32>(thread_count);
+#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
+		int mib[] = {
+			CTL_KERN,
+			KERN_PROC,
+			KERN_PROC_PID,
+			getpid(),
+#if defined(__NetBSD__)
+			sizeof(struct kinfo_proc),
+			1,
+#endif
+		};
+		u_int miblen = std::size(mib);
+		struct kinfo_proc info;
+		size_t size = sizeof(info);
+		if (sysctl(mib, miblen, &info, &size, NULL, 0))
+		{
+			return 0;
+		}
+		return KP_NLWP(info);
+#elif defined(__OpenBSD__)
+		int mib[] = {
+			CTL_KERN,
+			KERN_PROC,
+			KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
+			getpid(),
+			sizeof(struct kinfo_proc),
+			0,
+		};
+		u_int miblen = std::size(mib);
+
+		// get number of structs
+		size_t size;
+		if (sysctl(mib, miblen, NULL, &size, NULL, 0))
+		{
+			return 0;
+		}
+		mib[5] = size / mib[4];
+
+		// populate array of structs
+		struct kinfo_proc info[mib[5]];
+		if (sysctl(mib, miblen, &info, &size, NULL, 0))
+		{
+			return 0;
+		}
+
+		// exclude empty members
+		u32 thread_count{0};
+		for (int i = 0; i < size / mib[4]; i++)
+		{
+			if (info[i].p_tid != -1)
+				++thread_count;
+		}
+		return thread_count;
+#elif defined(__linux__)
+		u32 thread_count{0};
+
+		DIR* proc_dir = opendir("/proc/self/task");
+		if (proc_dir)
+		{
+			// proc available, iterate through tasks and count them
+			struct dirent* entry;
+			while ((entry = readdir(proc_dir)) != NULL)
+			{
+				if (entry->d_name[0] == '.')
+					continue;
+
+				++thread_count;
+			}
+
+			closedir(proc_dir);
+		}
+		return thread_count;
+#else
+		// unimplemented
+		return 0;
+#endif
+	}
+};
@@ -3,54 +3,54 @@

 #include "yaml-cpp/yaml.h"

+#include <typeinfo>
+
 namespace cfg
 {
-	logs::channel cfg("CFG", logs::level::notice);
-
-	entry_base::entry_base(type _type)
+	_base::_base(type _type)
 		: m_type(_type)
 	{
 		if (_type != type::node)
 		{
-			throw std::logic_error("Invalid root node");
+			fmt::throw_exception<std::logic_error>("Invalid root node" HERE);
 		}
 	}

-	entry_base::entry_base(type _type, node& owner, const std::string& name)
+	_base::_base(type _type, node* owner, const std::string& name)
 		: m_type(_type)
 	{
-		if (!owner.m_nodes.emplace(name, this).second)
+		for (const auto& pair : owner->m_nodes)
 		{
-			throw std::logic_error("Node already exists");
+			if (pair.first == name)
+			{
+				fmt::throw_exception<std::logic_error>("Node already exists: %s" HERE, name);
+			}
 		}
+
+		owner->m_nodes.emplace_back(name, this);
 	}

-	entry_base& entry_base::operator[](const std::string& name) const
+	bool _base::from_string(const std::string&)
 	{
-		if (m_type == type::node)
-		{
-			return *static_cast<const node&>(*this).m_nodes.at(name);
-		}
-
-		throw std::logic_error("Invalid node type");
+		fmt::throw_exception<std::logic_error>("from_string() purecall" HERE);
 	}

-	entry_base& entry_base::operator[](const char* name) const
+	bool _base::from_list(std::vector<std::string>&&)
 	{
-		if (m_type == type::node)
-		{
-			return *static_cast<const node&>(*this).m_nodes.at(name);
-		}
-
-		throw std::logic_error("Invalid node type");
+		fmt::throw_exception<std::logic_error>("from_list() purecall" HERE);
 	}

 	// Emit YAML
-	static void encode(YAML::Emitter& out, const class entry_base& rhs);
+	static void encode(YAML::Emitter& out, const class _base& rhs);

 	// Incrementally load config entries from YAML::Node.
 	// The config value is preserved if the corresponding YAML node doesn't exist.
-	static void decode(const YAML::Node& data, class entry_base& rhs);
+	static void decode(const YAML::Node& data, class _base& rhs);
+}
+
+std::vector<std::string> cfg::make_int_range(s64 min, s64 max)
+{
+	return {std::to_string(min), std::to_string(max)};
 }

 bool cfg::try_to_int64(s64* out, const std::string& value, s64 min, s64 max)
@@ -65,19 +65,19 @@ bool cfg::try_to_int64(s64* out, const std::string& value, s64 min, s64 max)
 	}
 	catch (const std::exception& e)
 	{
-		if (out) cfg.error("cfg::try_to_int('%s'): exception: %s", value, e.what());
+		if (out) LOG_ERROR(GENERAL, "cfg::try_to_int('%s'): exception: %s", value, e.what());
 		return false;
 	}

 	if (pos != value.size())
 	{
-		if (out) cfg.error("cfg::try_to_int('%s'): unexpected characters (pos=%zu)", value, pos);
+		if (out) LOG_ERROR(GENERAL, "cfg::try_to_int('%s'): unexpected characters (pos=%zu)", value, pos);
 		return false;
 	}

 	if (result < min || result > max)
 	{
-		if (out) cfg.error("cfg::try_to_int('%s'): out of bounds (%lld..%lld)", value, min, max);
+		if (out) LOG_ERROR(GENERAL, "cfg::try_to_int('%s'): out of bounds (%lld..%lld)", value, min, max);
 		return false;
 	}

@@ -85,7 +85,81 @@ bool cfg::try_to_int64(s64* out, const std::string& value, s64 min, s64 max)
 	return true;
 }

-void cfg::encode(YAML::Emitter& out, const cfg::entry_base& rhs)
+bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) func, const std::string& value)
+{
+	u64 max = -1;
+
+	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;
+		}
+
+		max = i;
+	}
+
+	try
+	{
+		std::size_t pos;
+		const auto val = std::stoull(value, &pos, 0);
+
+		if (pos != value.size())
+		{
+			if (out) LOG_ERROR(GENERAL, "cfg::try_to_enum_value('%s'): unexpected characters (pos=%zu)", value, pos);
+			return false;
+		}
+
+		if (val > max)
+		{
+			if (out) LOG_ERROR(GENERAL, "cfg::try_to_enum_value('%s'): out of bounds(0..%u)", value, max);
+			return false;
+		}
+
+		if (out) *out = val;
+		return true;
+	}
+	catch (const std::exception& e)
+	{
+		if (out) LOG_ERROR(GENERAL, "cfg::try_to_enum_value('%s'): invalid enum value: %s", value, e.what());
+		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::_base& rhs)
 {
 	switch (rhs.get_type())
 	{
@@ -95,7 +169,8 @@ void cfg::encode(YAML::Emitter& out, const cfg::entry_base& rhs)
 		for (const auto& np : static_cast<const node&>(rhs).get_nodes())
 		{
 			out << YAML::Key << np.first;
-			out << YAML::Value; encode(out, *np.second);
+			out << YAML::Value;
+			encode(out, *np.second);
 		}

 		out << YAML::EndMap;
@@ -112,12 +187,28 @@ void cfg::encode(YAML::Emitter& out, const cfg::entry_base& rhs)
 		out << YAML::EndSeq;
 		return;
 	}
-	}
+	case type::log:
+	{
+		out << YAML::BeginMap;
+		for (const auto& np : static_cast<const log_entry&>(rhs).get_map())
+		{
+			if (np.second == logs::level::notice) continue;
+			out << YAML::Key << np.first;
+			out << YAML::Value << fmt::format("%s", np.second);
+		}

-	out << rhs.to_string();
+		out << YAML::EndMap;
+		return;
+	}
+	default:
+	{
+		out << rhs.to_string();
+		return;
+	}
+	}
 }

-void cfg::decode(const YAML::Node& data, cfg::entry_base& rhs)
+void cfg::decode(const YAML::Node& data, cfg::_base& rhs)
 {
 	switch (rhs.get_type())
 	{
@@ -133,16 +224,12 @@ void cfg::decode(const YAML::Node& data, cfg::entry_base& rhs)
 			if (!pair.first.IsScalar()) continue;

 			// Find the key among existing nodes
-			const auto name = pair.first.Scalar();
-			const auto found = static_cast<node&>(rhs).get_nodes().find(name);
-
-			if (found != static_cast<node&>(rhs).get_nodes().cend())
+			for (const auto& _pair : static_cast<node&>(rhs).get_nodes())
 			{
-				decode(pair.second, *found->second);
-			}
-			else
-			{
-				// ???
+				if (_pair.first == pair.first.Scalar())
+				{
+					decode(pair.second, *_pair.second);
+				}
 			}
 		}

@@ -159,6 +246,29 @@ void cfg::decode(const YAML::Node& data, cfg::entry_base& rhs)

 		break;
 	}
+	case type::log:
+	{
+		if (data.IsScalar() || data.IsSequence())
+		{
+			return; // ???
+		}
+
+		std::map<std::string, logs::level> values;
+
+		for (const auto& pair : data)
+		{
+			if (!pair.first.IsScalar() || !pair.second.IsScalar()) continue;
+
+			u64 value;
+			if (cfg::try_to_enum_value(&value, &fmt_class_string<logs::level>::format, pair.second.Scalar()))
+			{
+				values.emplace(pair.first.Scalar(), static_cast<logs::level>(static_cast<int>(value)));
+			}
+		}
+
+		static_cast<log_entry&>(rhs).set_map(std::move(values));
+		break;
+	}
 	default:
 	{
 		std::string value;
@@ -178,14 +288,19 @@ std::string cfg::node::to_string() const
 	YAML::Emitter out;
 	cfg::encode(out, *this);

-	return{ out.c_str(), out.size() };
+	return {out.c_str(), out.size()};
 }

-bool cfg::node::from_string(const std::string& value)
+bool cfg::node::from_string(const std::string& value) try
 {
 	cfg::decode(YAML::Load(value), *this);
 	return true;
 }
+catch (const std::exception& e)
+{
+	LOG_FATAL(GENERAL, "%s thrown: %s", typeid(e).name(), e.what());
+	return false;
+}

 void cfg::node::from_default()
 {
@@ -195,9 +310,32 @@ void cfg::node::from_default()
 	}
 }

-cfg::root_node& cfg::get_root()
+void cfg::_bool::from_default()
 {
-	// Magic static
-	static root_node root;
-	return root;
+	m_value = def;
+}
+
+void cfg::string::from_default()
+{
+	m_value = def;
+}
+
+void cfg::set_entry::from_default()
+{
+	m_set = {};
+}
+
+void cfg::log_entry::set_map(std::map<std::string, logs::level>&& map)
+{
+	logs::reset();
+
+	for (auto&& pair : (m_map = std::move(map)))
+	{
+		logs::set_level(pair.first, pair.second);
+	}
+}
+
+void cfg::log_entry::from_default()
+{
+	set_map({});
 }
@@ -1,57 +1,61 @@
 #pragma once

 #include "Utilities/types.h"
-#include "Utilities/Atomic.h"
+#include "Utilities/StrFmt.h"
+#include "Utilities/Log.h"

-#include <initializer_list>
-#include <exception>
 #include <utility>
 #include <string>
 #include <vector>
 #include <set>
-#include <unordered_map>
 #include <map>
-#include <mutex>

 namespace cfg
 {
+	// Format min and max values
+	std::vector<std::string> make_int_range(s64 min, s64 max);
+
 	// 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
 	{
 		node = 0, // cfg::node type
-		boolean, // cfg::bool_entry type
-		fixed_map, // cfg::map_entry type
-		enumeration, // cfg::enum_entry type
-		integer, // cfg::int_entry type
-		string, // cfg::string_entry type
+		_bool, // cfg::_bool type
+		_enum, // cfg::_enum type
+		_int, // cfg::_int type
+		string, // cfg::string type
 		set, // cfg::set_entry type
+		log,
 	};

 	// Config tree entry abstract base class
-	class entry_base
+	class _base
 	{
 		const type m_type;

 	protected:
 		// Ownerless entry constructor
-		entry_base(type _type);
+		_base(type _type);

 		// Owned entry constructor
-		entry_base(type _type, class node& owner, const std::string& name);
+		_base(type _type, class node* owner, const std::string& name);

 	public:
-		// Disallow copy/move constructors and assignments
-		entry_base(const entry_base&) = delete;
+		_base(const _base&) = delete;
+
+		_base& operator=(const _base&) = delete;

 		// Get type
 		type get_type() const { return m_type; }

-		// Access child node (must exist)
-		entry_base& operator [](const std::string& name) const; entry_base& operator [](const char* name) const;
-
 		// Reset defaults
 		virtual void from_default() = 0;

@@ -62,10 +66,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,34 +75,31 @@ 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
-	class node : public entry_base
+	class node : public _base
 	{
-		std::map<std::string, entry_base*> m_nodes;
+		std::vector<std::pair<std::string, _base*>> m_nodes;

-		friend class entry_base;
+		friend class _base;

 	public:
 		// Root node constructor
 		node()
-			: entry_base(type::node)
+			: _base(type::node)
 		{
 		}

 		// Registered node constructor
-		node(node& owner, const std::string& name)
-			: entry_base(type::node, owner, name)
+		node(node* owner, const std::string& name)
+			: _base(type::node, owner, name)
 		{
 		}

 		// Get child nodes
-		const std::map<std::string, entry_base*>& get_nodes() const
+		const auto& get_nodes() const
 		{
 			return m_nodes;
 		}
@@ -116,163 +114,66 @@ namespace cfg
 		void from_default() override;
 	};

-	struct bool_entry final : public entry_base
+	class _bool final : public _base
 	{
-		atomic_t<bool> value;
+		bool m_value;

-		const bool def;
+	public:
+		bool def;

-		bool_entry(node& owner, const std::string& name, bool def = false)
-			: entry_base(type::boolean, owner, name)
-			, value(def)
+		_bool(node* owner, const std::string& name, bool def = false)
+			: _base(type::_bool, owner, name)
+			, m_value(def)
 			, def(def)
 		{
 		}

 		explicit operator bool() const
 		{
-			return value.load();
+			return m_value;
 		}

-		bool_entry& operator =(bool value)
+		bool get() const
 		{
-			value = value;
-			return *this;
+			return m_value;
 		}

-		void from_default() override
-		{
-			value = def;
-		}
+		void from_default() override;

 		std::string to_string() const override
 		{
-			return value.load() ? "true" : "false";
+			return m_value ? "true" : "false";
 		}

 		bool from_string(const std::string& value) override
 		{
 			if (value == "false")
-				this->value = false;
+				m_value = false;
 			else if (value == "true")
-				this->value = true;
+				m_value = true;
 			else
 				return false;

 			return true;
 		}
-	};

-	// Value node with fixed set of possible values, each maps to a value of type T.
-	template<typename T>
-	struct map_entry final : public entry_base
-	{
-		using init_type  = std::initializer_list<std::pair<std::string, T>>;
-		using map_type   = std::unordered_map<std::string, T>;
-		using list_type  = std::vector<std::string>;
-		using value_type = typename map_type::value_type;
-
-		static map_type make_map(init_type init)
+		void set(const bool& value)
 		{
-			map_type map(init.size());
-
-			for (const auto& v : init)
-			{
-				// Ensure elements are unique
-				VERIFY(map.emplace(v.first, v.second).second);
-			}
-
-			return map;
-		}
-
-		static list_type make_list(init_type init)
-		{
-			list_type list; list.reserve(init.size());
-
-			for (const auto& v : init)
-			{
-				list.emplace_back(v.first);
-			}
-
-			return list;
-		}
-
-	public:
-		const map_type map;
-		const list_type list; // Element list sorted in original order
-		const value_type& def; // Pointer to the default value
-
-	private:
-		atomic_t<const value_type*> m_value;
-
-	public:
-		map_entry(node& owner, const std::string& name, const std::string& def, init_type init)
-			: entry_base(type::fixed_map, owner, name)
-			, map(make_map(init))
-			, list(make_list(init))
-			, def(*map.find(def))
-			, m_value(&this->def)
-		{
-		}
-
-		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(node& owner, const std::string& name, init_type init)
-			: map_entry(owner, name, 0, init)
-		{
-		}
-
-		const T& get() const
-		{
-			return m_value.load()->second;
-		}
-
-		void from_default() override
-		{
-			m_value = &def;
-		}
-
-		std::string to_string() const override
-		{
-			return m_value.load()->first;
-		}
-
-		bool from_string(const std::string& value) override
-		{
-			const auto found = map.find(value);
-
-			if (found == map.end())
-			{
-				return false;
-			}
-			else
-			{
-				m_value = &*found;
-				return true;
-			}
-		}
-
-		std::vector<std::string> to_list() const override
-		{
-			return list;
+			m_value = value;
 		}
 	};

 	// Value node with fixed set of possible values, each maps to an enum value of type T.
-	template<typename T, bool External = false>
-	class enum_entry final : public entry_base
+	template <typename T>
+	class _enum final : public _base
 	{
-		// Value or reference
-		std::conditional_t<External, atomic_t<T>&, atomic_t<T>> m_value;
+		T m_value;

 	public:
 		const T def;

-		enum_entry(node& owner, const std::string& name, std::conditional_t<External, atomic_t<T>&, T> value)
-			: entry_base(type::enumeration, owner, name)
+		_enum(node* owner, const std::string& name, T value = {})
+			: _base(type::_enum, owner, name)
 			, m_value(value)
 			, def(value)
 		{
@@ -280,13 +181,12 @@ namespace cfg

 		operator T() const
 		{
-			return m_value.load();
+			return m_value;
 		}

-		enum_entry& operator =(T value)
+		T get() const
 		{
-			m_value = value;
-			return *this;
+			return m_value;
 		}

 		void from_default() override
@@ -296,26 +196,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,33 +217,26 @@ 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);
 		}
 	};

 	// Signed 32/64-bit integer entry with custom Min/Max range.
-	template<s64 Min, s64 Max>
-	class int_entry final : public entry_base
+	template <s64 Min, s64 Max>
+	class _int final : public _base
 	{
-		static_assert(Min < Max, "Invalid cfg::int_entry range");
+		static_assert(Min < Max, "Invalid cfg::_int range");

 		// Prefer 32 bit type if possible
 		using int_type = std::conditional_t<Min >= INT32_MIN && Max <= INT32_MAX, s32, s64>;

-		atomic_t<int_type> m_value;
+		int_type m_value;

 	public:
-		const int_type def;
+		int_type def;

-		int_entry(node& owner, const std::string& name, int_type def = std::min<int_type>(Max, std::max<int_type>(Min, 0)))
-			: entry_base(type::integer, owner, name)
+		_int(node* owner, const std::string& name, int_type def = std::min<int_type>(Max, std::max<int_type>(Min, 0)))
+			: _base(type::_int, owner, name)
 			, m_value(def)
 			, def(def)
 		{
@@ -357,18 +244,12 @@ namespace cfg

 		operator int_type() const
 		{
-			return m_value.load();
+			return m_value;
 		}

-		int_entry& operator =(int_type value)
+		int_type get() const
 		{
-			if (value < Min || value > Max)
-			{
-				throw fmt::exception("Value out of the valid range: %lld" HERE, s64{ value });
-			}
-
-			m_value = value;
-			return *this;
+			return m_value;
 		}

 		void from_default() override
@@ -378,7 +259,7 @@ namespace cfg

 		std::string to_string() const override
 		{
-			return std::to_string(m_value.load());
+			return std::to_string(m_value);
 		}

 		bool from_string(const std::string& value) override
@@ -392,25 +273,34 @@ namespace cfg

 			return false;
 		}
+
+		void set(const s64& value)
+		{
+			m_value = static_cast<int_type>(value);
+		}
+
+		std::vector<std::string> to_list() const override
+		{
+			return make_int_range(Min, Max);
+		}
 	};

 	// Alias for 32 bit int
-	using int32_entry = int_entry<INT32_MIN, INT32_MAX>;
+	using int32 = _int<INT32_MIN, INT32_MAX>;

 	// Alias for 64 bit int
-	using int64_entry = int_entry<INT64_MIN, INT64_MAX>;
+	using int64 = _int<INT64_MIN, INT64_MAX>;

 	// Simple string entry with mutex
-	class string_entry final : public entry_base
+	class string final : public _base
 	{
-		mutable std::mutex m_mutex;
 		std::string m_value;

 	public:
-		const std::string def;
+		std::string def;

-		string_entry(node& owner, const std::string& name, const std::string& def = {})
-			: entry_base(type::string, owner, name)
+		string(node* owner, const std::string& name, const std::string& def = {})
+			: _base(type::string, owner, name)
 			, m_value(def)
 			, def(def)
 		{
@@ -418,115 +308,87 @@ namespace cfg

 		operator std::string() const
 		{
-			std::lock_guard<std::mutex> lock(m_mutex);
 			return m_value;
 		}

-		std::string get() const
+		const std::string& get() const
 		{
-			return *this;
-		}
-
-		string_entry& operator =(const std::string& value)
-		{
-			std::lock_guard<std::mutex> lock(m_mutex);
-			m_value = value;
-			return *this;
+			return m_value;
 		}

 		std::size_t size() const
 		{
-			std::lock_guard<std::mutex> lock(m_mutex);
 			return m_value.size();
 		}

-		void from_default() override
-		{
-			*this = def;
-		}
+		void from_default() override;

 		std::string to_string() const override
 		{
-			std::lock_guard<std::mutex> lock(m_mutex);
 			return m_value;
 		}

 		bool from_string(const std::string& value) override
 		{
-			*this = value;
+			m_value = value;
 			return true;
 		}
 	};

 	// Simple set entry with mutex (TODO: template for various types)
-	class set_entry final : public entry_base
+	class set_entry final : public _base
 	{
-		mutable std::mutex m_mutex;
-
 		std::set<std::string> m_set;

 	public:
 		// Default value is empty list in current implementation
-		set_entry(node& owner, const std::string& name)
-			: entry_base(type::set, owner, name)
+		set_entry(node* owner, const std::string& name)
+			: _base(type::set, owner, name)
 		{
 		}

 		std::set<std::string> get_set() const
 		{
-			std::lock_guard<std::mutex> lock(m_mutex);
-
 			return m_set;
 		}

 		void set_set(std::set<std::string>&& set)
 		{
-			std::lock_guard<std::mutex> lock(m_mutex);
 			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
 		{
-			std::lock_guard<std::mutex> lock(m_mutex);
-
 			return{ m_set.begin(), m_set.end() };
 		}

 		bool from_list(std::vector<std::string>&& list) override
 		{
-			std::lock_guard<std::mutex> lock(m_mutex);
 			m_set = { std::make_move_iterator(list.begin()), std::make_move_iterator(list.end()) };

 			return true;
 		}
 	};

-	// Root type with some predefined nodes. Don't change it, this is not mandatory for adding nodes.
-	struct root_node : node
+	class log_entry final : public _base
 	{
-		node core  { *this, "Core" };
-		node vfs   { *this, "VFS" };
-		node log   { *this, "Log" };
-		node video { *this, "Video" };
-		node audio { *this, "Audio" };
-		node io    { *this, "Input/Output" };
-		node sys   { *this, "System" };
-		node net   { *this, "Net" };
-		node misc  { *this, "Miscellaneous" };
+		std::map<std::string, logs::level> m_map;
+
+	public:
+		log_entry(node* owner, const std::string& name)
+			: _base(type::log, owner, name)
+		{
+		}
+
+		std::map<std::string, logs::level> get_map() const
+		{
+			return m_map;
+		}
+
+		void set_map(std::map<std::string, logs::level>&& map);
+
+		void from_default() override;
 	};
-
-	// Get global configuration root instance
-	extern root_node& get_root();
-
-	// Global configuration root instance (cached reference)
-	static root_node& root = get_root();
 }
-
-// Registered log channel
-#define LOG_CHANNEL(name) extern logs::channel name; namespace logs { static cfg::enum_entry<logs::level, true> name(cfg::root.log, #name, ::name.enabled); }
@@ -1,17 +1,23 @@
 #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
 {
+#ifdef _WIN32
+	using native_handle = void*;
+#else
+	using native_handle = int;
+#endif
+
 	// File open mode flags
-	enum struct open_mode : u32
+	enum class open_mode : u32
 	{
 		read,
 		write,
@@ -19,16 +25,22 @@ namespace fs
 		create,
 		trunc,
 		excl,
+		lock,
+		unread,
+
+		__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 auto lock    = +open_mode::lock; // Prevent opening the file more than once
+	constexpr auto unread  = +open_mode::unread; // Aggressively prevent reading the opened file (do not use)

-	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
@@ -53,12 +65,19 @@ namespace fs
 		s64 ctime;
 	};

+	// Native handle getter
+	struct get_native_handle
+	{
+		virtual native_handle get() = 0;
+	};
+
 	// File handle base
 	struct file_base
 	{
-		virtual ~file_base() = default;
+		virtual ~file_base();

-		virtual stat_t stat() = 0;
+		virtual stat_t stat();
+		virtual void sync();
 		virtual bool trunc(u64 length) = 0;
 		virtual u64 read(void* buffer, u64 size) = 0;
 		virtual u64 write(const void* buffer, u64 size) = 0;
@@ -75,25 +94,36 @@ 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;
 	};

+	// Device information
+	struct device_stat
+	{
+		u64 block_size;
+		u64 total_size;
+		u64 total_free; // Total size of free space
+		u64 avail_free; // Free space available to unprivileged user
+	};
+
 	// 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 statfs(const std::string& path, device_stat& info) = 0;
 		virtual bool remove_dir(const std::string& path) = 0;
 		virtual bool create_dir(const std::string& path) = 0;
 		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;
 	};

@@ -118,6 +148,9 @@ namespace fs
 	// Check whether the directory exists and is NOT a file
 	bool is_dir(const std::string& path);

+	// Get filesystem information
+	bool statfs(const std::string& path, device_stat& info);
+
 	// Delete empty directory
 	bool remove_dir(const std::string& path);

@@ -128,7 +161,7 @@ namespace fs
 	bool create_path(const std::string& path);

 	// Rename (move) file or directory
-	bool rename(const std::string& from, const std::string& to);
+	bool rename(const std::string& from, const std::string& to, bool overwrite);

 	// Copy file contents
 	bool copy_file(const std::string& from, const std::string& to, bool overwrite);
@@ -139,6 +172,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 +187,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
 		{
@@ -198,6 +236,13 @@ namespace fs
 			return m_file->stat();
 		}

+		// Sync file buffers
+		void sync() const
+		{
+			if (!m_file) xnull();
+			return m_file->sync();
+		}
+
 		// Read the data from the file and return the amount of data written in buffer
 		u64 read(void* buffer, u64 count) const
 		{
@@ -318,6 +363,9 @@ namespace fs
 			if (seek(0), !read(result)) xfail();
 			return result;
 		}
+
+		// Get native handle if available
+		native_handle get_handle() const;
 	};

 	class dir final
@@ -354,7 +402,7 @@ namespace fs
 		{
 			m_dir = std::move(ptr);
 		}
-		
+
 		std::unique_ptr<dir_base> release()
 		{
 			return std::move(m_dir);
@@ -376,7 +424,7 @@ namespace fs

 		class iterator
 		{
-			dir* m_parent;
+			const dir* m_parent;
 			dir_entry m_entry;

 		public:
@@ -386,7 +434,7 @@ namespace fs
 				from_current
 			};

-			iterator(dir* parent, mode mode_ = mode::from_first)
+			iterator(const dir* parent, mode mode_ = mode::from_first)
 				: m_parent(parent)
 			{
 				if (!m_parent)
@@ -412,7 +460,7 @@ namespace fs

 			iterator& operator++()
 			{
-				*this = { m_parent, mode::from_current };
+				*this = {m_parent, mode::from_current};
 				return *this;
 			}

@@ -422,22 +470,22 @@ namespace fs
 			}
 		};

-		iterator begin()
+		iterator begin() const
 		{
-			return{ m_dir ? this : nullptr };
+			return {m_dir ? this : nullptr};
 		}

-		iterator end()
+		iterator end() const
 		{
-			return{ nullptr };
+			return {nullptr};
 		}
 	};

 	// Get configuration directory
 	const std::string& get_config_dir();

-	// Get executable directory
-	const std::string& get_executable_dir();
+	// Get common cache directory
+	const std::string& get_cache_dir();

 	// Delete directory and all its contents recursively
 	void remove_all(const std::string& path, bool remove_root = true);
@@ -452,8 +500,128 @@ namespace fs
 		inval,
 		noent,
 		exist,
+		acces,
+		notempty,
 	};

 	// 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
+		{
+		}
+
+		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
+		{
+			const s64 new_pos =
+				whence == fs::seek_set ? offset :
+				whence == fs::seek_cur ? offset + pos :
+				whence == fs::seek_end ? offset + size() :
+				(fmt::raw_error("fs::container_stream<>::seek(): invalid whence"), 0);
+
+			if (new_pos < 0)
+			{
+				fs::g_tls_error = fs::error::inval;
+				return -1;
+			}
+
+			pos = new_pos;
+			return pos;
+		}
+
+		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;
+	}
+
+	template <typename... Args>
+	bool write_file(const std::string& path, bs_t<fs::open_mode> mode, const Args&... args)
+	{
+		if (fs::file f{path, mode})
+		{
+			// Write args sequentially
+			(f.write(args), ...);
+			return true;
+		}
+
+		return false;
+	}
+
+	file make_gather(std::vector<file>);
 }
@@ -0,0 +1,853 @@
+#include "stdafx.h"
+#ifdef WITH_GDB_DEBUGGER
+
+#include "GDBDebugServer.h"
+#include "Log.h"
+#include <algorithm>
+#include "Emu/Memory/vm.h"
+#include "Emu/System.h"
+#include "Emu/IdManager.h"
+#include "Emu/CPU/CPUThread.h"
+#include "Emu/Cell/PPUThread.h"
+#include "Emu/Cell/RawSPUThread.h"
+#include "Emu/Cell/SPUThread.h"
+
+#ifndef _WIN32
+#include "fcntl.h"
+#endif
+
+extern void ppu_set_breakpoint(u32 addr);
+extern void ppu_remove_breakpoint(u32 addr);
+
+LOG_CHANNEL(gdbDebugServer);
+
+int sock_init(void)
+{
+#ifdef _WIN32
+	WSADATA wsa_data;
+	return WSAStartup(MAKEWORD(1, 1), &wsa_data);
+#else
+	return 0;
+#endif
+}
+
+int sock_quit(void)
+{
+#ifdef _WIN32
+	return WSACleanup();
+#else
+	return 0;
+#endif
+}
+
+#ifndef _WIN32
+int closesocket(socket_t s) {
+	return close(s);
+}
+const int SOCKET_ERROR = -1;
+const socket_t INVALID_SOCKET = -1;
+#define sscanf_s sscanf
+#define HEX_U32 "x"
+#define HEX_U64 "lx"
+#else
+#define HEX_U32 "lx"
+#define HEX_U64 "llx"
+#endif
+
+bool check_errno_again() {
+#ifdef _WIN32
+	int err = GetLastError();
+	return (err == WSAEWOULDBLOCK);
+#else
+	int err = errno;
+	return (err == EAGAIN) || (err == EWOULDBLOCK);
+#endif
+}
+
+std::string u32_to_hex(u32 i) {
+	return fmt::format("%" HEX_U32, i);
+}
+
+std::string u64_to_padded_hex(u64 value) {
+	return fmt::format("%.16" HEX_U64, value);
+}
+
+std::string u32_to_padded_hex(u32 value) {
+	return fmt::format("%.8" HEX_U32, value);
+}
+
+u8 hex_to_u8(std::string val) {
+	u8 result;
+	sscanf_s(val.c_str(), "%02hhX", &result);
+	return result;
+}
+
+u32 hex_to_u32(std::string val) {
+	u32 result;
+	sscanf_s(val.c_str(), "%" HEX_U32, &result);
+	return result;
+}
+
+u64 hex_to_u64(std::string val) {
+	u64 result;
+	sscanf_s(val.c_str(), "%" HEX_U64, &result);
+	return result;
+}
+
+void GDBDebugServer::start_server()
+{
+	server_socket = socket(AF_INET, SOCK_STREAM, 0);
+
+	if (server_socket == INVALID_SOCKET) {
+		gdbDebugServer.error("Error creating server socket");
+		return;
+	}
+
+#ifdef WIN32
+	{
+		int mode = 1;
+		ioctlsocket(server_socket, FIONBIO, (u_long FAR *)&mode);
+	}
+#else
+	fcntl(server_socket, F_SETFL, fcntl(server_socket, F_GETFL) | O_NONBLOCK);
+#endif
+
+	int err;
+
+	sockaddr_in server_saddr;
+	server_saddr.sin_family = AF_INET;
+	int port = g_cfg.misc.gdb_server_port;
+	server_saddr.sin_port = htons(port);
+	server_saddr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+	err = bind(server_socket, (struct sockaddr *) &server_saddr, sizeof(server_saddr));
+	if (err == SOCKET_ERROR) {
+		gdbDebugServer.error("Error binding to port %d", port);
+		return;
+	}
+
+	err = listen(server_socket, 1);
+	if (err == SOCKET_ERROR) {
+		gdbDebugServer.error("Error listening on port %d", port);
+		return;
+	}
+
+	gdbDebugServer.success("GDB Debug Server listening on port %d", port);
+}
+
+int GDBDebugServer::read(void * buf, int cnt)
+{
+	while (!stop) {
+		int result = recv(client_socket, reinterpret_cast<char*>(buf), cnt, 0);
+
+		if (result == SOCKET_ERROR) {
+			if (check_errno_again()) {
+				thread_ctrl::wait_for(50);
+				continue;
+			}
+
+			gdbDebugServer.error("Error during socket read");
+			fmt::throw_exception("Error during socket read" HERE);
+		}
+		return result;
+	}
+	return 0;
+}
+
+char GDBDebugServer::read_char()
+{
+	char result;
+	int cnt = read(&result, 1);
+	if (!cnt) {
+		fmt::throw_exception("Tried to read char, but no data was available" HERE);
+	}
+	return result;
+}
+
+u8 GDBDebugServer::read_hexbyte()
+{
+	std::string s = "";
+	s += read_char();
+	s += read_char();
+	return hex_to_u8(s);
+}
+
+void GDBDebugServer::try_read_cmd(gdb_cmd & out_cmd)
+{
+	char c = read_char();
+	//interrupt
+	if (UNLIKELY(c == 0x03)) {
+		out_cmd.cmd = '\x03';
+		out_cmd.data = "";
+		out_cmd.checksum = 0;
+		return;
+	}
+	if (UNLIKELY(c != '$')) {
+		//gdb starts conversation with + for some reason
+		if (c == '+') {
+			c = read_char();
+		}
+		if (c != '$') {
+			fmt::throw_exception("Expected start of packet character '$', got '%c' instead" HERE, c);
+		}
+	}
+	//clear packet data
+	out_cmd.cmd = "";
+	out_cmd.data = "";
+	out_cmd.checksum = 0;
+	bool cmd_part = true;
+	u8 checksum = 0;
+	while(true) {
+		c = read_char();
+		if (c == '#') {
+			break;
+		}
+		checksum = (checksum + reinterpret_cast<u8&>(c)) % 256;
+		//escaped char
+		if (c == '}') {
+			c = read_char() ^ 0x20;
+			checksum = (checksum + reinterpret_cast<u8&>(c)) % 256;
+		}
+		//cmd-data splitters
+		if (cmd_part && ((c == ':') || (c == '.') || (c == ';'))) {
+			cmd_part = false;
+		}
+		if (cmd_part) {
+			out_cmd.cmd += c;
+			//only q and v commands can have multi-char command
+			if ((out_cmd.cmd.length() == 1) && (c != 'q') && (c != 'v')) {
+				cmd_part = false;
+			}
+		} else {
+			out_cmd.data += c;
+		}
+	}
+	out_cmd.checksum = read_hexbyte();
+	if (out_cmd.checksum != checksum) {
+		throw wrong_checksum_exception("Wrong checksum for packet" HERE);
+	}
+}
+
+bool GDBDebugServer::read_cmd(gdb_cmd & out_cmd)
+{
+	while (true) {
+		try {
+			try_read_cmd(out_cmd);
+			ack(true);
+			return true;
+		}
+		catch (wrong_checksum_exception) {
+			ack(false);
+		}
+		catch (std::runtime_error e) {
+			gdbDebugServer.error(e.what());
+			return false;
+		}
+	}
+}
+
+void GDBDebugServer::send(const char * buf, int cnt)
+{
+	gdbDebugServer.trace("Sending %s (%d bytes)", buf, cnt);
+	while (!stop) {
+		int res = ::send(client_socket, buf, cnt, 0);
+		if (res == SOCKET_ERROR) {
+			if (check_errno_again()) {
+				thread_ctrl::wait_for(50);
+				continue;
+			}
+			gdbDebugServer.error("Failed sending %d bytes", cnt);
+			return;
+		}
+		return;
+	}
+}
+
+void GDBDebugServer::send_char(char c)
+{
+	send(&c, 1);
+}
+
+void GDBDebugServer::ack(bool accepted)
+{
+	send_char(accepted ? '+' : '-');
+}
+
+void GDBDebugServer::send_cmd(const std::string & cmd)
+{
+	u8 checksum = 0;
+	std::string buf;
+	buf.reserve(cmd.length() + 4);
+	buf += "$";
+	for (int i = 0; i < cmd.length(); ++i) {
+		checksum = (checksum + append_encoded_char(cmd[i], buf)) % 256;
+	}
+	buf += "#";
+	buf += to_hexbyte(checksum);
+	send(buf.c_str(), static_cast<int>(buf.length()));
+}
+
+bool GDBDebugServer::send_cmd_ack(const std::string & cmd)
+{
+	while (true) {
+		send_cmd(cmd);
+		char c = read_char();
+		if (LIKELY(c == '+')) {
+			return true;
+		}
+		if (UNLIKELY(c != '-')) {
+			gdbDebugServer.error("Wrong acknowledge character received %c", c);
+			return false;
+		}
+		gdbDebugServer.warning("Client rejected our cmd");
+	}
+}
+
+u8 GDBDebugServer::append_encoded_char(char c, std::string & str)
+{
+	u8 checksum = 0;
+	if (UNLIKELY((c == '#') || (c == '$') || (c == '}'))) {
+		str += '}';
+		c ^= 0x20;
+		checksum = '}';
+	}
+	checksum = (checksum + reinterpret_cast<u8&>(c)) % 256;
+	str += c;
+	return checksum;
+}
+
+std::string GDBDebugServer::to_hexbyte(u8 i)
+{
+	std::string result = "00";
+	u8 i1 = i & 0xF;
+	u8 i2 = i >> 4;
+	result[0] = i2 > 9 ? 'a' + i2 - 10 : '0' + i2;
+	result[1] = i1 > 9 ? 'a' + i1 - 10 : '0' + i1;
+	return result;
+}
+
+bool GDBDebugServer::select_thread(u64 id)
+{
+	//in case we have none at all
+	selected_thread.reset();
+	const auto on_select = [&](u32, cpu_thread& cpu)
+	{
+		return (id == ALL_THREADS) || (id == ANY_THREAD) || (cpu.id == id);
+	};
+	if (auto ppu = idm::select<ppu_thread>(on_select)) {
+		selected_thread = ppu.ptr;
+		return true;
+	}
+	gdbDebugServer.warning("Unable to select thread! Is the emulator running?");
+	return false;
+}
+
+std::string GDBDebugServer::get_reg(std::shared_ptr<ppu_thread> thread, u32 rid)
+{
+	std::string result;
+	//ids from gdb/features/rs6000/powerpc-64.c
+	//pc
+	switch (rid) {
+	case 64:
+		return u64_to_padded_hex(thread->cia);
+	//msr?
+	case 65:
+		return std::string(16, 'x');
+	case 66:
+		return u32_to_padded_hex(thread->cr_pack());
+	case 67:
+		return u64_to_padded_hex(thread->lr);
+	case 68:
+		return u64_to_padded_hex(thread->ctr);
+	//xer
+	case 69:
+		return std::string(8, 'x');
+	//fpscr
+	case 70:
+		return std::string(8, 'x');
+	default:
+		if (rid > 70) return "";
+		return (rid > 31)
+			? u64_to_padded_hex(reinterpret_cast<u64&>(thread->fpr[rid - 32])) //fpr
+			: u64_to_padded_hex(thread->gpr[rid]); //gpr
+	}
+}
+
+bool GDBDebugServer::set_reg(std::shared_ptr<ppu_thread> thread, u32 rid, std::string value)
+{
+	switch (rid) {
+	case 64:
+		thread->cia = static_cast<u32>(hex_to_u64(value));
+		return true;
+		//msr?
+	case 65:
+		return true;
+	case 66:
+		thread->cr_unpack(hex_to_u32(value));
+		return true;
+	case 67:
+		thread->lr = hex_to_u64(value);
+		return true;
+	case 68:
+		thread->ctr = hex_to_u64(value);
+		return true;
+		//xer
+	case 69:
+		return true;
+		//fpscr
+	case 70:
+		return true;
+	default:
+		if (rid > 70) return false;
+		if (rid > 31) {
+			u64 val = hex_to_u64(value);
+			thread->fpr[rid - 32] = reinterpret_cast<f64&>(val);
+		} else {
+			thread->gpr[rid] = hex_to_u64(value);
+		}
+		return true;
+	}
+}
+
+u32 GDBDebugServer::get_reg_size(std::shared_ptr<ppu_thread> thread, u32 rid)
+{
+	switch (rid) {
+	case 66:
+	case 69:
+	case 70:
+		return 4;
+	default:
+		if (rid > 70) {
+			return 0;
+		}
+		return 8;
+	}
+}
+
+bool GDBDebugServer::send_reason()
+{
+	return send_cmd_ack("S05");
+}
+
+void GDBDebugServer::wait_with_interrupts() {
+	char c;
+	while (!paused) {
+		int result = recv(client_socket, &c, 1, 0);
+
+		if (result == SOCKET_ERROR) {
+			if (check_errno_again()) {
+				thread_ctrl::wait_for(50);
+				continue;
+			}
+
+			gdbDebugServer.error("Error during socket read");
+			fmt::throw_exception("Error during socket read" HERE);
+		} else if (c == 0x03) {
+			paused = true;
+		}
+	}
+}
+
+bool GDBDebugServer::cmd_extended_mode(gdb_cmd & cmd)
+{
+	return send_cmd_ack("OK");
+}
+
+bool GDBDebugServer::cmd_reason(gdb_cmd & cmd)
+{
+	return send_reason();
+}
+
+bool GDBDebugServer::cmd_supported(gdb_cmd & cmd)
+{
+	return send_cmd_ack("PacketSize=1200");
+}
+
+bool GDBDebugServer::cmd_thread_info(gdb_cmd & cmd)
+{
+	std::string result = "";
+	const auto on_select = [&](u32, cpu_thread& cpu)
+	{
+		if (result.length()) {
+			result += ",";
+		}
+		result += u64_to_padded_hex(static_cast<u64>(cpu.id));
+	};
+	idm::select<ppu_thread>(on_select);
+	//idm::select<RawSPUThread>(on_select);
+	//idm::select<SPUThread>(on_select);
+
+	//todo: this may exceed max command length
+	result = "m" + result + "l";
+
+	return send_cmd_ack(result);;
+}
+
+bool GDBDebugServer::cmd_current_thread(gdb_cmd & cmd)
+{
+	return send_cmd_ack(selected_thread.expired() ? "" : ("QC" + u64_to_padded_hex(selected_thread.lock()->id)));
+}
+
+bool GDBDebugServer::cmd_read_register(gdb_cmd & cmd)
+{
+	if (!select_thread(general_ops_thread_id)) {
+		return send_cmd_ack("E02");
+	}
+	auto th = selected_thread.lock();
+	if (th->id_type() == 1) {
+		auto ppu = std::static_pointer_cast<ppu_thread>(th);
+		u32 rid = hex_to_u32(cmd.data);
+		std::string result = get_reg(ppu, rid);
+		if (!result.length()) {
+			gdbDebugServer.warning("Wrong register id %d", rid);
+			return send_cmd_ack("E01");
+		}
+		return send_cmd_ack(result);
+	}
+	gdbDebugServer.warning("Unimplemented thread type %d", th->id_type());
+	return send_cmd_ack("");
+}
+
+bool GDBDebugServer::cmd_write_register(gdb_cmd & cmd)
+{
+	if (!select_thread(general_ops_thread_id)) {
+		return send_cmd_ack("E02");
+	}
+	auto th = selected_thread.lock();
+	if (th->id_type() == 1) {
+		auto ppu = std::static_pointer_cast<ppu_thread>(th);
+		size_t eq_pos = cmd.data.find('=');
+		if (eq_pos == std::string::npos) {
+			gdbDebugServer.warning("Wrong write_register cmd data %s", cmd.data.c_str());
+			return send_cmd_ack("E02");
+		}
+		u32 rid = hex_to_u32(cmd.data.substr(0, eq_pos));
+		std::string value = cmd.data.substr(eq_pos + 1);
+		if (!set_reg(ppu, rid, value)) {
+			gdbDebugServer.warning("Wrong register id %d", rid);
+			return send_cmd_ack("E01");
+		}
+		return send_cmd_ack("OK");
+	}
+	gdbDebugServer.warning("Unimplemented thread type %d", th->id_type());
+	return send_cmd_ack("");
+}
+
+bool GDBDebugServer::cmd_read_memory(gdb_cmd & cmd)
+{
+	size_t s = cmd.data.find(',');
+	u32 addr = hex_to_u32(cmd.data.substr(0, s));
+	u32 len = hex_to_u32(cmd.data.substr(s + 1));
+	std::string result;
+	result.reserve(len * 2);
+	for (u32 i = 0; i < len; ++i) {
+		if (vm::check_addr(addr, 1, vm::page_allocated | vm::page_readable)) {
+			result += to_hexbyte(vm::read8(addr + i));
+		} else {
+			break;
+			//result += "xx";
+		}
+	}
+	if (len && !result.length()) {
+		//nothing read
+		return send_cmd_ack("E01");
+	}
+	return send_cmd_ack(result);
+}
+
+bool GDBDebugServer::cmd_write_memory(gdb_cmd & cmd)
+{
+	size_t s = cmd.data.find(',');
+	size_t s2 = cmd.data.find(':');
+	if ((s == std::string::npos) || (s2 == std::string::npos)) {
+		gdbDebugServer.warning("Malformed write memory request received: %s", cmd.data.c_str());
+		return send_cmd_ack("E01");
+	}
+	u32 addr = hex_to_u32(cmd.data.substr(0, s));
+	u32 len = hex_to_u32(cmd.data.substr(s + 1, s2 - s - 1));
+	const char* data_ptr = (cmd.data.c_str()) + s2 + 1;
+	for (u32 i = 0; i < len; ++i) {
+		if (vm::check_addr(addr + i, 1, vm::page_allocated | vm::page_writable)) {
+			u8 val;
+			int res = sscanf_s(data_ptr, "%02hhX", &val);
+			if (!res) {
+				gdbDebugServer.warning("Couldn't read u8 from string %s", data_ptr);
+				return send_cmd_ack("E02");
+			}
+			data_ptr += 2;
+			vm::write8(addr + i, val);
+		} else {
+			return send_cmd_ack("E03");
+		}
+	}
+	return send_cmd_ack("OK");
+}
+
+bool GDBDebugServer::cmd_read_all_registers(gdb_cmd & cmd)
+{
+	std::string result;
+	select_thread(general_ops_thread_id);
+
+	auto th = selected_thread.lock();
+	if (th->id_type() == 1) {
+		auto ppu = std::static_pointer_cast<ppu_thread>(th);
+		//68 64-bit registers, and 3 32-bit
+		result.reserve(68*16 + 3*8);
+		for (int i = 0; i < 71; ++i) {
+			result += get_reg(ppu, i);
+		}
+		return send_cmd_ack(result);
+	}
+	gdbDebugServer.warning("Unimplemented thread type %d", th->id_type());
+	return send_cmd_ack("");
+}
+
+bool GDBDebugServer::cmd_write_all_registers(gdb_cmd & cmd)
+{
+	select_thread(general_ops_thread_id);
+	auto th = selected_thread.lock();
+	if (th->id_type() == 1) {
+		auto ppu = std::static_pointer_cast<ppu_thread>(th);
+		int ptr = 0;
+		for (int i = 0; i < 71; ++i) {
+			int sz = get_reg_size(ppu, i);
+			set_reg(ppu, i, cmd.data.substr(ptr, sz * 2));
+			ptr += sz * 2;
+		}
+		return send_cmd_ack("OK");
+	}
+	gdbDebugServer.warning("Unimplemented thread type %d", th->id_type());
+	return send_cmd_ack("E01");
+}
+
+bool GDBDebugServer::cmd_set_thread_ops(gdb_cmd & cmd)
+{
+	char type = cmd.data[0];
+	std::string thread = cmd.data.substr(1);
+	u64 id = thread == "-1" ? ALL_THREADS : hex_to_u64(thread);
+	if (type == 'c') {
+		continue_ops_thread_id = id;
+	} else {
+		general_ops_thread_id = id;
+	}
+	if (select_thread(id)) {
+		return send_cmd_ack("OK");
+	}
+	gdbDebugServer.warning("Client asked to use thread %llx for %s, but no matching thread was found", id, type == 'c' ? "continue ops" : "general ops");
+	return send_cmd_ack("E01");
+}
+
+bool GDBDebugServer::cmd_attached_to_what(gdb_cmd & cmd)
+{
+	//creating processes from client is not available yet
+	return send_cmd_ack("1");
+}
+
+bool GDBDebugServer::cmd_kill(gdb_cmd & cmd)
+{
+	Emu.Stop();
+	return true;
+}
+
+bool GDBDebugServer::cmd_continue_support(gdb_cmd & cmd)
+{
+	return send_cmd_ack("vCont;c;s;C;S");
+}
+
+bool GDBDebugServer::cmd_vcont(gdb_cmd & cmd)
+{
+	//todo: handle multiple actions and thread ids
+	this->from_breakpoint = false;
+	if (cmd.data[1] == 'c' || cmd.data[1] == 's') {
+		select_thread(continue_ops_thread_id);
+		auto ppu = std::static_pointer_cast<ppu_thread>(selected_thread.lock());
+		paused = false;
+		if (cmd.data[1] == 's') {
+			ppu->state += cpu_flag::dbg_step;
+		}
+		ppu->state -= cpu_flag::dbg_pause;
+		//special case if app didn't start yet (only loaded)
+		if (!Emu.IsPaused() && !Emu.IsRunning()) {
+			Emu.Run();
+		}
+		if (Emu.IsPaused()) {
+			Emu.Resume();
+		} else {
+			ppu->notify();
+		}
+		wait_with_interrupts();
+		//we are in all-stop mode
+		Emu.Pause();
+		select_thread(pausedBy);
+		// we have to remove dbg_pause from thread that paused execution, otherwise
+		// it will be paused forever (Emu.Resume only removes dbg_global_pause)
+		ppu = std::static_pointer_cast<ppu_thread>(selected_thread.lock());
+		ppu->state -= cpu_flag::dbg_pause;
+		return send_reason();
+	}
+	return send_cmd_ack("");
+}
+
+static const u32 INVALID_PTR = 0xffffffff;
+
+bool GDBDebugServer::cmd_set_breakpoint(gdb_cmd & cmd)
+{
+	char type = cmd.data[0];
+	//software breakpoint
+	if (type == '0') {
+		u32 addr = INVALID_PTR;
+		if (cmd.data.find(';') != std::string::npos) {
+			gdbDebugServer.warning("Received request to set breakpoint with condition, but they are not supported");
+			return send_cmd_ack("E01");
+		}
+		sscanf_s(cmd.data.c_str(), "0,%x", &addr);
+		if (addr == INVALID_PTR) {
+			gdbDebugServer.warning("Can't parse breakpoint request, data: %s", cmd.data.c_str());
+			return send_cmd_ack("E02");
+		}
+		ppu_set_breakpoint(addr);
+		return send_cmd_ack("OK");
+	}
+	//other breakpoint types are not supported
+	return send_cmd_ack("");
+}
+
+bool GDBDebugServer::cmd_remove_breakpoint(gdb_cmd & cmd)
+{
+	char type = cmd.data[0];
+	//software breakpoint
+	if (type == '0') {
+		u32 addr = INVALID_PTR;
+		sscanf_s(cmd.data.c_str(), "0,%x", &addr);
+		if (addr == INVALID_PTR) {
+			gdbDebugServer.warning("Can't parse breakpoint remove request, data: %s", cmd.data.c_str());
+			return send_cmd_ack("E01");
+		}
+		ppu_remove_breakpoint(addr);
+		return send_cmd_ack("OK");
+	}
+	//other breakpoint types are not supported
+	return send_cmd_ack("");
+
+}
+
+#define PROCESS_CMD(cmds,handler) if (cmd.cmd == cmds) { if (!handler(cmd)) break; else continue; }
+
+void GDBDebugServer::on_task()
+{
+	sock_init();
+
+	start_server();
+
+	while (!stop) {
+		sockaddr_in client;
+		socklen_t client_len = sizeof(client);
+		client_socket = accept(server_socket, (struct sockaddr *) &client, &client_len);
+
+		if (client_socket == INVALID_SOCKET) {
+			if (check_errno_again()) {
+				thread_ctrl::wait_for(50);
+				continue;
+			}
+
+			gdbDebugServer.error("Could not establish new connection\n");
+			return;
+		}
+		//stop immediately
+		if (Emu.IsRunning()) {
+			Emu.Pause();
+		}
+
+		try {
+			char hostbuf[32];
+			inet_ntop(client.sin_family, reinterpret_cast<void*>(&client.sin_addr), hostbuf, 32);
+			gdbDebugServer.success("Got connection to GDB debug server from %s:%d", hostbuf, client.sin_port);
+
+			gdb_cmd cmd;
+
+			while (!stop) {
+				if (!read_cmd(cmd)) {
+					break;
+				}
+				gdbDebugServer.trace("Command %s with data %s received", cmd.cmd.c_str(), cmd.data.c_str());
+				PROCESS_CMD("!", cmd_extended_mode);
+				PROCESS_CMD("?", cmd_reason);
+				PROCESS_CMD("qSupported", cmd_supported);
+				PROCESS_CMD("qfThreadInfo", cmd_thread_info);
+				PROCESS_CMD("qC", cmd_current_thread);
+				PROCESS_CMD("p", cmd_read_register);
+				PROCESS_CMD("P", cmd_write_register);
+				PROCESS_CMD("m", cmd_read_memory);
+				PROCESS_CMD("M", cmd_write_memory);
+				PROCESS_CMD("g", cmd_read_all_registers);
+				PROCESS_CMD("G", cmd_write_all_registers);
+				PROCESS_CMD("H", cmd_set_thread_ops);
+				PROCESS_CMD("qAttached", cmd_attached_to_what);
+				PROCESS_CMD("k", cmd_kill);
+				PROCESS_CMD("vCont?", cmd_continue_support);
+				PROCESS_CMD("vCont", cmd_vcont);
+				PROCESS_CMD("z", cmd_remove_breakpoint);
+				PROCESS_CMD("Z", cmd_set_breakpoint);
+
+				gdbDebugServer.trace("Unsupported command received %s", cmd.cmd.c_str());
+				if (!send_cmd_ack("")) {
+					break;
+				}
+			}
+		}
+		catch (std::runtime_error& e)
+		{
+			if (client_socket) {
+				closesocket(client_socket);
+				client_socket = 0;
+			}
+			gdbDebugServer.error(e.what());
+		}
+	}
+}
+
+#undef PROCESS_CMD
+
+void GDBDebugServer::on_exit()
+{
+	if (server_socket) {
+		closesocket(server_socket);
+	}
+	if (client_socket) {
+		closesocket(client_socket);
+	}
+	sock_quit();
+}
+
+std::string GDBDebugServer::get_name() const
+{
+	return "GDBDebugger";
+}
+
+void GDBDebugServer::on_stop()
+{
+	this->stop = true;
+	//just in case we are waiting for breakpoint
+	this->notify();
+	old_thread::on_stop();
+}
+
+void GDBDebugServer::pause_from(cpu_thread* t) {
+	if (paused) {
+		return;
+	}
+	paused = true;
+	pausedBy = t->id;
+	notify();
+}
+
+u32 g_gdb_debugger_id = 0;
+
+#ifndef _WIN32
+#undef sscanf_s
+#endif
+
+#undef HEX_U32
+#undef HEX_U64
+
+#endif
@@ -0,0 +1,127 @@
+#pragma once
+
+#ifdef WITH_GDB_DEBUGGER
+
+#include "Thread.h"
+#include <Emu/IdManager.h>
+#include "Emu/CPU/CPUThread.h"
+#include "Emu/Cell/PPUThread.h"
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <WS2tcpip.h>
+#else
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#endif
+
+#ifdef _WIN32
+using socket_t = SOCKET;
+#else
+using socket_t = int;
+#endif
+
+typedef struct gdb_cmd {
+	std::string cmd;
+	std::string data;
+	u8 checksum;
+} gdb_cmd;
+
+class wrong_checksum_exception : public std::runtime_error {
+public:
+	wrong_checksum_exception(char const* const message) : runtime_error(message) {}
+};
+
+const u64 ALL_THREADS = 0xffffffffffffffff;
+const u64 ANY_THREAD = 0;
+
+class GDBDebugServer
+{
+	socket_t server_socket;
+	socket_t client_socket;
+	std::weak_ptr<cpu_thread> selected_thread;
+	u64 continue_ops_thread_id = ANY_THREAD;
+	u64 general_ops_thread_id = ANY_THREAD;
+
+	//initialize server socket and start listening
+	void start_server();
+	//read at most cnt bytes to buf, returns number of bytes actually read
+	int read(void* buf, int cnt);
+	//reads one character
+	char read_char();
+	//reads pairs of hex characters and returns their integer value
+	u8 read_hexbyte();
+	//tries to read command, throws exceptions if anything goes wrong
+	void try_read_cmd(gdb_cmd& out_cmd);
+	//reads commands until receiveing one with valid checksum
+	//in case of other exception (i.e. wrong first char of command)
+	//it will log exception text and return false
+	//in that case best for caller would be to stop reading, because
+	//chance of getting correct command is low
+	bool read_cmd(gdb_cmd& out_cmd);
+	//send cnt bytes from buf to client
+	void send(const char* buf, int cnt);
+	//send character to client
+	void send_char(char c);
+	//acknowledge packet, either as accepted or declined
+	void ack(bool accepted);
+	//sends command body cmd to client
+	void send_cmd(const std::string & cmd);
+	//sends command to client until receives positive acknowledgement
+	//returns false in case some error happened, and command wasn't sent
+	bool send_cmd_ack(const std::string & cmd);
+	//appends encoded char c to string str, and returns checksum. encoded byte can occupy 2 bytes
+	static u8 append_encoded_char(char c, std::string& str);
+	//convert u8 to 2 byte hexademical representation
+	static std::string to_hexbyte(u8 i);
+	//choose thread, support ALL_THREADS and ANY_THREAD values, returns true if some thread was selected
+	bool select_thread(u64 id);
+	//returns register value as hex string by register id (in gdb), in case of wrong id returns empty string
+	static std::string get_reg(std::shared_ptr<ppu_thread> thread, u32 rid);
+	//sets register value to hex string by register id (in gdb), in case of wrong id returns false
+	static bool set_reg(std::shared_ptr<ppu_thread> thread, u32 rid, std::string value);
+	//returns size of register with id rid in bytes, zero if invalid rid is provided
+	static u32 get_reg_size(std::shared_ptr<ppu_thread> thread, u32 rid);
+	//send reason of stop, returns false if sending response failed
+	bool send_reason();
+
+	void wait_with_interrupts();
+
+	//commands
+	bool cmd_extended_mode(gdb_cmd& cmd);
+	bool cmd_reason(gdb_cmd& cmd);
+	bool cmd_supported(gdb_cmd& cmd);
+	bool cmd_thread_info(gdb_cmd& cmd);
+	bool cmd_current_thread(gdb_cmd& cmd);
+	bool cmd_read_register(gdb_cmd& cmd);
+	bool cmd_write_register(gdb_cmd& cmd);
+	bool cmd_read_memory(gdb_cmd& cmd);
+	bool cmd_write_memory(gdb_cmd& cmd);
+	bool cmd_read_all_registers(gdb_cmd& cmd);
+	bool cmd_write_all_registers(gdb_cmd& cmd);
+	bool cmd_set_thread_ops(gdb_cmd& cmd);
+	bool cmd_attached_to_what(gdb_cmd& cmd);
+	bool cmd_kill(gdb_cmd& cmd);
+	bool cmd_continue_support(gdb_cmd& cmd);
+	bool cmd_vcont(gdb_cmd& cmd);
+	bool cmd_set_breakpoint(gdb_cmd& cmd);
+	bool cmd_remove_breakpoint(gdb_cmd& cmd);
+
+public:
+	bool from_breakpoint = true;
+	bool stop = false;
+	bool paused = false;
+	u64 pausedBy;
+
+	void operator()();
+	void pause_from(cpu_thread* t);
+};
+
+extern u32 g_gdb_debugger_id;
+
+#endif
@@ -4,7 +4,7 @@

 #pragma push_macro("new")
 #undef new
-#include <gsl.h>
+#include <gsl/gsl>
 #pragma pop_macro("new")
 #undef Expects
 #undef Ensures
@@ -1,3 +1,214 @@
+#include "types.h"
+#include "JIT.h"
+#include "StrFmt.h"
+#include "File.h"
+#include "Log.h"
+#include "mutex.h"
+#include "sysinfo.h"
+#include "VirtualMemory.h"
+#include <immintrin.h>
+
+// Memory manager mutex
+shared_mutex s_mutex2;
+
+#ifdef __linux__
+#define CAN_OVERCOMMIT
+#endif
+
+static u8* get_jit_memory()
+{
+	// Reserve 2G memory (magic static)
+	static void* const s_memory2 = []() -> void*
+	{
+		void* ptr = utils::memory_reserve(0x80000000);
+
+#ifdef CAN_OVERCOMMIT
+		utils::memory_commit(ptr, 0x80000000);
+		utils::memory_protect(ptr, 0x40000000, utils::protection::wx);
+#endif
+		return ptr;
+	}();
+
+	return static_cast<u8*>(s_memory2);
+}
+
+// Allocation counters (1G code, 1G data subranges)
+static atomic_t<u64> s_code_pos{0}, s_data_pos{0};
+
+// Snapshot of code generated before main()
+static std::vector<u8> s_code_init, s_data_init;
+
+template <atomic_t<u64>& Ctr, uint Off, utils::protection Prot>
+static u8* add_jit_memory(std::size_t size, uint align)
+{
+	// Select subrange
+	u8* pointer = get_jit_memory() + Off;
+
+	if (UNLIKELY(!size && !align))
+	{
+		// Return subrange info
+		return pointer;
+	}
+
+#ifndef CAN_OVERCOMMIT
+	std::lock_guard lock(s_mutex2);
+#endif
+
+	u64 olda, newa;
+
+	// Simple allocation by incrementing pointer to the next free data
+	const u64 pos = Ctr.atomic_op([&](u64& ctr) -> u64
+	{
+		const u64 _pos = ::align(ctr, align);
+		const u64 _new = ::align(_pos + size, align);
+
+		if (UNLIKELY(_new > 0x40000000))
+		{
+			return -1;
+		}
+
+		// Check the necessity to commit more memory
+		olda = ::align(ctr, 0x10000);
+		newa = ::align(_new, 0x10000);
+
+		ctr = _new;
+		return _pos;
+	});
+
+	if (UNLIKELY(pos == -1))
+	{
+		LOG_FATAL(GENERAL, "JIT: Out of memory (size=0x%x, align=0x%x, off=0x%x)", size, align, Off);
+		return nullptr;
+	}
+
+	if (UNLIKELY(olda != newa))
+	{
+#ifdef CAN_OVERCOMMIT
+		// TODO: possibly madvise
+#else
+		// Commit more memory
+		utils::memory_commit(pointer + olda, newa - olda, Prot);
+#endif
+	}
+
+	return pointer + pos;
+}
+
+jit_runtime::jit_runtime()
+	: HostRuntime()
+{
+}
+
+jit_runtime::~jit_runtime()
+{
+}
+
+asmjit::Error jit_runtime::_add(void** dst, asmjit::CodeHolder* code) noexcept
+{
+	std::size_t codeSize = code->getCodeSize();
+	if (UNLIKELY(!codeSize))
+	{
+		*dst = nullptr;
+		return asmjit::kErrorNoCodeGenerated;
+	}
+
+	void* p = jit_runtime::alloc(codeSize, 16);
+	if (UNLIKELY(!p))
+	{
+		*dst = nullptr;
+		return asmjit::kErrorNoVirtualMemory;
+	}
+
+	std::size_t relocSize = code->relocate(p);
+	if (UNLIKELY(!relocSize))
+	{
+		*dst = nullptr;
+		return asmjit::kErrorInvalidState;
+	}
+
+	flush(p, relocSize);
+	*dst = p;
+
+	return asmjit::kErrorOk;
+}
+
+asmjit::Error jit_runtime::_release(void* ptr) noexcept
+{
+	return asmjit::kErrorOk;
+}
+
+u8* jit_runtime::alloc(std::size_t size, uint align, bool exec) noexcept
+{
+	if (exec)
+	{
+		return add_jit_memory<s_code_pos, 0x0, utils::protection::wx>(size, align);
+	}
+	else
+	{
+		return add_jit_memory<s_data_pos, 0x40000000, utils::protection::rw>(size, align);
+	}
+}
+
+void jit_runtime::initialize()
+{
+	if (!s_code_init.empty() || !s_data_init.empty())
+	{
+		return;
+	}
+
+	// Create code/data snapshot
+	s_code_init.resize(s_code_pos);
+	std::memcpy(s_code_init.data(), alloc(0, 0, true), s_code_pos);
+	s_data_init.resize(s_data_pos);
+	std::memcpy(s_data_init.data(), alloc(0, 0, false), s_data_pos);
+}
+
+void jit_runtime::finalize() noexcept
+{
+	// Reset JIT memory
+#ifdef CAN_OVERCOMMIT
+	utils::memory_reset(get_jit_memory(), 0x80000000);
+	utils::memory_protect(get_jit_memory(), 0x40000000, utils::protection::wx);
+#else
+	utils::memory_decommit(get_jit_memory(), 0x80000000);
+#endif
+
+	s_code_pos = 0;
+	s_data_pos = 0;
+
+	// Restore code/data snapshot
+	std::memcpy(alloc(s_code_init.size(), 1, true), s_code_init.data(), s_code_init.size());
+	std::memcpy(alloc(s_data_init.size(), 1, false), s_data_init.data(), s_data_init.size());
+}
+
+::jit_runtime& asmjit::get_global_runtime()
+{
+	// Magic static
+	static ::jit_runtime g_rt;
+	return g_rt;
+}
+
+asmjit::Label asmjit::build_transaction_enter(asmjit::X86Assembler& c, asmjit::Label fallback)
+{
+	Label fall = c.newLabel();
+	Label begin = c.newLabel();
+	c.jmp(begin);
+	c.bind(fall);
+	c.test(x86::eax, _XABORT_RETRY);
+	c.jz(fallback);
+	c.align(kAlignCode, 16);
+	c.bind(begin);
+	c.xbegin(fall);
+	return begin;
+}
+
+void asmjit::build_transaction_abort(asmjit::X86Assembler& c, unsigned char code)
+{
+	c.db(0xc6);
+	c.db(0xf8);
+	c.db(code);
+}
+
 #ifdef LLVM_AVAILABLE

 #include <unordered_map>
@@ -5,12 +216,7 @@
 #include <unordered_set>
 #include <set>
 #include <array>
-
-#include "types.h"
-#include "Macro.h"
-#include "StrFmt.h"
-#include "File.h"
-#include "Log.h"
+#include <deque>

 #ifdef _MSC_VER
 #pragma warning(push, 0)
@@ -20,6 +226,7 @@
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
 #include "llvm/ExecutionEngine/JITEventListener.h"
+#include "llvm/ExecutionEngine/ObjectCache.h"
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
@@ -28,16 +235,10 @@
 #include <Windows.h>
 #else
 #include <sys/mman.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/types.h>
 #endif

-#include "JIT.h"
-
-// Global LLVM context (thread-unsafe)
-llvm::LLVMContext g_llvm_ctx;
+// Memory manager mutex
+shared_mutex s_mutex;

 // Size of virtual memory area reserved: 512 MB
 static const u64 s_memory_size = 0x20000000;
@@ -45,69 +246,146 @@ static const u64 s_memory_size = 0x20000000;
 // Try to reserve a portion of virtual memory in the first 2 GB address space beforehand, if possible.
 static void* const s_memory = []() -> void*
 {
-#ifdef _WIN32
-	for (u64 addr = 0x1000000; addr <= 0x60000000; addr += 0x1000000)
+	llvm::InitializeNativeTarget();
+	llvm::InitializeNativeTargetAsmPrinter();
+	LLVMLinkInMCJIT();
+
+#ifdef MAP_32BIT
+	auto ptr = ::mmap(nullptr, s_memory_size, PROT_NONE, MAP_ANON | MAP_PRIVATE | MAP_32BIT, -1, 0);
+	if (ptr != MAP_FAILED)
+		return ptr;
+#else
+	for (u64 addr = 0x10000000; addr <= 0x80000000 - s_memory_size; addr += 0x1000000)
 	{
-		if (VirtualAlloc((void*)addr, s_memory_size, MEM_RESERVE, PAGE_NOACCESS))
+		if (auto ptr = utils::memory_reserve(s_memory_size, (void*)addr))
 		{
-			return (void*)addr;
+			return ptr;
+		}
+	}
+#endif
+
+	return utils::memory_reserve(s_memory_size);
+}();
+
+static void* s_next = s_memory;
+
+#ifdef _WIN32
+static std::deque<std::vector<RUNTIME_FUNCTION>> s_unwater;
+static std::vector<std::vector<RUNTIME_FUNCTION>> s_unwind; // .pdata
+#else
+static std::deque<std::pair<u8*, std::size_t>> s_unfire;
+#endif
+
+// Reset memory manager
+extern void jit_finalize()
+{
+#ifdef _WIN32
+	for (auto&& unwind : s_unwind)
+	{
+		if (!RtlDeleteFunctionTable(unwind.data()))
+		{
+			LOG_FATAL(GENERAL, "RtlDeleteFunctionTable() failed! Error %u", GetLastError());
 		}
 	}

-	return VirtualAlloc(NULL, s_memory_size, MEM_RESERVE, PAGE_NOACCESS);
+	s_unwind.clear();
 #else
-	return ::mmap((void*)0x10000000, s_memory_size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
-#endif
-}();
+	for (auto&& t : s_unfire)
+	{
+		llvm::RTDyldMemoryManager::deregisterEHFramesInProcess(t.first, t.second);
+	}

-// 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
+	s_unfire.clear();
 #endif

+	utils::memory_decommit(s_memory, s_memory_size);
+
+	s_next = s_memory;
+}
+
 // Helper class
-struct MemoryManager final : llvm::RTDyldMemoryManager
+struct MemoryManager : llvm::RTDyldMemoryManager
 {
-	std::unordered_map<std::string, std::uintptr_t> table;
+	std::unordered_map<std::string, u64>& m_link;

-	MemoryManager(std::unordered_map<std::string, std::uintptr_t>&& table)
-		: table(std::move(table))
+	std::array<u8, 16>* m_tramps{};
+
+	u8* m_code_addr{}; // TODO
+
+	MemoryManager(std::unordered_map<std::string, u64>& 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
+	llvm::JITSymbol findSymbol(const std::string& name) override
 	{
-		if (u64 addr = RTDyldMemoryManager::getSymbolAddress(name))
+		auto& addr = m_link[name];
+
+		// Find function address
+		if (!addr)
 		{
-			// 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;
+			addr = RTDyldMemoryManager::getSymbolAddress(name);
+
+			if (addr)
+			{
+				LOG_WARNING(GENERAL, "LLVM: Symbol requested: %s -> 0x%016llx", name, addr);
+			}
+			else
+			{
+				LOG_ERROR(GENERAL, "LLVM: Linkage failed: %s", name);
+				addr = (u64)null;
+			}
 		}

-		const auto found = table.find(name);
-
-		if (found != table.end())
+		// Verify address for small code model
+		if ((u64)s_memory > 0x80000000 - s_memory_size ? (u64)addr - (u64)s_memory >= s_memory_size : addr >= 0x80000000)
 		{
-			return found->second;
+			// Lock memory manager
+			std::lock_guard lock(s_mutex);
+
+			// Allocate memory for trampolines
+			if (!m_tramps)
+			{
+				m_tramps = reinterpret_cast<decltype(m_tramps)>(s_next);
+				utils::memory_commit(s_next, 4096, utils::protection::wx);
+				s_next = (u8*)((u64)s_next + 4096);
+			}
+
+			// Create a trampoline
+			auto& data = *m_tramps++;
+			data[0x0] = 0xff; // JMP [rip+2]
+			data[0x1] = 0x25;
+			data[0x2] = 0x02;
+			data[0x3] = 0x00;
+			data[0x4] = 0x00;
+			data[0x5] = 0x00;
+			data[0x6] = 0x48; // MOV rax, imm64 (not executed)
+			data[0x7] = 0xb8;
+			std::memcpy(data.data() + 8, &addr, 8);
+			addr = (u64)&data;
+
+			// Reset pointer (memory page exhausted)
+			if (((u64)m_tramps % 4096) == 0)
+			{
+				m_tramps = nullptr;
+			}
 		}

-		// It's fine if some function is never called, for example.
-		LOG_ERROR(GENERAL, "LLVM: Linkage failed for %s", name);
-		return (u64)null;
+		return {addr, llvm::JITSymbolFlags::Exported};
 	}

-	virtual u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
+	u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
 	{
+		// Lock memory manager
+		std::lock_guard lock(s_mutex);
+
 		// Simple allocation
-		const u64 next = ::align((u64)m_next + size, 4096);
+		const u64 next = ::align((u64)s_next + size, 4096);

 		if (next > (u64)s_memory + s_memory_size)
 		{
@@ -115,24 +393,20 @@ struct MemoryManager final : llvm::RTDyldMemoryManager
 			return nullptr;
 		}

-#ifdef _WIN32
-		if (!VirtualAlloc(m_next, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE))
-#else
-		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);
-			return nullptr;
-		}
+		utils::memory_commit(s_next, size, utils::protection::wx);
+		m_code_addr = (u8*)s_next;

-		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);
-		return (u8*)std::exchange(m_next, (void*)next);
+		LOG_NOTICE(GENERAL, "LLVM: Code section %u '%s' allocated -> %p (size=0x%llx, aligned 0x%x)", sec_id, sec_name.data(), s_next, size, align);
+		return (u8*)std::exchange(s_next, (void*)next);
 	}

-	virtual u8* allocateDataSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name, bool is_ro) override
+	u8* allocateDataSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name, bool is_ro) override
 	{
+		// Lock memory manager
+		std::lock_guard lock(s_mutex);
+
 		// Simple allocation
-		const u64 next = ::align((u64)m_next + size, 4096);
+		const u64 next = ::align((u64)s_next + size, 4096);

 		if (next > (u64)s_memory + s_memory_size)
 		{
@@ -140,188 +414,352 @@ struct MemoryManager final : llvm::RTDyldMemoryManager
 			return nullptr;
 		}

-#ifdef _WIN32
-		if (!VirtualAlloc(m_next, size, MEM_COMMIT, PAGE_READWRITE))
-#else
-		if (::mprotect(m_next, size, PROT_READ | PROT_WRITE))
-#endif
+		if (!is_ro)
 		{
-			LOG_FATAL(GENERAL, "LLVM: Failed to allocate memory at 0x%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");
-		return (u8*)std::exchange(m_next, (void*)next);
+		utils::memory_commit(s_next, size);
+
+		LOG_NOTICE(GENERAL, "LLVM: Data section %u '%s' allocated -> %p (size=0x%llx, aligned 0x%x, %s)", sec_id, sec_name.data(), s_next, size, align, is_ro ? "ro" : "rw");
+		return (u8*)std::exchange(s_next, (void*)next);
 	}

-	virtual bool finalizeMemory(std::string* = nullptr) override
+	bool finalizeMemory(std::string* = nullptr) override
 	{
-		// TODO: make sections read-only when necessary
+		// Lock memory manager
+		std::lock_guard lock(s_mutex);
+
+		// 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;
 	}

-	virtual void registerEHFrames(u8* addr, u64 load_addr, std::size_t size) override
+	void registerEHFrames(u8* addr, u64 load_addr, std::size_t size) override
 	{
-		s_unwind_info = addr;
-		s_unwind_size = size;
+#ifdef _WIN32
+		// Lock memory manager
+		std::lock_guard lock(s_mutex);
+
+		// Use s_memory as a BASE, compute the difference
+		const u64 unwind_diff = (u64)addr - (u64)s_memory;
+
+		// Fix RUNTIME_FUNCTION records (.pdata section)
+		auto pdata = std::move(s_unwater.front());
+		s_unwater.pop_front();
+
+		for (auto& rf : pdata)
+		{
+			rf.UnwindData += static_cast<DWORD>(unwind_diff);
+		}
+
+		// Register .xdata UNWIND_INFO structs
+		if (!RtlAddFunctionTable(pdata.data(), (DWORD)pdata.size(), (u64)s_memory))
+		{
+			LOG_ERROR(GENERAL, "RtlAddFunctionTable() failed! Error %u", GetLastError());
+		}
+		else
+		{
+			s_unwind.emplace_back(std::move(pdata));
+		}
+#else
+		s_unfire.push_front(std::make_pair(addr, size));
+#endif

 		return RTDyldMemoryManager::registerEHFrames(addr, load_addr, size);
 	}

-	virtual void deregisterEHFrames(u8* addr, u64 load_addr, std::size_t size) override
+	void deregisterEHFrames() override
 	{
-		LOG_ERROR(GENERAL, "deregisterEHFrames() called"); // Not expected
+	}
+};

-		return RTDyldMemoryManager::deregisterEHFrames(addr, load_addr, size);
+// Simple memory manager
+struct MemoryManager2 : llvm::RTDyldMemoryManager
+{
+	MemoryManager2() = default;
+
+	~MemoryManager2() override
+	{
 	}

-	~MemoryManager()
+	u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
 	{
-#ifdef _WIN32
-		if (!RtlDeleteFunctionTable(s_unwind.data()))
-		{
-			LOG_FATAL(GENERAL, "RtlDeleteFunctionTable(addr=0x%p) failed! Error %u", s_unwind_info, GetLastError());
-		}
-
-		if (!VirtualFree(s_memory, 0, MEM_DECOMMIT))
-		{
-			LOG_FATAL(GENERAL, "VirtualFree(0x%p) failed! Error %u", s_memory, GetLastError());
-		}
-#else
-		if (::mprotect(s_memory, s_memory_size, PROT_NONE))
-		{
-			LOG_FATAL(GENERAL, "mprotect(0x%p) failed! Error %d", s_memory, errno);
-		}
-
-		// TODO: unregister EH frames if necessary
-#endif
+		return jit_runtime::alloc(size, align, true);
 	}

-private:
-	void* m_next = s_memory;
+	u8* allocateDataSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name, bool is_ro) override
+	{
+		return jit_runtime::alloc(size, align, false);
+	}
+
+	bool finalizeMemory(std::string* = nullptr) override
+	{
+		return false;
+	}
 };

 // Helper class
-struct EventListener final : llvm::JITEventListener
+struct EventListener : llvm::JITEventListener
 {
-	virtual void NotifyObjectEmitted(const llvm::object::ObjectFile& obj, const llvm::RuntimeDyld::LoadedObjectInfo& inf) override
+	MemoryManager& m_mem;
+
+	EventListener(MemoryManager& mem)
+		: m_mem(mem)
 	{
-		const llvm::StringRef elf = obj.getData();
-		fs::file(fs::get_config_dir() + "LLVM.obj", fs::rewrite)
-			.write(elf.data(), elf.size());
+	}
+
+	void NotifyObjectEmitted(const llvm::object::ObjectFile& obj, const llvm::RuntimeDyld::LoadedObjectInfo& inf) override
+	{
+#ifdef _WIN32
+		for (auto it = obj.section_begin(), end = obj.section_end(); it != end; ++it)
+		{
+			llvm::StringRef name;
+			it->getName(name);
+
+			if (name == ".pdata")
+			{
+				llvm::StringRef data;
+				it->getContents(data);
+
+				std::vector<RUNTIME_FUNCTION> rfs(data.size() / sizeof(RUNTIME_FUNCTION));
+
+				auto offsets = reinterpret_cast<DWORD*>(rfs.data());
+
+				// Initialize .pdata section using relocation info
+				for (auto ri = it->relocation_begin(), end = it->relocation_end(); ri != end; ++ri)
+				{
+					if (ri->getType() == 3 /*R_X86_64_GOT32*/)
+					{
+						const u64 value = *reinterpret_cast<const DWORD*>(data.data() + ri->getOffset());
+						offsets[ri->getOffset() / sizeof(DWORD)] = static_cast<DWORD>(value + ri->getSymbol()->getAddress().get());
+					}
+				}
+
+				// Lock memory manager
+				std::lock_guard lock(s_mutex);
+
+				// Use s_memory as a BASE, compute the difference
+				const u64 code_diff = (u64)m_mem.m_code_addr - (u64)s_memory;
+
+				// Fix RUNTIME_FUNCTION records (.pdata section)
+				for (auto& rf : rfs)
+				{
+					rf.BeginAddress += static_cast<DWORD>(code_diff);
+					rf.EndAddress   += static_cast<DWORD>(code_diff);
+				}
+
+				s_unwater.emplace_back(std::move(rfs));
+			}
+		}
+#endif
 	}
 };

-static EventListener s_listener;
-
-jit_compiler::jit_compiler(std::unique_ptr<llvm::Module>&& _module, std::unordered_map<std::string, std::uintptr_t>&& table)
+// Helper class
+class ObjectCache final : public llvm::ObjectCache
 {
-	EXPECTS(s_memory);
+	const std::string& m_path;

+public:
+	ObjectCache(const std::string& path)
+		: m_path(path)
+	{
+	}
+
+	~ObjectCache() override = default;
+
+	void notifyObjectCompiled(const llvm::Module* module, llvm::MemoryBufferRef obj) override
+	{
+		std::string name = m_path;
+		name.append(module->getName());
+		fs::file(name, fs::rewrite).write(obj.getBufferStart(), obj.getBufferSize());
+		LOG_NOTICE(GENERAL, "LLVM: Created module: %s", module->getName().data());
+	}
+
+	static std::unique_ptr<llvm::MemoryBuffer> load(const std::string& path)
+	{
+		if (fs::file cached{path, fs::read})
+		{
+			auto buf = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(cached.size());
+			cached.read(buf->getBufferStart(), buf->getBufferSize());
+			return buf;
+		}
+
+		return nullptr;
+	}
+
+	std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module* module) override
+	{
+		std::string path = m_path;
+		path.append(module->getName());
+
+		if (auto buf = load(path))
+		{
+			LOG_NOTICE(GENERAL, "LLVM: Loaded module: %s", module->getName().data());
+			return buf;
+		}
+
+		return nullptr;
+	}
+};
+
+std::string jit_compiler::cpu(const std::string& _cpu)
+{
+	std::string m_cpu = _cpu;
+
+	if (m_cpu.empty())
+	{
+		m_cpu = llvm::sys::getHostCPUName();
+
+		if (m_cpu == "sandybridge" ||
+			m_cpu == "ivybridge" ||
+			m_cpu == "haswell" ||
+			m_cpu == "broadwell" ||
+			m_cpu == "skylake" ||
+			m_cpu == "skylake-avx512" ||
+			m_cpu == "cannonlake" ||
+			m_cpu == "icelake")
+		{
+			// Downgrade if AVX is not supported by some chips
+			if (!utils::has_avx())
+			{
+				m_cpu = "nehalem";
+			}
+		}
+
+		if (m_cpu == "skylake-avx512" ||
+			m_cpu == "cannonlake" ||
+			m_cpu == "icelake")
+		{
+			// Downgrade if AVX-512 is disabled or not supported
+			if (!utils::has_512())
+			{
+				m_cpu = "skylake";
+			}
+		}
+	}
+
+	return m_cpu;
+}
+
+jit_compiler::jit_compiler(const std::unordered_map<std::string, u64>& _link, const std::string& _cpu, bool large)
+	: m_link(_link)
+	, m_cpu(cpu(_cpu))
+{
 	std::string result;

-	const auto module_ptr = _module.get();
-
-	// Initialization
-	llvm::InitializeNativeTarget();
-	llvm::InitializeNativeTargetAsmPrinter();
-	LLVMLinkInMCJIT();
-
-	m_engine.reset(llvm::EngineBuilder(std::move(_module))
-		.setErrorStr(&result)
-		.setMCJITMemoryManager(std::make_unique<MemoryManager>(std::move(table)))
-		.setOptLevel(llvm::CodeGenOpt::Aggressive)
-		.setRelocationModel(llvm::Reloc::PIC_)
-		.setCodeModel((u64)s_memory <= 0x60000000 ? llvm::CodeModel::Medium : llvm::CodeModel::Large) // TODO
-		.setMCPU(llvm::sys::getHostCPUName())
-		.create());
-
-	if (!m_engine)
+	if (m_link.empty())
 	{
-		throw fmt::exception("LLVM: Failed to create ExecutionEngine: %s", result);
-	}
-
-	m_engine->setProcessAllSections(true); // ???
-	m_engine->RegisterJITEventListener(&s_listener);
-	m_engine->finalizeObject();
-
-	for (auto& func : module_ptr->functions())
-	{
-		if (!func.empty())
-		{
-			const std::string& name = func.getName();
-
-			// Register compiled function
-			m_map[name] = m_engine->getFunctionAddress(name);
-		}
-
-		// Delete IR to lower memory consumption
-		func.deleteBody();
-	}
-
-#ifdef _WIN32
-	// Register .xdata UNWIND_INFO (.pdata section is empty for some reason)
-	std::set<u64> func_set;
-
-	for (const auto& pair : m_map)
-	{
-		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());
-
-	for (auto it = func_set.begin(), end = --func_set.end(); it != end; it++)
-	{
-		const u64 addr = *it;
-		const u64 next = *func_set.upper_bound(addr);
-
-		// 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);
-
-		// Parse .xdata UNWIND_INFO record
-		const u8 flags = *bits++; // Version and flags
-		const u8 prolog = *bits++; // Size of prolog
-		const u8 count = *bits++; // Count of unwind codes
-		const u8 frame = *bits++; // Frame Reg + Off
-		bits += ::align(std::max<u8>(1, count), 2) * sizeof(u16); // UNWIND_CODE array
-
-		if (flags != 1) 
-		{
-			LOG_ERROR(GENERAL, "LLVM: unsupported UNWIND_INFO version/flags (0x%02x)", flags);
-			break;
-		}
-
-		LOG_TRACE(GENERAL, "LLVM: .xdata at 0x%llx: function 0x%x..0x%x: p0x%02x, c0x%02x, f0x%02x", uw.UnwindData + base, uw.BeginAddress + base, uw.EndAddress + base, prolog, count, frame);
-	}
-
-	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);
-	}
-	else if (!RtlAddFunctionTable(s_unwind.data(), (DWORD)s_unwind.size(), base))
-	{
-		LOG_FATAL(GENERAL, "RtlAddFunctionTable(addr=0x%p) failed! Error %u", s_unwind_info, GetLastError());
+		// Auxiliary JIT (does not use custom memory manager, only writes the objects)
+		m_engine.reset(llvm::EngineBuilder(std::make_unique<llvm::Module>("null_", m_context))
+			.setErrorStr(&result)
+			.setEngineKind(llvm::EngineKind::JIT)
+			.setMCJITMemoryManager(std::make_unique<MemoryManager2>())
+			.setOptLevel(llvm::CodeGenOpt::Aggressive)
+			.setCodeModel(large ? llvm::CodeModel::Large : llvm::CodeModel::Small)
+			.setMCPU(m_cpu)
+			.create());
 	}
 	else
 	{
-		LOG_SUCCESS(GENERAL, "LLVM: UNWIND_INFO registered (addr=0x%p, size=0x%llx)", s_unwind_info, s_unwind_size);
+		// Primary JIT
+		auto mem = std::make_unique<MemoryManager>(m_link);
+		m_jit_el = std::make_unique<EventListener>(*mem);
+
+		m_engine.reset(llvm::EngineBuilder(std::make_unique<llvm::Module>("null", m_context))
+			.setErrorStr(&result)
+			.setEngineKind(llvm::EngineKind::JIT)
+			.setMCJITMemoryManager(std::move(mem))
+			.setOptLevel(llvm::CodeGenOpt::Aggressive)
+			.setCodeModel(large ? llvm::CodeModel::Large : llvm::CodeModel::Small)
+			.setMCPU(m_cpu)
+			.create());
+
+		if (m_engine)
+		{
+			m_engine->RegisterJITEventListener(m_jit_el.get());
+		}
+	}
+
+	if (!m_engine)
+	{
+		fmt::throw_exception("LLVM: Failed to create ExecutionEngine: %s", result);
 	}
-#endif
 }

 jit_compiler::~jit_compiler()
 {
 }

+bool jit_compiler::has_ssse3() const
+{
+	if (m_cpu == "generic" ||
+		m_cpu == "k8" ||
+		m_cpu == "opteron" ||
+		m_cpu == "athlon64" ||
+		m_cpu == "athlon-fx" ||
+		m_cpu == "k8-sse3" ||
+		m_cpu == "opteron-sse3" ||
+		m_cpu == "athlon64-sse3" ||
+		m_cpu == "amdfam10" ||
+		m_cpu == "barcelona")
+	{
+		return false;
+	}
+
+	return true;
+}
+
+void jit_compiler::add(std::unique_ptr<llvm::Module> module, const std::string& path)
+{
+	ObjectCache cache{path};
+	m_engine->setObjectCache(&cache);
+
+	const auto ptr = module.get();
+	m_engine->addModule(std::move(module));
+	m_engine->generateCodeForModule(ptr);
+	m_engine->setObjectCache(nullptr);
+
+	for (auto& func : ptr->functions())
+	{
+		// Delete IR to lower memory consumption
+		func.deleteBody();
+	}
+}
+
+void jit_compiler::add(std::unique_ptr<llvm::Module> module)
+{
+	const auto ptr = module.get();
+	m_engine->addModule(std::move(module));
+	m_engine->generateCodeForModule(ptr);
+
+	for (auto& func : ptr->functions())
+	{
+		// Delete IR to lower memory consumption
+		func.deleteBody();
+	}
+}
+
+void jit_compiler::add(const std::string& path)
+{
+	m_engine->addObjectFile(std::move(llvm::object::ObjectFile::createObjectFile(*ObjectCache::load(path)).get()));
+}
+
+void jit_compiler::fin()
+{
+	m_engine->finalizeObject();
+}
+
+u64 jit_compiler::get(const std::string& name)
+{
+	return m_engine->getGlobalValueAddress(name);
+}
+
 #endif
@@ -1,13 +1,103 @@
 #pragma once

+#define ASMJIT_EMBED
+#define ASMJIT_DEBUG
+
+#include <asmjit/asmjit.h>
+#include <array>
+#include <functional>
+
+enum class jit_class
+{
+	ppu_code,
+	ppu_data,
+	spu_code,
+	spu_data,
+};
+
+// ASMJIT runtime for emitting code in a single 2G region
+struct jit_runtime final : asmjit::HostRuntime
+{
+	jit_runtime();
+	~jit_runtime() override;
+
+	// Allocate executable memory
+	asmjit::Error _add(void** dst, asmjit::CodeHolder* code) noexcept override;
+
+	// Do nothing (deallocation is delayed)
+	asmjit::Error _release(void* p) noexcept override;
+
+	// Allocate memory
+	static u8* alloc(std::size_t size, uint align, bool exec = true) noexcept;
+
+	// Should be called at least once after global initialization
+	static void initialize();
+
+	// Deallocate all memory
+	static void finalize() noexcept;
+};
+
+namespace asmjit
+{
+	// Should only be used to build global functions
+	::jit_runtime& get_global_runtime();
+
+	// Emit xbegin and adjacent loop, return label at xbegin
+	Label build_transaction_enter(X86Assembler& c, Label fallback);
+
+	// Emit xabort
+	void build_transaction_abort(X86Assembler& c, unsigned char code);
+}
+
+// Build runtime function with asmjit::X86Assembler
+template <typename FT, typename F>
+FT build_function_asm(F&& builder)
+{
+	using namespace asmjit;
+
+	auto& rt = get_global_runtime();
+
+	CodeHolder code;
+	code.init(rt.getCodeInfo());
+	code._globalHints = asmjit::CodeEmitter::kHintOptimizedAlign;
+
+	std::array<X86Gp, 4> args;
+#ifdef _WIN32
+	args[0] = x86::rcx;
+	args[1] = x86::rdx;
+	args[2] = x86::r8;
+	args[3] = x86::r9;
+#else
+	args[0] = x86::rdi;
+	args[1] = x86::rsi;
+	args[2] = x86::rdx;
+	args[3] = x86::rcx;
+#endif
+
+	X86Assembler compiler(&code);
+	builder(std::ref(compiler), args);
+
+	FT result;
+
+	if (rt.add(&result, &code))
+	{
+		return nullptr;
+	}
+
+	return result;
+}
+
 #ifdef LLVM_AVAILABLE

 #include <memory>
 #include <string>
+#include <string_view>
 #include <unordered_map>

 #include "types.h"
+#include "mutex.h"

+#include "restore_new.h"
 #ifdef _MSC_VER
 #pragma warning(push, 0)
 #endif
@@ -17,33 +107,66 @@
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-
-extern llvm::LLVMContext g_llvm_ctx;
+#include "define_new_memleakdetect.h"

 // Temporary compiler interface
 class jit_compiler final
 {
+	// Local LLVM context
+	llvm::LLVMContext m_context;
+
+	// JIT Event Listener
+	std::unique_ptr<struct EventListener> m_jit_el;
+
 	// Execution instance
 	std::unique_ptr<llvm::ExecutionEngine> m_engine;

-	// Compiled functions
-	std::unordered_map<std::string, std::uintptr_t> m_map;
+	// Link table
+	std::unordered_map<std::string, u64> m_link;
+
+	// Arch
+	std::string m_cpu;

 public:
-	jit_compiler(std::unique_ptr<llvm::Module>&&, std::unordered_map<std::string, std::uintptr_t>&&);
+	jit_compiler(const std::unordered_map<std::string, u64>& _link, const std::string& _cpu, bool large = false);
 	~jit_compiler();

-	// Get compiled function address
-	std::uintptr_t get(const std::string& name) const
+	// Get LLVM context
+	auto& get_context()
 	{
-		const auto found = m_map.find(name);
-		
-		if (found != m_map.end())
-		{
-			return found->second;
-		}
+		return m_context;
+	}

-		return 0;
+	auto& get_engine() const
+	{
+		return *m_engine;
+	}
+
+	// Test SSSE3 feature
+	bool has_ssse3() const;
+
+	// Add module (path to obj cache dir)
+	void add(std::unique_ptr<llvm::Module> module, const std::string& path);
+
+	// Add module (not cached)
+	void add(std::unique_ptr<llvm::Module> module);
+
+	// Add object (path to obj file)
+	void add(const std::string& path);
+
+	// Finalize
+	void fin();
+
+	// Get compiled function address
+	u64 get(const std::string& name);
+
+	// Get CPU info
+	static std::string cpu(const std::string& _cpu);
+
+	// Check JIT purpose
+	bool is_primary() const
+	{
+		return !m_link.empty();
 	}
 };

@@ -0,0 +1,265 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ * 
+ * The MIT License (MIT)
+ * 
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "LUrlParser.h"
+
+#include <algorithm>
+#include <cstring>
+#include <stdlib.h>
+
+// check if the scheme name is valid
+static bool IsSchemeValid( const std::string& SchemeName )
+{
+	for ( auto c : SchemeName  )
+	{
+		if ( !isalpha( c ) && c != '+' && c != '-' && c != '.' ) return false;
+	}
+
+	return true;
+}
+
+bool LUrlParser::clParseURL::GetPort( int* OutPort ) const
+{
+	if ( !IsValid() ) { return false; }
+
+	int Port = atoi( m_Port.c_str() );
+
+	if ( Port <= 0 || Port > 65535 ) { return false; }
+
+	if ( OutPort ) { *OutPort = Port; }
+
+	return true;
+}
+
+// based on RFC 1738 and RFC 3986
+LUrlParser::clParseURL LUrlParser::clParseURL::ParseURL( const std::string& URL )
+{
+	LUrlParser::clParseURL Result;
+
+	const char* CurrentString = URL.c_str();
+
+	/*
+	 *	<scheme>:<scheme-specific-part>
+	 *	<scheme> := [a-z\+\-\.]+
+	 *	For resiliency, programs interpreting URLs should treat upper case letters as equivalent to lower case in scheme names
+	 */
+
+	// try to read scheme
+	{
+		const char* LocalString = strchr( CurrentString, ':' );
+
+		if ( !LocalString )
+		{
+			return clParseURL( LUrlParserError_NoUrlCharacter );
+		}
+
+		// save the scheme name
+		Result.m_Scheme = std::string( CurrentString, LocalString - CurrentString );
+
+		if ( !IsSchemeValid( Result.m_Scheme ) )
+		{
+			return clParseURL( LUrlParserError_InvalidSchemeName );
+		}
+
+		// scheme should be lowercase
+		std::transform( Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower );
+
+		// skip ':'
+		CurrentString = LocalString+1;
+	}
+
+	/*
+	 *	//<user>:<password>@<host>:<port>/<url-path>
+	 *	any ":", "@" and "/" must be normalized
+	 */
+
+	// skip "//"
+	if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+	if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+
+	// check if the user name and password are specified
+	bool bHasUserName = false;
+
+	const char* LocalString = CurrentString;
+
+	while ( *LocalString )
+	{
+		if ( *LocalString == '@' )
+		{
+			// user name and password are specified
+			bHasUserName = true;
+			break;
+		}
+		else if ( *LocalString == '/' )
+		{
+			// end of <host>:<port> specification
+			bHasUserName = false;
+			break;
+		}
+
+		LocalString++;
+	}
+
+	// user name and password
+	LocalString = CurrentString;
+
+	if ( bHasUserName )
+	{
+		// read user name
+		while ( *LocalString && *LocalString != ':' && *LocalString != '@' ) LocalString++;
+
+		Result.m_UserName = std::string( CurrentString, LocalString - CurrentString );
+
+		// proceed with the current pointer
+		CurrentString = LocalString;
+
+		if ( *CurrentString == ':' )
+		{
+			// skip ':'
+			CurrentString++;
+
+			// read password
+			LocalString = CurrentString;
+
+			while ( *LocalString && *LocalString != '@' ) LocalString++;
+
+			Result.m_Password = std::string( CurrentString, LocalString - CurrentString );
+
+			CurrentString = LocalString;
+		}
+
+		// skip '@'
+		if ( *CurrentString != '@' )
+		{
+			return clParseURL( LUrlParserError_NoAtSign );
+		}
+
+		CurrentString++;
+	}
+
+	bool bHasBracket = ( *CurrentString == '[' );
+
+	// go ahead, read the host name
+	LocalString = CurrentString;
+
+	while ( *LocalString )
+	{
+		if ( bHasBracket && *LocalString == ']' )
+		{
+			// end of IPv6 address
+			LocalString++;
+			break;
+		}
+		else if ( !bHasBracket && ( *LocalString == ':' || *LocalString == '/' ) )
+		{
+			// port number is specified
+			break;
+		}
+
+		LocalString++;
+	}
+
+	Result.m_Host = std::string( CurrentString, LocalString - CurrentString );
+
+	CurrentString = LocalString;
+
+	// is port number specified?
+	if ( *CurrentString == ':' )
+	{
+		CurrentString++;
+
+		// read port number
+		LocalString = CurrentString;
+
+		while ( *LocalString && *LocalString != '/' ) LocalString++;
+
+		Result.m_Port = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	// end of string
+	if ( !*CurrentString )
+	{
+		Result.m_ErrorCode = LUrlParserError_Ok;
+
+		return Result;
+	}
+
+	// skip '/'
+	if ( *CurrentString != '/' )
+	{
+		return clParseURL( LUrlParserError_NoSlash );
+	}
+
+	CurrentString++;
+
+	// parse the path
+	LocalString = CurrentString;
+
+	while ( *LocalString && *LocalString != '#' && *LocalString != '?' ) LocalString++;
+
+	Result.m_Path = std::string( CurrentString, LocalString - CurrentString );
+
+	CurrentString = LocalString;
+
+	// check for query
+	if ( *CurrentString == '?' )
+	{
+		// skip '?'
+		CurrentString++;
+
+		// read query
+		LocalString = CurrentString;
+
+		while ( *LocalString && *LocalString != '#' ) LocalString++;
+
+		Result.m_Query = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	// check for fragment
+	if ( *CurrentString == '#' )
+	{
+		// skip '#'
+		CurrentString++;
+
+		// read fragment
+		LocalString = CurrentString;
+
+		while ( *LocalString ) LocalString++;
+
+		Result.m_Fragment = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	Result.m_ErrorCode = LUrlParserError_Ok;
+
+	return Result;
+}
@@ -0,0 +1,78 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ * 
+ * The MIT License (MIT)
+ * 
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace LUrlParser
+{
+	enum LUrlParserError
+	{
+		LUrlParserError_Ok = 0,
+		LUrlParserError_Uninitialized = 1,
+		LUrlParserError_NoUrlCharacter = 2,
+		LUrlParserError_InvalidSchemeName = 3,
+		LUrlParserError_NoDoubleSlash = 4,
+		LUrlParserError_NoAtSign = 5,
+		LUrlParserError_UnexpectedEndOfLine = 6,
+		LUrlParserError_NoSlash = 7,
+	};
+
+	class clParseURL
+	{
+	public:
+		LUrlParserError m_ErrorCode;
+		std::string m_Scheme;
+		std::string m_Host;
+		std::string m_Port;
+		std::string m_Path;
+		std::string m_Query;
+		std::string m_Fragment;
+		std::string m_UserName;
+		std::string m_Password;
+
+		clParseURL()
+			: m_ErrorCode( LUrlParserError_Uninitialized )
+		{}
+
+		/// return 'true' if the parsing was successful
+		bool IsValid() const { return m_ErrorCode == LUrlParserError_Ok; }
+
+		/// helper to convert the port number to int, return 'true' if the port is valid (within the 0..65535 range)
+		bool GetPort( int* OutPort ) const;
+
+		/// parse the URL
+		static clParseURL ParseURL( const std::string& URL );
+
+	private:
+		explicit clParseURL( LUrlParserError ErrorCode )
+			: m_ErrorCode( ErrorCode )
+		{}
+	};
+
+} // namespace LUrlParser
@@ -1,147 +1,654 @@
 #include "Log.h"
 #include "File.h"
 #include "StrFmt.h"
+#include "sema.h"

+#include "Utilities/sysinfo.h"
+#include "Utilities/Thread.h"
+#include "rpcs3_version.h"
+#include <cstring>
 #include <cstdarg>
 #include <string>
+#include <unordered_map>
+#include <thread>
+#include <chrono>
+#include <cstring>
+
+using namespace std::literals::chrono_literals;
+
+#ifdef _WIN32
+#define NOMINMAX
+#include <Windows.h>
+#else
+#include <sys/mman.h>
+#include <sys/stat.h>
+#endif
+
+#include <zlib.h>
+
+static std::string empty_string()
+{
+	return {};
+}

 // Thread-specific log prefix provider
-thread_local std::string(*g_tls_log_prefix)() = nullptr;
+thread_local std::string(*g_tls_log_prefix)() = &empty_string;

-#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";
+		case logs::level::_uninit: return unknown;
+		}
+
+		return unknown;
+	});
+}

 namespace logs
 {
-	struct listener
-	{
-		listener() = default;
-
-		virtual ~listener() = default;
-
-		virtual void log(const channel& ch, level sev, const std::string& text) = 0;
-	};
+	// Memory-mapped buffer size
+	constexpr u64 s_log_size = 32 * 1024 * 1024;

 	class file_writer
 	{
-		// Could be memory-mapped file
 		fs::file m_file;
+		std::string m_name;
+		std::thread m_writer;
+		fs::file m_fout;
+		fs::file m_fout2;
+		u64 m_max_size;
+
+#ifdef _WIN32
+		::HANDLE m_fmap;
+#endif
+		uchar* m_fptr{};
+		z_stream m_zs{};
+		shared_mutex m_m;
+
+		alignas(128) atomic_t<u64> m_buf{0}; // MSB (40 bit): push begin, LSB (24 bis): push size
+		alignas(128) atomic_t<u64> m_out{0}; // Amount of bytes written to file
+
+		uchar m_zout[65536];
+
+		// Write buffered logs immediately
+		bool flush(u64 bufv);

 	public:
 		file_writer(const std::string& name);

-		virtual ~file_writer() = default;
+		virtual ~file_writer();

 		// Append raw data
-		void log(const std::string& text);
+		void log(logs::level sev, const char* text, std::size_t size);
+	};

-		// Get current file size (may be used by secondary readers)
-		std::size_t size() const;
+	struct channel_info
+	{
+		channel* pointer = nullptr;
+		level enabled = level::notice;
+
+		void set_level(level value)
+		{
+			enabled = value;
+
+			if (pointer)
+			{
+				pointer->enabled = value;
+			}
+		}
+	};
+
+	struct stored_message
+	{
+		message m;
+		u64 stamp;
+		std::string prefix;
+		std::string text;
 	};

 	struct file_listener : public file_writer, public listener
 	{
-		file_listener(const std::string& name)
-			: file_writer(name)
-			, listener()
-		{
-		}
+		file_listener(const std::string& name);
+
+		virtual ~file_listener() = default;

 		// 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;
+
+		// Channel registry
+		std::unordered_map<std::string, channel_info> channels;
+
+		// Messages for delayed listener initialization
+		std::vector<stored_message> messages;
 	};

-	static file_listener& get_logger()
+	static file_listener* get_logger()
 	{
 		// Use magic static
-		static file_listener logger("RPCS3.log");
-		return logger;
+		static file_listener logger("RPCS3");
+		return &logger;
 	}

-	channel GENERAL(nullptr, level::notice);
-	channel LOADER("LDR", level::notice);
-	channel MEMORY("MEM", level::notice);
-	channel RSX("RSX", level::notice);
-	channel HLE("HLE", level::notice);
-	channel PPU("PPU", level::notice);
-	channel SPU("SPU", level::notice);
-	channel ARMv7("ARMv7");
+	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("");
+	channel LOADER("LDR");
+	channel MEMORY("MEM");
+	channel RSX("RSX");
+	channel HLE("HLE");
+	channel PPU("PPU");
+	channel SPU("SPU");
+
+	// Channel registry mutex
+	shared_mutex g_mutex;
+
+	// Must be set to true in main()
+	atomic_t<bool> g_init{false};
+
+	void reset()
+	{
+		std::lock_guard lock(g_mutex);
+
+		for (auto&& pair : get_logger()->channels)
+		{
+			pair.second.set_level(level::notice);
+		}
+	}
+
+	void set_level(const std::string& ch_name, level value)
+	{
+		std::lock_guard lock(g_mutex);
+
+		get_logger()->channels[ch_name].set_level(value);
+	}
+
+	// Must be called in main() to stop accumulating messages in g_messages
+	void set_init()
+	{
+		if (!g_init)
+		{
+			std::lock_guard lock(g_mutex);
+			get_logger()->messages.clear();
+			g_init = true;
+		}
+	}
 }

-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();
+
+	std::lock_guard lock(g_mutex);
+
+	// 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;
+	}
+
+	// Send initial messages
+	for (const auto& msg : get_logger()->messages)
+	{
+		_new->log(msg.stamp, msg.m, msg.prefix, msg.text);
+	}
+}
+
+void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, ...) const
+{
+	// Get timestamp
+	const u64 stamp = get_stamp();
+
+	// Register channel
+	if (ch->enabled == level::_uninit)
+	{
+		std::lock_guard lock(g_mutex);
+
+		auto& info = get_logger()->channels[ch->name];
+
+		if (info.pointer && info.pointer != ch)
+		{
+			fmt::throw_exception("logs::channel repetition: %s", ch->name);
+		}
+		else if (!info.pointer)
+		{
+			info.pointer = ch;
+			ch->enabled  = info.enabled;
+
+			// Check level again
+			if (info.enabled < sev)
+			{
+				return;
+			}
+		}
+	}
+
+	// Get text, extract va_args
+	thread_local std::string text;
+	thread_local std::vector<u64> args;
+
+	std::size_t args_count = 0;
+	for (auto v = sup; v->fmt_string; v++)
+		args_count++;
+
+	text.clear();
+	args.resize(args_count);
+
+	va_list c_args;
+	va_start(c_args, sup);
+	for (u64& arg : args)
+		arg = va_arg(c_args, u64);
+	va_end(c_args);
+	fmt::raw_append(text, fmt, sup, args.data());
+	std::string prefix = g_tls_log_prefix();
+
+	// Get first (main) listener
+	listener* lis = get_logger();
+
+	if (!g_init)
+	{
+		std::lock_guard lock(g_mutex);
+
+		if (!g_init)
+		{
+			while (lis)
+			{
+				lis->log(stamp, *this, prefix, text);
+				lis = lis->m_next;
+			}
+
+			// Store message additionally
+			get_logger()->messages.emplace_back(stored_message{*this, stamp, std::move(prefix), text});
+		}
+	}
+
+	// Send message to all listeners
+	while (lis)
+	{
+		lis->log(stamp, *this, prefix, text);
+		lis = lis->m_next;
+	}
 }

 [[noreturn]] extern void catch_all_exceptions();

 logs::file_writer::file_writer(const std::string& name)
+	: m_name(name)
 {
+	const std::string log_name = fs::get_cache_dir() + name + ".log";
+	const std::string buf_name = fs::get_cache_dir() + name + ".buf";
+
 	try
 	{
-		if (!m_file.open(fs::get_config_dir() + name, fs::rewrite + fs::append))
+		if (!m_file.open(buf_name, fs::read + fs::rewrite + fs::lock))
 		{
-			throw fmt::exception("Can't create log file %s (error %d)", name, fs::g_tls_error);
+			if (fs::g_tls_error == fs::error::acces)
+			{
+				if (fs::exists(buf_name))
+				{
+					fmt::throw_exception("Another instance of %s is running. Close it or kill its process, if necessary.", name);
+				}
+				else
+				{
+					fmt::throw_exception("Cannot create %s.log (access denied)."
+#ifdef _WIN32
+						"\nNote that %s cannot be installed in Program Files or similar directory with limited permissions."
+#else
+						"\nPlease, check %s permissions in '~/.config/'."
+#endif
+						, name, name);
+				}
+			}
+
+			fmt::throw_exception("Cannot create %s.log (error %s)", name, fs::g_tls_error);
 		}
+
+		// Check free space
+		fs::device_stat stats{};
+		if (!fs::statfs(fs::get_cache_dir(), stats) || stats.avail_free < s_log_size * 8)
+		{
+			fmt::throw_exception("Not enough free space (%f KB)", stats.avail_free / 1000000.);
+		}
+
+		// Limit log size to ~25% of free space
+		m_max_size = stats.avail_free / 4;
+
+		// Initialize memory mapped file
+#ifdef _WIN32
+		m_fmap = CreateFileMappingW(m_file.get_handle(), 0, PAGE_READWRITE, s_log_size >> 32, s_log_size & 0xffffffff, 0);
+		m_fptr = m_fmap ? (uchar*)MapViewOfFile(m_fmap, FILE_MAP_WRITE, 0, 0, 0) : nullptr;
+#else
+		m_file.trunc(s_log_size);
+		m_fptr = (uchar*)::mmap(0, s_log_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_file.get_handle(), 0);
+#endif
+
+		verify(name.c_str()), m_fptr;
+
+		// Rotate backups (TODO)
+		fs::remove_file(fs::get_cache_dir() + name + "1.log.gz");
+		fs::create_dir(fs::get_cache_dir() + "old_logs");
+		fs::rename(fs::get_cache_dir() + m_name + ".log.gz", fs::get_cache_dir() + "old_logs/" + m_name + ".log.gz", true);
+
+		// Actual log file (allowed to fail)
+		m_fout.open(log_name, fs::rewrite);
+
+		// Compressed log, make it inaccessible (foolproof)
+		if (!m_fout2.open(log_name + ".gz", fs::rewrite + fs::unread) || deflateInit2(&m_zs, 9, Z_DEFLATED, 16 + 15, 9, Z_DEFAULT_STRATEGY) != Z_OK)
+		{
+			m_fout2.close();
+		}
+
+#ifdef _WIN32
+		// Autodelete compressed log file
+		FILE_DISPOSITION_INFO disp;
+		disp.DeleteFileW = TRUE;
+		SetFileInformationByHandle(m_fout2.get_handle(), FileDispositionInfo, &disp, sizeof(disp));
+#endif
+	}
+	catch (const std::exception& e)
+	{
+		std::thread([text = std::string{e.what()}]{ report_fatal_error(text); }).detach();
+		return;
 	}
 	catch (...)
 	{
-		catch_all_exceptions();
+		std::thread([]{ report_fatal_error("Unknown error" HERE); }).detach();
+		return;
+	}
+
+	m_writer = std::thread([this]()
+	{
+		thread_ctrl::set_native_priority(-1);
+
+		while (true)
+		{
+			const u64 bufv = m_buf;
+
+			if (bufv & 0xffffff)
+			{
+				// Wait if threads are writing logs
+				std::this_thread::yield();
+				continue;
+			}
+
+			if (!flush(bufv))
+			{
+				if (m_out == -1)
+				{
+					break;
+				}
+
+				std::this_thread::sleep_for(10ms);
+			}
+		}
+	});
+}
+
+logs::file_writer::~file_writer()
+{
+	if (!m_fptr)
+	{
+		return;
+	}
+
+	// Stop writer thread
+	while (m_out << 24 < m_buf)
+	{
+		std::this_thread::yield();
+	}
+
+	m_out = -1;
+	m_writer.join();
+
+	if (m_fout2)
+	{
+		m_zs.avail_in = 0;
+		m_zs.next_in  = nullptr;
+
+		do
+		{
+			m_zs.avail_out = sizeof(m_zout);
+			m_zs.next_out  = m_zout;
+
+			if (deflate(&m_zs, Z_FINISH) == Z_STREAM_ERROR || m_fout2.write(m_zout, sizeof(m_zout) - m_zs.avail_out) != sizeof(m_zout) - m_zs.avail_out)
+			{
+				break;
+			}
+		}
+		while (m_zs.avail_out == 0);
+
+		deflateEnd(&m_zs);
+	}
+
+#ifdef _WIN32
+	// Cancel compressed log file autodeletion
+	FILE_DISPOSITION_INFO disp;
+	disp.DeleteFileW = FALSE;
+	SetFileInformationByHandle(m_fout2.get_handle(), FileDispositionInfo, &disp, sizeof(disp));
+
+	UnmapViewOfFile(m_fptr);
+	CloseHandle(m_fmap);
+#else
+	// Restore compressed log file permissions
+	::fchmod(m_fout2.get_handle(), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+	::munmap(m_fptr, s_log_size);
+#endif
+}
+
+bool logs::file_writer::flush(u64 bufv)
+{
+	std::lock_guard lock(m_m);
+
+	const u64 st  = +m_out;
+	const u64 end = std::min<u64>((st + s_log_size) & ~(s_log_size - 1), bufv >> 24);
+
+	if (end > st)
+	{
+		// Avoid writing too big fragments
+		const u64 size = std::min<u64>(end - st, sizeof(m_zout) / 2);
+
+		// Write uncompressed
+		if (m_fout && st < m_max_size && m_fout.write(m_fptr + st % s_log_size, size) != size)
+		{
+			m_fout.close();
+		}
+
+		// Write compressed
+		if (m_fout2 && st < m_max_size)
+		{
+			m_zs.avail_in = size;
+			m_zs.next_in  = m_fptr + st % s_log_size;
+
+			do
+			{
+				m_zs.avail_out = sizeof(m_zout);
+				m_zs.next_out  = m_zout;
+
+				if (deflate(&m_zs, Z_NO_FLUSH) == Z_STREAM_ERROR || m_fout2.write(m_zout, sizeof(m_zout) - m_zs.avail_out) != sizeof(m_zout) - m_zs.avail_out)
+				{
+					deflateEnd(&m_zs);
+					m_fout2.close();
+					break;
+				}
+			}
+			while (m_zs.avail_out == 0);
+		}
+
+		m_out += size;
+		return true;
+	}
+
+	return false;
+}
+
+void logs::file_writer::log(logs::level sev, const char* text, std::size_t size)
+{
+	if (!m_fptr)
+	{
+		return;
+	}
+
+	// TODO: write bigger fragment directly in blocking manner
+	while (size && size <= 0xffffff)
+	{
+		u64 bufv;
+
+		const auto pos = m_buf.atomic_op([&](u64& v) -> uchar*
+		{
+			const u64 v1 = v >> 24;
+			const u64 v2 = v & 0xffffff;
+
+			if (UNLIKELY(v2 + size > 0xffffff || v1 + v2 + size >= m_out + s_log_size))
+			{
+				bufv = v;
+				return nullptr;
+			}
+
+			v += size;
+			return m_fptr + (v1 + v2) % s_log_size;
+		});
+
+		if (UNLIKELY(!pos))
+		{
+			if ((bufv & 0xffffff) + size > 0xffffff || bufv & 0xffffff)
+			{
+				// Concurrency limit reached
+				std::this_thread::yield();
+			}
+			else
+			{
+				// Queue is full, need to write out
+				flush(bufv);
+			}
+			continue;
+		}
+
+		if (pos + size > m_fptr + s_log_size)
+		{
+			const auto frag = m_fptr + s_log_size - pos;
+			std::memcpy(pos, text, frag);
+			std::memcpy(m_fptr, text + frag, size - frag);
+		}
+		else
+		{
+			std::memcpy(pos, text, size);
+		}
+
+		m_buf += (u64{size} << 24) - size;
+		break;
 	}
 }

-void logs::file_writer::log(const std::string& text)
+logs::file_listener::file_listener(const std::string& name)
+	: file_writer(name)
+	, listener()
 {
-	m_file.write(text);
+	// Write UTF-8 BOM
+	file_writer::log(logs::level::always, "\xEF\xBB\xBF", 3);
+
+	// Write initial message
+	stored_message ver;
+	ver.m.ch  = nullptr;
+	ver.m.sev = level::always;
+	ver.stamp = 0;
+	ver.text = fmt::format("RPCS3 v%s | %s\n%s", rpcs3::version.to_string(), rpcs3::get_branch(), utils::get_system_info());
+
+	file_writer::log(logs::level::always, ver.text.data(), ver.text.size());
+	file_writer::log(logs::level::always, "\n", 1);
+	messages.emplace_back(std::move(ver));
 }

-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);
+	thread_local std::string text;

 	// 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;
+	case level::_uninit: text = u8"·  "; break;
 	}

-	// TODO: print time?
+	// Print µs 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)
-	{
-		msg += ch.name;
-		msg += sev == level::todo ? " TODO: " : ": ";
-	}
-	else if (sev == level::todo)
-	{
-		msg += "TODO: ";
-	}
-	
-	msg += text;
-	msg += '\n';

-	file_writer::log(msg);
+	if (msg.ch && '\0' != *msg.ch->name)
+	{
+		text += msg.ch->name;
+		text += msg.sev == level::todo ? " TODO: " : ": ";
+	}
+	else if (msg.sev == level::todo)
+	{
+		text += "TODO: ";
+	}
+
+	text += _text;
+	text += '\n';
+
+	file_writer::log(msg.sev, text.data(), text.size());
 }
@@ -2,19 +2,57 @@

 #include "types.h"
 #include "Atomic.h"
+#include "StrFmt.h"
+#include <climits>

 namespace logs
 {
 	enum class level : uint
 	{
-		always, // highest level (unused, cannot be disabled)
+		always, // Highest log severity (unused, cannot be disabled)
 		fatal,
 		error,
 		todo,
 		success,
 		warning,
 		notice,
-		trace, // lowest level (usually disabled)
+		trace, // Lowest severity (usually disabled)
+
+		_uninit = UINT_MAX, // Special value for delayed initialization
+	};
+
+	struct channel;
+
+	// Message information
+	struct message
+	{
+		channel* ch;
+		level sev;
+
+	private:
+		// Send log message to global logger instance
+		void broadcast(const char*, const fmt_type_info*, ...) const;
+
+		friend struct channel;
+	};
+
+	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
@@ -25,30 +63,23 @@ namespace logs
 		// The lowest logging level enabled for this channel (used for early filtering)
 		atomic_t<level> enabled;

-		// Constant initialization: name and initial log level
-		constexpr channel(const char* name, level enabled = level::trace)
+		// Constant initialization: channel name
+		constexpr channel(const char* name)
 			: name(name)
-			, enabled(enabled)
+			, enabled(level::_uninit)
 		{
 		}

-		// Formatting function
-		template<typename... Args>
-		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)...);
-		}
-
 #define GEN_LOG_METHOD(_sev)\
-		template<typename... Args>\
-		void _sev(const char* fmt, const Args&... args) const\
+		const message msg_##_sev{this, level::_sev};\
+		template <typename... Args>\
+		void _sev(const char* fmt, const Args&... args)\
 		{\
-			return format<Args...>(level::_sev, fmt, args...);\
+			if (UNLIKELY(level::_sev <= enabled))\
+			{\
+				static constexpr fmt_type_info type_list[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};\
+				msg_##_sev.broadcast(fmt, type_list, u64{fmt_unveil<Args>::get(args)}...);\
+			}\
 		}

 		GEN_LOG_METHOD(fatal)
@@ -60,10 +91,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 */
@@ -75,31 +102,22 @@ namespace logs
 	extern channel HLE;
 	extern channel PPU;
 	extern channel SPU;
-	extern channel ARMv7;
+
+	// Log level control: set all channels to level::notice
+	void reset();
+
+	// Log level control: register channel if necessary, set channel level
+	void set_level(const std::string&, level);
 }

-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" },
-	};
-};
+#define LOG_CHANNEL(ch, ...) ::logs::channel ch(#ch, ##__VA_ARGS__);

 // 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__)
@@ -1,98 +0,0 @@
-#pragma once
-
-class MTProgressDialog : public wxDialog
-{
-	wxGauge** m_gauge;
-	wxStaticText** m_msg;
-
-	wxArrayLong m_maximum;
-	const u8 m_cores;
-
-	static const uint layout = 16;
-	static const uint maxdial = 65536;
-	wxArrayInt m_lastupdate;
-
-public:
-	MTProgressDialog(wxWindow* parent, const wxSize& size, const wxString& title,
-			const wxString& msg, const wxArrayLong& maximum, const u8 cores)
-		: wxDialog(parent, wxID_ANY, title, wxDefaultPosition)
-		, m_maximum(maximum)
-		, m_cores(cores)
-	{
-		wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
-
-		m_gauge = new wxGauge*[m_cores];
-		m_msg = new wxStaticText*[m_cores];
-
-		m_lastupdate.SetCount(cores);
-
-		for(uint i=0; i<m_cores; ++i)
-		{
-			m_lastupdate[i] = -1;
-
-			m_msg[i] = new wxStaticText(this, wxID_ANY, msg);
-			sizer->Add(m_msg[i], 0, wxLEFT | wxTOP, layout);
-
-			m_gauge[i] = new wxGauge(this, wxID_ANY, maxdial,
-									  wxDefaultPosition, wxDefaultSize,
-									  wxGA_HORIZONTAL );
-
-			sizer->Add(m_gauge[i], 0, wxLEFT | wxRIGHT | wxTOP | wxEXPAND, layout);
-			m_gauge[i]->SetValue(0);
-
-			sizer->AddSpacer(5);
-		}
-
-		SetSizerAndFit(sizer);
-		if(size != wxDefaultSize)
-		{
-			SetSize(size);
-		}
-		else
-		{
-			wxSize ws;
-			ws.x = 400;
-			ws.y = GetSize().y + 8;
-			SetSize(ws);
-		}
-
-		m_maximum.SetCount(m_cores);
-
-		Show();
-	}
-
-	force_inline void Update(const u8 thread_id, const u64 value, const wxString& msg)
-	{
-		if(thread_id > m_cores) return;
-
-		const int curupdate = (int)(((double)value/(double)m_maximum[thread_id])*1000);
-		if(curupdate == m_lastupdate[thread_id]) return;
-		m_lastupdate[thread_id] = curupdate;
-
-		m_msg[thread_id]->SetLabel(msg);
-
-		if(value >= (u32)m_maximum[thread_id]) return;
-		m_gauge[thread_id]->SetValue(((double)value / (double)m_maximum[thread_id]) * maxdial);
-	}
-
-	const u32 GetMaxValue(const uint thread_id) const
-	{
-		if(thread_id > m_cores) return 0;
-		return m_maximum[thread_id];
-	}
-
-	void SetMaxFor(const uint thread_id, const u64 val)
-	{
-		if(thread_id > m_cores) return;
-		m_maximum[thread_id] = val;
-		m_lastupdate[thread_id] = 0;
-	}
-
-	virtual void Close(bool force = false)
-	{
-		m_lastupdate.Empty();
-		m_maximum.Empty();
-
-		wxDialog::Close(force);
-	}
-};
@@ -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
@@ -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__ */
@@ -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
-}
@@ -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;
-}
@@ -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();
-		}
-	}
-};
@@ -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;
-}
@@ -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();
-	}
-};
@@ -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;
-	}
-};
@@ -1,73 +1,353 @@
 #include "StrFmt.h"
 #include "BEType.h"
 #include "StrUtil.h"
+#include "cfmt.h"

-#include <cassert>
-#include <array>
-#include <memory>
 #include <algorithm>
+#include <string_view>

-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
+template <>
+void fmt_class_string<fmt::base57>::format(std::string& out, u64 arg)
 {
-	va_list args;
-	va_start(args, fmt);
-	auto result = unsafe_vformat(fmt, args);
-	va_end(args);
+	const auto& _arg = get_object(arg);

-	return result;
+	if (_arg.data && _arg.size)
+	{
+		// Precomputed tail sizes if input data is not multiple of 8
+		static constexpr u8 s_tail[8] = {0, 2, 3, 5, 6, 7, 9, 10};
+
+		// Get full output size
+		const std::size_t out_size = _arg.size / 8 * 11 + s_tail[_arg.size % 8];
+
+		out.resize(out.size() + out_size);
+
+		const auto ptr = &out.front() + (out.size() - out_size);
+
+		// Each 8 bytes of input data produce 11 bytes of base57 output
+		for (std::size_t i = 0, p = 0; i < _arg.size; i += 8, p += 11)
+		{
+			// Load up to 8 bytes
+			be_t<u64> be_value;
+
+			if (_arg.size - i < sizeof(be_value))
+			{
+				std::memset(&be_value, 0, sizeof(be_value));
+				std::memcpy(&be_value, _arg.data + i, _arg.size - i);
+			}
+			else
+			{
+				std::memcpy(&be_value, _arg.data + i, sizeof(be_value));
+			}
+
+			u64 value = be_value;
+
+			for (int j = 10; j >= 0; j--)
+			{
+				if (p + j < out_size)
+				{
+					ptr[p + j] = "0123456789ACEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"[value % 57];
+				}
+
+				value /= 57;
+			}
+		}
+	}
 }

-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 void*>::format(std::string& out, u64 arg)
 {
-	va_end(m_args);
+	fmt::append(out, "%p", arg);
+}
+
+void fmt_class_string<const char*>::format(std::string& out, u64 arg)
+{
+	if (arg)
+	{
+		out += reinterpret_cast<const char*>(arg);
+	}
+	else
+	{
+		out += "(NULLSTR)";
+	}
+}
+
+template <>
+void fmt_class_string<std::string>::format(std::string& out, u64 arg)
+{
+	out += get_object(arg);
+}
+
+template <>
+void fmt_class_string<std::string_view>::format(std::string& out, u64 arg)
+{
+	out += get_object(arg);
+}
+
+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 + 1;
+		args += extra + 1;
+	}
+
+	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;
+	}
+
+	static constexpr std::size_t size_char  = 1;
+	static constexpr std::size_t size_short = 2;
+	static constexpr std::size_t size_int   = 0;
+	static constexpr std::size_t size_long  = sizeof(ulong);
+	static constexpr std::size_t size_llong = sizeof(ullong);
+	static constexpr std::size_t size_size  = sizeof(std::size_t);
+	static constexpr std::size_t size_max   = sizeof(std::uintmax_t);
+	static constexpr std::size_t size_diff  = sizeof(std::ptrdiff_t);
+};
+
+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 +362,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 +382,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 +391,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 +410,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 +423,15 @@ std::string fmt::to_upper(const std::string& string)
 	return result;
 }

-bool fmt::match(const std::string &source, const std::string &mask)
+std::string fmt::to_lower(const std::string& string)
+{
+	std::string result;
+	result.resize(string.size());
+	std::transform(string.begin(), string.end(), result.begin(), ::tolower);
+	return result;
+}
+
+bool fmt::match(const std::string& source, const std::string& mask)
 {
 	std::size_t source_position = 0, mask_position = 0;

@@ -1,52 +1,316 @@
 #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<> error: incomplete type");
+
+	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...);
+		// Allow implicit conversion
+		operator u64() const
+		{
+			return reinterpret_cast<std::uintptr_t>(&arg);
+		}
 	};

-	// Exception type derived from std::runtime_error with formatting constructor
-	class exception : public exception_base
+	// This overload resolution takes the precedence
+	static inline u64_wrapper get(T&& arg)
 	{
-	public:
-		template<typename... Args>
-		exception(const char* fmt, const Args&... args)
-			: exception_base(fmt, ::unveil<Args>::get(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 as u64
+	static inline u64 get(const f64& arg)
+	{
+		return *reinterpret_cast<const u64*>(reinterpret_cast<const u8*>(&arg));
+	}
+};
+
+template <>
+struct fmt_unveil<f16, void>
+{
+	using type = f16;
+
+	static inline u64 get(const f16& arg)
+	{
+		return fmt_unveil<f64>::get(arg.operator float());
+	}
+};
+
+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 = std::add_const_t<T>*;
+
+	static inline u64 get(type arg)
+	{
+		return reinterpret_cast<std::uintptr_t>(arg);
+	}
+};
+
+template <typename T, std::size_t N>
+struct fmt_unveil<T[N], void>
+{
+	using type = std::add_const_t<T>*;
+
+	static inline u64 get(type 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));
+	}
+
+	// Enum -> string function type
+	using convert_t = const char*(*)(T value);
+
+	// Enum -> string function registered
+	static convert_t convert_enum;
+
+	// Helper function (safely converts arg to enum value)
+	static SAFE_BUFFERS FORCE_INLINE void format_enum(std::string& out, u64 arg, convert_t convert)
+	{
+		// Save convert function
+		if (convert_enum == nullptr)
+		{
+			convert_enum = convert;
+		}
+
+		const auto value = static_cast<std::underlying_type_t<T>>(arg);
+
+		// Check narrowing
+		if (static_cast<u64>(value) == arg)
+		{
+			if (const char* str = convert(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 <typename T, typename V>
+const char*(*fmt_class_string<T, V>::convert_enum)(T) = 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
+{
+	// Base-57 format helper
+	struct base57
+	{
+		const uchar* data;
+		std::size_t size;
+
+		template <typename T>
+		base57(const T& arg)
+			: data(reinterpret_cast<const uchar*>(&arg))
+			, size(sizeof(T))
+		{
+		}
+
+		base57(const uchar* data, std::size_t size)
+			: data(data)
+			, size(size)
 		{
 		}
 	};

-	// 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>())))
+	template <typename... Args>
+	SAFE_BUFFERS FORCE_INLINE const fmt_type_info* get_type_info()
 	{
-		const auto result = static_cast<To>(value);
-		if (static_cast<From>(result) != value) throw fmt::exception(format_str, value, args...);
+		// Constantly initialized null-terminated list of type-specific information
+		static constexpr fmt_type_info result[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
+
 		return result;
 	}
+
+	template <typename... Args>
+	constexpr const fmt_type_info type_info_v[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
+
+	// 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)
+	{
+		static constexpr fmt_type_info type_list[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
+		raw_append(out, fmt, type_list, 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)
+	{
+		static constexpr fmt_type_info type_list[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
+		raw_throw_exception<T>(fmt, type_list, fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+	}
 }
@@ -5,10 +5,11 @@
 #include <string>
 #include <vector>
 #include <functional>
+#include <string_view>

 // 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,21 +17,27 @@ 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);
 	dst[count] = '\0';
 }

+template <std::size_t N>
+inline bool ends_with(const std::string& src, const char (&end)[N])
+{
+	return src.size() >= N - 1 && src.compare(src.size() - (N - 1), N - 1, end, N - 1) == 0;
+}
+
 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 +60,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,43 +87,43 @@ 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)
 		{
-			result += *it + separator;
+			result += std::string{*it} + separator;
 		}

-		return result + source.back();
+		return result + std::string{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
 			{
@@ -128,6 +135,7 @@ namespace fmt
 	}

 	std::string to_upper(const std::string& string);
+	std::string to_lower(const std::string& string);

-	bool match(const std::string &source, const std::string &mask);
+	bool match(const std::string& source, const std::string& mask);
 }
@@ -1,375 +1,430 @@
 #pragma once

-#include <exception>
+#include "types.h"
+#include "Atomic.h"
+
 #include <string>
 #include <memory>
+#include <string_view>

-#include "Platform.h"
-#include "Atomic.h"
+#include "mutex.h"
+#include "cond.h"
+#include "lockless.h"
+
+// Report error and call std::abort(), defined in main.cpp
+[[noreturn]] void report_fatal_error(const std::string&);

 // Will report exception and call std::abort() if put in catch(...)
 [[noreturn]] void catch_all_exceptions();

-// Simple list of void() functors
-class task_stack
+// Hardware core layout
+enum class native_core_arrangement : u32
 {
-	struct task_base
-	{
-		std::unique_ptr<task_base> next;
-
-		virtual ~task_base() = default;
-
-		virtual void exec()
-		{
-			if (next)
-			{
-				next->exec();
-			}
-		}
-	};
-
-	template<typename F>
-	struct task_type : task_base
-	{
-		std::remove_reference_t<F> func;
-
-		task_type(F&& func)
-			: func(std::forward<F>(func))
-		{
-		}
-
-		void exec() override
-		{
-			func();
-			task_base::exec();
-		}
-	};
-
-	std::unique_ptr<task_base> m_stack;
-
-public:
-	task_stack() = default;
-
-	template<typename F>
-	task_stack(F&& func)
-		: m_stack(new task_type<F>(std::forward<F>(func)))
+	undefined,
+	generic,
+	intel_ht,
+	amd_ccx
+};
+
+enum class thread_class : u32
+{
+	general,
+	rsx,
+	spu,
+	ppu
+};
+
+enum class thread_state
+{
+	created,  // Initial state
+	detached, // The thread has been detached to destroy its own named_thread object (can be dangerously misused)
+	aborting, // The thread has been joined in the destructor or explicitly aborted (mutually exclusive with detached)
+	finished  // Final state, always set at the end of thread execution
+};
+
+template <class Context>
+class named_thread;
+
+template <typename T>
+struct result_storage
+{
+	alignas(T) std::byte data[sizeof(T)];
+
+	static constexpr bool empty = false;
+
+	using type = T;
+
+	T* get()
 	{
+		return reinterpret_cast<T*>(&data);
 	}

-	void push(task_stack stack)
+	const T* get() const
 	{
-		auto _top = stack.m_stack.release();
-		auto _next = m_stack.release();
-		m_stack.reset(_top);
-		while (UNLIKELY(_top->next)) _top = _top->next.get();
-		_top->next.reset(_next);
+		return reinterpret_cast<const T*>(&data);
 	}

-	void reset()
+	void destroy() noexcept
 	{
-		m_stack.reset();
-	}
-
-	void exec() const
-	{
-		if (m_stack)
-		{
-			m_stack->exec();
-		}
+		get()->~T();
 	}
 };

-// Thread control class
-class thread_ctrl final
+template <>
+struct result_storage<void>
 {
-public: // TODO
-	struct internal;
+	static constexpr bool empty = true;

-private:
-	static thread_local thread_ctrl* g_tls_this_thread;
+	using type = void;
+};

-	// Thread handle storage
-	std::aligned_storage_t<16> m_thread;
+template <class Context, typename... Args>
+using result_storage_t = result_storage<std::invoke_result_t<Context, Args...>>;

-	// Thread join contention counter
-	atomic_t<u32> m_joining{};
+// Detect on_abort() method (should return void)
+template <typename T, typename = void>
+struct thread_on_abort : std::bool_constant<false> {};

-	// Thread internals
-	atomic_t<internal*> m_data{};
+template <typename T>
+struct thread_on_abort<T, decltype(std::declval<named_thread<T>&>().on_abort())> : std::bool_constant<true> {};

-	// Fixed name
-	std::string m_name;
+// Detect on_cleanup() static member function (should return void) (in C++20 can use destroying delete instead)
+template <typename T, typename = void>
+struct thread_on_cleanup : std::bool_constant<false> {};
+
+template <typename T>
+struct thread_on_cleanup<T, decltype(named_thread<T>::on_cleanup(std::declval<named_thread<T>*>()))> : std::bool_constant<true> {};
+
+// Thread base class
+class thread_base
+{
+	// Native thread entry point function type
+#ifdef _WIN32
+	using native_entry = uint(__stdcall*)(void* arg);
+#else
+	using native_entry = void*(*)(void* arg);
+#endif
+
+	// Thread handle (platform-specific)
+	atomic_t<std::uintptr_t> m_thread{0};
+
+	// Thread mutex
+	mutable shared_mutex m_mutex;
+
+	// Thread condition variable
+	cond_variable m_cond;
+
+	// Thread flags
+	atomic_t<u32> m_signal{0};
+
+	// Thread joining condition variable
+	mutable cond_variable m_jcv;
+
+	// Thread state
+	atomic_t<thread_state> m_state = thread_state::created;
+
+	// Thread name
+	lf_value<std::string> m_name;
+
+	//
+	atomic_t<u64> m_cycles = 0;

 	// Start thread
-	static void start(const std::shared_ptr<thread_ctrl>&, task_stack);
+	void start(native_entry);

 	// Called at the thread start
 	void initialize();

-	// Called at the thread end
-	void finalize() noexcept;
+	// Called at the thread end, returns true if needs destruction
+	bool finalize(int) noexcept;

-	// Get atexit function
-	void push_atexit(task_stack);
+	// Cleanup after possibly deleting the thread instance
+	static void finalize() noexcept;

-	// Start waiting
-	void wait_start(u64 timeout);
+	friend class thread_ctrl;

-	// Proceed waiting
-	bool wait_wait(u64 timeout);
+	template <class Context>
+	friend class named_thread;

-	// Check exception
-	void test();
+protected:
+	thread_base(std::string_view name);
+
+	~thread_base();

 public:
-	thread_ctrl(std::string&& name);
+	// Get CPU cycles since last time this function was called. First call returns 0.
+	u64 get_cycles();

-	thread_ctrl(const thread_ctrl&) = delete;
+	// Wait for the thread (it does NOT change thread state, and can be called from multiple threads)
+	void join() const;

-	~thread_ctrl();
+	// Notify the thread
+	void notify();
+};
+
+// Collection of global function for current thread
+class thread_ctrl final
+{
+	// Current thread
+	static thread_local thread_base* g_tls_this_thread;
+
+	// Target cpu core layout
+	static atomic_t<native_core_arrangement> g_native_core_layout;
+
+	// Internal waiting function, may throw. Infinite value is -1.
+	static bool _wait_for(u64 usec);
+
+	friend class thread_base;
+
+public:
+	// Get current thread name
+	static std::string_view get_name()
+	{
+		return g_tls_this_thread->m_name.get();
+	}

 	// Get thread name
-	const std::string& get_name() const
+	template <typename T>
+	static std::string_view get_name(const named_thread<T>& thread)
 	{
-		return m_name;
+		return static_cast<const thread_base&>(thread).m_name.get();
 	}

-	// Initialize internal data
-	void initialize_once();
-
-	// 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)
+	// Set current thread name (not recommended)
+	static void set_name(std::string_view name)
 	{
-		if (pred())
-		{
-			lock();
-
-			try
-			{
-				if (LIKELY(pred()))
-				{
-					return true;
-				}
-				else
-				{
-					unlock();
-					return false;
-				}
-			}
-			catch (...)
-			{
-				unlock();
-				throw;
-			}
-		}
-		else
-		{
-			return false;
-		}
+		g_tls_this_thread->m_name.assign(name);
 	}

-	// 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)
-	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)
+	// Set thread name (not recommended)
+	template <typename T>
+	static void set_name(named_thread<T>& thread, std::string_view name)
 	{
-		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;
-			}
-		}
+		static_cast<thread_base&>(thread).m_name.assign(name);
 	}

-	// Wait until pred(). Abortable, may throw. Thread must be locked.
-	template<typename F>
-	static inline auto wait(F&& pred)
+	template <typename T>
+	static u64 get_cycles(named_thread<T>& thread)
 	{
-		while (true)
-		{
-			g_tls_this_thread->test();
-
-			if (auto&& result = pred())
-			{
-				return result;
-			}
-
-			g_tls_this_thread->wait_wait(0);
-		}
+		return static_cast<thread_base&>(thread).get_cycles();
 	}

-	// Wait once. Thread must be locked.
+	template <typename T>
+	static void notify(named_thread<T>& thread)
+	{
+		static_cast<thread_base&>(thread).notify();
+	}
+
+	// Read current state
+	static inline thread_state state()
+	{
+		return g_tls_this_thread->m_state;
+	}
+
+	// Wait once with timeout. May spuriously return false.
+	static inline bool wait_for(u64 usec)
+	{
+		return _wait_for(usec);
+	}
+
+	// Wait.
 	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.
-	[[noreturn]] static inline void eternalize()
+	// Wait until pred().
+	template <typename F, typename RT = std::invoke_result_t<F>>
+	static inline RT wait(F&& pred)
 	{
 		while (true)
 		{
-			g_tls_this_thread->test();
-			g_tls_this_thread->wait_wait(0);
+			if (RT result = pred())
+			{
+				return result;
+			}
+
+			_wait_for(-1);
 		}
 	}

 	// Get current thread (may be nullptr)
-	static thread_ctrl* get_current()
+	static thread_base* get_current()
 	{
 		return g_tls_this_thread;
 	}

-	// Register function at thread exit (for the current thread)
-	template<typename F>
-	static inline void atexit(F&& func)
+	// Detect layout
+	static void detect_cpu_layout();
+
+	// Returns a core affinity mask. Set whether to generate the high priority set or not
+	static u16 get_affinity_mask(thread_class group);
+
+	// Sets the native thread priority
+	static void set_native_priority(int priority);
+
+	// Sets the preferred affinity mask for this thread
+	static void set_thread_affinity_mask(u16 mask);
+
+	// Spawn a detached named thread
+	template <typename F>
+	static void spawn(std::string_view name, F&& func)
 	{
-		return g_tls_this_thread->push_atexit(std::forward<F>(func));
-	}
-
-	// Named thread factory
-	template<typename N, typename F>
-	static inline std::shared_ptr<thread_ctrl> spawn(N&& name, F&& func)
-	{
-		auto ctrl = std::make_shared<thread_ctrl>(std::forward<N>(name));
-
-		thread_ctrl::start(ctrl, std::forward<F>(func));
-
-		return ctrl;
+		new named_thread<F>(thread_state::detached, name, std::forward<F>(func));
 	}
 };

-class named_thread : public std::enable_shared_from_this<named_thread>
+// Derived from the callable object Context, possibly a lambda
+template <class Context>
+class named_thread final : public Context, result_storage_t<Context>, thread_base
 {
-	// Pointer to managed resource (shared with actual thread)
-	std::shared_ptr<thread_ctrl> m_thread;
+	using result = result_storage_t<Context>;
+	using thread = thread_base;
+
+	// Type-erased thread entry point
+#ifdef _WIN32
+	static inline uint __stdcall entry_point(void* arg) try
+#else
+	static inline void* entry_point(void* arg) try
+#endif
+	{
+		const auto _this = static_cast<named_thread*>(static_cast<thread*>(arg));
+
+		// Perform self-cleanup if necessary
+		if (_this->entry_point())
+		{
+			// Call on_cleanup() static member function if it's available
+			if constexpr (thread_on_cleanup<Context>())
+			{
+				Context::on_cleanup(_this);
+			}
+			else
+			{
+				delete _this;
+			}
+		}
+
+		thread::finalize();
+		return 0;
+	}
+	catch (...)
+	{
+		catch_all_exceptions();
+	}
+
+	bool entry_point()
+	{
+		thread::initialize();
+
+		if constexpr (result::empty)
+		{
+			// No result
+			Context::operator()();
+		}
+		else
+		{
+			// Construct the result using placement new (copy elision should happen)
+			new (result::get()) typename result::type(Context::operator()());
+		}
+
+		return thread::finalize(0);
+	}
+
+	// Detached thread constructor
+	named_thread(thread_state s, std::string_view name, Context&& f)
+		: Context(std::forward<Context>(f))
+		, thread(name)
+	{
+		thread::m_state.raw() = s;
+		thread::start(&named_thread::entry_point);
+	}
+
+	friend class thread_ctrl;

 public:
-	named_thread();
+	// Normal forwarding constructor
+	template <typename... Args, typename = std::enable_if_t<std::is_constructible_v<Context, Args&&...>>>
+	named_thread(std::string_view name, Args&&... args)
+		: Context(std::forward<Args>(args)...)
+		, thread(name)
+	{
+		thread::start(&named_thread::entry_point);
+	}

-	virtual ~named_thread();
+	// Lambda constructor, also the implicit deduction guide candidate
+	named_thread(std::string_view name, Context&& f)
+		: Context(std::forward<Context>(f))
+		, thread(name)
+	{
+		thread::start(&named_thread::entry_point);
+	}

-	// Deleted copy/move constructors + copy/move operators
 	named_thread(const named_thread&) = delete;

-	// Get thread name
-	virtual std::string get_name() const;
+	named_thread& operator=(const named_thread&) = delete;

-protected:
-	// Start thread (cannot be called from the constructor: should throw bad_weak_ptr in such case)
-	void start();
-
-	// Thread task (called in the thread)
-	virtual void on_task() = 0;
-
-	// Thread finalization (called after on_task)
-	virtual void on_exit() {}
-
-public:
-	// ID initialization
-	virtual void on_init()
+	// Wait for the completion and access result (if not void)
+	[[nodiscard]] decltype(auto) operator()()
 	{
-		start();
+		thread::join();
+
+		if constexpr (!result::empty)
+		{
+			return *result::get();
+		}
 	}

-	// ID finalization
-	virtual void on_stop()
+	// Wait for the completion and access result (if not void)
+	[[nodiscard]] decltype(auto) operator()() const
 	{
-		m_thread->join();
+		thread::join();
+
+		if constexpr (!result::empty)
+		{
+			return *result::get();
+		}
 	}

-	// Access thread_ctrl
-	thread_ctrl* operator->() const
+	// Access thread state
+	operator thread_state() 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)
-	{
-		m_thread->lock();
-	}
-
-	// Lock specified named_thread
-	thread_lock(named_thread& thread)
-		: thread_lock(thread.operator->())
-	{
-	}
-
-	// Lock current thread
-	thread_lock()
-		: thread_lock(thread_ctrl::get_current())
-	{
-	}
-
-	~thread_lock()
-	{
-		m_thread->unlock();
-	}
-};
-
-// Wrapper for named thread, joins automatically in the destructor, can only be used in function scope
-class scope_thread final
-{
-	std::shared_ptr<thread_ctrl> m_thread;
-
-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)))
-	{
-	}
-
-	// Deleted copy/move constructors + copy/move operators
-	scope_thread(const scope_thread&) = delete;
-
-	// Destructor with exceptions allowed
-	~scope_thread() noexcept(false)
-	{
-		m_thread->join();
+		return thread::m_state.load();
+	}
+
+	// Try to abort/detach
+	named_thread& operator=(thread_state s)
+	{
+		if (s != thread_state::aborting && s != thread_state::detached)
+		{
+			ASSUME(0);
+		}
+
+		if (thread::m_state.compare_and_swap_test(thread_state::created, s))
+		{
+			if (s == thread_state::aborting)
+			{
+				// Call on_abort() method if it's available
+				if constexpr (thread_on_abort<Context>())
+				{
+					Context::on_abort();
+				}
+			}
+
+			thread::notify();
+		}
+
+		return *this;
+	}
+
+	// Context type doesn't need virtual destructor
+	~named_thread()
+	{
+		*this = thread_state::aborting;
+		thread::join();
+
+		if constexpr (!result::empty)
+		{
+			result::destroy();
+		}
 	}
 };
@@ -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,15 +38,22 @@ 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();
 	}
+
+	u64 GetMsSince(std::chrono::steady_clock::time_point timestamp)
+	{
+		std::chrono::steady_clock::time_point now = m_stopped ? m_end : std::chrono::steady_clock::now();
+
+		return std::chrono::duration_cast<std::chrono::milliseconds>(now - timestamp).count();
+	}
 };
@@ -7,39 +7,272 @@
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include <errno.h>
 #include <unistd.h>
 #include <sys/types.h>
 #endif

-namespace memory_helper
+#ifdef __linux__
+#include <sys/syscall.h>
+
+#ifdef __NR_memfd_create
+#elif __x86_64__
+#define __NR_memfd_create 319
+#elif __aarch64__
+#define __NR_memfd_create 279
+#endif
+
+static int memfd_create_(const char *name, uint flags)
 {
-	void* reserve_memory(size_t size)
+    return syscall(__NR_memfd_create, name, flags);
+}
+#endif
+
+namespace utils
+{
+	// Convert memory protection (internal)
+	static auto operator +(protection prot)
 	{
 #ifdef _WIN32
-		void* ret = VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS);
-		ENSURES(ret != NULL);
+		DWORD _prot = PAGE_NOACCESS;
+		switch (prot)
+		{
+		case protection::rw: _prot = PAGE_READWRITE; break;
+		case protection::ro: _prot = PAGE_READONLY; break;
+		case protection::no: break;
+		case protection::wx: _prot = PAGE_EXECUTE_READWRITE; break;
+		case protection::rx: _prot = PAGE_EXECUTE_READ; break;
+		}
 #else
-		void* ret = mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
-		ENSURES(ret != 0);
+		int _prot = PROT_NONE;
+		switch (prot)
+		{
+		case protection::rw: _prot = PROT_READ | PROT_WRITE; break;
+		case protection::ro: _prot = PROT_READ; break;
+		case protection::no: break;
+		case protection::wx: _prot = PROT_READ | PROT_WRITE | PROT_EXEC; break;
+		case protection::rx: _prot = PROT_READ | PROT_EXEC; break;
+		}
 #endif
-		return ret;
+
+		return _prot;
 	}

-	void commit_page_memory(void* pointer, size_t size)
+	void* memory_reserve(std::size_t size, void* use_addr)
 	{
 #ifdef _WIN32
-		VERIFY(VirtualAlloc(pointer, size, MEM_COMMIT, PAGE_READWRITE) != NULL);
+		return ::VirtualAlloc(use_addr, size, MEM_RESERVE, PAGE_NOACCESS);
 #else
-		VERIFY(mprotect((void*)((u64)pointer & -4096), size, PROT_READ | PROT_WRITE) != -1);
+		auto ptr = ::mmap(use_addr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
+
+		if (use_addr && ptr != use_addr)
+		{
+			::munmap(ptr, size);
+			return nullptr;
+		}
+
+		return ptr;
 #endif
 	}

-	void free_reserved_memory(void* pointer, size_t size)
+	void memory_commit(void* pointer, std::size_t size, protection prot)
 	{
 #ifdef _WIN32
-		VERIFY(VirtualFree(pointer, 0, MEM_DECOMMIT) != 0);
+		verify(HERE), ::VirtualAlloc(pointer, size, MEM_COMMIT, +prot);
 #else
-		VERIFY(mprotect(pointer, size, PROT_NONE) != -1);
+		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), size + ((u64)pointer & 4095), +prot) != -1;
+#endif
+	}
+
+	void memory_decommit(void* pointer, std::size_t size)
+	{
+#ifdef _WIN32
+		verify(HERE), ::VirtualFree(pointer, size, MEM_DECOMMIT);
+#else
+		verify(HERE), ::mmap(pointer, size, PROT_NONE, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
+#endif
+	}
+
+	void memory_reset(void* pointer, std::size_t size, protection prot)
+	{
+#ifdef _WIN32
+		memory_decommit(pointer, size);
+		memory_commit(pointer, size, prot);
+#else
+		verify(HERE), ::mmap(pointer, size, +prot, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
+#endif
+	}
+
+	void memory_release(void* pointer, std::size_t size)
+	{
+#ifdef _WIN32
+		verify(HERE), ::VirtualFree(pointer, 0, MEM_RELEASE);
+#else
+		verify(HERE), ::munmap(pointer, size) != -1;
+#endif
+	}
+
+	void memory_protect(void* pointer, std::size_t size, protection prot)
+	{
+#ifdef _WIN32
+		for (u64 addr = (u64)pointer, end = addr + size; addr < end;)
+		{
+			const u64 boundary = (addr + 0x10000) & -0x10000;
+			const u64 block_size = std::min(boundary, end) - addr;
+
+			DWORD old;
+			if (!::VirtualProtect((LPVOID)addr, block_size, +prot, &old))
+			{
+				fmt::throw_exception("VirtualProtect failed (%p, 0x%x, addr=0x%x, error=%#x)", pointer, size, addr, GetLastError());
+			}
+
+			// Next region
+			addr += block_size;
+		}
+#else
+		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), size + ((u64)pointer & 4095), +prot) != -1;
+#endif
+	}
+
+	shm::shm(u32 size)
+		: m_size(::align(size, 0x10000))
+	{
+#ifdef _WIN32
+		m_handle = ::CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, 0, m_size, NULL);
+		verify(HERE), m_handle != INVALID_HANDLE_VALUE;
+#elif __linux__
+		m_file = ::memfd_create_("", 0);
+		verify(HERE), m_file >= 0;
+		verify(HERE), ::ftruncate(m_file, m_size) >= 0;
+#else
+		while ((m_file = ::shm_open("/rpcs3-mem1", O_RDWR | O_CREAT | O_EXCL, S_IWUSR | S_IRUSR)) == -1)
+		{
+			if (m_file == -1 && errno == EMFILE)
+			{
+				fmt::throw_exception("Too many open files. Raise the limit and try again.");
+			}
+
+			verify(HERE), errno == EEXIST;
+		}
+
+		verify(HERE), ::shm_unlink("/rpcs3-mem1") >= 0;
+		verify(HERE), ::ftruncate(m_file, m_size) >= 0;
+#endif
+	}
+
+	shm::~shm()
+	{
+#ifdef _WIN32
+		::CloseHandle(m_handle);
+#else
+		::close(m_file);
+#endif
+	}
+
+	u8* shm::map(void* ptr, protection prot) const
+	{
+#ifdef _WIN32
+		DWORD access = FILE_MAP_WRITE;
+		switch (prot)
+		{
+		case protection::rw:
+		case protection::ro:
+		case protection::no:
+			break;
+		case protection::wx:
+		case protection::rx:
+			access |= FILE_MAP_EXECUTE;
+			break;
+		}
+
+		if (auto ret = static_cast<u8*>(::MapViewOfFileEx(m_handle, access, 0, 0, m_size, ptr)))
+		{
+			if (prot != protection::rw && prot != protection::wx)
+			{
+				DWORD old;
+				if (!::VirtualProtect(ret, m_size, +prot, &old))
+				{
+					::UnmapViewOfFile(ret);
+					return nullptr;
+				}
+			}
+
+			return ret;
+		}
+
+		return nullptr;
+#else
+		return static_cast<u8*>(::mmap((void*)((u64)ptr & -0x10000), m_size, +prot, MAP_SHARED | (ptr ? MAP_FIXED : 0), m_file, 0));
+#endif
+	}
+
+	u8* shm::map_critical(void* ptr, protection prot)
+	{
+		const auto target = (u8*)((u64)ptr & -0x10000);
+
+#ifdef _WIN32
+		::MEMORY_BASIC_INFORMATION mem;
+		if (!::VirtualQuery(target, &mem, sizeof(mem)) || mem.State != MEM_RESERVE || !::VirtualFree(mem.AllocationBase, 0, MEM_RELEASE))
+		{
+			return nullptr;
+		}
+
+		const auto base = (u8*)mem.AllocationBase;
+		const auto size = mem.RegionSize + (target - base);
+
+		if (base < target && !::VirtualAlloc(base, target - base, MEM_RESERVE, PAGE_NOACCESS))
+		{
+			return nullptr;
+		}
+
+		if (target + m_size < base + size && !::VirtualAlloc(target + m_size, base + size - target - m_size, MEM_RESERVE, PAGE_NOACCESS))
+		{
+			return nullptr;
+		}
+#endif
+
+		return this->map(target, prot);
+	}
+
+	void shm::unmap(void* ptr) const
+	{
+#ifdef _WIN32
+		::UnmapViewOfFile(ptr);
+#else
+		::munmap(ptr, m_size);
+#endif
+	}
+
+	void shm::unmap_critical(void* ptr)
+	{
+		const auto target = (u8*)((u64)ptr & -0x10000);
+
+		this->unmap(target);
+
+#ifdef _WIN32
+		::MEMORY_BASIC_INFORMATION mem, mem2;
+		if (!::VirtualQuery(target - 1, &mem, sizeof(mem)) || !::VirtualQuery(target + m_size, &mem2, sizeof(mem2)))
+		{
+			return;
+		}
+
+		if (mem.State == MEM_RESERVE && !::VirtualFree(mem.AllocationBase, 0, MEM_RELEASE))
+		{
+			return;
+		}
+
+		if (mem2.State == MEM_RESERVE && !::VirtualFree(mem2.AllocationBase, 0, MEM_RELEASE))
+		{
+			return;
+		}
+
+		const auto size1 = mem.State == MEM_RESERVE ? target - (u8*)mem.AllocationBase : 0;
+		const auto size2 = mem2.State == MEM_RESERVE ? mem2.RegionSize : 0;
+
+		if (!::VirtualAlloc(mem.State == MEM_RESERVE ? mem.AllocationBase : target, m_size + size1 + size2, MEM_RESERVE, PAGE_NOACCESS))
+		{
+			return;
+		}
 #endif
 	}
 }
@@ -1,22 +1,76 @@
 #pragma once

-namespace memory_helper
+namespace utils
 {
+	// Memory protection type
+	enum class protection
+	{
+		rw, // Read + write (default)
+		ro, // Read only
+		no, // No access
+		wx, // Read + write + execute
+		rx, // Read + execute
+	};
+
 	/**
 	* Reserve `size` bytes of virtual memory and returns it.
 	* The memory should be commited before usage.
 	*/
-	void* reserve_memory(std::size_t size);
+	void* memory_reserve(std::size_t size, void* use_addr = nullptr);

 	/**
 	* Commit `size` bytes of virtual memory starting at pointer.
 	* That is, bake reserved memory with physical memory.
 	* pointer should belong to a range of reserved memory.
 	*/
-	void commit_page_memory(void* pointer, std::size_t size);
+	void memory_commit(void* pointer, std::size_t size, protection prot = protection::rw);

-	/**
-	* Decommit all memory committed via commit_page_memory.
-	*/
-	void free_reserved_memory(void* pointer, std::size_t size);
+	// Decommit all memory committed via commit_page_memory.
+	void memory_decommit(void* pointer, std::size_t size);
+
+	// Decommit all memory and commit it again.
+	void memory_reset(void* pointer, std::size_t size, protection prot = protection::rw);
+
+	// Free memory after reserved by memory_reserve, should specify original size
+	void memory_release(void* pointer, std::size_t size);
+
+	// Set memory protection
+	void memory_protect(void* pointer, std::size_t size, protection prot);
+
+	// Shared memory handle
+	class shm
+	{
+#ifdef _WIN32
+		void* m_handle;
+#else
+		int m_file;
+#endif
+		u32 m_size;
+
+	public:
+		explicit shm(u32 size);
+
+		shm(const shm&) = delete;
+
+		shm& operator=(const shm&) = delete;
+
+		~shm();
+
+		// Map shared memory
+		u8* map(void* ptr, protection prot = protection::rw) const;
+
+		// Map shared memory over reserved memory region, which is unsafe (non-atomic) under Win32
+		u8* map_critical(void* ptr, protection prot = protection::rw);
+
+		// Unmap shared memory
+		void unmap(void* ptr) const;
+
+		// Unmap shared memory, undoing map_critical
+		void unmap_critical(void* ptr);
+
+		u32 size() const
+		{
+			return m_size;
+		}
+	};
 }
@@ -0,0 +1,590 @@
+#include "types.h"
+#include "StrFmt.h"
+#include <vector>
+
+
+namespace utils
+{
+	class address_range_vector;
+
+
+	/**
+	 * Constexprs
+	 */
+	constexpr inline u32 page_start(u32 addr)
+	{
+		return addr & ~4095u;
+	}
+
+	constexpr inline u32 next_page(u32 addr)
+	{
+		return page_start(addr + 4096u);
+	}
+
+	constexpr inline u32 page_end(u32 addr)
+	{
+		return next_page(addr) - 1;
+	}
+
+	constexpr inline u32 is_page_aligned(u32 addr)
+	{
+		return page_start(addr) == addr;
+	}
+
+
+	/**
+	 * Address Range utility class
+	 */
+	class address_range
+	{
+	public:
+		u32 start = UINT32_MAX; // First address in range
+		u32 end = 0; // Last address
+
+	private:
+		// Helper constexprs
+		static constexpr inline bool range_overlaps(u32 start1, u32 end1, u32 start2, u32 end2)
+		{
+			return (start1 <= end2 && start2 <= end1);
+		}
+
+		static constexpr inline bool address_overlaps(u32 address, u32 start, u32 end)
+		{
+			return (start <= address && address <= end);
+		}
+
+		static constexpr inline bool range_inside_range(u32 start1, u32 end1, u32 start2, u32 end2)
+		{
+			return (start1 >= start2 && end1 <= end2);
+		}
+
+		address_range(u32 _start, u32 _end) : start(_start), end(_end) {};
+
+	public:
+		// Constructors
+		address_range() = default;
+		address_range(const address_range &other) : start(other.start), end(other.end) {};
+
+		static inline address_range start_length(u32 _start, u32 _length)
+		{
+			return address_range(_start, _start + (_length - 1));
+		}
+
+		static inline address_range start_end(u32 _start, u32 _end)
+		{
+			return address_range(_start, _end);
+		}
+
+		// Length
+		u32 length() const
+		{
+			AUDIT(valid());
+			return end - start + 1;
+		}
+
+		void set_length(const u32 new_length)
+		{
+			end = start + new_length - 1;
+			ASSERT(valid());
+		}
+
+		u32 next_address() const
+		{
+			return end + 1;
+		}
+
+		u32 prev_address() const
+		{
+			return start - 1;
+		}
+
+		// Overlapping checks
+		bool overlaps(const address_range &other) const
+		{
+			AUDIT(valid() && other.valid());
+			return range_overlaps(start, end, other.start, other.end);
+		}
+
+		bool overlaps(const u32 addr) const
+		{
+			AUDIT(valid());
+			return address_overlaps(addr, start, end);
+		}
+
+		bool inside(const address_range &other) const
+		{
+			AUDIT(valid() && other.valid());
+			return range_inside_range(start, end, other.start, other.end);
+		}
+
+		inline bool inside(const address_range_vector &vec) const;
+		inline bool overlaps(const address_range_vector &vec) const;
+
+		bool touches(const address_range &other) const
+		{
+			AUDIT(valid() && other.valid());
+			// returns true if there is overlap, or if sections are side-by-side
+			return overlaps(other) || other.start == next_address() || other.end == prev_address();
+		}
+
+		// Utilities
+		s32 signed_distance(const address_range &other) const
+		{
+			if (touches(other))
+			{
+				return 0;
+			}
+
+			// other after this
+			if (other.start > end)
+			{
+				return (s32)(other.start - end - 1);
+			}
+
+			// this after other
+			AUDIT(start > other.end);
+			return -((s32)(start - other.end - 1));
+		}
+
+		u32 distance(const address_range &other) const
+		{
+			if (touches(other))
+			{
+				return 0;
+			}
+
+			// other after this
+			if (other.start > end)
+			{
+				return (other.start - end - 1);
+			}
+
+			// this after other
+			AUDIT(start > other.end);
+			return (start - other.end - 1);
+		}
+
+		address_range get_min_max(const address_range &other) const
+		{
+			return {
+				std::min(valid() ? start : UINT32_MAX, other.valid() ? other.start : UINT32_MAX),
+				std::max(valid() ? end : 0, other.valid() ? other.end : 0)
+			};
+		}
+
+		void set_min_max(const address_range &other)
+		{
+			const address_range _range = get_min_max(other);
+			start = _range.start;
+			end = _range.end;
+		}
+
+		bool is_page_range() const
+		{
+			return (valid() && start % 4096u == 0 && length() % 4096u == 0);
+		}
+
+		address_range to_page_range() const
+		{
+			AUDIT(valid());
+			return { page_start(start), page_end(end) };
+		}
+
+		void page_align()
+		{
+			AUDIT(valid());
+			start = page_start(start);
+			end = page_end(end);
+			AUDIT(is_page_range());
+		}
+
+		address_range get_intersect(const address_range &clamp) const
+		{
+			if (!valid() || !clamp.valid())
+			{
+				return {};
+			}
+
+			return { std::max(start, clamp.start), std::min(end, clamp.end) };
+		}
+
+		void intersect(const address_range &clamp)
+		{
+			if (!clamp.valid())
+			{
+				invalidate();
+			}
+			else
+			{
+				start = std::max(start, clamp.start);
+				end = std::min(end, clamp.end);
+			}
+		}
+
+		// Validity
+		bool valid() const
+		{
+			return (start <= end);
+		}
+
+		void invalidate()
+		{
+			start = UINT32_MAX;
+			end = 0;
+		}
+
+		// Comparison Operators
+		bool operator ==(const address_range &other) const
+		{
+			return (start == other.start && end == other.end);
+		}
+
+		bool operator !=(const address_range &other) const
+		{
+			return (start != other.start || end != other.end);
+		}
+
+		/**
+		 * Debug
+		 */
+		std::string str() const
+		{
+			return fmt::format("{0x%x->0x%x}", start, end);
+		}
+	};
+
+	static inline address_range page_for(u32 addr)
+	{
+		return address_range::start_end(page_start(addr), page_end(addr));
+	}
+
+
+	/**
+	 * Address Range Vector utility class
+	 *
+	 * Collection of address_range objects. Allows for merging and removing ranges from the set.
+	 */
+	class address_range_vector
+	{
+	public:
+		using vector_type = typename std::vector<address_range>;
+		using iterator = typename vector_type::iterator;
+		using const_iterator = typename vector_type::const_iterator;
+		using size_type = typename vector_type::size_type;
+
+	private:
+		vector_type data;
+
+	public:
+		// Wrapped functions
+		inline void reserve(size_t nr) { data.reserve(nr); }
+		inline void clear() { data.clear(); }
+		inline size_type size() const { return data.size(); }
+		inline bool empty() const { return data.empty(); }
+		inline address_range& operator[](size_type n) { return data[n]; }
+		inline const address_range& operator[](size_type n) const { return data[n]; }
+		inline iterator begin() { return data.begin(); }
+		inline const_iterator begin() const { return data.begin(); }
+		inline iterator end() { return data.end(); }
+		inline const_iterator end() const { return data.end(); }
+
+		// Search for ranges that touch new_range. If found, merge instead of adding new_range.
+		// When adding a new range, re-use invalid ranges whenever possible
+		void merge(const address_range &new_range)
+		{
+			// Note the case where we have
+			//   AAAA  BBBB
+			//      CCCC
+			// If we have data={A,B}, and new_range=C, we have to merge A with C, then B with A and invalidate B
+
+			if (!new_range.valid())
+			{
+				return;
+			}
+
+			address_range *found = nullptr;
+			address_range *invalid = nullptr;
+
+			for (auto &existing : data)
+			{
+				if (!existing.valid())
+				{
+					invalid = &existing;
+					continue;
+				}
+
+				// range1 overlaps, is immediately before, or is immediately after range2
+				if (existing.touches(new_range))
+				{
+					if (found != nullptr)
+					{
+						// Already found a match, merge and invalidate "existing"
+						found->set_min_max(existing);
+						existing.invalidate();
+					}
+					else
+					{
+						// First match, merge "new_range"
+						existing.set_min_max(new_range);
+						found = &existing;
+					}
+				}
+			}
+
+			if (found != nullptr)
+			{
+				return;
+			}
+
+			if (invalid != nullptr)
+			{
+				*invalid = new_range;
+			}
+			else
+			{
+				data.push_back(new_range);
+			}
+
+			AUDIT(check_consistency());
+		}
+
+		void merge(const address_range_vector &other)
+		{
+			for (const address_range &new_range : other)
+			{
+				merge(new_range);
+			}
+		}
+
+		// Exclude a given range from data
+		void exclude(const address_range &exclusion)
+		{
+			// Note the case where we have
+			//    AAAAAAA
+			//      EEE
+			// where data={A} and exclusion=E.
+			// In this case, we need to reduce A to the head (before E starts), and then create a new address_range B for the tail (after E ends), i.e.
+			//    AA   BB
+			//      EEE
+
+			if (!exclusion.valid())
+			{
+				return;
+			}
+
+			address_range *invalid = nullptr; // try to re-use an invalid range instead of calling push_back
+
+			// We use index access because we might have to push_back within the loop, which could invalidate the iterators
+			size_type _size = data.size();
+			for (int n = 0; n < _size; ++n)
+			{
+				address_range &existing = data[n];
+
+				if (!existing.valid())
+				{
+					// Null
+					invalid = &existing;
+					continue;
+				}
+
+				if (!existing.overlaps(exclusion))
+				{
+					// No overlap, skip
+					continue;
+				}
+
+				const bool head_excluded = exclusion.overlaps(existing.start); // This section has its start inside excluded range
+				const bool tail_excluded = exclusion.overlaps(existing.end); // This section has its end inside excluded range
+
+				if (head_excluded && tail_excluded)
+				{
+					// Cannot be salvaged, fully excluded
+					existing.invalidate();
+					invalid = &existing;
+				}
+				else if (head_excluded)
+				{
+					// Head overlaps, truncate head
+					existing.start = exclusion.next_address();
+				}
+				else if (tail_excluded)
+				{
+					// Tail overlaps, truncate tail
+					existing.end = exclusion.prev_address();
+				}
+				else
+				{
+					// Section sits in the middle (see comment above function header)
+					AUDIT(exclusion.inside(existing));
+					const auto tail_end = existing.end;
+
+					// Head
+					existing.end = exclusion.prev_address();
+
+					// Tail
+					if (invalid != nullptr)
+					{
+						invalid->start = exclusion.next_address();
+						invalid->end = tail_end;
+						invalid = nullptr;
+					}
+					else
+					{
+						// IMPORTANT: adding to data invalidates "existing". This must be done last!
+						data.push_back(address_range::start_end(exclusion.next_address(), tail_end));
+					}
+				}
+			}
+			AUDIT(check_consistency());
+			AUDIT(!overlaps(exclusion));
+		}
+
+		void exclude(const address_range_vector &other)
+		{
+			for (const address_range &exclusion : other)
+			{
+				exclude(exclusion);
+			}
+		}
+
+		// Checks the consistency of this vector.
+		// Will fail if ranges within the vector overlap our touch each-other
+		bool check_consistency() const
+		{
+			size_t _size = data.size();
+
+			for (int i = 0; i < _size; ++i)
+			{
+				const auto &r1 = data[i];
+				if (!r1.valid())
+				{
+					continue;
+				}
+
+				for (int j = i + 1; j < _size; ++j)
+				{
+					const auto &r2 = data[j];
+					if (!r2.valid())
+					{
+						continue;
+					}
+
+					if (r1.touches(r2))
+					{
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+
+		// Test for overlap with a given range
+		bool overlaps(const address_range &range) const
+		{
+			for (const address_range &current : data)
+			{
+				if (!current.valid())
+				{
+					continue;
+				}
+
+				if (current.overlaps(range))
+				{
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		// Test for overlap with a given address_range vector
+		bool overlaps(const address_range_vector &other) const
+		{
+			for (const address_range &rng1 : data)
+			{
+				if (!rng1.valid())
+				{
+					continue;
+				}
+
+				for (const address_range &rng2 : other.data)
+				{
+					if (!rng2.valid())
+					{
+						continue;
+					}
+
+					if (rng1.overlaps(rng2))
+					{
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+
+		// Test if a given range is fully contained inside this vector
+		bool contains(const address_range &range) const
+		{
+			for (const address_range &cur : *this)
+			{
+				if (!cur.valid())
+				{
+					continue;
+				}
+
+				if (range.inside(cur))
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+
+		// Test if all ranges in this vector are full contained inside a specific range
+		bool inside(const address_range &range) const
+		{
+			for (const address_range &cur : *this)
+			{
+				if (!cur.valid())
+				{
+					continue;
+				}
+
+				if (!cur.inside(range))
+				{
+					return false;
+				}
+			}
+			return true;
+		}
+	};
+
+
+	// These declarations must be done after address_range_vector has been defined
+	bool address_range::inside(const address_range_vector &vec) const
+	{
+		return vec.contains(*this);
+	}
+
+	bool address_range::overlaps(const address_range_vector &vec) const
+	{
+		return vec.overlaps(*this);
+	}
+
+}; // namespace utils
+
+
+namespace std {
+	static_assert(sizeof(size_t) >= 2 * sizeof(u32), "size_t must be at least twice the size of u32");
+
+	template <>
+	struct hash<utils::address_range>
+	{
+		std::size_t operator()(const utils::address_range& k) const
+		{
+			// we can guarantee a unique hash since our type is 64 bits and size_t as well
+			return (size_t{ k.start } << 32) | size_t{ k.end };
+		}
+	};
+};
@@ -0,0 +1,185 @@
+#pragma once
+
+#include "types.h"
+
+namespace utils
+{
+	inline u32 cntlz32(u32 arg, bool nonzero = false)
+	{
+#ifdef _MSC_VER
+		ulong res;
+		return _BitScanReverse(&res, arg) || nonzero ? res ^ 31 : 32;
+#else
+		return arg || nonzero ? __builtin_clz(arg) : 32;
+#endif
+	}
+
+	inline u64 cntlz64(u64 arg, bool nonzero = false)
+	{
+#ifdef _MSC_VER
+		ulong res;
+		return _BitScanReverse64(&res, arg) || nonzero ? res ^ 63 : 64;
+#else
+		return arg || nonzero ? __builtin_clzll(arg) : 64;
+#endif
+	}
+
+	inline u32 cnttz32(u32 arg, bool nonzero = false)
+	{
+#ifdef _MSC_VER
+		ulong res;
+		return _BitScanForward(&res, arg) || nonzero ? res : 32;
+#else
+		return arg || nonzero ? __builtin_ctz(arg) : 32;
+#endif
+	}
+
+	inline u64 cnttz64(u64 arg, bool nonzero = false)
+	{
+#ifdef _MSC_VER
+		ulong res;
+		return _BitScanForward64(&res, arg) || nonzero ? res : 64;
+#else
+		return arg || nonzero ? __builtin_ctzll(arg) : 64;
+#endif
+	}
+
+	inline u8 popcnt16(u16 arg)
+	{
+		const u32 a1 = arg & 0x5555;
+		const u32 a2 = (arg >> 1) & 0x5555;
+		const u32 a3 = a1 + a2;
+		const u32 b1 = a3 & 0x3333;
+		const u32 b2 = (a3 >> 2) & 0x3333;
+		const u32 b3 = b1 + b2;
+		const u32 c1 = b3 & 0x0f0f;
+		const u32 c2 = (b3 >> 4) & 0x0f0f;
+		const u32 c3 = c1 + c2;
+		return static_cast<u8>(c3 + (c3 >> 8));
+	}
+
+// Rotate helpers
+#if defined(__GNUG__)
+
+	inline u8 rol8(u8 x, u8 n)
+	{
+		u8 result = x;
+		__asm__("rolb %[n], %[result]" : [result] "+g"(result) : [n] "c"(n));
+		return result;
+	}
+
+	inline u8 ror8(u8 x, u8 n)
+	{
+		u8 result = x;
+		__asm__("rorb %[n], %[result]" : [result] "+g"(result) : [n] "c"(n));
+		return result;
+	}
+
+	inline u16 rol16(u16 x, u16 n)
+	{
+		u16 result = x;
+		__asm__("rolw %b[n], %[result]" : [result] "+g"(result) : [n] "c"(n));
+		return result;
+	}
+
+	inline u16 ror16(u16 x, u16 n)
+	{
+		u16 result = x;
+		__asm__("rorw %b[n], %[result]" : [result] "+g"(result) : [n] "c"(n));
+		return result;
+	}
+
+	inline u32 rol32(u32 x, u32 n)
+	{
+		u32 result = x;
+		__asm__("roll %b[n], %[result]" : [result] "+g"(result) : [n] "c"(n));
+		return result;
+	}
+
+	inline u32 ror32(u32 x, u32 n)
+	{
+		u32 result = x;
+		__asm__("rorl %b[n], %[result]" : [result] "+g"(result) : [n] "c"(n));
+		return result;
+	}
+
+	inline u64 rol64(u64 x, u64 n)
+	{
+		u64 result = x;
+		__asm__("rolq %b[n], %[result]" : [result] "+g"(result) : [n] "c"(n));
+		return result;
+	}
+
+	inline u64 ror64(u64 x, u64 n)
+	{
+		u64 result = x;
+		__asm__("rorq %b[n], %[result]" : [result] "+g"(result) : [n] "c"(n));
+		return result;
+	}
+
+	inline u64 umulh64(u64 a, u64 b)
+	{
+		u64 result;
+		__asm__("mulq %[b]" : "=d"(result) : [a] "a"(a), [b] "rm"(b));
+		return result;
+	}
+
+	inline s64 mulh64(s64 a, s64 b)
+	{
+		s64 result;
+		__asm__("imulq %[b]" : "=d"(result) : [a] "a"(a), [b] "rm"(b));
+		return result;
+	}
+
+#elif defined(_MSC_VER)
+	inline u8 rol8(u8 x, u8 n)
+	{
+		return _rotl8(x, n);
+	}
+
+	inline u8 ror8(u8 x, u8 n)
+	{
+		return _rotr8(x, n);
+	}
+
+	inline u16 rol16(u16 x, u16 n)
+	{
+		return _rotl16(x, (u8)n);
+	}
+
+	inline u16 ror16(u16 x, u16 n)
+	{
+		return _rotr16(x, (u8)n);
+	}
+
+	inline u32 rol32(u32 x, u32 n)
+	{
+		return _rotl(x, (int)n);
+	}
+
+	inline u32 ror32(u32 x, u32 n)
+	{
+		return _rotr(x, (int)n);
+	}
+
+	inline u64 rol64(u64 x, u64 n)
+	{
+		return _rotl64(x, (int)n);
+	}
+
+	inline u64 ror64(u64 x, u64 n)
+	{
+		return _rotr64(x, (int)n);
+	}
+
+	inline u64 umulh64(u64 x, u64 y)
+	{
+		return __umulh(x, y);
+	}
+
+	inline s64 mulh64(s64 x, s64 y)
+	{
+		return __mulh(x, y);
+	}
+#endif
+} // namespace utils
@@ -0,0 +1,175 @@
+#include "bin_patch.h"
+#include <yaml-cpp/yaml.h>
+#include "File.h"
+#include "Config.h"
+
+template <>
+void fmt_class_string<patch_type>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](patch_type value)
+	{
+		switch (value)
+		{
+		case patch_type::load: return "load";
+		case patch_type::byte: return "byte";
+		case patch_type::le16: return "le16";
+		case patch_type::le32: return "le32";
+		case patch_type::le64: return "le64";
+		case patch_type::bef32: return "bef32";
+		case patch_type::bef64: return "bef64";
+		case patch_type::be16: return "be16";
+		case patch_type::be32: return "be32";
+		case patch_type::be64: return "be64";
+		case patch_type::lef32: return "lef32";
+		case patch_type::lef64: return "lef64";
+		}
+
+		return unknown;
+	});
+}
+
+void patch_engine::append(const std::string& patch)
+{
+	if (fs::file f{patch})
+	{
+		YAML::Node root;
+
+		try
+		{
+			root = YAML::Load(f.to_string());
+		}
+		catch (const std::exception& e)
+		{
+			LOG_FATAL(GENERAL, "Failed to load patch file %s\n%s thrown: %s", patch, typeid(e).name(), e.what());
+			return;
+		}
+
+		for (auto pair : root)
+		{
+			auto& name = pair.first.Scalar();
+			auto& data = m_map[name];
+
+			for (auto patch : pair.second)
+			{
+				u64 type64 = 0;
+				cfg::try_to_enum_value(&type64, &fmt_class_string<patch_type>::format, patch[0].Scalar());
+
+				struct patch info{};
+				info.type   = static_cast<patch_type>(type64);
+				info.offset = patch[1].as<u32>(0);
+
+				switch (info.type)
+				{
+				case patch_type::load:
+				{
+					// Special syntax: copy named sequence (must be loaded before)
+					const auto found = m_map.find(patch[1].Scalar());
+
+					if (found != m_map.end())
+					{
+						// Address modifier (optional)
+						const u32 mod = patch[2].as<u32>(0);
+
+						for (const auto& rd : found->second)
+						{
+							info = rd;
+							info.offset += mod;
+							data.emplace_back(info);
+						}
+
+						continue;
+					}
+
+					// TODO: error
+					break;
+				}
+				case patch_type::bef32:
+				case patch_type::lef32:
+				{
+					info.value_as<f32>() = patch[2].as<f32>();
+					break;
+				}
+				case patch_type::bef64:
+				case patch_type::lef64:
+				{
+					info.value_as<f64>() = patch[2].as<f64>();
+					break;
+				}
+				default:
+				{
+					info.value = patch[2].as<u64>();
+					break;
+				}
+				}
+
+				data.emplace_back(info);
+			}
+		}
+	}
+}
+
+std::size_t patch_engine::apply(const std::string& name, u8* dst) const
+{
+	const auto found = m_map.find(name);
+
+	if (found == m_map.cend())
+	{
+		return 0;
+	}
+
+	// Apply modifications sequentially
+	for (const auto& p : found->second)
+	{
+		auto ptr = dst + p.offset;
+
+		switch (p.type)
+		{
+		case patch_type::load:
+		{
+			// Invalid in this context
+			break;
+		}
+		case patch_type::byte:
+		{
+			*ptr = static_cast<u8>(p.value);
+			break;
+		}
+		case patch_type::le16:
+		{
+			*reinterpret_cast<le_t<u16, 1>*>(ptr) = static_cast<u16>(p.value);
+			break;
+		}
+		case patch_type::le32:
+		case patch_type::lef32:
+		{
+			*reinterpret_cast<le_t<u32, 1>*>(ptr) = static_cast<u32>(p.value);
+			break;
+		}
+		case patch_type::le64:
+		case patch_type::lef64:
+		{
+			*reinterpret_cast<le_t<u64, 1>*>(ptr) = static_cast<u64>(p.value);
+			break;
+		}
+		case patch_type::be16:
+		{
+			*reinterpret_cast<be_t<u16, 1>*>(ptr) = static_cast<u16>(p.value);
+			break;
+		}
+		case patch_type::be32:
+		case patch_type::bef32:
+		{
+			*reinterpret_cast<be_t<u32, 1>*>(ptr) = static_cast<u32>(p.value);
+			break;
+		}
+		case patch_type::be64:
+		case patch_type::bef64:
+		{
+			*reinterpret_cast<be_t<u64, 1>*>(ptr) = static_cast<u64>(p.value);
+			break;
+		}
+		}
+	}
+
+	return found->second.size();
+}
@@ -0,0 +1,48 @@
+#pragma once
+
+#include "BEType.h"
+#include <vector>
+#include <string>
+#include <unordered_map>
+
+enum class patch_type
+{
+	load,
+	byte,
+	le16,
+	le32,
+	le64,
+	lef32,
+	lef64,
+	be16,
+	be32,
+	be64,
+	bef32,
+	bef64,
+};
+
+class patch_engine
+{
+	struct patch
+	{
+		patch_type type;
+		u32 offset;
+		u64 value;
+
+		template <typename T>
+		T& value_as()
+		{
+			return *reinterpret_cast<T*>(reinterpret_cast<char*>(&value));
+		}
+	};
+
+	// Database
+	std::unordered_map<std::string, std::vector<patch>> m_map;
+
+public:
+	// Load from file
+	void append(const std::string& path);
+
+	// Apply patch (returns the number of entries applied)
+	std::size_t apply(const std::string& name, u8* dst) const;
+};
@@ -0,0 +1,413 @@
+#pragma once
+
+/*
+This header implements bs_t<> class for scoped enum types (enum class).
+To enable bs_t<>, 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
+};
+
+This also enables helper operators for this enum type.
+
+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"
+#include "Atomic.h"
+
+template <typename T>
+class atomic_bs_t;
+
+// Bitset type for enum class with available bits [0, T::__bitset_enum_max)
+template <typename T>
+class bs_t final
+{
+public:
+	// Underlying type
+	using under = std::underlying_type_t<T>;
+
+private:
+	// Underlying value
+	under m_data;
+
+	friend class atomic_bs_t<T>;
+
+	// Value constructor
+	constexpr explicit bs_t(int, under data)
+		: m_data(data)
+	{
+	}
+
+public:
+	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 <= bitmax, "bs_t<> error: invalid __bitset_enum_max");
+	static_assert(bitsize != bitmax || std::is_unsigned<under>::value, "bs_t<> error: invalid __bitset_enum_max (sign bit)");
+
+	// Helper function
+	static constexpr under shift(T value)
+	{
+		return static_cast<under>(1) << static_cast<under>(value);
+	}
+
+	bs_t() = default;
+
+	// Construct from a single bit
+	constexpr bs_t(T bit)
+		: m_data(shift(bit))
+	{
+	}
+
+	// Test for empty bitset
+	constexpr explicit operator bool() const
+	{
+		return m_data != 0;
+	}
+
+	// Extract underlying data
+	constexpr explicit operator under() const
+	{
+		return m_data;
+	}
+
+	// Copy
+	constexpr bs_t operator +() const
+	{
+		return *this;
+	}
+
+	constexpr bs_t& operator +=(bs_t rhs)
+	{
+		m_data |= static_cast<under>(rhs);
+		return *this;
+	}
+
+	constexpr bs_t& operator -=(bs_t rhs)
+	{
+		m_data &= ~static_cast<under>(rhs);
+		return *this;
+	}
+
+	constexpr bs_t& operator &=(bs_t rhs)
+	{
+		m_data &= static_cast<under>(rhs);
+		return *this;
+	}
+
+	constexpr bs_t& operator ^=(bs_t rhs)
+	{
+		m_data ^= static_cast<under>(rhs);
+		return *this;
+	}
+
+	constexpr bs_t operator +(bs_t rhs) const
+	{
+		return bs_t(0, m_data | rhs.m_data);
+	}
+
+	constexpr bs_t operator -(bs_t rhs) const
+	{
+		return bs_t(0, m_data & ~rhs.m_data);
+	}
+
+	constexpr bs_t operator &(bs_t rhs) const
+	{
+		return bs_t(0, m_data & rhs.m_data);
+	}
+
+	constexpr bs_t operator ^(bs_t rhs) const
+	{
+		return bs_t(0, m_data ^ rhs.m_data);
+	}
+
+	constexpr bool operator ==(bs_t rhs) const
+	{
+		return m_data == rhs.m_data;
+	}
+
+	constexpr bool operator !=(bs_t rhs) const
+	{
+		return m_data != rhs.m_data;
+	}
+
+	constexpr bool test(bs_t rhs) const
+	{
+		return (m_data & rhs.m_data) != 0;
+	}
+
+	constexpr bool test_and_set(T bit)
+	{
+		bool r = (m_data & shift(bit)) != 0;
+		m_data |= shift(bit);
+		return r;
+	}
+
+	constexpr bool test_and_reset(T bit)
+	{
+		bool r = (m_data & shift(bit)) != 0;
+		m_data &= ~shift(bit);
+		return r;
+	}
+
+	constexpr bool test_and_complement(T bit)
+	{
+		bool r = (m_data & shift(bit)) != 0;
+		m_data ^= shift(bit);
+		return r;
+	}
+};
+
+// Unary '+' operator: promote plain enum value to bitset value
+template <typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator +(T bit)
+{
+	return bit;
+}
+
+// Binary '+' operator: bitset union
+template <typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator +(T lhs, T rhs)
+{
+	return bs_t<T>(lhs) + bs_t<T>(rhs);
+}
+
+// Binary '-' operator: bitset difference
+template <typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator -(T lhs, T rhs)
+{
+	return bs_t<T>(lhs) - bs_t<T>(rhs);
+}
+
+// Binary '&' operator: bitset intersection
+template <typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator &(T lhs, T rhs)
+{
+	return bs_t<T>(lhs) & bs_t<T>(rhs);
+}
+
+// Binary '^' operator: bitset symmetric difference
+template <typename T, typename = decltype(T::__bitset_enum_max)>
+constexpr bs_t<T> operator ^(T lhs, T rhs)
+{
+	return bs_t<T>(lhs) ^ bs_t<T>(rhs);
+}
+
+// Atomic bitset specialization with optimized operations
+template <typename T>
+class atomic_bs_t : public atomic_t<::bs_t<T>> // TODO: true specialization
+{
+	// Corresponding bitset type
+	using bs_t = ::bs_t<T>;
+
+	// Base class
+	using base = atomic_t<::bs_t<T>>;
+
+	// Use underlying m_data
+	using base::m_data;
+
+public:
+	// Underlying type
+	using under = typename bs_t::under;
+
+	atomic_bs_t() = default;
+
+	atomic_bs_t(const atomic_bs_t&) = delete;
+
+	atomic_bs_t& operator =(const atomic_bs_t&) = delete;
+
+	explicit constexpr atomic_bs_t(bs_t value)
+		: base(value)
+	{
+	}
+
+	explicit constexpr atomic_bs_t(T bit)
+		: base(bit)
+	{
+	}
+
+	explicit operator bool() const
+	{
+		return static_cast<bool>(base::load());
+	}
+
+	explicit operator under() const
+	{
+		return static_cast<under>(base::load());
+	}
+
+	bs_t operator +() const
+	{
+		return base::load();
+	}
+
+	bs_t fetch_add(const bs_t& rhs)
+	{
+		return bs_t(0, atomic_storage<under>::fetch_or(m_data.m_data, rhs.m_data));
+	}
+
+	bs_t add_fetch(const bs_t& rhs)
+	{
+		return bs_t(0, atomic_storage<under>::or_fetch(m_data.m_data, rhs.m_data));
+	}
+
+	bs_t operator +=(const bs_t& rhs)
+	{
+		return add_fetch(rhs);
+	}
+
+	bs_t fetch_sub(const bs_t& rhs)
+	{
+		return bs_t(0, atomic_storage<under>::fetch_and(m_data.m_data, ~rhs.m_data));
+	}
+
+	bs_t sub_fetch(const bs_t& rhs)
+	{
+		return bs_t(0, atomic_storage<under>::and_fetch(m_data.m_data, ~rhs.m_data));
+	}
+
+	bs_t operator -=(const bs_t& rhs)
+	{
+		return sub_fetch(rhs);
+	}
+
+	bs_t fetch_and(const bs_t& rhs)
+	{
+		return bs_t(0, atomic_storage<under>::fetch_and(m_data.m_data, rhs.m_data));
+	}
+
+	bs_t and_fetch(const bs_t& rhs)
+	{
+		return bs_t(0, atomic_storage<under>::and_fetch(m_data.m_data, rhs.m_data));
+	}
+
+	bs_t operator &=(const bs_t& rhs)
+	{
+		return and_fetch(rhs);
+	}
+
+	bs_t fetch_xor(const bs_t& rhs)
+	{
+		return bs_t(0, atomic_storage<under>::fetch_xor(m_data.m_data, rhs.m_data));
+	}
+
+	bs_t xor_fetch(const bs_t& rhs)
+	{
+		return bs_t(0, atomic_storage<under>::xor_fetch(m_data.m_data, rhs.m_data));
+	}
+
+	bs_t operator ^=(const bs_t& rhs)
+	{
+		return xor_fetch(rhs);
+	}
+
+	auto fetch_or(const bs_t&) = delete;
+	auto or_fetch(const bs_t&) = delete;
+	auto operator |=(const bs_t&) = delete;
+	auto operator ++() = delete;
+	auto operator --() = delete;
+	auto operator ++(int) = delete;
+	auto operator --(int) = delete;
+
+	bs_t operator +(bs_t rhs) const
+	{
+		return bs_t(0, base::load().m_data | rhs.m_data);
+	}
+
+	bs_t operator -(bs_t rhs) const
+	{
+		return bs_t(0, base::load().m_data & ~rhs.m_data);
+	}
+
+	bs_t operator &(bs_t rhs) const
+	{
+		return bs_t(0, base::load().m_data & rhs.m_data);
+	}
+
+	bs_t operator ^(bs_t rhs) const
+	{
+		return bs_t(0, base::load().m_data ^ rhs.m_data);
+	}
+
+	bs_t operator ==(bs_t rhs) const
+	{
+		return base::load().m_data == rhs.m_data;
+	}
+
+	bs_t operator !=(bs_t rhs) const
+	{
+		return base::load().m_data != rhs.m_data;
+	}
+
+	friend bs_t operator +(bs_t lhs, const atomic_bs_t& rhs)
+	{
+		return bs_t(0, lhs.m_data | rhs.load().m_data);
+	}
+
+	friend bs_t operator -(bs_t lhs, const atomic_bs_t& rhs)
+	{
+		return bs_t(0, lhs.m_data & ~rhs.load().m_data);
+	}
+
+	friend bs_t operator &(bs_t lhs, const atomic_bs_t& rhs)
+	{
+		return bs_t(0, lhs.m_data & rhs.load().m_data);
+	}
+
+	friend bs_t operator ^(bs_t lhs, const atomic_bs_t& rhs)
+	{
+		return bs_t(0, lhs.m_data ^ rhs.load().m_data);
+	}
+
+	friend bs_t operator ==(bs_t lhs, const atomic_bs_t& rhs)
+	{
+		return lhs.m_data == rhs.load().m_data;
+	}
+
+	friend bs_t operator !=(bs_t lhs, const atomic_bs_t& rhs)
+	{
+		return lhs.m_data != rhs.load().m_data;
+	}
+
+	bool test(const bs_t& rhs)
+	{
+		return base::load().test(rhs);
+	}
+
+	bool test_and_set(T rhs)
+	{
+		return atomic_storage<under>::bts(m_data.m_data, static_cast<uint>(static_cast<under>(rhs)));
+	}
+
+	bool test_and_reset(T rhs)
+	{
+		return atomic_storage<under>::btr(m_data.m_data, static_cast<uint>(static_cast<under>(rhs)));
+	}
+
+	bool test_and_complement(T rhs)
+	{
+		return atomic_storage<under>::btc(m_data.m_data, static_cast<uint>(static_cast<under>(rhs)));
+	}
+};
+
+template <typename T>
+struct fmt_unveil<bs_t<T>, void>
+{
+	// Format as is
+	using type = bs_t<T>;
+
+	static inline u64 get(const bs_t<T>& bitset)
+	{
+		return static_cast<std::underlying_type_t<T>>(bitset);
+	}
+};
@@ -0,0 +1,635 @@
+#pragma once
+
+#include "types.h"
+#include "asm.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 - (utils::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 - utils::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 = src.size_char;
+		}
+		else
+		{
+			ctx.type = src.size_short;
+		}
+
+		break;
+	}
+
+	case 'l':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else if (fmt[0] == 'l')
+		{
+			fmt++, ctx.size++;
+			ctx.type = src.size_llong;
+		}
+		else
+		{
+			ctx.type = src.size_long;
+		}
+
+		break;
+	}
+
+	case 'z':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else
+		{
+			ctx.type = src.size_size;
+		}
+
+		break;
+	}
+
+	case 'j':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else
+		{
+			ctx.type = src.size_max;
+		}
+
+		break;
+	}
+
+	case 't':
+	{
+		if (UNLIKELY(ctx.type))
+		{
+			drop_sequence();
+		}
+		else
+		{
+			ctx.type = src.size_diff;
+		}
+
+		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);
+
+			if (!ctx.type)
+			{
+				ctx.type = src.size_int;
+			}
+		}
+
+		// 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);
+
+			if (!ctx.type)
+			{
+				ctx.type = src.size_int;
+			}
+		}
+
+		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);
+
+			if (!ctx.type)
+			{
+				ctx.type = src.size_int;
+			}
+		}
+
+		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);
+
+			if (!ctx.type)
+			{
+				ctx.type = src.size_int;
+			}
+		}
+
+		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;
+}
@@ -0,0 +1,295 @@
+#include "cond.h"
+#include "sync.h"
+#include "lockless.h"
+
+#include <limits.h>
+
+#ifndef _WIN32
+#include <thread>
+#endif
+
+bool cond_variable::imp_wait(u32 _old, u64 _timeout) noexcept
+{
+	verify("cond_variable overflow" HERE), (_old & 0xffff) != 0xffff; // Very unlikely: it requires 65535 distinct threads to wait simultaneously
+
+	return balanced_wait_until(m_value, _timeout, [&](u32& value, auto... ret) -> int
+	{
+		if (value >> 16)
+		{
+			// Success
+			value -= 0x10001;
+			return +1;
+		}
+
+		if constexpr (sizeof...(ret))
+		{
+			// Retire
+			value -= 1;
+			return -1;
+		}
+
+		return 0;
+	});
+
+#ifdef _WIN32
+	if (_old >= 0x10000 && !OptWaitOnAddress && m_value)
+	{
+		// Workaround possibly stolen signal
+		imp_wake(1);
+	}
+#endif
+}
+
+void cond_variable::imp_wake(u32 _count) noexcept
+{
+	// TODO (notify_one)
+	balanced_awaken<true>(m_value, m_value.atomic_op([&](u32& value) -> u32
+	{
+		// Subtract already signaled number from total amount of waiters
+		const u32 can_sig = (value & 0xffff) - (value >> 16);
+		const u32 num_sig = std::min<u32>(can_sig, _count);
+
+		value += num_sig << 16;
+		return num_sig;
+	}));
+}
+
+bool notifier::imp_try_lock(u32 count)
+{
+	return m_counter.atomic_op([&](u32& value)
+	{
+		if ((value % (max_readers + 1)) + count <= max_readers)
+		{
+			value += count;
+			return true;
+		}
+
+		return false;
+	});
+}
+
+void notifier::imp_unlock(u32 count)
+{
+	const u32 counter = m_counter.sub_fetch(count);
+
+	if (UNLIKELY(counter % (max_readers + 1)))
+	{
+		return;
+	}
+
+	if (counter)
+	{
+		const u32 _old = m_counter.atomic_op([](u32& value) -> u32
+		{
+			if (value % (max_readers + 1))
+			{
+				return 0;
+			}
+
+			return std::exchange(value, 0) / (max_readers + 1);
+		});
+
+		const u32 wc = m_cond.m_value;
+
+		if (_old && wc)
+		{
+			m_cond.imp_wake(_old > wc ? wc : _old);
+		}
+	}
+}
+
+u32 notifier::imp_notify(u32 count)
+{
+	return m_counter.atomic_op([&](u32& value) -> u32
+	{
+		if (const u32 add = value % (max_readers + 1))
+		{
+			// Mutex is locked
+			const u32 result = add > count ? count : add;
+			value += result * (max_readers + 1);
+			return result;
+		}
+		else
+		{
+			// Mutex is unlocked
+			value = 0;
+			return count;
+		}
+	});
+}
+
+bool notifier::wait(u64 usec_timeout)
+{
+	const u32 _old = m_cond.m_value.fetch_add(1);
+
+	if (max_readers < m_counter.fetch_op([](u32& value)
+	{
+		if (value > max_readers)
+		{
+			value -= max_readers;
+		}
+
+		value -= 1;
+	}))
+	{
+		// Return without waiting
+		m_cond.imp_wait(_old, 0);
+		return true;
+	}
+
+	const bool res = m_cond.imp_wait(_old, usec_timeout);
+
+	while (!try_lock_shared())
+	{
+		// TODO
+		busy_wait();
+	}
+
+	return res;
+}
+
+bool cond_one::imp_wait(u64 _timeout) noexcept
+{
+	// State transition: c_sig -> c_lock \ c_lock -> c_wait
+	const u32 _old = m_value.fetch_sub(1);
+	if (LIKELY(_old == c_sig))
+		return true;
+
+	return balanced_wait_until(m_value, _timeout, [&](u32& value, auto... ret) -> int
+	{
+		if (value == c_sig)
+		{
+			value = c_lock;
+			return +1;
+		}
+
+		if constexpr (sizeof...(ret))
+		{
+			value = c_lock;
+			return -1;
+		}
+
+		return 0;
+	});
+}
+
+void cond_one::imp_notify() noexcept
+{
+	auto [old, ok] = m_value.fetch_op([](u32& v)
+	{
+		if (UNLIKELY(v > 0 && v < c_sig))
+		{
+			v = c_sig;
+			return true;
+		}
+
+		return false;
+	});
+
+	verify(HERE), old <= c_sig;
+
+	if (LIKELY(!ok || old == c_lock))
+	{
+		return;
+	}
+
+	balanced_awaken(m_value, 1);
+}
+
+bool cond_x16::imp_wait(u32 slot, u64 _timeout) noexcept
+{
+	const u32 wait_bit = c_wait << slot;
+	const u32 lock_bit = c_lock << slot;
+
+	// Change state from c_lock to c_wait
+	const u32 old_ = m_cvx16.fetch_op([=](u32& cvx16)
+	{
+		if (cvx16 & wait_bit)
+		{
+			// c_sig -> c_lock
+			cvx16 &= ~wait_bit;
+		}
+		else
+		{
+			cvx16 |= wait_bit;
+			cvx16 &= ~lock_bit;
+		}
+	});
+
+	if (old_ & wait_bit)
+	{
+		// Already signaled, return without waiting
+		return true;
+	}
+
+	return balanced_wait_until(m_cvx16, _timeout, [&](u32& cvx16, auto... ret) -> int
+	{
+		if (cvx16 & lock_bit)
+		{
+			// c_sig -> c_lock
+			cvx16 &= ~wait_bit;
+			return +1;
+		}
+
+		if constexpr (sizeof...(ret))
+		{
+			// Retire
+			cvx16 |= lock_bit;
+			cvx16 &= ~wait_bit;
+			return -1;
+		}
+
+		return 0;
+	});
+}
+
+void cond_x16::imp_notify() noexcept
+{
+	auto [old, ok] = m_cvx16.fetch_op([](u32& v)
+	{
+		const u32 lock_mask = v >> 16;
+		const u32 wait_mask = v & 0xffff;
+
+		if (const u32 sig_mask = lock_mask ^ wait_mask)
+		{
+			v |= sig_mask | sig_mask << 16;
+			return true;
+		}
+
+		return false;
+	});
+
+	// Determine if some waiters need a syscall notification
+	const u32 wait_mask = old & (~old >> 16);
+
+	if (UNLIKELY(!ok || !wait_mask))
+	{
+		return;
+	}
+
+	balanced_awaken<true>(m_cvx16, utils::popcnt16(wait_mask));
+}
+
+bool lf_queue_base::wait(u64 _timeout)
+{
+	return balanced_wait_until(m_head, _timeout, [](std::uintptr_t& head, auto... ret) -> int
+	{
+		if (head != 1)
+		{
+			return +1;
+		}
+
+		if constexpr (sizeof...(ret))
+		{
+			head = 0;
+			return -1;
+		}
+
+		return 0;
+	});
+}
+
+void lf_queue_base::imp_notify()
+{
+	balanced_awaken(m_head, 1);
+}
@@ -0,0 +1,265 @@
+#pragma once
+
+#include "types.h"
+#include "Atomic.h"
+#include <shared_mutex>
+#include "asm.h"
+
+// Lightweight condition variable
+class cond_variable
+{
+	// Internal waiter counter
+	atomic_t<u32> m_value{0};
+
+	friend class notifier;
+
+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>
+	bool 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;
+	}
+
+	// Unlock all specified objects but don't lock them again
+	template <typename... Locks>
+	bool wait_unlock(u64 usec_timeout, Locks&&... locks)
+	{
+		const u32 _old = m_value.fetch_add(1); // Increment waiter counter
+		(..., std::forward<Locks>(locks).unlock());
+		return imp_wait(_old, usec_timeout);
+	}
+
+	// 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(65535);
+		}
+	}
+
+	static constexpr u64 max_timeout = u64{UINT32_MAX} / 1000 * 1000000;
+};
+
+// Pair of a fake shared mutex (only limited shared locking) and a condition variable
+class notifier
+{
+	atomic_t<u32> m_counter{0};
+	cond_variable m_cond;
+
+	bool imp_try_lock(u32 count);
+
+	void imp_unlock(u32 count);
+
+	u32 imp_notify(u32 count);
+
+public:
+	constexpr notifier() = default;
+
+	bool try_lock()
+	{
+		return imp_try_lock(max_readers);
+	}
+
+	void unlock()
+	{
+		imp_unlock(max_readers);
+	}
+
+	bool try_lock_shared()
+	{
+		return imp_try_lock(1);
+	}
+
+	void unlock_shared()
+	{
+		imp_unlock(1);
+	}
+
+	bool wait(u64 usec_timeout = -1);
+
+	void notify_all()
+	{
+		if (m_counter)
+		{
+			imp_notify(-1);
+		}
+
+		// Notify after imaginary "exclusive" lock+unlock
+		m_cond.notify_all();
+	}
+
+	void notify_one()
+	{
+		// TODO
+		if (m_counter)
+		{
+			if (imp_notify(1))
+			{
+				return;
+			}
+		}
+
+		m_cond.notify_one();
+	}
+
+	static constexpr u32 max_readers = 0x7f;
+};
+
+class cond_one
+{
+	enum : u32
+	{
+		c_wait = 1,
+		c_lock = 2,
+		c_sig  = 3,
+	};
+
+	atomic_t<u32> m_value{0};
+
+	bool imp_wait(u64 _timeout) noexcept;
+	void imp_notify() noexcept;
+
+public:
+	constexpr cond_one() = default;
+
+	void lock() noexcept
+	{
+		// Shouldn't be locked by more than one thread concurrently
+		while (UNLIKELY(!m_value.compare_and_swap_test(0, c_lock)))
+			;
+	}
+
+	void unlock() noexcept
+	{
+		m_value = 0;
+	}
+
+	bool wait(std::unique_lock<cond_one>& lock, u64 usec_timeout = -1) noexcept
+	{
+		AUDIT(lock.owns_lock());
+		AUDIT(lock.mutex() == this);
+		return imp_wait(usec_timeout);
+	}
+
+	void notify() noexcept
+	{
+		// Early exit if notification is not required
+		if (LIKELY(!m_value))
+			return;
+
+		imp_notify();
+	}
+};
+
+// Packed version of cond_one, supports up to 16 readers.
+class cond_x16
+{
+	// For information, shouldn't modify
+	enum : u32
+	{
+		c_wait = 1,
+		c_lock = 1 << 16,
+		c_sig  = 1 << 16 | 1,
+	};
+
+	// Split in 16-bit parts for convenient bit combining
+	atomic_t<u32> m_cvx16{0};
+
+	// Effectively unused, only counts readers
+	atomic_t<u32> m_total{0};
+
+	class lock_x16
+	{
+		cond_x16* m_this;
+		u32 m_slot;
+
+		friend class cond_x16;
+
+	public:
+		lock_x16(cond_x16* _this) noexcept
+			: m_this(_this)
+		{
+			// Spin if the number of readers exceeds 16
+			while (UNLIKELY(m_this->m_total++ >= 16))
+				m_this->m_total--;
+
+			// Lock and remember obtained slot index
+			m_slot = m_this->m_cvx16.atomic_op([](u32& cvx16)
+			{
+				// Combine used bits and invert to find least significant bit unused
+				const u32 slot = utils::cnttz32(~((cvx16 & 0xffff) | (cvx16 >> 16)), true);
+
+				// Set lock bit
+				cvx16 |= c_lock << slot;
+
+				AUDIT(slot < 16);
+				return slot;
+			});
+		}
+
+		lock_x16(const lock_x16&) = delete;
+
+		lock_x16& operator=(const lock_x16&) = delete;
+
+		~lock_x16()
+		{
+			// Clear the slot
+			m_this->m_cvx16 &= ~((c_wait | c_lock) << m_slot);
+			m_this->m_total -= 1;
+		}
+
+		bool wait(u64 usec_timeout = -1) const noexcept
+		{
+			return m_this->wait(*this, usec_timeout);
+		}
+	};
+
+	bool imp_wait(u32 slot, u64 _timeout) noexcept;
+	void imp_notify() noexcept;
+
+public:
+	constexpr cond_x16() = default;
+
+	lock_x16 lock_one() noexcept
+	{
+		return lock_x16(this);
+	}
+
+	bool wait(lock_x16 const& lock, u64 usec_timeout = -1) noexcept
+	{
+		AUDIT(lock.m_this == this);
+		return imp_wait(lock.m_slot, usec_timeout);
+	}
+
+	void notify_all() noexcept
+	{
+		if (LIKELY(!m_cvx16))
+			return;
+
+		imp_notify();
+	}
+};
@@ -0,0 +1,32 @@
+#pragma once
+
+namespace date_time
+{
+	static inline tm get_time(time_t* _time)
+	{
+		tm buf;
+		time_t t = time(_time);
+#ifdef _MSC_VER
+		localtime_s(&buf, &t);
+#else
+		buf = *localtime(&t);
+#endif
+		return buf;
+	}
+
+	static inline std::string current_time()
+	{
+		char str[80];
+		tm now = get_time(0);
+		strftime(str, sizeof(str), "%c", &now);
+		return str;
+	}
+
+	static inline std::string current_time_narrow()
+	{
+		char str[80];
+		tm now = get_time(0);
+		strftime(str, sizeof(str), "%Y%m%d%H%M%S", &now);
+		return str;
+	}
+}
@@ -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
+	}
 }
@@ -38,4 +38,55 @@ 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)
+		{
+		}
+
+		void init()
+		{
+			if (!ptr)
+			{
+				// TODO: atomic
+				ptr = reinterpret_cast<R(*)(Args...)>(get_proc_address(lib, name));
+			}
+		}
+
+		operator bool()
+		{
+			init();
+
+			return ptr;
+		}
+
+		// Caller
+		R operator()(Args... args)
+		{
+			init();
+
+			return ptr(args...);
+		}
+	};
 }
+
+#define DYNAMIC_IMPORT(lib, name, ...) inline utils::dynamic_import<__VA_ARGS__> name(lib, #name);
@@ -1,8 +1,195 @@
 #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)
+	bool 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)
+	bool 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.atomic_op([&](T& value)
+		{
+			_old = value++;
+			return value;
+		});
+
+		(static_cast<CRT*>(this)->*transition_get(state))(_old);
+	}
+
+	// Unconditionally set previous state
+	void state_prev()
+	{
+		T _old, state = m_value.atomic_op([&](T& value)
+		{
+			_old = value--;
+			return 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,
@@ -731,9 +731,9 @@ struct area_base
 	{
 		return{ x1 * size.width, y1 * size.height, x2 * size.width, y2 * size.height };
 	}
-	constexpr area_base operator * (const T& value) const
+	constexpr area_base operator * (const f32& value) const
 	{
-		return{ x1 * value, y1 * value, x2 * value, y2 * value };
+		return{ (T)(x1 * value), (T)(y1 * value), (T)(x2 * value), (T)(y2 * value) };
 	}

 	template<typename NT>
@@ -976,62 +976,77 @@ struct color1_base
 };

 //specializations
+using positionu = position_base<unsigned int>;
 using positioni = position_base<int>;
 using positionf = position_base<float>;
 using positiond = position_base<double>;

+using coordu = coord_base<unsigned int>;
 using coordi = coord_base<int>;
 using coordf = coord_base<float>;
 using coordd = coord_base<double>;

+using areau = area_base<unsigned int>;
 using areai = area_base<int>;
 using areaf = area_base<float>;
 using aread = area_base<double>;

+using position1u = position1_base<unsigned int>;
 using position1i = position1_base<int>;
 using position1f = position1_base<float>;
 using position1d = position1_base<double>;

+using position2u = position2_base<unsigned int>;
 using position2i = position2_base<int>;
 using position2f = position2_base<float>;
 using position2d = position2_base<double>;

+using position3u = position3_base<unsigned int>;
 using position3i = position3_base<int>;
 using position3f = position3_base<float>;
 using position3d = position3_base<double>;

+using position4u = position4_base<unsigned int>;
 using position4i = position4_base<int>;
 using position4f = position4_base<float>;
 using position4d = position4_base<double>;

+using size2u = size2_base<unsigned int>;
 using size2i = size2_base<int>;
 using size2f = size2_base<float>;
 using size2d = size2_base<double>;

+using sizeu = size2u;
 using sizei = size2i;
 using sizef = size2f;
 using sized = size2d;

+using size3u = size3_base<unsigned int>;
 using size3i = size3_base<int>;
 using size3f = size3_base<float>;
 using size3d = size3_base<double>;

+using coord3u = coord3_base<unsigned int>;
 using coord3i = coord3_base<int>;
 using coord3f = coord3_base<float>;
 using coord3d = coord3_base<double>;

+using color4u = color4_base<unsigned int>;
 using color4i = color4_base<int>;
 using color4f = color4_base<float>;
 using color4d = color4_base<double>;

+using color3u = color3_base<unsigned int>;
 using color3i = color3_base<int>;
 using color3f = color3_base<float>;
 using color3d = color3_base<double>;

+using color2u = color2_base<unsigned int>;
 using color2i = color2_base<int>;
 using color2f = color2_base<float>;
 using color2d = color2_base<double>;

+using color1u = color1_base<unsigned int>;
 using color1i = color1_base<int>;
 using color1f = color1_base<float>;
 using color1d = color1_base<double>;
@@ -13,9 +13,10 @@ rem // A copy of the GPL 2.0 should have been included with the program.
 rem // If not, see http://www.gnu.org/licenses/

 rem // Official git repository and contact information can be found at
-rem // https://github.com/RPCS3/rpcs3 and http://rpcs3.net/.
+rem // https://github.com/RPCS3/rpcs3 and https://rpcs3.net/.

 setlocal ENABLEDELAYEDEXPANSION
+setlocal ENABLEEXTENSIONS

 set GIT_VERSION_FILE=%~p0..\rpcs3\git-version.h
 if not defined GIT (
@@ -47,14 +48,40 @@ if errorlevel 1 (
 	echo // This is a generated file. > "%GIT_VERSION_FILE%"
 	echo. >> "%GIT_VERSION_FILE%"
 	echo #define RPCS3_GIT_VERSION "unknown" >> "%GIT_VERSION_FILE%"
+	echo #define RPCS3_GIT_BRANCH "unknown" >> "%GIT_VERSION_FILE%"
 	echo. >> "%GIT_VERSION_FILE%"
 	echo // If you don't want this file to update/recompile, change to 1. >> "%GIT_VERSION_FILE%"
 	echo #define RPCS3_GIT_VERSION_NO_UPDATE 0 >> "%GIT_VERSION_FILE%"
 	goto done
 )

-for /F %%I IN ('call %GIT% rev-list HEAD --count') do set GIT_VERSION=%%I
-for /F %%I IN ('call %GIT% rev-parse --short HEAD') do set GIT_VERSION=%GIT_VERSION%-%%I
+rem // Get commit count from (unshallowed) HEAD
+for /F %%I IN ('call %GIT% rev-list HEAD --count') do set COMMIT_COUNT=%%I
+
+rem // If we're in AppVeyor, building a non-master, pull request artifact
+if defined APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH (
+
+	if "%APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH%"=="master" (
+		rem // If pull request comes from a master branch, GIT_BRANCH = username/branch in order to distinguish from upstream/master
+		for /f "tokens=1* delims=/" %%a in ("%APPVEYOR_PULL_REQUEST_HEAD_REPO_NAME%") do set user=%%a
+		set "GIT_BRANCH=!user!/%APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH%"
+	) else (
+		rem // Otherwise, GIT_BRANCH=branch
+		set GIT_BRANCH=%APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH%
+	)
+
+	rem // Make GIT_VERSION the last commit (shortened); Don't include commit count on non-master builds
+	for /F %%I IN ('call %GIT% rev-parse --short^=8 HEAD') do set GIT_VERSION=%%I
+
+) else (
+	rem // Get last commit (shortened) and concat after commit count in GIT_VERSION
+	for /F %%I IN ('call %GIT% rev-parse --short^=8 HEAD') do set GIT_VERSION=%COMMIT_COUNT%-%%I
+
+	for /F %%I IN ('call %GIT% rev-parse --abbrev-ref HEAD') do set GIT_BRANCH=%%I
+)
+
+rem // Echo obtained GIT_VERSION for debug purposes if needed
+echo %GIT_VERSION%

 rem // Don't modify the file if it already has the current version.
 if exist "%GIT_VERSION_FILE%" (
@@ -67,6 +94,7 @@ if exist "%GIT_VERSION_FILE%" (
 echo // This is a generated file. > "%GIT_VERSION_FILE%"
 echo. >> "%GIT_VERSION_FILE%"
 echo #define RPCS3_GIT_VERSION "%GIT_VERSION%" >> "%GIT_VERSION_FILE%"
+echo #define RPCS3_GIT_BRANCH ^"%GIT_BRANCH%^" >> "%GIT_VERSION_FILE%"
 echo. >> "%GIT_VERSION_FILE%"
 echo // If you don't want this file to update/recompile, change to 1. >> "%GIT_VERSION_FILE%"
 echo #define RPCS3_GIT_VERSION_NO_UPDATE 0 >> "%GIT_VERSION_FILE%"
@@ -0,0 +1,51 @@
+#pragma once
+#include <stdint.h>
+
+namespace rpcs3
+{
+	template<typename T>
+	static size_t hash_base(T value)
+	{
+		return static_cast<size_t>(value);
+	}
+
+	template<typename T, typename U>
+	static size_t hash_struct_base(const T& value)
+	{
+		// FNV 64-bit
+		size_t result = 14695981039346656037ull;
+		const U *bits = reinterpret_cast<const U*>(&value);
+
+		for (size_t n = 0; n < (sizeof(T) / sizeof(U)); ++n)
+		{
+			result ^= bits[n];
+			result *= 1099511628211ull;
+		}
+
+		return result;
+	}
+
+	template<typename T>
+	static size_t hash_struct(const T& value)
+	{
+		// TODO: use c++17 if constexpr
+		static constexpr auto block_sz = sizeof(T);
+
+		if ((block_sz & 0x7) == 0)
+		{
+			return hash_struct_base<T, u64>(value);
+		}
+
+		if ((block_sz & 0x3) == 0)
+		{
+			return hash_struct_base<T, u32>(value);
+		}
+
+		if ((block_sz & 0x1) == 0)
+		{
+			return hash_struct_base<T, u16>(value);
+		}
+
+		return hash_struct_base<T, u8>(value);
+	}
+}
--- a/Show More
+++ b/Show More