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
904 changed files with 93193 additions and 75838 deletions
@@ -11,11 +11,11 @@ BreakConstructorInitializersBeforeComma: true
 BreakBeforeBinaryOperators: false
 BreakBeforeTernaryOperators: false
 AlwaysBreakTemplateDeclarations: true
-AllowShortIfStatementsOnASingleLine: true
-AllowShortBlocksOnASingleLine: true
+AllowShortIfStatementsOnASingleLine: false
+AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: false
-AllowShortLoopsOnASingleLine: true
+AllowShortLoopsOnASingleLine: false
 Cpp11BracedListStyle: true
 IndentCaseLabels: false
 SortIncludes: false
@@ -29,5 +29,3 @@ BinPackParameters: true
 AlwaysBreakAfterReturnType: None
 KeepEmptyLinesAtTheStartOfBlocks: true
 IndentWrappedFunctionNames: false
-
-#SpaceAfterTemplateKeyword: false
@@ -1,7 +1,7 @@
 root = true

 [*.{h,cpp,hpp}]
-charset = utf-8
+charset = utf-8-bom
 indent_style = tab
 indent_size = 4
 trim_trailing_whitespace = true
@@ -6,7 +6,7 @@ or our discord:
 https://discord.me/RPCS3

 PLEASE READ THE GUIDELINES BEFORE OPENING AN ISSUE:
-https://github.com/RPCS3/rpcs3/blob/master/CONTRIBUTING.md
+https://github.com/RPCS3/rpcs3/blob/master/.github/CONTRIBUTING.md

 ====================================================

@@ -31,7 +31,6 @@
 *.wav

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

+!/bin
+/bin/*
+
 # Themes
 !/bin/GuiConfigs/
 /bin/GuiConfigs/*.ini
-
-/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/GuiConfigs/*.ini.*
+/bin/GuiConfigs/*.dat
+/bin/GuiConfigs/*.dat.*

 # Visual Studio Files
 .vs/*
+.vscode/*
+*.ipch
 *.vspx
 *.psess
 *.VC.*
 *.vcxproj.user
-
-# 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/
-/bin/dev_hdd0/disc/*
+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
@@ -92,8 +76,24 @@ CMakeCache.txt
 rpcs3/cotire/*
 rpcs3/rpcs3_*_cotire.cmake

+# kdevelop
+*.kdev4
+.kdev4/*
+
 # Qt
 moc_*.cpp
-qrc_resources.cpp
+qrc_*.cpp
 rpcs3_automoc.cpp
 ui_*.h
+rpcs3/rpcs3_autogen/*
+
+# QtCreator
+CMakeLists.txt.user
+
+# CLion
+/.idea/*
+/cmake-build-*/
+
+# macOS
+.DS_Store
+
@@ -1,6 +1,7 @@
 [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
@@ -9,36 +10,41 @@
 	path = llvm
 	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/Optional"]
-	path = 3rdparty/Optional
-	url = https://github.com/akrzemi1/Optional.git
 [submodule "3rdparty/pugixml"]
 	path = 3rdparty/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,124 +1,37 @@
 language: cpp
-sudo: required
-
-os:
-  - linux
-  #- osx
-
-# osx_image: xcode6.4
-
-compiler:
-  - clang
-  - gcc
-
-cache:
-  ccache: true
-  directories:
-    - $HOME/hombebrew_cache
-
 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:
-  - if [ "$TRAVIS_OS_NAME" = "linux" ] && [ "$CXX" = "g++" ]; then
-      export CXX="g++-5" CC="gcc-5" CXXFLAGS="-Wno-format-security";
-    fi;
-  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      wget http://download.qt.io/official_releases/online_installers/qt-unified-linux-x64-online.run ;
-      chmod a+x ./qt-unified-linux-x64-online.run ;
-      export QT_QPA_PLATFORM=minimal ;
-      travis_wait 60 ./qt-unified-linux-x64-online.run --script qt-installer-noninteractive.qs --no-force-installations --verbose ;
-    fi;
-
-  # Install updated libglew-dev since the version provided by trusty is outdated
-  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      wget https://mirrors.kernel.org/ubuntu/pool/universe/g/glew/libglew-dev_2.0.0-5_amd64.deb;
-      wget https://mirrors.kernel.org/ubuntu/pool/universe/g/glew/libglew2.0_2.0.0-5_amd64.deb;
-      wget https://mirrors.kernel.org/ubuntu/pool/universe/v/vulkan/libvulkan1_1.0.61.1+dfsg1-1ubuntu1~16.04.1_amd64.deb;
-      wget https://mirrors.kernel.org/ubuntu/pool/universe/v/vulkan/libvulkan-dev_1.0.61.1+dfsg1-1ubuntu1~16.04.1_amd64.deb;
-      sudo dpkg -i libglew2.0_2.0.0-5_amd64.deb libglew-dev_2.0.0-5_amd64.deb libvulkan1_1.0.61.1+dfsg1-1ubuntu1~16.04.1_amd64.deb libvulkan-dev_1.0.61.1+dfsg1-1ubuntu1~16.04.1_amd64.deb;
-    else
-      brew update;
-      brew install ccache glew llvm40;
-    fi;
-
-before_script:
-  - git submodule update --init asmjit 3rdparty/ffmpeg 3rdparty/pugixml 3rdparty/GSL 3rdparty/libpng Utilities/yaml-cpp 3rdparty/cereal 3rdparty/hidapi 3rdparty/Optional Vulkan/glslang Vulkan/Vulkan-LoaderAndValidationLayers
-  - mkdir build
-  - cd build
-  - export CMAKE_PREFIX_PATH=~/Qt/5.10.0/gcc_64/lib/cmake
-  - export CXXFLAGS="$CXXFLAGS -DTRAVIS=true";
-  - if [ "$TRAVIS_PULL_REQUEST" = false ]; then
-      export CXXFLAGS="$CXXFLAGS -DBRANCH=$TRAVIS_REPO_SLUG/$TRAVIS_BRANCH";
-    else
-      export CXXFLAGS="$CXXFLAGS -DBRANCH=$TRAVIS_REPO_SLUG/$TRAVIS_BRANCH/#$TRAVIS_PULL_REQUEST";
-    fi;
-  - cmake .. -DCMAKE_INSTALL_PREFIX=/usr -G Ninja;
-  - ninja
-  - # AppImage generation
-  - if [ -n "$UPLOAD_URL" ] && [ "$TRAVIS_BRANCH" = "master" ] && [ "$CC" = "clang" ] && [ "$TRAVIS_PULL_REQUEST" = false ]; then
-      export LD_LIBRARY_PATH=~/Qt/5.10.0/gcc_64/lib;
-      DESTDIR=appdir ninja install ; find appdir/ ;
-      find ../bin ;
-      wget -c "https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage" ;
-      chmod a+x linuxdeployqt*.AppImage ;
-      export PATH=~/Qt/5.10.0/gcc_64/bin/:${PATH} ;
-      ./linuxdeployqt*.AppImage --appimage-extract ;
-      ./linuxdeployqt*.AppImage ./appdir/usr/share/applications/*.desktop -bundle-non-qt-libs ;
-      mkdir ./appdir/usr/plugins/xcbglintegrations/ ;
-      mkdir ./appdir/usr/plugins/imageformats/ ;
-      cp ~/Qt/5.10.0/gcc_64/lib/libQt5Svg.so.5 ./appdir/usr/lib/ ;
-      cp ~/Qt/5.10.0/gcc_64/plugins/xcbglintegrations/* ./appdir/usr/plugins/xcbglintegrations/ ;
-      cp ~/Qt/5.10.0/gcc_64/plugins/imageformats/* ./appdir/usr/plugins/imageformats/ ;
-      cp ~/Qt/5.10.0/gcc_64/plugins/platforms/* ./appdir/usr/plugins/platforms/ ;
-      rm ./appdir/usr/lib/libfreetype.so.6 ;
-      export PATH=${TRAVIS_BUILD_DIR}/build/squashfs-root/usr/bin/:${PATH} ;
-      ./squashfs-root/usr/bin/appimagetool ${TRAVIS_BUILD_DIR}/build/appdir ;
-      find ./appdir -executable -type f -exec ldd {} \; | grep " => /usr" | cut -d " " -f 2-3 | sort | uniq ;
-      curl ${UPLOAD_URL}${TRAVIS_COMMIT:0:7}-${TRAVIS_BUILD_NUMBER}_linux64 --upload-file ./RPCS3*.AppImage;
-   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";
-
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-trusty-4.0
-      - sourceline: 'ppa:jonathonf/binutils' # We need to update binutils to a newer version to link against the ffmpeg libs on.
-    packages:
-      - binutils
-      - cmake
-      - ninja-build
-      - libasound2-dev
-      - libopenal-dev
-      - freeglut3-dev
-      #- libglew-dev
-      #- libvulkan1
-      #- libvulkan-dev
-      - libc6-dev
-      - llvm-4.0
-      - llvm-4.0-dev
-      # Clang 5.0 is now bundled in travis, so we no longer need the ppa version.
-      #- clang-4.0
-      - libedit-dev
-      - g++-5
-      - gcc-5
-      - libstdc++-5-dev
-      - lib32stdc++6
-      - zlib1g-dev
-      # We need to install qt 5.10.0 manually because the version trusty provides is too old.
-      #- qtbase5-dev
-      - libudev-dev
-      - libevdev-dev
-      - libpulse-dev
@@ -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">
@@ -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
 *
@@ -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,19 +1,41 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.8.2)
+
+project(rpcs3)

 option(WITH_GDB "WITH_GDB" OFF)
-option(WITHOUT_LLVM "WITHOUT_LLVM" 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()

-set(ASMJIT_STATIC TRUE)
-
 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()
@@ -24,36 +46,23 @@ if (CCACHE_FOUND)
 	set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
 endif()

-add_definitions(-DCMAKE_BUILD)
-
-# We use libpng's static library and don't need to build the shared library and run the tests
-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 )
+if(WIN32)
+	add_definitions(-DUNICODE)
+	add_definitions(-D_WIN32_WINNT=0x0602)
 endif()

-option(VULKAN_PREBUILT "" OFF)
+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")
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${PROJECT_BINARY_DIR}/bin")

-add_subdirectory( Vulkan )
-add_subdirectory( rpcs3 )
-
-include_directories(3rdparty/hidapi/hidapi)
-if(APPLE)
-	add_subdirectory(3rdparty/hidapi/mac)
-	#list(APPEND LIBS hidapi)
-elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-	add_subdirectory(3rdparty/hidapi/linux)
-elseif(MSVC)
-	add_subdirectory(3rdparty/hidapi/windows)
-else()
-	add_subdirectory(3rdparty/hidapi/libusb)
-	#list(APPEND LIBS hidapi-libusb)
-endif()
+add_subdirectory(rpcs3)
@@ -4,103 +4,93 @@ 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)

-The world's first open-source PlayStation 3 emulator/debugger written in C++ for Windows and Linux.
+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 our [**website**](https://rpcs3.net/). 
-For discussion about this emulator and PS3 emulation please visit our [**forums**](https://forums.rpcs3.net) and our [**Discord server**](https://discord.me/RPCS3).
+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 forums or in Discord in order to know more 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

 ### Windows
-* [Visual Studio 2015](https://www.visualstudio.com/vs/older-downloads/)
-* [Visual C++ Redistributable Packages for Visual Studio 2015](http://www.microsoft.com/en-us/download/details.aspx?id=48145)
-* [Cmake 3.1.0+](https://www.cmake.org/download/) (required; add to PATH)
-* [Python 3.3+](https://www.python.org/downloads/) (required; add to PATH)
-* [Qt 5.8+](https://www.qt.io/download-open-source/) (required; add QTDIR `<QtInstallFolder>\5.8\msvc2015_64\` environment variable if you do not want to use the Visual Studio Qt Plugin)
-* [Visual Studio Qt Plugin](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.QtVisualStudioTools2015) (optional; see above)
+* [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)
+
+
+**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.7+](https://www.qt.io/download-open-source/)
-* GCC 5.1+ or Clang 3.5.0+ ([not GCC 6.1](https://github.com/RPCS3/rpcs3/issues/1691))
-* Debian & Ubuntu: `sudo apt-get install cmake build-essential libasound2-dev libpulse-dev libopenal-dev libglew-dev zlib1g-dev libedit-dev libvulkan-dev libudev-dev git qt5-default`
-* Arch: `sudo pacman -S glew openal cmake llvm qt5-base`
-* Fedora: `sudo dnf install cmake glew glew-devel libatomic libudev-devel openal-devel qt5-devel vulkan-devel`
+* [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 a NVIDIA GPU, you may need to install the libglvnd package.**

-### MacOS
-MacOS is not supported at this moment because it doesn't meet system requirements (OpenGL 4.3)
-* Xcode 6+ (tested with Xcode 6.4)
-* Install with Homebrew: `brew install glew llvm qt cmake`
+**If you have an NVIDIA GPU, you may need to install the libglvnd package.**


-## Building on Windows:
-To initialize the repository don't forget to execute `git submodule update --init` to pull the submodules.
+## Building

-### Configuring Qt
+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).

-*If you're using Visual Studio 2017 without Qt plugin support (or simply dont want to use it):* 
-1) Add `QTDIR` environment variable and set it to `<QtInstallFolder>\5.8\msvc2015_64\` </br>
+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*.


-Open `rpcs3.sln`
+`Build > Build Solution`


-*If you wish to use the Visual Studio plugin for Qt:* </br>
-1) Go to the Qt5 menu and edit Qt5 options. Add the path to your Qt installation with compiler e.g. `C:\Qt\5.8\msvc2015_64`. </br>
-2) While selecting the rpcs3qt project, go to Qt5->Project Setting and select the version you added. 
+### Linux

-### Building the projects
-You may want to download precompiled [LLVM lib](https://drive.google.com/uc?export=download&id=0B8A6NaxhQAGRY2k3Q2Yya05lcm8) 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=0B8A6NaxhQAGRaHYxV3VOS2d0a0U) to `lib\%CONFIGURATION%-x64\` to speed up compilation time (unoptimised/debug libs are currently not available precompiled).
+While still in the project root:

-If you're not using precompiled libs, build the projects in *__BUILD_BEFORE* folder: right-click on every project > *Build*. </br></br>
-
-`Build > Build Solution`</br>
-
-
-
-## Building on Linux & Mac OS:
-
-1) `git clone https://github.com/RPCS3/rpcs3.git` </br>
-2) `cd rpcs3/` </br>
-3) `git submodule update --init` </br>
-4) `cd ../ && mkdir rpcs3_build && cd rpcs3_build`
-4) `cmake ../rpcs3/ && make GitVersion && make` </br>
-5) Run RPCS3 with `./bin/rpcs3` </br>
-
-If you are on MacOS and want to build with brew llvm and qt don't forget to add the following environment variables
-
- * `LLVM_DIR=/usr/local/opt/llvm/` (or wherever llvm was installed).
- * `Qt5_DIR=/usr/local/opt/qt/lib/cmake/Qt5` (or wherever qt was installed).
+1) `cd .. && mkdir rpcs3_build && cd rpcs3_build`
+2) `cmake ../rpcs3/ && make GitVersion && make`
+3) Run RPCS3 with `./bin/rpcs3`

 When using GDB, configure it to ignore SIGSEGV signal (`handle SIGSEGV nostop noprint`).
-
-
-## CMake Build Options (Linux & Mac OS)
-
- ```-DUSE_SYSTEM_LIBPNG=ON/OFF``` (default = *OFF*)  
-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*)  
-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.
-
- ```-DWITHOUT_LLVM=ON/OFF``` (default = *OFF*)  
-This forces RPCS3 to build without LLVM, not recommended.
-
- ```-DWITH_GDB=ON/OFF``` (default = *OFF*)  
-This Builds RPCS3 with support for debugging PS3 games using gdb.
-
- ```-DUSE_VULKAN=ON/OFF``` (default = *ON*)  
-This builds RPCS3 with Vulkan support.
+If desired, use the various build options in [CMakeLists](https://github.com/RPCS3/rpcs3/blob/master/CMakeLists.txt).

 ## License

-Most files are licensed under the terms of GNU GPLv2 License, see LICENSE file for details. Some files may be licensed differently, check appropriate file headers for details.
+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,6 +1,7 @@
 #pragma once

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

 // 128-bit vector type and also se_storage<> storage type
 union alignas(16) v128
@@ -307,7 +308,7 @@ struct offset32_array<v128::masked_array_t<T, N, M>>
 	template <typename Arg>
 	static inline u32 index32(const Arg& arg)
 	{
-		return SIZE_32(T) * (static_cast<u32>(arg) ^ static_cast<u32>(M));
+		return u32{sizeof(T)} * (static_cast<u32>(arg) ^ static_cast<u32>(M));
 	}
 };

@@ -334,7 +335,10 @@ inline v128 operator~(const v128& other)
 template <typename T, std::size_t Align, std::size_t Size>
 struct se_storage
 {
-	using type = std::aligned_storage_t<Size, Align>;
+	struct type
+	{
+		alignas(Align) std::byte data[Size];
+	};

 	// Unoptimized generic byteswap for unaligned data
 	static void reverse(u8* dst, const u8* src)
@@ -358,16 +362,6 @@ struct se_storage
 		reverse(reinterpret_cast<u8*>(&result), reinterpret_cast<const u8*>(&src));
 		return result;
 	}
-
-	static type copy(const type& src)
-	{
-		type result;
-		for (std::size_t i = 0; i < Size; i++)
-		{
-			reinterpret_cast<u8*>(&result)[i] = reinterpret_cast<const u8*>(&src)[i];
-		}
-		return result;
-	}
 };

 template <typename T>
@@ -394,11 +388,6 @@ struct se_storage<T, 2, 2>
 		const u16 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
-
-	static inline T copy(const T& src)
-	{
-		return src;
-	}
 };

 template <typename T>
@@ -425,11 +414,6 @@ struct se_storage<T, 4, 4>
 		const u32 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
-
-	static inline T copy(const T& src)
-	{
-		return src;
-	}
 };

 template <typename T>
@@ -456,11 +440,6 @@ struct se_storage<T, 8, 8>
 		const u64 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
-
-	static inline T copy(const T& src)
-	{
-		return src;
-	}
 };

 template <typename T>
@@ -483,11 +462,6 @@ struct se_storage<T, 16, 16>
 		const v128 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
-
-	static inline T copy(const T& src)
-	{
-		return src;
-	}
 };

 // Switched endianness
@@ -550,31 +524,41 @@ class se_t<T, false, Align>

 	stype m_data;

+	static stype init(type value)
+	{
+		stype result;
+		std::memcpy(&result, &value, sizeof(result));
+		return result;
+	}
+
 public:
 	se_t() = default;

 	se_t(type value)
-		: m_data(reinterpret_cast<const stype&>(value))
+		: m_data(init(value))
 	{
 	}

 	type value() const
 	{
-		return storage::copy(reinterpret_cast<const type&>(m_data));
+		type result;
+		std::memcpy(&result, &m_data, sizeof(result));
+		return result;
 	}

 	se_t& operator=(const se_t& value) = default;

 	se_t& operator=(type value)
 	{
-		return m_data = reinterpret_cast<const stype&>(value), *this;
+		std::memcpy(&m_data, &value, sizeof(m_data));
+		return *this;
 	}

 	using simple_type = simple_t<T>;

 	operator type() const
 	{
-		return storage::copy(reinterpret_cast<const type&>(m_data));
+		return value();
 	}
 };

@@ -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
+	}
+};
@@ -7,8 +7,6 @@

 namespace cfg
 {
-	logs::channel cfg("CFG");
-
 	_base::_base(type _type)
 		: m_type(_type)
 	{
@@ -67,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;
 	}

@@ -119,13 +117,13 @@ bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) f

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

 		if (val > max)
 		{
-			if (out) cfg.error("cfg::try_to_enum_value('%s'): out of bounds(0..%u)", value, max);
+			if (out) LOG_ERROR(GENERAL, "cfg::try_to_enum_value('%s'): out of bounds(0..%u)", value, max);
 			return false;
 		}

@@ -134,7 +132,7 @@ bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) f
 	}
 	catch (const std::exception& e)
 	{
-		if (out) cfg.error("cfg::try_to_enum_value('%s'): invalid enum value: %s", value, e.what());
+		if (out) LOG_ERROR(GENERAL, "cfg::try_to_enum_value('%s'): invalid enum value: %s", value, e.what());
 		return false;
 	}
 }
@@ -300,7 +298,7 @@ bool cfg::node::from_string(const std::string& value) try
 }
 catch (const std::exception& e)
 {
-	cfg.fatal("%s thrown: %s", typeid(e).name(), e.what());
+	LOG_FATAL(GENERAL, "%s thrown: %s", typeid(e).name(), e.what());
 	return false;
 }

@@ -49,9 +49,10 @@ namespace cfg
 		_base(type _type, class node* owner, const std::string& name);

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

+		_base& operator=(const _base&) = delete;
+
 		// Get type
 		type get_type() const { return m_type; }

@@ -132,6 +133,11 @@ namespace cfg
 			return m_value;
 		}

+		bool get() const
+		{
+			return m_value;
+		}
+
 		void from_default() override;

 		std::string to_string() const override
@@ -178,6 +184,11 @@ namespace cfg
 			return m_value;
 		}

+		T get() const
+		{
+			return m_value;
+		}
+
 		void from_default() override
 		{
 			m_value = def;
@@ -236,6 +247,11 @@ namespace cfg
 			return m_value;
 		}

+		int_type get() const
+		{
+			return m_value;
+		}
+
 		void from_default() override
 		{
 			m_value = def;
@@ -9,6 +9,7 @@
 #include <cstring>
 #include <cerrno>
 #include <typeinfo>
+#include <map>

 using namespace std::literals::string_literals;

@@ -134,10 +135,10 @@ static fs::error to_error(DWORD e)
 #if defined(__APPLE__)
 #include <copyfile.h>
 #include <mach-o/dyld.h>
-#elif defined(__DragonFly__) || defined(__FreeBSD__)
-#include <sys/socket.h> // sendfile
 #elif defined(__linux__) || defined(__sun)
 #include <sys/sendfile.h>
+#else
+#include <fstream>
 #endif

 static fs::error to_error(int e)
@@ -216,7 +217,7 @@ std::shared_ptr<fs::device_base> fs::device_manager::get_device(const std::strin

 std::shared_ptr<fs::device_base> fs::device_manager::set_device(const std::string& name, const std::shared_ptr<device_base>& device)
 {
-	writer_lock lock(m_mutex);
+	std::lock_guard lock(m_mutex);

 	return m_map[name] = device;
 }
@@ -283,7 +284,7 @@ bool fs::stat(const std::string& path, stat_t& info)
 	info.size = (u64)attrs.nFileSizeLow | ((u64)attrs.nFileSizeHigh << 32);
 	info.atime = to_time(attrs.ftLastAccessTime);
 	info.mtime = to_time(attrs.ftLastWriteTime);
-	info.ctime = to_time(attrs.ftCreationTime);
+	info.ctime = info.mtime;
 #else
 	struct ::stat file_info;
 	if (::stat(path.c_str(), &file_info) != 0)
@@ -297,9 +298,12 @@ bool fs::stat(const std::string& path, stat_t& info)
 	info.size = file_info.st_size;
 	info.atime = file_info.st_atime;
 	info.mtime = file_info.st_mtime;
-	info.ctime = file_info.st_ctime;
+	info.ctime = info.mtime;
 #endif

+	if (info.atime < info.mtime)
+		info.atime = info.mtime;
+
 	return true;
 }

@@ -495,18 +499,30 @@ bool fs::create_dir(const std::string& path)

 bool fs::create_path(const std::string& path)
 {
-	const auto& parent = get_parent_dir(path);
+	const std::string parent = get_parent_dir(path);

-	if (!parent.empty() && !is_dir(parent) && !create_path(parent))
+	if (!parent.empty() && !create_path(parent))
 	{
 		return false;
 	}

-	return create_dir(path);
+	if (!create_dir(path) && g_tls_error != error::exist)
+	{
+		return false;
+	}
+
+	return true;
 }

 bool fs::remove_dir(const std::string& path)
 {
+	if (path.empty())
+	{
+		// Don't allow removing empty path (TODO)
+		g_tls_error = fs::error::noent;
+		return false;
+	}
+
 	if (auto device = get_virtual_device(path))
 	{
 		return device->remove_dir(path);
@@ -533,6 +549,13 @@ bool fs::remove_dir(const std::string& path)

 bool fs::rename(const std::string& from, const std::string& to, bool overwrite)
 {
+	if (from.empty() || to.empty())
+	{
+		// Don't allow opening empty path (TODO)
+		g_tls_error = fs::error::noent;
+		return false;
+	}
+
 	const auto device = get_virtual_device(from);

 	if (device != get_virtual_device(to))
@@ -610,7 +633,7 @@ bool fs::copy_file(const std::string& from, const std::string& to, bool overwrit
 	}

 	return true;
-#else
+#elif defined(__APPLE__) || defined(__linux__) || defined(__sun)
 	/* Source: http://stackoverflow.com/questions/2180079/how-can-i-copy-a-file-on-unix-using-c */

 	const int input = ::open(from.c_str(), O_RDONLY);
@@ -634,17 +657,13 @@ bool fs::copy_file(const std::string& from, const std::string& to, bool overwrit
 #if defined(__APPLE__)
 	// fcopyfile works on OS X 10.5+
 	if (::fcopyfile(input, output, 0, COPYFILE_ALL))
-#elif defined(__DragonFly__) || defined(__FreeBSD__)
-	if (::sendfile(input, output, 0, 0, NULL, NULL, 0))
 #elif defined(__linux__) || defined(__sun)
 	// sendfile will work with non-socket output (i.e. regular file) on Linux 2.6.33+
 	off_t bytes_copied = 0;
 	struct ::stat fileinfo = { 0 };
 	if (::fstat(input, &fileinfo) || ::sendfile(output, input, &bytes_copied, fileinfo.st_size))
-#else // NetBSD, OpenBSD, etc.
-	fmt::throw_exception("fs::copy_file() isn't implemented for this platform.\nFrom: %s\nTo: %s", from, to);
-	errno = 0;
-	if (true)
+#else
+#error "Native file copy implementation is missing"
 #endif
 	{
 		const int err = errno;
@@ -657,6 +676,31 @@ bool fs::copy_file(const std::string& from, const std::string& to, bool overwrit

 	::close(input);
 	::close(output);
+	return true;
+#else // fallback
+	{
+		std::ifstream out{to, std::ios::binary};
+		if (out.good() && !overwrite)
+		{
+			g_tls_error = to_error(EEXIST);
+			return false;
+		}
+	}
+
+	std::ifstream in{from, std::ios::binary};
+	std::ofstream out{to,  std::ios::binary};
+
+	if (!in.good() || !out.good())
+	{
+		g_tls_error = to_error(errno);
+		return false;
+	}
+
+	std::istreambuf_iterator<char> bin(in);
+	std::istreambuf_iterator<char> ein;
+	std::ostreambuf_iterator<char> bout(out);
+	std::copy(bin, ein, bout);
+
 	return true;
 #endif
 }
@@ -780,6 +824,13 @@ void fs::file::xfail() const

 fs::file::file(const std::string& path, bs_t<open_mode> mode)
 {
+	if (path.empty())
+	{
+		// Don't allow opening empty path (TODO)
+		g_tls_error = fs::error::noent;
+		return;
+	}
+
 	if (auto device = get_virtual_device(path))
 	{
 		if (auto&& _file = device->open(path, mode))
@@ -793,29 +844,34 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)

 #ifdef _WIN32
 	DWORD access = 0;
-	if (test(mode & fs::read)) access |= GENERIC_READ;
-	if (test(mode & fs::write)) access |= test(mode & fs::append) ? FILE_APPEND_DATA : GENERIC_WRITE;
+	if (mode & fs::read) access |= GENERIC_READ;
+	if (mode & fs::write) access |= DELETE | (mode & fs::append ? FILE_APPEND_DATA : GENERIC_WRITE);

 	DWORD disp = 0;
-	if (test(mode & fs::create))
+	if (mode & fs::create)
 	{
 		disp =
-			test(mode & fs::excl) ? CREATE_NEW :
-			test(mode & fs::trunc) ? CREATE_ALWAYS : OPEN_ALWAYS;
+			mode & fs::excl ? CREATE_NEW :
+			mode & fs::trunc ? CREATE_ALWAYS : OPEN_ALWAYS;
 	}
 	else
 	{
-		if (test(mode & fs::excl))
+		if (mode & fs::excl)
 		{
 			g_tls_error = error::inval;
 			return;
 		}

-		disp = test(mode & fs::trunc) ? TRUNCATE_EXISTING : OPEN_EXISTING;
+		disp = mode & fs::trunc ? TRUNCATE_EXISTING : OPEN_EXISTING;
 	}

-	DWORD share = FILE_SHARE_READ;
-	if (!test(mode & fs::unshare))
+	DWORD share = 0;
+	if (!(mode & fs::unread) || !(mode & fs::write))
+	{
+		share |= FILE_SHARE_READ;
+	}
+
+	if (!(mode & (fs::lock + fs::unread)) || !(mode & fs::write))
 	{
 		share |= FILE_SHARE_WRITE | FILE_SHARE_DELETE;
 	}
@@ -854,7 +910,10 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 			info.size = this->size();
 			info.atime = to_time(basic_info.LastAccessTime);
 			info.mtime = to_time(basic_info.ChangeTime);
-			info.ctime = to_time(basic_info.CreationTime);
+			info.ctime = info.mtime;
+
+			if (info.atime < info.mtime)
+				info.atime = info.mtime;

 			return info;
 		}
@@ -938,16 +997,23 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 #else
 	int flags = 0;

-	if (test(mode & fs::read) && test(mode & fs::write)) flags |= O_RDWR;
-	else if (test(mode & fs::read)) flags |= O_RDONLY;
-	else if (test(mode & fs::write)) flags |= O_WRONLY;
+	if (mode & fs::read && mode & fs::write) flags |= O_RDWR;
+	else if (mode & fs::read) flags |= O_RDONLY;
+	else if (mode & fs::write) flags |= O_WRONLY;

-	if (test(mode & fs::append)) flags |= O_APPEND;
-	if (test(mode & fs::create)) flags |= O_CREAT;
-	if (test(mode & fs::trunc)) flags |= O_TRUNC;
-	if (test(mode & fs::excl)) flags |= O_EXCL;
+	if (mode & fs::append) flags |= O_APPEND;
+	if (mode & fs::create) flags |= O_CREAT;
+	if (mode & fs::trunc && !(mode & (fs::lock + fs::unread))) flags |= O_TRUNC;
+	if (mode & fs::excl) flags |= O_EXCL;

-	const int fd = ::open(path.c_str(), flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+	int perm = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+
+	if (mode & fs::write && mode & fs::unread)
+	{
+		perm = 0;
+	}
+
+	const int fd = ::open(path.c_str(), flags, perm);

 	if (fd == -1)
 	{
@@ -955,13 +1021,19 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 		return;
 	}

-	if (test(mode & fs::unshare) && ::flock(fd, LOCK_EX | LOCK_NB) != 0)
+	if (mode & fs::write && mode & (fs::lock + fs::unread) && ::flock(fd, LOCK_EX | LOCK_NB) != 0)
 	{
 		g_tls_error = errno == EWOULDBLOCK ? fs::error::acces : to_error(errno);
 		::close(fd);
 		return;
 	}

+	if (mode & fs::trunc && mode & (fs::lock + fs::unread))
+	{
+		// Postpone truncation in order to avoid using O_TRUNC on a locked file
+		::ftruncate(fd, 0);
+	}
+
 	class unix_file final : public file_base, public get_native_handle
 	{
 		const int m_fd;
@@ -988,7 +1060,10 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 			info.size = file_info.st_size;
 			info.atime = file_info.st_atime;
 			info.mtime = file_info.st_mtime;
-			info.ctime = file_info.st_ctime;
+			info.ctime = info.mtime;
+
+			if (info.atime < info.mtime)
+				info.atime = info.mtime;

 			return info;
 		}
@@ -1152,6 +1227,13 @@ void fs::dir::xnull() const

 bool fs::dir::open(const std::string& path)
 {
+	if (path.empty())
+	{
+		// Don't allow opening empty path (TODO)
+		g_tls_error = fs::error::noent;
+		return false;
+	}
+
 	if (auto device = get_virtual_device(path))
 	{
 		if (auto&& _dir = device->open_dir(path))
@@ -1188,7 +1270,10 @@ bool fs::dir::open(const std::string& path)
 			info.size = ((u64)found.nFileSizeHigh << 32) | (u64)found.nFileSizeLow;
 			info.atime = to_time(found.ftLastAccessTime);
 			info.mtime = to_time(found.ftLastWriteTime);
-			info.ctime = to_time(found.ftCreationTime);
+			info.ctime = info.mtime;
+
+			if (info.atime < info.mtime)
+				info.atime = info.mtime;

 			m_entries.emplace_back(std::move(info));
 		}
@@ -1271,7 +1356,10 @@ bool fs::dir::open(const std::string& path)
 			info.size = file_info.st_size;
 			info.atime = file_info.st_atime;
 			info.mtime = file_info.st_mtime;
-			info.ctime = file_info.st_ctime;
+			info.ctime = info.mtime;
+
+			if (info.atime < info.mtime)
+				info.atime = info.mtime;

 			return true;
 		}
@@ -1296,8 +1384,9 @@ const std::string& fs::get_config_dir()
 		std::string dir;

 #ifdef _WIN32
-		wchar_t buf[2048];
-		if (GetModuleFileName(NULL, buf, ::size32(buf)) - 1 >= ::size32(buf) - 1)
+		wchar_t buf[32768];
+		if (GetEnvironmentVariable(L"RPCS3_CONFIG_DIR", buf, std::size(buf)) - 1 >= std::size(buf) - 1 &&
+			GetModuleFileName(NULL, buf, std::size(buf)) - 1 >= std::size(buf) - 1)
 		{
 			MessageBoxA(0, fmt::format("GetModuleFileName() failed: error %u.", GetLastError()).c_str(), "fs::get_config_dir()", MB_ICONERROR);
 			return dir; // empty
@@ -1309,16 +1398,22 @@ const std::string& fs::get_config_dir()

 		dir.resize(dir.rfind('/') + 1);
 #else
-		if (const char* home = ::getenv("XDG_CONFIG_HOME"))
-			dir = home;
+
+#ifdef __APPLE__
+		if (const char* home = ::getenv("HOME"))
+			dir = home + "/Library/Application Support"s;
+#else
+		if (const char* conf = ::getenv("XDG_CONFIG_HOME"))
+			dir = conf;
 		else if (const char* home = ::getenv("HOME"))
 			dir = home + "/.config"s;
+#endif
 		else // Just in case
 			dir = "./config";

 		dir += "/rpcs3/";

-		if (!is_dir(dir) && !create_path(dir))
+		if (!create_path(dir))
 		{
 			std::printf("Failed to create configuration directory '%s' (%d).\n", dir.c_str(), errno);
 		}
@@ -1330,76 +1425,42 @@ const std::string& fs::get_config_dir()
 	return s_dir;
 }

-std::string fs::get_data_dir(const std::string& prefix, const std::string& location, const std::string& suffix)
+const std::string& fs::get_cache_dir()
 {
 	static const std::string s_dir = []
 	{
-		const std::string& dir = get_config_dir() + "data/";
+		std::string dir;

-		if (!is_dir(dir) && !create_path(dir))
+#ifdef _WIN32
+		dir = get_config_dir();
+#else
+
+#ifdef __APPLE__
+		if (const char* home = ::getenv("HOME"))
+			dir = home + "/Library/Caches"s;
+#else
+		if (const char* cache = ::getenv("XDG_CACHE_HOME"))
+			dir = cache;
+		else if (const char* conf = ::getenv("XDG_CONFIG_HOME"))
+			dir = conf;
+		else if (const char* home = ::getenv("HOME"))
+			dir = home + "/.cache"s;
+#endif
+		else // Just in case
+			dir = "./cache";
+
+		dir += "/rpcs3/";
+
+		if (!create_path(dir))
 		{
-			return get_config_dir();
+			std::printf("Failed to create configuration directory '%s' (%d).\n", dir.c_str(), errno);
 		}
+#endif

 		return dir;
 	}();

-	std::vector<u8> buf;
-	buf.reserve(location.size() + 1);
-
-	// Normalize location
-	for (char c : location)
-	{
-#ifdef _WIN32
-		if (c == '/' || c == '\\')
-#else
-		if (c == '/')
-#endif
-		{
-			if (buf.empty() || buf.back() != '/')
-			{
-				buf.push_back('/');
-			}
-
-			continue;
-		}
-
-		buf.push_back(c);
-	}
-
-	// Calculate hash
-	u8 hash[20];
-	sha1(buf.data(), buf.size(), hash);
-
-	// Concatenate
-	std::string&& result = fmt::format("%s%s/%016llx%08x-%s/", s_dir, prefix, reinterpret_cast<be_t<u64>&>(hash[0]), reinterpret_cast<be_t<u32>&>(hash[8]), suffix);
-
-	if (!is_dir(result))
-	{
-		// Create dir if necessary
-		if (create_path(result))
-		{
-			// Acknowledge original location
-			file(result + ".location", rewrite).write(buf);
-		}
-	}
-
-	return result;
-}
-
-std::string fs::get_data_dir(const std::string& prefix, const std::string& path)
-{
-#ifdef _WIN32
-	const auto& delim = "/\\";
-#else
-	const auto& delim = "/";
-#endif
-
-	// Extract file name and location
-	const std::string& location = fs::get_parent_dir(path);
-	const std::size_t name_pos = path.find_first_not_of(delim, location.size());
-
-	return fs::get_data_dir(prefix, location, name_pos == -1 ? std::string{} : path.substr(name_pos));
+	return s_dir;
 }

 void fs::remove_all(const std::string& path, bool remove_root)
@@ -1453,6 +1514,122 @@ u64 fs::get_dir_size(const std::string& path)
 	return result;
 }

+fs::file fs::make_gather(std::vector<fs::file> files)
+{
+	struct gather_stream : file_base
+	{
+		u64 pos = 0;
+		u64 end = 0;
+		std::vector<file> files;
+		std::map<u64, u64> ends; // Fragment End Offset -> Index
+
+		gather_stream(std::vector<fs::file> arg)
+			: files(std::move(arg))
+		{
+			// Preprocess files
+			for (auto&& f : files)
+			{
+				end += f.size();
+				ends.emplace(end, ends.size());
+			}
+		}
+
+		~gather_stream() override
+		{
+		}
+
+		fs::stat_t stat() override
+		{
+			fs::stat_t result{};
+
+			if (!files.empty())
+			{
+				result = files[0].stat();
+			}
+
+			result.is_directory = false;
+			result.is_writable = false;
+			result.size = end;
+			return result;
+		}
+
+		bool trunc(u64 length) override
+		{
+			return false;
+		}
+
+		u64 read(void* buffer, u64 size) override
+		{
+			if (pos < end)
+			{
+				// Current pos
+				const u64 start = pos;
+
+				// Get readable size
+				if (const u64 max = std::min<u64>(size, end - pos))
+				{
+					u8* buf_out = static_cast<u8*>(buffer);
+					u64 buf_max = max;
+
+					for (auto it = ends.upper_bound(pos); it != ends.end(); ++it)
+					{
+						// Set position for the fragment
+						files[it->second].seek(pos - it->first, fs::seek_end);
+
+						const u64 count = std::min<u64>(it->first - pos, buf_max);
+						const u64 read  = files[it->second].read(buf_out, count);
+
+						buf_out += count;
+						buf_max -= count;
+						pos     += read;
+
+						if (read < count || buf_max == 0)
+						{
+							break;
+						}
+					}
+
+					return pos - start;
+				}
+			}
+
+			return 0;
+		}
+
+		u64 write(const void* buffer, u64 size) override
+		{
+			return 0;
+		}
+
+		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 + end :
+				(fmt::raw_error("fs::gather_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 end;
+		}
+	};
+
+	fs::file result;
+	result.reset(std::make_unique<gather_stream>(std::move(files)));
+	return result;
+}
+
 template<>
 void fmt_class_string<fs::seek_mode>::format(std::string& out, u64 arg)
 {
@@ -25,7 +25,8 @@ namespace fs
 		create,
 		trunc,
 		excl,
-		unshare,
+		lock,
+		unread,

 		__bitset_enum_max
 	};
@@ -36,7 +37,8 @@ namespace fs
 	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 unshare = +open_mode::unshare; // Prevent opening the file twice
+	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 auto rewrite = open_mode::write + open_mode::create + open_mode::trunc;

@@ -185,7 +187,7 @@ namespace fs
 		file() = default;

 		// Open file with specified mode
-		explicit file(const std::string& path, bs_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);
@@ -400,7 +402,7 @@ namespace fs
 		{
 			m_dir = std::move(ptr);
 		}
-		
+
 		std::unique_ptr<dir_base> release()
 		{
 			return std::move(m_dir);
@@ -482,11 +484,8 @@ namespace fs
 	// Get configuration directory
 	const std::string& get_config_dir();

-	// Get data/cache directory for specified prefix and suffix
-	std::string get_data_dir(const std::string& prefix, const std::string& location, const std::string& suffix);
-
-	// Get data/cache directory for specified prefix and path (suffix will be filename)
-	std::string get_data_dir(const std::string& prefix, const std::string& path);
+	// 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);
@@ -617,10 +616,12 @@ namespace fs
 		if (fs::file f{path, mode})
 		{
 			// Write args sequentially
-			int seq[]{ (f.write(args), 0)... };
+			(f.write(args), ...);
 			return true;
 		}

 		return false;
 	}
+
+	file make_gather(std::vector<file>);
 }
@@ -4,7 +4,7 @@
 #include "GDBDebugServer.h"
 #include "Log.h"
 #include <algorithm>
-#include "Emu/Memory/Memory.h"
+#include "Emu/Memory/vm.h"
 #include "Emu/System.h"
 #include "Emu/IdManager.h"
 #include "Emu/CPU/CPUThread.h"
@@ -13,13 +13,13 @@
 #include "Emu/Cell/SPUThread.h"

 #ifndef _WIN32
-#include"fcntl.h"
+#include "fcntl.h"
 #endif

 extern void ppu_set_breakpoint(u32 addr);
 extern void ppu_remove_breakpoint(u32 addr);

-logs::channel gdbDebugServer("gdbDebugServer");
+LOG_CHANNEL(gdbDebugServer);

 int sock_init(void)
 {
@@ -166,9 +166,10 @@ char GDBDebugServer::read_char()

 u8 GDBDebugServer::read_hexbyte()
 {
-	char buf[2];
-	read(buf, 2);
-	return static_cast<u8>(strtol(buf, nullptr, 16));
+	std::string s = "";
+	s += read_char();
+	s += read_char();
+	return hex_to_u8(s);
 }

 void GDBDebugServer::try_read_cmd(gdb_cmd & out_cmd)
@@ -176,7 +177,7 @@ void GDBDebugServer::try_read_cmd(gdb_cmd & out_cmd)
 	char c = read_char();
 	//interrupt
 	if (UNLIKELY(c == 0x03)) {
-		out_cmd.cmd = "\0x03";
+		out_cmd.cmd = '\x03';
 		out_cmd.data = "";
 		out_cmd.checksum = 0;
 		return;
@@ -223,7 +224,7 @@ void GDBDebugServer::try_read_cmd(gdb_cmd & out_cmd)
 	}
 	out_cmd.checksum = read_hexbyte();
 	if (out_cmd.checksum != checksum) {
-		throw new wrong_checksum_exception("Wrong checksum for packet" HERE);
+		throw wrong_checksum_exception("Wrong checksum for packet" HERE);
 	}
 }

@@ -337,6 +338,7 @@ bool GDBDebugServer::select_thread(u64 id)
 		selected_thread = ppu.ptr;
 		return true;
 	}
+	gdbDebugServer.warning("Unable to select thread! Is the emulator running?");
 	return false;
 }

@@ -365,7 +367,7 @@ std::string GDBDebugServer::get_reg(std::shared_ptr<ppu_thread> thread, u32 rid)
 		return std::string(8, 'x');
 	default:
 		if (rid > 70) return "";
-		return (rid > 31) 
+		return (rid > 31)
 			? u64_to_padded_hex(reinterpret_cast<u64&>(thread->fpr[rid - 32])) //fpr
 			: u64_to_padded_hex(thread->gpr[rid]); //gpr
 	}
@@ -427,6 +429,25 @@ 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");
@@ -453,24 +474,25 @@ bool GDBDebugServer::cmd_thread_info(gdb_cmd & cmd)
 		result += u64_to_padded_hex(static_cast<u64>(cpu.id));
 	};
 	idm::select<ppu_thread>(on_select);
-	idm::select<ARMv7Thread>(on_select);
-	idm::select<RawSPUThread>(on_select);
-	idm::select<SPUThread>(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() ? "" : u64_to_padded_hex(selected_thread.lock()->id));
+	return send_cmd_ack(selected_thread.expired() ? "" : ("QC" + u64_to_padded_hex(selected_thread.lock()->id)));
 }

 bool GDBDebugServer::cmd_read_register(gdb_cmd & cmd)
 {
-	select_thread(general_ops_thread_id);
+	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);
@@ -488,7 +510,9 @@ bool GDBDebugServer::cmd_read_register(gdb_cmd & cmd)

 bool GDBDebugServer::cmd_write_register(gdb_cmd & cmd)
 {
-	select_thread(general_ops_thread_id);
+	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);
@@ -517,7 +541,7 @@ bool GDBDebugServer::cmd_read_memory(gdb_cmd & cmd)
 	std::string result;
 	result.reserve(len * 2);
 	for (u32 i = 0; i < len; ++i) {
-		if (vm::check_addr(addr + i)) {
+		if (vm::check_addr(addr, 1, vm::page_allocated | vm::page_readable)) {
 			result += to_hexbyte(vm::read8(addr + i));
 		} else {
 			break;
@@ -543,7 +567,7 @@ bool GDBDebugServer::cmd_write_memory(gdb_cmd & cmd)
 	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)) {
+		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) {
@@ -634,30 +658,31 @@ bool GDBDebugServer::cmd_vcont(gdb_cmd & cmd)
 {
 	//todo: handle multiple actions and thread ids
 	this->from_breakpoint = false;
-	if (cmd.data[1] == 'c') {
+	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());
-		ppu->state -= cpu_flag::dbg_pause;
-		if (Emu.IsPaused()) {
-			Emu.Resume();
+		paused = false;
+		if (cmd.data[1] == 's') {
+			ppu->state += cpu_flag::dbg_step;
 		}
-		thread_ctrl::wait();
-		//we are in all-stop mode
-		Emu.Pause();
-		return send_reason();
-	} else if (cmd.data[1] == 's') {
-		select_thread(continue_ops_thread_id);
-		auto ppu = std::static_pointer_cast<ppu_thread>(selected_thread.lock());
-		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();
 		}
-		thread_ctrl::wait();
+		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("");
@@ -729,7 +754,9 @@ void GDBDebugServer::on_task()
 			return;
 		}
 		//stop immediately
-		Emu.Pause();
+		if (Emu.IsRunning()) {
+			Emu.Pause();
+		}

 		try {
 			char hostbuf[32];
@@ -768,7 +795,7 @@ void GDBDebugServer::on_task()
 				}
 			}
 		}
-		catch (std::runtime_error& e) 
+		catch (std::runtime_error& e)
 		{
 			if (client_socket) {
 				closesocket(client_socket);
@@ -802,7 +829,16 @@ void GDBDebugServer::on_stop()
 	this->stop = true;
 	//just in case we are waiting for breakpoint
 	this->notify();
-	named_thread::on_stop();
+	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;
@@ -40,8 +40,8 @@ public:
 const u64 ALL_THREADS = 0xffffffffffffffff;
 const u64 ANY_THREAD = 0;

-class GDBDebugServer : public named_thread {
-
+class GDBDebugServer
+{
 	socket_t server_socket;
 	socket_t client_socket;
 	std::weak_ptr<cpu_thread> selected_thread;
@@ -50,7 +50,7 @@ class GDBDebugServer : public named_thread {

 	//initialize server socket and start listening
 	void start_server();
-	//read at most cnt bytes to buf, returns nubmer of bytes actually read
+	//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();
@@ -60,8 +60,8 @@ class GDBDebugServer : public named_thread {
 	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 
+	//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
@@ -90,6 +90,8 @@ class GDBDebugServer : public named_thread {
 	//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);
@@ -110,20 +112,14 @@ class GDBDebugServer : public named_thread {
 	bool cmd_set_breakpoint(gdb_cmd& cmd);
 	bool cmd_remove_breakpoint(gdb_cmd& cmd);

-protected:
-	void on_task() override final;
-	void on_exit() override final;
-
 public:
-	static const u32 id_base = 1;
-	static const u32 id_step = 1;
-	static const u32 id_count = 0x100000;
-
 	bool from_breakpoint = true;
 	bool stop = false;
+	bool paused = false;
+	u64 pausedBy;

-	virtual std::string get_name() const;
-	virtual void on_stop() override final;
+	void operator()();
+	void pause_from(cpu_thread* t);
 };

 extern u32 g_gdb_debugger_id;
@@ -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>
@@ -7,14 +218,6 @@
 #include <array>
 #include <deque>

-#include "types.h"
-#include "StrFmt.h"
-#include "File.h"
-#include "Log.h"
-#include "mutex.h"
-#include "sysinfo.h"
-#include "VirtualMemory.h"
-
 #ifdef _MSC_VER
 #pragma warning(push, 0)
 #endif
@@ -34,8 +237,6 @@
 #include <sys/mman.h>
 #endif

-#include "JIT.h"
-
 // Memory manager mutex
 shared_mutex s_mutex;

@@ -72,7 +273,7 @@ static void* s_next = s_memory;
 static std::deque<std::vector<RUNTIME_FUNCTION>> s_unwater;
 static std::vector<std::vector<RUNTIME_FUNCTION>> s_unwind; // .pdata
 #else
-static std::deque<std::tuple<u8*, u64, std::size_t>> s_unfire;
+static std::deque<std::pair<u8*, std::size_t>> s_unfire;
 #endif

 // Reset memory manager
@@ -89,27 +290,9 @@ extern void jit_finalize()

 	s_unwind.clear();
 #else
-	struct MemoryManager : llvm::RTDyldMemoryManager
-	{
-		u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
-		{
-			return nullptr;
-		}
-
-		u8* allocateDataSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name, bool is_ro) override
-		{
-			return nullptr;
-		}
-
-		bool finalizeMemory(std::string* = nullptr) override
-		{
-			return false;
-		}
-	} mem;
-
 	for (auto&& t : s_unfire)
 	{
-		mem.deregisterEHFrames(std::get<0>(t), std::get<1>(t), std::get<2>(t));
+		llvm::RTDyldMemoryManager::deregisterEHFramesInProcess(t.first, t.second);
 	}

 	s_unfire.clear();
@@ -163,7 +346,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 		if ((u64)s_memory > 0x80000000 - s_memory_size ? (u64)addr - (u64)s_memory >= s_memory_size : addr >= 0x80000000)
 		{
 			// Lock memory manager
-			writer_lock lock(s_mutex);
+			std::lock_guard lock(s_mutex);

 			// Allocate memory for trampolines
 			if (!m_tramps)
@@ -199,7 +382,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 	u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
 	{
 		// Lock memory manager
-		writer_lock lock(s_mutex);
+		std::lock_guard lock(s_mutex);

 		// Simple allocation
 		const u64 next = ::align((u64)s_next + size, 4096);
@@ -220,7 +403,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 	u8* allocateDataSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name, bool is_ro) override
 	{
 		// Lock memory manager
-		writer_lock lock(s_mutex);
+		std::lock_guard lock(s_mutex);

 		// Simple allocation
 		const u64 next = ::align((u64)s_next + size, 4096);
@@ -233,7 +416,6 @@ struct MemoryManager : llvm::RTDyldMemoryManager

 		if (!is_ro)
 		{
-			LOG_ERROR(GENERAL, "LLVM: Writeable data section not supported!");
 		}

 		utils::memory_commit(s_next, size);
@@ -245,7 +427,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 	bool finalizeMemory(std::string* = nullptr) override
 	{
 		// Lock memory manager
-		writer_lock lock(s_mutex);
+		std::lock_guard lock(s_mutex);

 		// TODO: make only read-only sections read-only
 //#ifdef _WIN32
@@ -263,7 +445,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 	{
 #ifdef _WIN32
 		// Lock memory manager
-		writer_lock lock(s_mutex);
+		std::lock_guard lock(s_mutex);

 		// Use s_memory as a BASE, compute the difference
 		const u64 unwind_diff = (u64)addr - (u64)s_memory;
@@ -287,17 +469,42 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 			s_unwind.emplace_back(std::move(pdata));
 		}
 #else
-		s_unfire.push_front(std::make_tuple(addr, load_addr, size));
+		s_unfire.push_front(std::make_pair(addr, size));
 #endif

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

-	void deregisterEHFrames(u8* addr, u64 load_addr, std::size_t size) override
+	void deregisterEHFrames() override
 	{
 	}
 };

+// Simple memory manager
+struct MemoryManager2 : llvm::RTDyldMemoryManager
+{
+	MemoryManager2() = default;
+
+	~MemoryManager2() override
+	{
+	}
+
+	u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
+	{
+		return jit_runtime::alloc(size, align, true);
+	}
+
+	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 : llvm::JITEventListener
 {
@@ -336,7 +543,7 @@ struct EventListener : llvm::JITEventListener
 				}

 				// Lock memory manager
-				writer_lock lock(s_mutex);
+				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;
@@ -373,15 +580,15 @@ public:
 		std::string name = m_path;
 		name.append(module->getName());
 		fs::file(name, fs::rewrite).write(obj.getBufferStart(), obj.getBufferSize());
-		LOG_SUCCESS(GENERAL, "LLVM: Created module: %s", module->getName().data());
+		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::MemoryBuffer::getNewUninitMemBuffer(cached.size());
-			cached.read(const_cast<char*>(buf->getBufferStart()), buf->getBufferSize());
+			auto buf = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(cached.size());
+			cached.read(buf->getBufferStart(), buf->getBufferSize());
 			return buf;
 		}

@@ -395,7 +602,7 @@ public:

 		if (auto buf = load(path))
 		{
-			LOG_SUCCESS(GENERAL, "LLVM: Loaded module: %s", module->getName().data());
+			LOG_NOTICE(GENERAL, "LLVM: Loaded module: %s", module->getName().data());
 			return buf;
 		}

@@ -403,10 +610,10 @@ public:
 	}
 };

-jit_compiler::jit_compiler(const std::unordered_map<std::string, u64>& _link, std::string _cpu)
-	: m_link(_link)
-	, m_cpu(std::move(_cpu))
+std::string jit_compiler::cpu(const std::string& _cpu)
 {
+	std::string m_cpu = _cpu;
+
 	if (m_cpu.empty())
 	{
 		m_cpu = llvm::sys::getHostCPUName();
@@ -417,15 +624,35 @@ jit_compiler::jit_compiler(const std::unordered_map<std::string, u64>& _link, st
 			m_cpu == "broadwell" ||
 			m_cpu == "skylake" ||
 			m_cpu == "skylake-avx512" ||
-			m_cpu == "cannonlake")
+			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;

 	if (m_link.empty())
@@ -433,8 +660,10 @@ jit_compiler::jit_compiler(const std::unordered_map<std::string, u64>& _link, st
 		// 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(llvm::CodeModel::Small)
+			.setCodeModel(large ? llvm::CodeModel::Large : llvm::CodeModel::Small)
 			.setMCPU(m_cpu)
 			.create());
 	}
@@ -446,9 +675,10 @@ jit_compiler::jit_compiler(const std::unordered_map<std::string, u64>& _link, st

 		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(llvm::CodeModel::Small)
+			.setCodeModel(large ? llvm::CodeModel::Large : llvm::CodeModel::Small)
 			.setMCPU(m_cpu)
 			.create());

@@ -468,6 +698,25 @@ 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};
@@ -485,6 +734,19 @@ void jit_compiler::add(std::unique_ptr<llvm::Module> module, const std::string&
 	}
 }

+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()));
@@ -500,33 +762,4 @@ u64 jit_compiler::get(const std::string& name)
 	return m_engine->getGlobalValueAddress(name);
 }

-std::unordered_map<std::string, u64> jit_compiler::add(std::unordered_map<std::string, std::string> data)
-{
-	// Lock memory manager
-	writer_lock lock(s_mutex);
-
-	std::unordered_map<std::string, u64> result;
-
-	std::size_t size = 0;
-
-	for (auto&& pair : data)
-	{
-		size += ::align(pair.second.size(), 16);
-	}
-
-	utils::memory_commit(s_next, size, utils::protection::wx);
-	std::memset(s_next, 0xc3, ::align(size, 4096));
-
-	for (auto&& pair : data)
-	{
-		std::memcpy(s_next, pair.second.data(), pair.second.size());
-		result.emplace(pair.first, (u64)s_next);
-		s_next = (void*)::align((u64)s_next + pair.second.size(), 16);
-	}
-
-	s_next = (void*)::align((u64)s_next, 4096);
-
-	return result;
-}
-
 #endif
@@ -1,9 +1,97 @@
 #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"
@@ -40,7 +128,7 @@ class jit_compiler final
 	std::string m_cpu;

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

 	// Get LLVM context
@@ -49,9 +137,20 @@ public:
 		return m_context;
 	}

+	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);

@@ -61,14 +160,8 @@ public:
 	// Get compiled function address
 	u64 get(const std::string& name);

-	// Add functions directly to the memory manager (name -> code)
-	static std::unordered_map<std::string, u64> add(std::unordered_map<std::string, std::string>);
-
 	// Get CPU info
-	const std::string& cpu() const
-	{
-		return m_cpu;
-	}
+	static std::string cpu(const std::string& _cpu);

 	// Check JIT purpose
 	bool is_primary() const
@@ -6,10 +6,13 @@
 #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;

@@ -18,6 +21,7 @@ using namespace std::literals::chrono_literals;
 #include <Windows.h>
 #else
 #include <sys/mman.h>
+#include <sys/stat.h>
 #endif

 #include <zlib.h>
@@ -71,7 +75,7 @@ namespace logs
 #endif
 		uchar* m_fptr{};
 		z_stream m_zs{};
-		semaphore<> m_m;
+		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
@@ -177,17 +181,16 @@ namespace logs
 	channel HLE("HLE");
 	channel PPU("PPU");
 	channel SPU("SPU");
-	channel ARMv7("ARMv7");

 	// Channel registry mutex
-	semaphore<> g_mutex;
+	shared_mutex g_mutex;

 	// Must be set to true in main()
 	atomic_t<bool> g_init{false};

 	void reset()
 	{
-		semaphore_lock lock(g_mutex);
+		std::lock_guard lock(g_mutex);

 		for (auto&& pair : get_logger()->channels)
 		{
@@ -197,7 +200,7 @@ namespace logs

 	void set_level(const std::string& ch_name, level value)
 	{
-		semaphore_lock lock(g_mutex);
+		std::lock_guard lock(g_mutex);

 		get_logger()->channels[ch_name].set_level(value);
 	}
@@ -207,7 +210,7 @@ namespace logs
 	{
 		if (!g_init)
 		{
-			semaphore_lock lock(g_mutex);
+			std::lock_guard lock(g_mutex);
 			get_logger()->messages.clear();
 			g_init = true;
 		}
@@ -223,7 +226,7 @@ void logs::listener::add(logs::listener* _new)
 	// Get first (main) listener
 	listener* lis = get_logger();

-	semaphore_lock lock(g_mutex);
+	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))
@@ -238,7 +241,7 @@ void logs::listener::add(logs::listener* _new)
 	}
 }

-void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u64* args)
+void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, ...) const
 {
 	// Get timestamp
 	const u64 stamp = get_stamp();
@@ -246,7 +249,7 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u
 	// Register channel
 	if (ch->enabled == level::_uninit)
 	{
-		semaphore_lock lock(g_mutex);
+		std::lock_guard lock(g_mutex);

 		auto& info = get_logger()->channels[ch->name];

@@ -267,9 +270,23 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u
 		}
 	}

-	// Get text
-	thread_local std::string text; text.clear();
-	fmt::raw_append(text, fmt, sup, args);
+	// 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
@@ -277,7 +294,7 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u

 	if (!g_init)
 	{
-		semaphore_lock lock(g_mutex);
+		std::lock_guard lock(g_mutex);

 		if (!g_init)
 		{
@@ -305,12 +322,12 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u
 logs::file_writer::file_writer(const std::string& name)
 	: m_name(name)
 {
-	const std::string log_name = fs::get_config_dir() + name + ".log";
-	const std::string buf_name = fs::get_config_dir() + name + ".buf";
+	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(buf_name, fs::read + fs::write + fs::create + fs::trunc + fs::unshare))
+		if (!m_file.open(buf_name, fs::read + fs::rewrite + fs::lock))
 		{
 			if (fs::g_tls_error == fs::error::acces)
 			{
@@ -335,7 +352,7 @@ logs::file_writer::file_writer(const std::string& name)

 		// Check free space
 		fs::device_stat stats{};
-		if (!fs::statfs(fs::get_config_dir(), stats) || stats.avail_free < s_log_size * 8)
+		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.);
 		}
@@ -355,18 +372,25 @@ logs::file_writer::file_writer(const std::string& name)
 		verify(name.c_str()), m_fptr;

 		// Rotate backups (TODO)
-		fs::remove_file(fs::get_config_dir() + name + "1.log.gz");
-		fs::create_dir(fs::get_config_dir() + "old_logs");
-		fs::rename(fs::get_config_dir() + m_name + ".log.gz", fs::get_config_dir() + "old_logs/" + m_name + ".log.gz", true);
+		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
-		if (!m_fout2.open(log_name + ".gz", fs::rewrite) || deflateInit2(&m_zs, 9, Z_DEFLATED, 16 + 15, 9, Z_DEFAULT_STRATEGY) != Z_OK)
+		// 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)
 	{
@@ -444,16 +468,23 @@ logs::file_writer::~file_writer()
 	}

 #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)
 {
-	semaphore_lock lock(m_m);
+	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);
@@ -592,7 +623,7 @@ void logs::file_listener::log(u64 stamp, const logs::message& msg, const std::st
 	case level::_uninit: text = u8"·  "; break;
 	}

-	// Print miscosecond timestamp
+	// 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;
@@ -23,14 +23,17 @@ namespace logs

 	struct channel;

-	// Message information (temporary data)
+	// 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 u64*);
+		void broadcast(const char*, const fmt_type_info*, ...) const;
+
+		friend struct channel;
 	};

 	class listener
@@ -67,21 +70,16 @@ namespace logs
 		{
 		}

-		// Formatting function
-		template<typename... Args>
-		SAFE_BUFFERS FORCE_INLINE void format(level sev, const char* fmt, const Args&... args)
-		{
-			if (UNLIKELY(sev <= enabled))
-			{
-				message{this, sev}.broadcast(fmt, fmt::get_type_info<fmt_unveil_t<Args>...>(), fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
-			}
-		}
-
 #define GEN_LOG_METHOD(_sev)\
-		template<typename... Args>\
-		SAFE_BUFFERS void _sev(const char* fmt, const Args&... args)\
+		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)
@@ -104,7 +102,6 @@ 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();
@@ -113,6 +110,8 @@ namespace logs
 	void set_level(const std::string&, level);
 }

+#define LOG_CHANNEL(ch, ...) ::logs::channel ch(#ch, ##__VA_ARGS__);
+
 // Legacy:

 #define LOG_SUCCESS(ch, fmt, ...) logs::ch.success("" fmt, ##__VA_ARGS__)
@@ -4,6 +4,7 @@
 #include "cfmt.h"

 #include <algorithm>
+#include <string_view>

 #ifdef _WIN32
 #include <Windows.h>
@@ -23,34 +24,81 @@ void fmt_class_string<std::pair<const fmt_type_info*, u64>>::format(std::string&
 	}
 }

+template <>
+void fmt_class_string<fmt::base57>::format(std::string& out, u64 arg)
+{
+	const auto& _arg = get_object(arg);
+
+	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;
+			}
+		}
+	}
+}
+
 void fmt_class_string<const void*>::format(std::string& out, u64 arg)
 {
-	if (arg)
-	{
-		fmt::append(out, "%p", reinterpret_cast<const void*>(static_cast<std::uintptr_t>(arg)));
-	}
-	else
-	{
-		out += "(NULL)";		
-	}
+	fmt::append(out, "%p", arg);
 }

 void fmt_class_string<const char*>::format(std::string& out, u64 arg)
 {
 	if (arg)
 	{
-		out += reinterpret_cast<const char*>(static_cast<std::uintptr_t>(arg));
+		out += reinterpret_cast<const char*>(arg);
 	}
 	else
 	{
-		out += "(NULL)";
+		out += "(NULLSTR)";
 	}
 }

 template <>
 void fmt_class_string<std::string>::format(std::string& out, u64 arg)
 {
-	out += get_object(arg).c_str(); // TODO?
+	out += get_object(arg);
+}
+
+template <>
+void fmt_class_string<std::string_view>::format(std::string& out, u64 arg)
+{
+	out += get_object(arg);
 }

 template <>
@@ -375,6 +423,14 @@ std::string fmt::to_upper(const std::string& string)
 	return result;
 }

+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;
@@ -91,9 +91,9 @@ struct fmt_unveil<T, std::enable_if_t<std::is_enum<T>::value>>
 template <typename T>
 struct fmt_unveil<T*, void>
 {
-	using type = const T*;
+	using type = std::add_const_t<T>*;

-	static inline u64 get(const T* arg)
+	static inline u64 get(type arg)
 	{
 		return reinterpret_cast<std::uintptr_t>(arg);
 	}
@@ -102,9 +102,9 @@ struct fmt_unveil<T*, void>
 template <typename T, std::size_t N>
 struct fmt_unveil<T[N], void>
 {
-	using type = const T*;
+	using type = std::add_const_t<T>*;

-	static inline u64 get(const T* arg)
+	static inline u64 get(type arg)
 	{
 		return reinterpret_cast<std::uintptr_t>(arg);
 	}
@@ -250,15 +250,38 @@ 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)
+		{
+		}
+	};
+
 	template <typename... Args>
 	SAFE_BUFFERS FORCE_INLINE const fmt_type_info* get_type_info()
 	{
 		// Constantly initialized null-terminated list of type-specific information
-		static constexpr fmt_type_info result[sizeof...(Args) + 1]{fmt_type_info::make<Args>()...};
+		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;

@@ -266,7 +289,8 @@ namespace fmt
 	template <typename... Args>
 	SAFE_BUFFERS FORCE_INLINE void append(std::string& out, const char* fmt, const Args&... args)
 	{
-		raw_append(out, fmt, fmt::get_type_info<fmt_unveil_t<Args>...>(), fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+		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
@@ -286,6 +310,7 @@ namespace fmt
 	template <typename T = std::runtime_error, typename... Args>
 	[[noreturn]] SAFE_BUFFERS FORCE_INLINE void throw_exception(const char* fmt, const Args&... args)
 	{
-		raw_throw_exception<T>(fmt, fmt::get_type_info<fmt_unveil_t<Args>...>(), fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+		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,6 +5,7 @@
 #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>
@@ -100,10 +101,10 @@ namespace fmt
 		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>
@@ -134,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);
 }
@@ -1,5 +1,5 @@
 #include "stdafx.h"
-#include "Emu/Memory/Memory.h"
+#include "Emu/Memory/vm.h"
 #include "Emu/System.h"
 #include "Emu/IdManager.h"
 #include "Emu/Cell/RawSPUThread.h"
@@ -14,6 +14,7 @@
 #include <Windows.h>
 #include <Psapi.h>
 #include <process.h>
+#include <sysinfoapi.h>
 #else
 #ifdef __APPLE__
 #define _XOPEN_SOURCE
@@ -21,7 +22,7 @@
 #include <mach/thread_act.h>
 #include <mach/thread_policy.h>
 #endif
-#if defined(__DragonFly__) || defined(__FreeBSD__)
+#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 #include <pthread_np.h>
 #define cpu_set_t cpuset_t
 #endif
@@ -31,13 +32,16 @@
 #include <pthread.h>
 #include <sys/time.h>
 #include <sys/resource.h>
+#include <time.h>
 #endif

 #include "sync.h"
+#include "Log.h"

 thread_local u64 g_tls_fault_all = 0;
 thread_local u64 g_tls_fault_rsx = 0;
 thread_local u64 g_tls_fault_spu = 0;
+extern thread_local std::string(*g_tls_log_prefix)();

 [[noreturn]] void catch_all_exceptions()
 {
@@ -47,11 +51,11 @@ thread_local u64 g_tls_fault_spu = 0;
 	}
 	catch (const std::exception& e)
 	{
-		report_fatal_error("Unhandled exception of type '"s + typeid(e).name() + "': "s + e.what());
+		report_fatal_error("{" + g_tls_log_prefix() + "} Unhandled exception of type '"s + typeid(e).name() + "': "s + e.what());
 	}
 	catch (...)
 	{
-		report_fatal_error("Unhandled exception (unknown)");
+		report_fatal_error("{" + g_tls_log_prefix() + "} Unhandled exception (unknown)");
 	}
 }

@@ -90,7 +94,7 @@ enum x64_reg_t : u32
 	X64R_XMM13,
 	X64R_XMM14,
 	X64R_XMM15,
-	
+
 	X64R_AL,
 	X64R_CL,
 	X64R_DL,
@@ -99,7 +103,7 @@ enum x64_reg_t : u32
 	X64R_CH,
 	X64R_DH,
 	X64R_BH,
-	
+
 	X64_NOT_SET,
 	X64_IMM8,
 	X64_IMM16,
@@ -176,7 +180,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
 			{
 				LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): LOCK prefix found twice", (size_t)code - out_length);
 			}
-			
+
 			lock = true;
 			continue;
 		}
@@ -186,7 +190,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
 			{
 				LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): REPNE/REPNZ prefix found twice", (size_t)code - out_length);
 			}
-			
+
 			repne = true;
 			continue;
 		}
@@ -196,7 +200,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
 			{
 				LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): REP/REPE/REPZ prefix found twice", (size_t)code - out_length);
 			}
-			
+
 			repe = true;
 			continue;
 		}
@@ -225,7 +229,7 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
 			{
 				LOG_ERROR(MEMORY, "decode_x64_reg_op(%016llxh): operand-size override prefix found twice", (size_t)code - out_length);
 			}
-			
+
 			oso = true;
 			continue;
 		}
@@ -837,7 +841,7 @@ static const decltype(_REG_RAX) reg_table[] =

 #else

-static const decltype(REG_RAX) reg_table[] =
+static const int reg_table[] =
 {
 	REG_RAX, REG_RCX, REG_RDX, REG_RBX, REG_RSP, REG_RBP, REG_RSI, REG_RDI,
 	REG_R8, REG_R9, REG_R10, REG_R11, REG_R12, REG_R13, REG_R14, REG_R15, REG_RIP
@@ -917,7 +921,7 @@ bool get_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, size_
 	else if (reg == X64_IMM32)
 	{
 		const s32 imm_value = *(s32*)(RIP(context) + i_size - 4);
-		
+
 		switch (d_size)
 		{
 		case 4: out_value = (u32)imm_value; return true;
@@ -1088,16 +1092,42 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)

 	const auto cpu = get_current_cpu_thread();

-	if (rsx::g_access_violation_handler && rsx::g_access_violation_handler(addr, is_writing))
+	if (rsx::g_access_violation_handler)
 	{
-		g_tls_fault_rsx++;
+		bool handled = false;

-		if (cpu)
+		try
 		{
-			cpu->test_state();
+			handled = rsx::g_access_violation_handler(addr, is_writing);
+		}
+		catch (const std::exception& e)
+		{
+			LOG_FATAL(RSX, "g_access_violation_handler(0x%x, %d): %s", addr, is_writing, e.what());
+
+			if (cpu)
+			{
+				vm::temporary_unlock(*cpu);
+				cpu->state += cpu_flag::dbg_pause;
+
+				if (cpu->test_stopped())
+				{
+					std::terminate();
+				}
+			}
+
+			return false;
 		}

-		return true;
+		if (handled)
+		{
+			g_tls_fault_rsx++;
+			if (cpu && cpu->test_stopped())
+			{
+				//
+			}
+
+			return true;
+		}
 	}

 	auto code = (const u8*)RIP(context);
@@ -1138,7 +1168,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 	// check if address is RawSPU MMIO register
 	if (addr - RAW_SPU_BASE_ADDR < (6 * RAW_SPU_OFFSET) && (addr % RAW_SPU_OFFSET) >= RAW_SPU_PROB_OFFSET)
 	{
-		auto thread = idm::get<RawSPUThread>((addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET);
+		auto thread = idm::get<named_thread<spu_thread>>(spu_thread::find_raw_spu((addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET));

 		if (!thread)
 		{
@@ -1233,9 +1263,9 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)

 	if (vm::check_addr(addr, std::max<std::size_t>(1, d_size), vm::page_allocated | (is_writing ? vm::page_writable : vm::page_readable)))
 	{
-		if (cpu)
+		if (cpu && cpu->test_stopped())
 		{
-			cpu->test_state();
+			//
 		}

 		return true;
@@ -1243,7 +1273,8 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)

 	if (cpu)
 	{
-		if (fxm::check<page_fault_notification_entries>())
+		// TODO: Only PPU thread page fault notifications are supported
+		if (cpu->id_type() == 1 && fxm::check<page_fault_notification_entries>())
 		{
 			for (const auto& entry : fxm::get<page_fault_notification_entries>()->entries)
 			{
@@ -1254,27 +1285,27 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 				}
 				if (entry.start_addr <= addr && addr <= addr + mem->size - 1)
 				{
-					// Place the page fault event onto table so that other functions [sys_mmapper_free_address and ppu pagefault funcs] 
+					// Place the page fault event onto table so that other functions [sys_mmapper_free_address and ppu pagefault funcs]
 					// know that this thread is page faulted and where.

 					auto pf_entries = fxm::get_always<page_fault_event_entries>();
 					{
-						semaphore_lock pf_lock(pf_entries->pf_mutex);
+						std::lock_guard pf_lock(pf_entries->pf_mutex);
 						page_fault_event pf_event{ cpu->id, addr };
 						pf_entries->events.emplace_back(pf_event);
 					}

 					// Now, we notify the game that a page fault occurred so it can rectify it.
 					// Note, for data3, were the memory readable AND we got a page fault, it must be due to a write violation since reads are allowed.
-					be_t<u64> data1 = addr;
-					be_t<u64> data2 = (SYS_MEMORY_PAGE_FAULT_TYPE_PPU_THREAD << 32) + cpu->id; // TODO: fix hack for now that assumes PPU thread always.
-					be_t<u64> data3 = vm::check_addr(addr, a_size, vm::page_readable) ? SYS_MEMORY_PAGE_FAULT_CAUSE_READ_ONLY : SYS_MEMORY_PAGE_FAULT_CAUSE_NON_MAPPED;
+					u64 data1 = addr;
+					u64 data2 = ((u64)SYS_MEMORY_PAGE_FAULT_TYPE_PPU_THREAD << 32) + cpu->id;
+					u64 data3 = vm::check_addr(addr, a_size, vm::page_readable) ? SYS_MEMORY_PAGE_FAULT_CAUSE_READ_ONLY : SYS_MEMORY_PAGE_FAULT_CAUSE_NON_MAPPED;

 					LOG_ERROR(MEMORY, "Page_fault %s location 0x%x because of %s memory", is_writing ? "writing" : "reading",
 						addr, data3 == SYS_MEMORY_PAGE_FAULT_CAUSE_READ_ONLY ? "writing read-only" : "using unmapped");

 					error_code sending_error = sys_event_port_send(entry.port_id, data1, data2, data3);
-					
+
 					// If we fail due to being busy, wait a bit and try again.
 					while (sending_error == CELL_EBUSY)
 					{
@@ -1282,7 +1313,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 						thread_ctrl::wait_for(1000);
 						sending_error = sys_event_port_send(entry.port_id, data1, data2, data3);
 					}
-					
+
 					if (sending_error)
 					{
 						fmt::throw_exception("Unknown error %x while trying to pass page fault.", sending_error.value);
@@ -1295,9 +1326,20 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 			}
 		}

-		LOG_FATAL(MEMORY, "Access violation %s location 0x%x", is_writing ? "writing" : "reading", addr);
-		cpu->state += cpu_flag::dbg_pause;
-		cpu->check_state();
+		vm::temporary_unlock(*cpu);
+	}
+
+	LOG_FATAL(MEMORY, "Access violation %s location 0x%x", is_writing ? "writing" : "reading", addr);
+	Emu.Pause();
+
+	while (Emu.IsPaused())
+	{
+		thread_ctrl::wait();
+	}
+
+	if (Emu.IsStopped())
+	{
+		std::terminate();
 	}

 	return true;
@@ -1382,7 +1424,6 @@ static LONG exception_handler(PEXCEPTION_POINTERS pExp)
 			return EXCEPTION_CONTINUE_EXECUTION;
 		}
 	}
-
 	return EXCEPTION_CONTINUE_SEARCH;
 }

@@ -1547,66 +1588,26 @@ extern atomic_t<u32> g_thread_count(0);

 thread_local DECLARE(thread_ctrl::g_tls_this_thread) = nullptr;

-extern thread_local std::string(*g_tls_log_prefix)();
-
 DECLARE(thread_ctrl::g_native_core_layout) { native_core_arrangement::undefined };

-void thread_ctrl::start(const std::shared_ptr<thread_ctrl>& ctrl, task_stack task)
+void thread_base::start(native_entry entry)
 {
 #ifdef _WIN32
-	using thread_result = uint;
-	using thread_type = thread_result(__stdcall*)(void* arg);
+	m_thread = ::_beginthreadex(nullptr, 0, entry, this, CREATE_SUSPENDED, nullptr);
+	verify("thread_ctrl::start" HERE), m_thread, ::ResumeThread(reinterpret_cast<HANDLE>(+m_thread)) != -1;
 #else
-	using thread_result = void*;
-	using thread_type = thread_result(*)(void* arg);
+	verify("thread_ctrl::start" HERE), pthread_create(reinterpret_cast<pthread_t*>(&m_thread.raw()), nullptr, entry, this) == 0;
 #endif
-
-	// Thread entry point
-	const thread_type entry = [](void* arg) -> thread_result
-	{
-		// Recover shared_ptr from short-circuited thread_ctrl object pointer
-		const std::shared_ptr<thread_ctrl> ctrl = static_cast<thread_ctrl*>(arg)->m_self;
-
-		try
-		{
-			ctrl->initialize();
-			task_stack{std::move(ctrl->m_task)}.invoke();
-		}
-		catch (...)
-		{
-			// Capture exception
-			ctrl->finalize(std::current_exception());
-			return 0;
-		}
-
-		ctrl->finalize(nullptr);
-		return 0;
-	};
-
-	ctrl->m_self = ctrl;
-	ctrl->m_task = std::move(task);
-
-	// TODO: implement simple thread pool
-#ifdef _WIN32
-	std::uintptr_t thread = _beginthreadex(nullptr, 0, entry, ctrl.get(), 0, nullptr);
-	verify("thread_ctrl::start" HERE), thread != 0;
-#else
-	pthread_t thread;
-	verify("thread_ctrl::start" HERE), pthread_create(&thread, nullptr, entry, ctrl.get()) == 0;
-#endif
-
-	// TODO: this is unsafe and must be duplicated in thread_ctrl::initialize
-	ctrl->m_thread = (uintptr_t)thread;
 }

-void thread_ctrl::initialize()
+void thread_base::initialize()
 {
 	// Initialize TLS variable
-	g_tls_this_thread = this;
+	thread_ctrl::g_tls_this_thread = this;

 	g_tls_log_prefix = []
 	{
-		return g_tls_this_thread->m_name;
+		return thread_ctrl::g_tls_this_thread->m_name.get();
 	};

 	++g_thread_count;
@@ -1625,7 +1626,7 @@ void thread_ctrl::initialize()
 	{
 		THREADNAME_INFO info;
 		info.dwType = 0x1000;
-		info.szName = m_name.c_str();
+		info.szName = m_name.get().c_str();
 		info.dwThreadID = -1;
 		info.dwFlags = 0;

@@ -1638,13 +1639,22 @@ void thread_ctrl::initialize()
 		}
 	}
 #endif
+
+#if defined(__APPLE__)
+	pthread_setname_np(m_name.get().substr(0, 15).c_str());
+#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+	pthread_set_name_np(pthread_self(), m_name.get().c_str());
+#elif defined(__NetBSD__)
+	pthread_setname_np(pthread_self(), "%s", (void*)m_name.get().c_str());
+#elif !defined(_WIN32)
+	pthread_setname_np(pthread_self(), m_name.get().substr(0, 15).c_str());
+#endif
 }

-void thread_ctrl::finalize(std::exception_ptr eptr) noexcept
+bool thread_base::finalize(int) noexcept
 {
-	// Run atexit functions
-	m_task.invoke();
-	m_task.reset();
+	// Report pending errors
+	error_code::error_report(0, 0, 0, 0);

 #ifdef _WIN32
 	ULONG64 cycles{};
@@ -1664,7 +1674,7 @@ void thread_ctrl::finalize(std::exception_ptr eptr) noexcept

 	g_tls_log_prefix = []
 	{
-		return g_tls_this_thread->m_name;
+		return thread_ctrl::g_tls_this_thread->m_name.get();
 	};

 	LOG_NOTICE(GENERAL, "Thread time: %fs (%fGc); Faults: %u [rsx:%u, spu:%u];",
@@ -1674,47 +1684,31 @@ void thread_ctrl::finalize(std::exception_ptr eptr) noexcept
 		g_tls_fault_rsx,
 		g_tls_fault_spu);

-	--g_thread_count;
+	// Return true if need to delete thread object
+	const bool result = m_state.exchange(thread_state::finished) == thread_state::detached;

-	// Untangle circular reference, set exception
-	semaphore_lock{m_mutex}, m_self.reset(), m_exception = eptr;
-
-	// Signal joining waiters
+	// Signal waiting threads
+	m_mutex.lock_unlock();
 	m_jcv.notify_all();
+	return result;
 }

-void thread_ctrl::_push(task_stack task)
+void thread_base::finalize() noexcept
 {
-	g_tls_this_thread->m_task.push(std::move(task));
+	g_tls_log_prefix = []() -> std::string { return {}; };
+	thread_ctrl::g_tls_this_thread = nullptr;
+	--g_thread_count;
 }

 bool thread_ctrl::_wait_for(u64 usec)
 {
 	auto _this = g_tls_this_thread;

-	struct half_lock
-	{
-		semaphore<>& ref;
-
-		void lock()
-		{
-			// Used to avoid additional lock + unlock
-		}
-
-		void unlock()
-		{
-			ref.post();
-		}
-	}
-	_lock{_this->m_mutex};
-	
 	do
 	{
 		// Mutex is unlocked at the start and after the waiting
 		if (u32 sig = _this->m_signal.load())
 		{
-			thread_ctrl::test();
-
 			if (sig & 1)
 			{
 				_this->m_signal &= ~1;
@@ -1728,57 +1722,31 @@ bool thread_ctrl::_wait_for(u64 usec)
 			return false;
 		}

-		// Lock (semaphore)
-		_this->m_mutex.wait();
+		_this->m_mutex.lock();

 		// Double-check the value
 		if (u32 sig = _this->m_signal.load())
 		{
-			if (sig & 2 && _this->m_exception)
-			{
-				_this->_throw();
-			}
-
 			if (sig & 1)
 			{
 				_this->m_signal &= ~1;
-				_this->m_mutex.post();
+				_this->m_mutex.unlock();
 				return true;
 			}
 		}
 	}
-	while (_this->m_cond.wait(_lock, std::exchange(usec, usec > cond_variable::max_timeout ? -1 : 0)));
+	while (_this->m_cond.wait_unlock(std::exchange(usec, usec > cond_variable::max_timeout ? -1 : 0), _this->m_mutex));

 	// Timeout
 	return false;
 }

-[[noreturn]] void thread_ctrl::_throw()
-{
-	std::exception_ptr ex = std::exchange(m_exception, std::exception_ptr{});
-	m_signal &= ~3;
-	m_mutex.post();
-	std::rethrow_exception(std::move(ex));
-}
-
-void thread_ctrl::_notify(cond_variable thread_ctrl::* ptr)
-{
-	// Optimized lock + unlock
-	if (!m_mutex.get())
-	{
-		m_mutex.wait();
-		m_mutex.post();
-	}
-
-	(this->*ptr).notify_one();
-}
-
-thread_ctrl::thread_ctrl(std::string&& name)
-	: m_name(std::move(name))
+thread_base::thread_base(std::string_view name)
+	: m_name(name)
 {
 }

-thread_ctrl::~thread_ctrl()
+thread_base::~thread_base()
 {
 	if (m_thread)
 	{
@@ -1790,70 +1758,65 @@ thread_ctrl::~thread_ctrl()
 	}
 }

-std::exception_ptr thread_ctrl::get_exception() const
+void thread_base::join() const
 {
-	semaphore_lock lock(m_mutex);
-	return m_exception;
-}
-
-void thread_ctrl::set_exception(std::exception_ptr ptr)
-{
-	semaphore_lock lock(m_mutex);
-	m_exception = ptr;
-
-	if (m_exception)
+	if (m_state == thread_state::finished)
 	{
-		m_signal |= 2;
-		m_cond.notify_one();
+		return;
 	}
-	else
-	{
-		m_signal &= ~2;
-	}
-}

-void thread_ctrl::join()
-{
-#ifdef _WIN32
-	//verify("thread_ctrl::join" HERE), WaitForSingleObjectEx((HANDLE)m_thread.load(), -1, false) == WAIT_OBJECT_0;
-#endif
+	std::unique_lock lock(m_mutex);

-	semaphore_lock lock(m_mutex);
-
-	while (m_self)
+	while (m_state != thread_state::finished)
 	{
 		m_jcv.wait(lock);
 	}
-
-	if (UNLIKELY(m_exception && !std::uncaught_exception()))
-	{
-		std::rethrow_exception(m_exception);
-	}
 }

-void thread_ctrl::notify()
+void thread_base::notify()
 {
 	if (!(m_signal & 1))
 	{
 		m_signal |= 1;
-		_notify(&thread_ctrl::m_cond);
+		m_mutex.lock_unlock();
+		m_cond.notify_one();
 	}
 }

-void thread_ctrl::test()
+u64 thread_base::get_cycles()
 {
-	const auto _this = g_tls_this_thread;
+	u64 cycles;

-	if (_this->m_signal & 2)
+#ifdef _WIN32
+	if (QueryThreadCycleTime((HANDLE)m_thread.load(), &cycles))
 	{
-		_this->m_mutex.wait();
-
-		if (_this->m_exception)
+#elif __APPLE__
+	mach_port_name_t port = pthread_mach_thread_np((pthread_t)m_thread.load());
+	mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
+	thread_basic_info_data_t info;
+	kern_return_t ret = thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count);
+	if (ret == KERN_SUCCESS)
+	{
+		cycles = static_cast<u64>(info.user_time.seconds + info.system_time.seconds) * 1'000'000'000 +
+			static_cast<u64>(info.user_time.microseconds + info.system_time.microseconds) * 1'000;
+#else
+	clockid_t _clock;
+	struct timespec thread_time;
+	if (!pthread_getcpuclockid((pthread_t)m_thread.load(), &_clock) && !clock_gettime(_clock, &thread_time))
+	{
+		cycles = static_cast<u64>(thread_time.tv_sec) * 1'000'000'000 + thread_time.tv_nsec;
+#endif
+		if (const u64 old_cycles = m_cycles.exchange(cycles))
 		{
-			_this->_throw();
+			return cycles - old_cycles;
 		}

-		_this->m_mutex.post();
+		// Report 0 the first time this function is called
+		return 0;
+	}
+	else
+	{
+		return m_cycles;
 	}
 }

@@ -1867,9 +1830,52 @@ void thread_ctrl::detect_cpu_layout()
 	{
 		g_native_core_layout.store(native_core_arrangement::amd_ccx);
 	}
-	else if (system_id.find("i3") != std::string::npos || system_id.find("i7") != std::string::npos)
+	else if (system_id.find("Intel") != std::string::npos)
 	{
-		g_native_core_layout.store(native_core_arrangement::intel_ht);
+#ifdef _WIN32
+		const LOGICAL_PROCESSOR_RELATIONSHIP relationship = LOGICAL_PROCESSOR_RELATIONSHIP::RelationProcessorCore;
+		DWORD buffer_size = 0;
+
+		// If buffer size is set to 0 bytes, it will be overwritten with the required size
+		if (GetLogicalProcessorInformationEx(relationship, nullptr, &buffer_size))
+		{
+			LOG_ERROR(GENERAL, "GetLogicalProcessorInformationEx returned 0 bytes");
+			return;
+		}
+		DWORD error_code = GetLastError();
+		if (error_code != ERROR_INSUFFICIENT_BUFFER)
+		{
+			LOG_ERROR(GENERAL, "Unexpected windows error code when detecting CPU layout: %u", error_code);
+			return;
+		}
+
+		std::vector<u8> buffer(buffer_size);
+
+		if (!GetLogicalProcessorInformationEx(relationship,
+			reinterpret_cast<SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *>(buffer.data()), &buffer_size))
+		{
+			LOG_ERROR(GENERAL, "GetLogicalProcessorInformationEx failed (size=%u, error=%u)", buffer_size, GetLastError());
+		}
+		else
+		{
+			// Iterate through the buffer until a core with hyperthreading is found
+			auto ptr = reinterpret_cast<std::uintptr_t>(buffer.data());
+			const std::uintptr_t end = ptr + buffer_size;
+
+			while (ptr < end)
+			{
+				auto info = reinterpret_cast<SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *>(ptr);
+				if (info->Relationship == relationship && info->Processor.Flags == LTP_PC_SMT)
+				{
+					g_native_core_layout.store(native_core_arrangement::intel_ht);
+					break;
+				}
+				ptr += info->Size;
+			}
+		}
+#else
+		LOG_TODO(GENERAL, "Thread scheduler is not implemented for Intel and this OS");
+#endif
 	}
 }

@@ -1926,6 +1932,7 @@ u16 thread_ctrl::get_affinity_mask(thread_class group)
 		}
 		case native_core_arrangement::intel_ht:
 		{
+			/* This has been disabled as it seems to degrade performance instead of improving it.
 			if (thread_count <= 4)
 			{
 				//i3 or worse
@@ -1940,6 +1947,7 @@ u16 thread_ctrl::get_affinity_mask(thread_class group)
 					return all_cores_mask;
 				}
 			}
+			*/

 			return all_cores_mask;
 		}
@@ -2006,45 +2014,3 @@ void thread_ctrl::set_thread_affinity_mask(u16 mask)
 	pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cs);
 #endif
 }
-
-named_thread::named_thread()
-{
-}
-
-named_thread::~named_thread()
-{
-}
-
-std::string named_thread::get_name() const
-{
-	return fmt::format("('%s') Unnamed Thread", typeid(*this).name());
-}
-
-void named_thread::start_thread(const std::shared_ptr<void>& _this)
-{
-	// Ensure it's not called from the constructor and the correct object is passed
-	verify("named_thread::start_thread" HERE), _this.get() == this;
-
-	// Run thread
-	thread_ctrl::spawn(m_thread, get_name(), [this, _this]()
-	{
-		try
-		{
-			LOG_TRACE(GENERAL, "Thread started");
-			on_spawn();
-			on_task();
-			LOG_TRACE(GENERAL, "Thread ended");
-		}
-		catch (const std::exception& e)
-		{
-			LOG_FATAL(GENERAL, "%s thrown: %s", typeid(e).name(), e.what());
-			Emu.Pause();
-		}
-
-		on_exit();
-	});
-}
-
-task_stack::task_base::~task_base()
-{
-}
@@ -3,12 +3,13 @@
 #include "types.h"
 #include "Atomic.h"

-#include <exception>
 #include <string>
 #include <memory>
+#include <string_view>

-#include "sema.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&);
@@ -33,92 +34,82 @@ enum class thread_class : u32
 	ppu
 };

-// Simple list of void() functors
-class task_stack
+enum class thread_state
 {
-	struct task_base
-	{
-		std::unique_ptr<task_base> next;
-
-		virtual ~task_base();
-
-		virtual void invoke()
-		{
-			if (next)
-			{
-				next->invoke();
-			}
-		}
-	};
-
-	template <typename F>
-	struct task_type final : task_base
-	{
-		std::remove_reference_t<F> func;
-
-		task_type(F&& func)
-			: func(std::forward<F>(func))
-		{
-		}
-
-		void invoke() final override
-		{
-			func();
-			task_base::invoke();
-		}
-	};
-
-	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)))
+	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 invoke() const
-	{
-		if (m_stack)
-		{
-			m_stack->invoke();
-		}
+		get()->~T();
 	}
 };

-// Thread control class
-class thread_ctrl final
+template <>
+struct result_storage<void>
 {
-	// Current thread
-	static thread_local thread_ctrl* g_tls_this_thread;
+	static constexpr bool empty = true;

-	// Target cpu core layout
-	static atomic_t<native_core_arrangement> g_native_core_layout;
+	using type = void;
+};

-	// Self pointer
-	std::shared_ptr<thread_ctrl> m_self;
+template <class Context, typename... Args>
+using result_storage_t = result_storage<std::invoke_result_t<Context, Args...>>;
+
+// Detect on_abort() method (should return void)
+template <typename T, typename = void>
+struct thread_on_abort : std::bool_constant<false> {};
+
+template <typename T>
+struct thread_on_abort<T, decltype(std::declval<named_thread<T>&>().on_abort())> : std::bool_constant<true> {};
+
+// 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 semaphore<> m_mutex;
+	mutable shared_mutex m_mutex;

 	// Thread condition variable
 	cond_variable m_cond;
@@ -127,77 +118,123 @@ class thread_ctrl final
 	atomic_t<u32> m_signal{0};

 	// Thread joining condition variable
-	cond_variable m_jcv;
+	mutable cond_variable m_jcv;

-	// Remotely set or caught exception
-	std::exception_ptr m_exception;
+	// Thread state
+	atomic_t<thread_state> m_state = thread_state::created;

-	// Thread initial task or atexit task
-	task_stack m_task;
+	// Thread name
+	lf_value<std::string> m_name;

-	// Fixed name
-	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(std::exception_ptr) noexcept;
+	// Called at the thread end, returns true if needs destruction
+	bool finalize(int) noexcept;

-	// Add task (atexit)
-	static void _push(task_stack);
+	// Cleanup after possibly deleting the thread instance
+	static void finalize() noexcept;
+
+	friend class thread_ctrl;
+
+	template <class Context>
+	friend class named_thread;
+
+protected:
+	thread_base(std::string_view name);
+
+	~thread_base();
+
+public:
+	// Get CPU cycles since last time this function was called. First call returns 0.
+	u64 get_cycles();
+
+	// Wait for the thread (it does NOT change thread state, and can be called from multiple threads)
+	void join() const;
+
+	// 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);

-	// Internal throwing function. Mutex must be locked and will be unlocked.
-	[[noreturn]] void _throw();
-
-	// Internal notification function
-	void _notify(cond_variable thread_ctrl::*);
+	friend class thread_base;

 public:
-	thread_ctrl(std::string&& name);
-
-	thread_ctrl(const thread_ctrl&) = delete;
-
-	~thread_ctrl();
-
-	// Get thread name
-	const std::string& get_name() const
+	// Get current thread name
+	static std::string_view get_name()
 	{
-		return m_name;
+		return g_tls_this_thread->m_name.get();
 	}

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

-	// Set exception
-	void set_exception(std::exception_ptr ptr);
+	// Set current thread name (not recommended)
+	static void set_name(std::string_view name)
+	{
+		g_tls_this_thread->m_name.assign(name);
+	}

-	// Get thread result (may throw, simultaneous joining allowed)
-	void join();
+	// Set thread name (not recommended)
+	template <typename T>
+	static void set_name(named_thread<T>& thread, std::string_view name)
+	{
+		static_cast<thread_base&>(thread).m_name.assign(name);
+	}

-	// Notify the thread
-	void notify();
+	template <typename T>
+	static u64 get_cycles(named_thread<T>& thread)
+	{
+		return static_cast<thread_base&>(thread).get_cycles();
+	}

-	// Wait once with timeout. Abortable, may throw. May spuriously return false.
+	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. Abortable, may throw.
+	// Wait.
 	static inline void wait()
 	{
 		_wait_for(-1);
 	}

-	// Wait until pred(). Abortable, may throw.
-	template<typename F, typename RT = std::result_of_t<F()>>
+	// Wait until pred().
+	template <typename F, typename RT = std::invoke_result_t<F>>
 	static inline RT wait(F&& pred)
 	{
 		while (true)
@@ -211,49 +248,12 @@ public:
 		}
 	}

-	// Wait eternally until aborted.
-	[[noreturn]] static inline void eternalize()
-	{
-		while (true)
-		{
-			_wait_for(-1);
-		}
-	}
-
-	// Test exception (may throw).
-	static void test();
-
 	// 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)
-	{
-		_push(std::forward<F>(func));
-	}
-
-	// Create detached named thread
-	template<typename N, typename F>
-	static inline void spawn(N&& name, F&& func)
-	{
-		auto out = std::make_shared<thread_ctrl>(std::forward<N>(name));
-
-		thread_ctrl::start(out, std::forward<F>(func));
-	}
-
-	// Named thread factory
-	template<typename N, typename F>
-	static inline void spawn(std::shared_ptr<thread_ctrl>& out, N&& name, F&& func)
-	{
-		out = std::make_shared<thread_ctrl>(std::forward<N>(name));
-
-		thread_ctrl::start(out, std::forward<F>(func));
-	}
-
 	// Detect layout
 	static void detect_cpu_layout();

@@ -265,91 +265,166 @@ public:

 	// 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)
+	{
+		new named_thread<F>(thread_state::detached, name, std::forward<F>(func));
+	}
 };

-class 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 in such case)
-	void start_thread(const std::shared_ptr<void>& _this);
-
-	// Thread task (called in the thread)
-	virtual void on_task() = 0;
-
-	// Thread finalization (called after on_task)
-	virtual void on_exit() {}
-
-	// Called once upon thread spawn within the thread's own context
-	virtual void on_spawn() {}
-
-public:
-	// ID initialization
-	virtual void on_init(const std::shared_ptr<void>& _this)
+	// Wait for the completion and access result (if not void)
+	[[nodiscard]] decltype(auto) operator()()
 	{
-		return start_thread(_this);
+		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* get() const
+	// Access thread state
+	operator thread_state() const
 	{
-		return m_thread.get();
+		return thread::m_state.load();
 	}

-	void join() const
+	// Try to abort/detach
+	named_thread& operator=(thread_state s)
 	{
-		return m_thread->join();
+		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;
 	}

-	void notify() const
+	// Context type doesn't need virtual destructor
+	~named_thread()
 	{
-		return m_thread->notify();
-	}
-};
-
-// 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)
-	{
-		thread_ctrl::spawn(m_thread, 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();
-	}
-
-	// Access thread_ctrl
-	thread_ctrl* get() const
-	{
-		return m_thread.get();
+		*this = thread_state::aborting;
+		thread::join();
+
+		if constexpr (!result::empty)
+		{
+			result::destroy();
+		}
 	}
 };
@@ -49,4 +49,11 @@ public:

 		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,10 +7,27 @@
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include <errno.h>
 #include <unistd.h>
 #include <sys/types.h>
 #endif

+#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)
+{
+    return syscall(__NR_memfd_create, name, flags);
+}
+#endif
+
 namespace utils
 {
 	// Convert memory protection (internal)
@@ -63,7 +80,7 @@ namespace utils
 #ifdef _WIN32
 		verify(HERE), ::VirtualAlloc(pointer, size, MEM_COMMIT, +prot);
 #else
-		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), ::align(size, 4096), +prot) != -1;
+		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), size + ((u64)pointer & 4095), +prot) != -1;
 #endif
 	}

@@ -76,13 +93,186 @@ namespace utils
 #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
-		DWORD old;
-		verify(HERE), ::VirtualProtect(pointer, size, +prot, &old);
+		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), ::align(size, 4096), +prot) != -1;
+		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
 	}
 }
@@ -25,11 +25,52 @@ namespace utils
 	*/
 	void memory_commit(void* pointer, std::size_t size, protection prot = protection::rw);

-	/**
-	* Decommit all memory committed via commit_page_memory.
-	*/
+	// 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
@@ -1,5 +1,5 @@
 #include "bin_patch.h"
-#include "yaml-cpp/yaml.h"
+#include <yaml-cpp/yaml.h>
 #include "File.h"
 #include "Config.h"

@@ -1,6 +1,7 @@
 #pragma once

 #include "types.h"
+#include "asm.h"
 #include <climits>
 #include <string>
 #include <vector>
@@ -56,7 +57,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)

 	const auto write_octal = [&](u64 value, u64 min_num)
 	{
-		out.resize(out.size() + std::max<u64>(min_num, 66 / 3 - (cntlz64(value | 1, true) + 2) / 3), '0');
+		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)
@@ -67,8 +68,8 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)

 	const auto write_hex = [&](u64 value, bool upper, u64 min_num)
 	{
-		out.resize(out.size() + std::max<u64>(min_num, 64 / 4 - cntlz64(value | 1, true) / 4), '0');
-		
+		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)
 		{
@@ -141,7 +142,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
 		{
 			ctx.width = read_decimal(ch - '0');
 		}
-		
+
 		break;
 	}

@@ -157,7 +158,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
 			ctx.width = std::abs(warg);
 			ctx.left |= warg < 0;
 		}
-		
+
 		break;
 	}

@@ -307,7 +308,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)

 		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
@@ -576,7 +577,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
 			// Add padding if necessary
 			out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
 		}
-		
+
 		src.skip(ctx.args);
 		ctx = {0};
 		break;
@@ -1,5 +1,6 @@
 #include "cond.h"
 #include "sync.h"
+#include "lockless.h"

 #include <limits.h>

@@ -9,100 +10,286 @@

 bool cond_variable::imp_wait(u32 _old, u64 _timeout) noexcept
 {
-	verify(HERE), _old != -1; // Very unlikely: it requires 2^32 distinct threads to wait simultaneously
-	const bool is_inf = _timeout > max_timeout;
+	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
-	LARGE_INTEGER timeout;
-	timeout.QuadPart = _timeout * -10;
-
-	if (HRESULT rc = NtWaitForKeyedEvent(nullptr, &m_value, false, is_inf ? nullptr : &timeout))
+	if (_old >= 0x10000 && !OptWaitOnAddress && m_value)
 	{
-		verify(HERE), rc == WAIT_TIMEOUT;
-
-		// Retire
-		if (!m_value.fetch_op([](u32& value) { if (value) value--; }))
-		{
-			NtWaitForKeyedEvent(nullptr, &m_value, false, nullptr);
-			return true;
-		}
-
-		return false;
-	}
-
-	return true;
-#else
-	timespec timeout;
-	timeout.tv_sec  = _timeout / 1000000;
-	timeout.tv_nsec = (_timeout % 1000000) * 1000;
-
-	for (u32 value = _old + 1;; value = m_value)
-	{
-		const int err = futex((int*)&m_value.raw(), FUTEX_WAIT_PRIVATE, value, is_inf ? nullptr : &timeout, nullptr, 0) == 0
-			? 0
-			: errno;
-
-		// Normal or timeout wakeup
-		if (!err || (!is_inf && err == ETIMEDOUT))
-		{
-			// Cleanup (remove waiter)
-			verify(HERE), m_value--;
-			return !err;
-		}
-
-		// Not a wakeup
-		verify(HERE), err == EAGAIN;
+		// Workaround possibly stolen signal
+		imp_wake(1);
 	}
 #endif
 }

 void cond_variable::imp_wake(u32 _count) noexcept
 {
-#ifdef _WIN32
-	// Try to subtract required amount of waiters
-	const u32 count = m_value.atomic_op([=](u32& value)
+	// TODO (notify_one)
+	balanced_awaken<true>(m_value, m_value.atomic_op([&](u32& value) -> u32
 	{
-		if (value > _count)
+		// 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 _count;
+			value += count;
+			return true;
 		}

-		return std::exchange(value, 0);
+		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;
 	});

-	for (u32 i = count; i > 0; i--)
+	verify(HERE), old <= c_sig;
+
+	if (LIKELY(!ok || old == c_lock))
 	{
-		NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
+		return;
 	}
-#else
-	for (u32 i = _count; i > 0; std::this_thread::yield())
-	{
-		const u32 value = m_value;

-		// Constrain remaining amount with imaginary waiter count
-		if (i > value)
-		{
-			i = value;
-		}
-
-		if (!value || i == 0)
-		{
-			// Nothing to do
-			return;
-		}
-
-		if (const int res = futex((int*)&m_value.raw(), FUTEX_WAKE_PRIVATE, i > INT_MAX ? INT_MAX : i, nullptr, nullptr, 0))
-		{
-			verify(HERE), res >= 0 && (u32)res <= i;
-			i -= res;
-		}
-
-		if (!m_value || i == 0)
-		{
-			// Escape
-			return;
-		}
-	}
-#endif
+	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);
 }
@@ -2,6 +2,8 @@

 #include "types.h"
 #include "Atomic.h"
+#include <shared_mutex>
+#include "asm.h"

 // Lightweight condition variable
 class cond_variable
@@ -9,6 +11,8 @@ 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;
@@ -21,7 +25,7 @@ public:

 	// Intrusive wait algorithm for lockable objects
 	template <typename T>
-	explicit_bool_t wait(T& object, u64 usec_timeout = -1)
+	bool wait(T& object, u64 usec_timeout = -1)
 	{
 		const u32 _old = m_value.fetch_add(1); // Increment waiter counter
 		object.unlock();
@@ -30,6 +34,15 @@ public:
 		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
 	{
@@ -44,9 +57,209 @@ public:
 	{
 		if (m_value)
 		{
-			imp_wake(-1);
+			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;
+	}
+}
@@ -63,18 +63,30 @@ namespace utils
 		{
 		}

-		// Caller
-		R operator()(Args... args)
+		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, ...) static utils::dynamic_import<__VA_ARGS__> name(lib, #name);
+#define DYNAMIC_IMPORT(lib, name, ...) inline utils::dynamic_import<__VA_ARGS__> name(lib, #name);
@@ -71,7 +71,7 @@ public:
 	}

 	// Conditionally set state (optimized)
-	explicit_bool_t state_test_and_set(T expected, T state)
+	bool state_test_and_set(T expected, T state)
 	{
 		if (m_value == expected && m_value.compare_and_swap_test(expected, state))
 		{
@@ -83,7 +83,7 @@ public:
 	}

 	// Conditionally set state (list version)
-	explicit_bool_t state_test_and_set(std::initializer_list<T> expected, T state)
+	bool state_test_and_set(std::initializer_list<T> expected, T state)
 	{
 		T _old;

@@ -111,9 +111,10 @@ public:
 	// Unconditionally set next state
 	void state_next()
 	{
-		T _old, state = m_value.op_fetch([&](T& value)
+		T _old, state = m_value.atomic_op([&](T& value)
 		{
 			_old = value++;
+			return value;
 		});

 		(static_cast<CRT*>(this)->*transition_get(state))(_old);
@@ -122,9 +123,10 @@ public:
 	// Unconditionally set previous state
 	void state_prev()
 	{
-		T _old, state = m_value.op_fetch([&](T& value)
+		T _old, state = m_value.atomic_op([&](T& value)
 		{
 			_old = value--;
+			return value;
 		});

 		(static_cast<CRT*>(this)->*transition_get(state))(_old);
@@ -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>;
@@ -69,14 +69,14 @@ if defined APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH (
 		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 HEAD') do set GIT_VERSION=%%I
-	
+	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 HEAD') do set GIT_VERSION=%COMMIT_COUNT%-%%I
-	
+	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
 )

@@ -9,19 +9,43 @@ namespace rpcs3
 		return static_cast<size_t>(value);
 	}

-	template<typename T>
-	static size_t hash_struct(const T& value)
+	template<typename T, typename U>
+	static size_t hash_struct_base(const T& value)
 	{
 		// FNV 64-bit
 		size_t result = 14695981039346656037ull;
-		const unsigned char *bytes = reinterpret_cast<const unsigned char*>(&value);
+		const U *bits = reinterpret_cast<const U*>(&value);

-		for (size_t n = 0; n < sizeof(T); ++n)
+		for (size_t n = 0; n < (sizeof(T) / sizeof(U)); ++n)
 		{
-			result ^= bytes[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);
+	}
 }
@@ -5,10 +5,10 @@

 //! Simple sizeless array base for concurrent access. Cannot shrink, only growths automatically.
 //! There is no way to know the current size. The smaller index is, the faster it's accessed.
-//! 
+//!
 //! T is the type of elements. Currently, default constructor of T shall be constexpr.
 //! N is initial element count, available without any memory allocation and only stored contiguously.
-template<typename T, std::size_t N>
+template <typename T, std::size_t N>
 class lf_array
 {
 	// Data (default-initialized)
@@ -70,7 +70,7 @@ public:
 	{
 		return reinterpret_cast<const atomic_t<u32>&>(m_ctrl).load(); // Hack
 	}
-	
+
 	// Acquire the place for one or more elements.
 	u32 push_begin(u32 count = 1)
 	{
@@ -130,7 +130,7 @@ public:
 		{
 			return m_default_key_data;
 		}
-		
+
 		// Calculate hash and array position
 		for (std::size_t pos = Hash{}(key) % Size;; pos += Size)
 		{
@@ -146,185 +146,347 @@ public:
 	}
 };

-// Fixed-size single-producer single-consumer queue
-template <typename T, std::uint32_t N>
-class lf_spsc
+// Helper type, linked list element
+template <typename T>
+class lf_queue_item final
 {
-	// If N is a power of 2, m_push/m_pop can safely overflow and the algorithm is simplified
-	static_assert(N && (1u << 31) % N == 0, "lf_spsc<> error: size must be power of 2");
+	lf_queue_item* m_link = nullptr;

-protected:
-	volatile std::uint32_t m_push{0};
-	volatile std::uint32_t m_pop{0};
-	T m_data[N]{};
+	T m_data;

-public:
-	constexpr lf_spsc() = default;
+	template <typename U>
+	friend class lf_queue_iterator;

-	// Try to push (producer only)
-	template <typename T2>
-	bool try_push(T2&& data)
+	template <typename U>
+	friend class lf_queue_slice;
+
+	template <typename U>
+	friend class lf_queue;
+
+	constexpr lf_queue_item() = default;
+
+	template <typename... Args>
+	constexpr lf_queue_item(lf_queue_item* link, Args&&... args)
+	    : m_link(link)
+	    , m_data(std::forward<Args>(args)...)
 	{
-		const std::uint32_t pos = m_push;
-
-		if (pos - m_pop >= N)
-		{
-			return false;
-		}
-
-		_mm_lfence();
-		m_data[pos % N] = std::forward<T2>(data);
-		_mm_sfence();
-		m_push = pos + 1;
-		return true;
-	}
-
-	// Try to get push pointer (producer only)
-	operator T*()
-	{
-		const std::uint32_t pos = m_push;
-
-		if (pos - m_pop >= N)
-		{
-			return nullptr;
-		}
-
-		_mm_lfence();
-		return m_data + (pos % N);
-	}
-
-	// Increment push counter (producer only)
-	void end_push()
-	{
-		const std::uint32_t pos = m_push;
-
-		if (pos - m_pop < N)
-		{
-			_mm_sfence();
-			m_push = pos + 1;
-		}
-	}
-
-	// Unsafe access
-	T& get_push(std::size_t i)
-	{
-		_mm_lfence();
-		return m_data[(m_push + i) % N];
-	}
-
-	// Try to pop (consumer only)
-	template <typename T2>
-	bool try_pop(T2& out)
-	{
-		const std::uint32_t pos = m_pop;
-
-		if (m_push - pos <= 0)
-		{
-			return false;
-		}
-
-		_mm_lfence();
-		out = std::move(m_data[pos % N]);
-		_mm_sfence();
-		m_pop = pos + 1;
-		return true;
-	}
-
-	// Increment pop counter (consumer only)
-	void end_pop()
-	{
-		const std::uint32_t pos = m_pop;
-
-		if (m_push - pos > 0)
-		{
-			_mm_sfence();
-			m_pop = pos + 1;
-		}
-	}
-
-	// Get size (consumer only)
-	std::uint32_t size() const
-	{
-		return m_push - m_pop;
-	}
-
-	// Direct access (consumer only)
-	T& operator [](std::size_t i)
-	{
-		_mm_lfence();
-		return m_data[(m_pop + i) % N];
-	}
-};
-
-// Fixed-size multi-producer single-consumer queue
-template <typename T, std::uint32_t N>
-class lf_mpsc : lf_spsc<T, N>
-{
-protected:
-	using lf_spsc<T, N>::m_push;
-	using lf_spsc<T, N>::m_pop;
-	using lf_spsc<T, N>::m_data;
-
-	enum : std::uint64_t
-	{
-		c_ack = 1ull << 0,
-		c_rel = 1ull << 32,
-	};
-
-	atomic_t<std::uint64_t> m_lock{0};
-
-	void release(std::uint64_t value)
-	{
-		// Push all pending elements at once when possible
-		if (value && value % c_rel == value / c_rel)
-		{
-			_mm_sfence();
-			m_push += value % c_rel;
-			m_lock.compare_and_swap_test(value, 0);
-		}
 	}

 public:
-	constexpr lf_mpsc() = default;
+	lf_queue_item(const lf_queue_item&) = delete;

-	// Try to get push pointer
-	operator T*()
+	lf_queue_item& operator=(const lf_queue_item&) = delete;
+
+	~lf_queue_item()
 	{
-		const std::uint64_t old = m_lock.fetch_add(c_ack);
-		const std::uint32_t pos = m_push;
-
-		if (old % N >= N || pos - m_pop >= N - (old % N))
+		for (lf_queue_item* ptr = m_link; ptr;)
 		{
-			release(m_lock.sub_fetch(c_ack));
-			return nullptr;
+			delete std::exchange(ptr, std::exchange(ptr->m_link, nullptr));
 		}
-
-		return m_data + ((pos + old) % N);
 	}
-
-	// Increment push counter (producer only)
-	void end_push()
-	{
-		release(m_lock.add_fetch(c_rel));
-	}
-
-	// Try to push
-	template <typename T2>
-	bool try_push(T2&& data)
-	{
-		if (T* ptr = *this)
-		{
-			*ptr = std::forward<T2>(data);
-			end_push();
-			return true;
-		}
-
-		return false;
-	}
-
-	// Enable consumer methods
-	using lf_spsc<T, N>::try_pop;
-	using lf_spsc<T, N>::end_pop;
-	using lf_spsc<T, N>::size;
-	using lf_spsc<T, N>::operator [];
+};
+
+// Forward iterator: non-owning pointer to the list element in lf_queue_slice<>
+template <typename T>
+class lf_queue_iterator
+{
+	lf_queue_item<T>* m_ptr = nullptr;
+
+	template <typename U>
+	friend class lf_queue_slice;
+
+public:
+	constexpr lf_queue_iterator() = default;
+
+	bool operator ==(const lf_queue_iterator& rhs) const
+	{
+		return m_ptr == rhs.m_ptr;
+	}
+
+	bool operator !=(const lf_queue_iterator& rhs) const
+	{
+		return m_ptr != rhs.m_ptr;
+	}
+
+	T& operator *() const
+	{
+		return m_ptr->m_data;
+	}
+
+	T* operator ->() const
+	{
+		return &m_ptr->m_data;
+	}
+
+	lf_queue_iterator& operator ++()
+	{
+		m_ptr = m_ptr->m_link;
+		return *this;
+	}
+
+	lf_queue_iterator operator ++(int)
+	{
+		lf_queue_iterator result;
+		result.m_ptr = m_ptr;
+		m_ptr = m_ptr->m_link;
+		return result;
+	}
+};
+
+// Owning pointer to the linked list taken from the lf_queue<>
+template <typename T>
+class lf_queue_slice
+{
+	lf_queue_item<T>* m_head = nullptr;
+
+	template <typename U>
+	friend class lf_queue;
+
+public:
+	constexpr lf_queue_slice() = default;
+
+	lf_queue_slice(const lf_queue_slice&) = delete;
+
+	lf_queue_slice(lf_queue_slice&& r) noexcept
+		: m_head(r.m_head)
+	{
+		r.m_head = nullptr;
+	}
+
+	lf_queue_slice& operator =(const lf_queue_slice&) = delete;
+
+	lf_queue_slice& operator =(lf_queue_slice&& r) noexcept
+	{
+		if (this != &r)
+		{
+			delete m_head;
+			m_head = r.m_head;
+			r.m_head = nullptr;
+		}
+
+		return *this;
+	}
+
+	~lf_queue_slice()
+	{
+		delete m_head;
+	}
+
+	T& operator *() const
+	{
+		return m_head->m_data;
+	}
+
+	T* operator ->() const
+	{
+		return &m_head->m_data;
+	}
+
+	explicit operator bool() const
+	{
+		return m_head != nullptr;
+	}
+
+	T* get() const
+	{
+		return m_head ? &m_head->m_data : nullptr;
+	}
+
+	lf_queue_iterator<T> begin() const
+	{
+		lf_queue_iterator<T> result;
+		result.m_ptr = m_head;
+		return result;
+	}
+
+	lf_queue_iterator<T> end() const
+	{
+		return {};
+	}
+
+	lf_queue_slice& pop_front()
+	{
+		delete std::exchange(m_head, std::exchange(m_head->m_link, nullptr));
+		return *this;
+	}
+};
+
+class lf_queue_base
+{
+protected:
+	atomic_t<std::uintptr_t> m_head = 0;
+
+	void imp_notify();
+
+public:
+	// Wait for new elements pushed, no other thread shall call wait() or pop_all() simultaneously
+	bool wait(u64 usec_timeout = -1);
+};
+
+// Linked list-based multi-producer queue (the consumer drains the whole queue at once)
+template <typename T>
+class lf_queue : public lf_queue_base
+{
+	using lf_queue_base::m_head;
+
+	// Extract all elements and reverse element order (FILO to FIFO)
+	lf_queue_item<T>* reverse() noexcept
+	{
+		if (auto* head = m_head.load() ? reinterpret_cast<lf_queue_item<T>*>(m_head.exchange(0)) : nullptr)
+		{
+			if (auto* prev = head->m_link)
+			{
+				head->m_link = nullptr;
+
+				do
+				{
+					auto* pprev  = prev->m_link;
+					prev->m_link = head;
+					head         = std::exchange(prev, pprev);
+				}
+				while (prev);
+			}
+
+			return head;
+		}
+
+		return nullptr;
+	}
+
+public:
+	constexpr lf_queue() = default;
+
+	~lf_queue()
+	{
+		delete reinterpret_cast<T*>(m_head.load());
+	}
+
+	template <typename... Args>
+	void push(Args&&... args)
+	{
+		auto  _old = m_head.load();
+		auto* item = new lf_queue_item<T>(_old & 1 ? nullptr : reinterpret_cast<lf_queue_item<T>*>(_old), std::forward<Args>(args)...);
+
+		while (!m_head.compare_exchange(_old, reinterpret_cast<std::uint64_t>(item)))
+		{
+			item->m_link = _old & 1 ? nullptr : reinterpret_cast<lf_queue_item<T>*>(_old);
+		}
+
+		if (_old & 1)
+		{
+			lf_queue_base::imp_notify();
+		}
+	}
+
+	// Withdraw the list, supports range-for loop: for (auto&& x : y.pop_all()) ...
+	lf_queue_slice<T> pop_all()
+	{
+		lf_queue_slice<T> result;
+		result.m_head = reverse();
+		return result;
+	}
+
+	// Apply func(data) to each element, return the total length
+	template <typename F>
+	std::size_t apply(F&& func)
+	{
+		std::size_t count = 0;
+
+		for (auto slice = pop_all(); slice; slice.pop_front())
+		{
+			std::invoke(std::forward<F>(func), *slice);
+		}
+
+		return count;
+	}
+
+	// apply() overload for callable template argument
+	template <auto F>
+	std::size_t apply()
+	{
+		std::size_t count = 0;
+
+		for (auto slice = pop_all(); slice; slice.pop_front())
+		{
+			std::invoke(F, *slice);
+		}
+
+		return count;
+	}
+};
+
+// Assignable lock-free thread-safe value of any type (memory-inefficient)
+template <typename T>
+class lf_value final
+{
+	atomic_t<lf_value*> m_head;
+
+	T m_data;
+
+public:
+	template <typename... Args>
+	explicit constexpr lf_value(Args&&... args)
+	    : m_head(this)
+	    , m_data(std::forward<Args>(args)...)
+	{
+	}
+
+	~lf_value()
+	{
+		// All values are kept in the queue until the end
+		for (lf_value* ptr = m_head.load(); ptr != this;)
+		{
+			delete std::exchange(ptr, std::exchange(ptr->m_head.raw(), ptr));
+		}
+	}
+
+	// Get current head, allows to inspect old values
+	[[nodiscard]] const lf_value* head() const
+	{
+		return m_head.load();
+	}
+
+	// Inspect the initial (oldest) value
+	[[nodiscard]] const T& first() const
+	{
+		return m_data;
+	}
+
+	[[nodiscard]] const T& get() const
+	{
+		return m_head.load()->m_data;
+	}
+
+	[[nodiscard]] operator const T&() const
+	{
+		return m_head.load()->m_data;
+	}
+
+	// Construct new value in-place
+	template <typename... Args>
+	const T& assign(Args&&... args)
+	{
+		lf_value* val = new lf_value(std::forward<Args>(args)...);
+		lf_value* old = m_head.load();
+
+		do
+		{
+			val->m_head = old;
+		}
+		while (!m_head.compare_exchange(old, val));
+
+		return val->m_data;
+	}
+
+	// Copy-assign new value
+	const T& operator =(const T& value)
+	{
+		return assign(value);
+	}
+
+	// Move-assign new value
+	const T& operator =(T&& value)
+	{
+		return assign(std::move(value));
+	}
 };
@@ -2,333 +2,159 @@
 #include "sync.h"

 #include <climits>
-#include <vector>
-#include <algorithm>

-// TLS variable for tracking owned mutexes
-thread_local std::vector<shared_mutex*> g_tls_locks;
-
-void shared_mutex::imp_lock_shared(s64 _old)
+void shared_mutex::imp_lock_shared(u32 val)
 {
-	verify("shared_mutex overflow" HERE), _old <= c_max;
+	verify("shared_mutex underflow" HERE), val < c_err;

 	for (int i = 0; i < 10; i++)
 	{
 		busy_wait();

-		const s64 value = m_value.load();
-
-		if (value >= c_min && m_value.compare_and_swap_test(value, value - c_min))
+		if (try_lock_shared())
 		{
 			return;
 		}
 	}

-#ifdef _WIN32
-	// Acquire writer lock
-	imp_wait(m_value.load());
+	// Acquire writer lock and downgrade
+	const u32 old = m_value.fetch_add(c_one);

-	// Convert to reader lock
-	s64 value = m_value.fetch_add(c_one - c_min);
-
-	// Proceed exclusively
-	return;
-
-	if (value != 0)
+	if (old == 0)
 	{
-		imp_unlock(value);
-	}
-
-	// Wait as a reader if necessary
-	if (value + c_one - c_min < 0)
-	{
-		NtWaitForKeyedEvent(nullptr, (int*)&m_value + 1, false, nullptr);
-	}
-#else
-	// Acquire writer lock
-	imp_wait(0);
-
-	// Convert to reader lock
-	m_value += c_one - c_min;
-
-	// Disabled code
-	while (false)
-	{
-		const s64 value0 = m_value.fetch_op([](s64& value)
-		{
-			if (value >= c_min)
-			{
-				value -= c_min;
-			}
-		});
-
-		if (value0 >= c_min)
-		{
-			return;	
-		}
-
-		// Acquire writer lock
-		imp_wait(value0);
-
-		// Convert to reader lock
-		s64 value1 = m_value.fetch_add(c_one - c_min);
-
-		if (value1 != 0)
-		{
-			imp_unlock(value1);
-		}
-
-		value1 += c_one - c_min;
-		
-		if (value1 > 0)
-		{
-			return;
-		}
-
-		// Wait as a reader if necessary
-		while (futex((int*)&m_value.raw() + IS_LE_MACHINE, FUTEX_WAIT_BITSET_PRIVATE, int(value1 >> 32), nullptr, nullptr, INT_MIN))
-		{
-			value1 = m_value.load();
-
-			if (value1 >= 0)
-			{
-				return;
-			}
-		}
-
-		// If blocked by writers, release the reader lock and try again
-		const s64 value2 = m_value.fetch_op([](s64& value)
-		{
-			if (value < 0)
-			{
-				value += c_min;
-			}
-		});
-
-		if (value2 >= 0)
-		{
-			return;
-		}
-		
-		imp_unlock_shared(value2);
-	}
-#endif
-}
-
-void shared_mutex::imp_unlock_shared(s64 _old)
-{
-	verify("shared_mutex overflow" HERE), _old + c_min <= c_max;
-
-	// Check reader count, notify the writer if necessary
-	if ((_old + c_min) % c_one == 0)
-	{
-#ifdef _WIN32
-		NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
-#else
-		m_value -= c_sig;
-
-		futex((int*)&m_value.raw() + IS_LE_MACHINE, FUTEX_WAKE_BITSET_PRIVATE, 1, nullptr, nullptr, u32(c_sig >> 32));
-#endif
-	}
-}
-
-void shared_mutex::imp_wait(s64)
-{
-#ifdef _WIN32
-	if (m_value.sub_fetch(c_one))
-	{
-		NtWaitForKeyedEvent(nullptr, &m_value, false, nullptr);
-	}
-#else
-	if (!m_value.sub_fetch(c_one))
-	{
-		// Return immediately if locked
+		lock_downgrade();
 		return;
 	}

-	while (true)
-	{
-		// Load new value, try to acquire c_sig
-		const s64 value = m_value.fetch_op([](s64& value)
-		{
-			if (value <= c_one - c_sig)
-			{
-				value += c_sig;
-			}
-		});
-
-		if (value <= c_one - c_sig)
-		{
-			return;
-		}
-
-		futex((int*)&m_value.raw() + IS_LE_MACHINE, FUTEX_WAIT_BITSET_PRIVATE, int(value >> 32), nullptr, nullptr, u32(c_sig >> 32));
-	}
-#endif
+	verify("shared_mutex overflow" HERE), (old % c_sig) + c_one < c_sig;
+	imp_wait();
+	lock_downgrade();
 }

-void shared_mutex::imp_lock(s64 _old)
+void shared_mutex::imp_unlock_shared(u32 old)
 {
-	verify("shared_mutex overflow" HERE), _old <= c_max;
+	verify("shared_mutex underflow" HERE), old - 1 < c_err;
+
+	// Check reader count, notify the writer if necessary
+	if ((old - 1) % c_one == 0)
+	{
+		imp_signal();
+	}
+}
+
+void shared_mutex::imp_wait()
+{
+	while (!balanced_wait_until(m_value, -1, [&](u32& value, auto...)
+	{
+		if (value >= c_sig)
+		{
+			value -= c_sig;
+			return true;
+		}
+
+		return false;
+	}))
+	{
+	}
+}
+
+void shared_mutex::imp_signal()
+{
+	m_value += c_sig;
+	balanced_awaken(m_value, 1);
+}
+
+void shared_mutex::imp_lock(u32 val)
+{
+	verify("shared_mutex underflow" HERE), val < c_err;

 	for (int i = 0; i < 10; i++)
 	{
 		busy_wait();

-		const s64 value = m_value.load();
-
-		if (value == c_one && m_value.compare_and_swap_test(c_one, 0))
+		if (!m_value && try_lock())
 		{
 			return;
 		}
 	}

-	imp_wait(m_value.load());
+	const u32 old = m_value.fetch_add(c_one);
+
+	if (old == 0)
+	{
+		return;
+	}
+
+	verify("shared_mutex overflow" HERE), (old % c_sig) + c_one < c_sig;
+	imp_wait();
 }

-void shared_mutex::imp_unlock(s64 _old)
+void shared_mutex::imp_unlock(u32 old)
 {
-	verify("shared_mutex overflow" HERE), _old + c_one <= c_max;
+	verify("shared_mutex underflow" HERE), old - c_one < c_err;

 	// 1) Notify the next writer if necessary
-	// 2) Notify all readers otherwise if necessary
-#ifdef _WIN32
-	if (_old + c_one <= 0)
+	// 2) Notify all readers otherwise if necessary (currently indistinguishable from writers)
+	if (old - c_one)
 	{
-		NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
+		imp_signal();
 	}
-	else if (s64 count = -_old / c_min * 0)
-	{
-		// Disabled code
-		while (count--)
-		{
-			NtReleaseKeyedEvent(nullptr, (int*)&m_value + 1, false, nullptr);
-		}
-	}
-#else
-	if (_old + c_one <= 0)
-	{
-		m_value -= c_sig;
-
-		futex((int*)&m_value.raw() + IS_LE_MACHINE, FUTEX_WAKE_BITSET_PRIVATE, 1, nullptr, nullptr, u32(c_sig >> 32));
-	}
-	else if (false)
-	{
-		// Disabled code
-		futex((int*)&m_value.raw() + IS_LE_MACHINE, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, nullptr, INT_MIN);
-	}
-#endif
 }

 void shared_mutex::imp_lock_upgrade()
 {
-	// TODO
-	unlock_shared();
-	lock();
+	for (int i = 0; i < 10; i++)
+	{
+		busy_wait();
+
+		if (try_lock_upgrade())
+		{
+			return;
+		}
+	}
+
+	// Convert to writer lock
+	const u32 old = m_value.fetch_add(c_one - 1);
+
+	verify("shared_mutex overflow" HERE), (old % c_sig) + c_one - 1 < c_sig;
+
+	if (old % c_one == 1)
+	{
+		return;
+	}
+
+	imp_wait();
 }

-void shared_mutex::imp_lock_degrade()
+void shared_mutex::imp_lock_unlock()
 {
-	// TODO
+	u32 _max = 1;
+
+	for (int i = 0; i < 30; i++)
+	{
+		const u32 val = m_value;
+
+		if (val % c_one == 0 && (val / c_one < _max || val >= c_sig))
+		{
+			// Return if have cought a state where:
+			// 1) Mutex is free
+			// 2) Total number of waiters decreased since last check
+			// 3) Signal bit is set (if used on the platform)
+			return;
+		}
+
+		_max = val / c_one;
+
+		busy_wait(1500);
+	}
+
+	// Lock and unlock
+	if (!m_value.fetch_add(c_one))
+	{
+		unlock();
+		return;
+	}
+
+	imp_wait();
 	unlock();
-	lock_shared();
-}
-
-bool shared_mutex::try_lock_shared()
-{
-	// Conditional decrement
-	return m_value.fetch_op([](s64& value) { if (value >= c_min) value -= c_min; }) >= c_min;
-}
-
-bool shared_mutex::try_lock()
-{
-	// Conditional decrement (TODO: obtain c_sig)
-	return m_value.compare_and_swap_test(c_one, 0);
-}
-
-bool shared_mutex::try_lock_upgrade()
-{
-	// TODO
-	return m_value.compare_and_swap_test(c_one - c_min, 0);
-}
-
-bool shared_mutex::try_lock_degrade()
-{
-	// TODO
-	return m_value.compare_and_swap_test(0, c_one - c_min);
-}
-
-safe_reader_lock::safe_reader_lock(shared_mutex& mutex)
-	: m_mutex(mutex)
-	, m_is_owned(false)
-{
-	if (std::count(g_tls_locks.cbegin(), g_tls_locks.cend(), &m_mutex) == 0)
-	{
-		m_is_owned = true;
-
-		if (m_is_owned)
-		{
-			m_mutex.lock_shared();
-			g_tls_locks.emplace_back(&m_mutex);
-			return;
-		}
-
-		// TODO: order locks
-	}
-}
-
-safe_reader_lock::~safe_reader_lock()
-{
-	if (m_is_owned)
-	{
-		m_mutex.unlock_shared();
-		g_tls_locks.erase(std::remove(g_tls_locks.begin(), g_tls_locks.end(), &m_mutex), g_tls_locks.cend());
-		return;
-	}
-
-	// TODO: order locks
-}
-
-safe_writer_lock::safe_writer_lock(shared_mutex& mutex)
-	: m_mutex(mutex)
-	, m_is_owned(false)
-	, m_is_upgraded(false)
-{
-	if (std::count(g_tls_locks.cbegin(), g_tls_locks.cend(), &m_mutex) == 0)
-	{
-		m_is_owned = true;
-
-		if (m_is_owned)
-		{
-			m_mutex.lock_shared();
-			g_tls_locks.emplace_back(&m_mutex);
-			return;
-		}
-
-		// TODO: order locks
-	}
-
-	if (m_mutex.is_reading())
-	{
-		m_is_upgraded = true;
-		m_mutex.lock_upgrade();
-	}
-}
-
-safe_writer_lock::~safe_writer_lock()
-{
-	if (m_is_upgraded)
-	{
-		m_mutex.lock_degrade();
-		return;
-	}
-
-	if (m_is_owned)
-	{
-		m_mutex.unlock();
-		g_tls_locks.erase(std::remove(g_tls_locks.begin(), g_tls_locks.end(), &m_mutex), g_tls_locks.cend());
-		return;
-	}
-
-	// TODO: order locks
 }
@@ -1,65 +1,108 @@
 #pragma once

+#include <mutex>
 #include "types.h"
 #include "Atomic.h"

-// Shared mutex.
+// Shared mutex with small size (u32).
 class shared_mutex final
 {
-	enum : s64
+	enum : u32
 	{
-		c_one = 1ull << 31, // Fixed-point 1.0 value (one writer)
-		c_min = 0x00000001, // Fixed-point 1.0/max_readers value
-		c_sig = 1ull << 62,
-		c_max = c_one
+		c_one = 1u << 14, // Fixed-point 1.0 value (one writer, max_readers = c_one - 1)
+		c_sig = 1u << 30,
+		c_err = 1u << 31,
 	};

-	atomic_t<s64> m_value{c_one}; // Semaphore-alike counter
-
-	void imp_lock_shared(s64 _old);
-	void imp_unlock_shared(s64 _old);
-	void imp_wait(s64 _old);
-	void imp_lock(s64 _old);
-	void imp_unlock(s64 _old);
+	atomic_t<u32> m_value{};

+	void imp_lock_shared(u32 val);
+	void imp_unlock_shared(u32 old);
+	void imp_wait();
+	void imp_signal();
+	void imp_lock(u32 val);
+	void imp_unlock(u32 old);
 	void imp_lock_upgrade();
-	void imp_lock_degrade();
+	void imp_lock_unlock();

 public:
 	constexpr shared_mutex() = default;

-	bool try_lock_shared();
+	bool try_lock_shared()
+	{
+		const u32 value = m_value.load();
+
+		// Conditional increment
+		return value < c_one - 1 && m_value.compare_and_swap_test(value, value + 1);
+	}

 	void lock_shared()
 	{
-		const s64 value = m_value.load();
+		const u32 value = m_value.load();

-		// Fast path: decrement if positive
-		if (UNLIKELY(value < c_min || value > c_one || !m_value.compare_and_swap_test(value, value - c_min)))
+		if (UNLIKELY(value >= c_one - 1 || !m_value.compare_and_swap_test(value, value + 1)))
 		{
 			imp_lock_shared(value);
 		}
 	}

+	void lock_shared_hle()
+	{
+		const u32 value = m_value.load();
+
+		if (LIKELY(value < c_one - 1))
+		{
+			u32 old = value;
+			if (LIKELY(atomic_storage<u32>::compare_exchange_hle_acq(m_value.raw(), old, value + 1)))
+			{
+				return;
+			}
+		}
+
+		imp_lock_shared(value);
+	}
+
 	void unlock_shared()
 	{
-		// Unconditional increment
-		const s64 value = m_value.fetch_add(c_min);
+		// Unconditional decrement (can result in broken state)
+		const u32 value = m_value.fetch_sub(1);

-		if (value < 0 || value > c_one - c_min)
+		if (UNLIKELY(value >= c_one))
 		{
 			imp_unlock_shared(value);
 		}
 	}

-	bool try_lock();
+	void unlock_shared_hle()
+	{
+		const u32 value = atomic_storage<u32>::fetch_add_hle_rel(m_value.raw(), -1);
+
+		if (UNLIKELY(value >= c_one))
+		{
+			imp_unlock_shared(value);
+		}
+	}
+
+	bool try_lock()
+	{
+		return m_value.compare_and_swap_test(0, c_one);
+	}

 	void lock()
 	{
-		// Try to lock
-		const s64 value = m_value.compare_and_swap(c_one, 0);
+		const u32 value = m_value.compare_and_swap(0, c_one);

-		if (value != c_one)
+		if (UNLIKELY(value))
+		{
+			imp_lock(value);
+		}
+	}
+
+	void lock_hle()
+	{
+		u32 value = 0;
+
+		if (UNLIKELY(!atomic_storage<u32>::compare_exchange_hle_acq(m_value.raw(), value, c_one)))
 		{
 			imp_lock(value);
 		}
@@ -67,38 +110,66 @@ public:

 	void unlock()
 	{
-		// Unconditional increment
-		const s64 value = m_value.fetch_add(c_one);
+		// Unconditional decrement (can result in broken state)
+		const u32 value = m_value.fetch_sub(c_one);

-		if (value != 0)
+		if (UNLIKELY(value != c_one))
 		{
 			imp_unlock(value);
 		}
 	}

-	bool try_lock_upgrade();
+	void unlock_hle()
+	{
+		const u32 value = atomic_storage<u32>::fetch_add_hle_rel(m_value.raw(), -c_one);
+
+		if (UNLIKELY(value != c_one))
+		{
+			imp_unlock(value);
+		}
+	}
+
+	bool try_lock_upgrade()
+	{
+		const u32 value = m_value.load();
+
+		// Conditional increment, try to convert a single reader into a writer, ignoring other writers
+		return (value + c_one - 1) % c_one == 0 && m_value.compare_and_swap_test(value, value + c_one - 1);
+	}

 	void lock_upgrade()
 	{
-		if (!m_value.compare_and_swap_test(c_one - c_min, 0))
+		if (UNLIKELY(!try_lock_upgrade()))
 		{
 			imp_lock_upgrade();
 		}
 	}

-	bool try_lock_degrade();
-
-	void lock_degrade()
+	void lock_downgrade()
 	{
-		if (!m_value.compare_and_swap_test(0, c_one - c_min))
+		// Convert to reader lock (can result in broken state)
+		m_value -= c_one - 1;
+	}
+
+	// Optimized wait for lockability without locking, relaxed
+	void lock_unlock()
+	{
+		if (UNLIKELY(m_value != 0))
 		{
-			imp_lock_degrade();
+			imp_lock_unlock();
 		}
 	}

-	bool is_reading() const
+	// Check whether can immediately obtain an exclusive (writer) lock
+	bool is_free() const
 	{
-		return (m_value.load() % c_one) != 0;
+		return m_value.load() == 0;
+	}
+
+	// Check whether can immediately obtain a shared (reader) lock
+	bool is_lockable() const
+	{
+		return m_value.load() < c_one - 1;
 	}
 };

@@ -108,28 +179,18 @@ class reader_lock final
 	shared_mutex& m_mutex;
 	bool m_upgraded = false;

-	void lock()
-	{
-		m_upgraded ? m_mutex.lock() : m_mutex.lock_shared();
-	}
-
-	void unlock()
-	{
-		m_upgraded ? m_mutex.unlock() : m_mutex.unlock_shared();
-	}
-
-	friend class cond_variable;
-
 public:
 	reader_lock(const reader_lock&) = delete;

+	reader_lock& operator=(const reader_lock&) = delete;
+
 	explicit reader_lock(shared_mutex& mutex)
 		: m_mutex(mutex)
 	{
-		lock();
+		m_mutex.lock_shared();
 	}

-	// One-way lock upgrade
+	// One-way lock upgrade; note that the observed state could have been changed
 	void upgrade()
 	{
 		if (!m_upgraded)
@@ -139,93 +200,14 @@ public:
 		}
 	}

+	// Try to upgrade; if it succeeds, the observed state has NOT been changed
+	bool try_upgrade()
+	{
+		return m_upgraded || (m_upgraded = m_mutex.try_lock_upgrade());
+	}
+
 	~reader_lock()
 	{
-		unlock();
+		m_upgraded ? m_mutex.unlock() : m_mutex.unlock_shared();
 	}
 };
-
-// Simplified exclusive (writer) lock implementation.
-class writer_lock final
-{
-	shared_mutex& m_mutex;
-
-	void lock()
-	{
-		m_mutex.lock();
-	}
-
-	void unlock()
-	{
-		m_mutex.unlock();
-	}
-
-	friend class cond_variable;
-
-public:
-	writer_lock(const writer_lock&) = delete;
-
-	explicit writer_lock(shared_mutex& mutex)
-		: m_mutex(mutex)
-	{
-		lock();
-	}
-
-	~writer_lock()
-	{
-		unlock();
-	}
-};
-
-// Safe reader lock. Can be recursive above other safe locks (reader or writer).
-class safe_reader_lock final
-{
-	shared_mutex& m_mutex;
-	bool m_is_owned;
-
-	void lock()
-	{
-		m_mutex.lock_shared();
-	}
-
-	void unlock()
-	{
-		m_mutex.unlock_shared();
-	}
-
-	friend class cond_variable;
-
-public:
-	safe_reader_lock(const safe_reader_lock&) = delete;
-
-	explicit safe_reader_lock(shared_mutex& mutex);
-
-	~safe_reader_lock();
-};
-
-// Safe writer lock. Can be recursive above other safe locks. Performs upgrade and degrade operations above existing reader lock if necessary.
-class safe_writer_lock final
-{
-	shared_mutex& m_mutex;
-	bool m_is_owned;
-	bool m_is_upgraded;
-
-	void lock()
-	{
-		m_mutex.lock();
-	}
-
-	void unlock()
-	{
-		m_mutex.unlock();
-	}
-
-	friend class cond_variable;
-
-public:
-	safe_writer_lock(const safe_writer_lock&) = delete;
-
-	explicit safe_writer_lock(shared_mutex& mutex);
-
-	~safe_writer_lock();
-};
@@ -1,10 +1,6 @@
 #pragma once

-#ifndef PUGIXML_HEADER_ONLY
-#define PUGIXML_HEADER_ONLY 1
-#endif // !PUGIXML_HEADER_ONLY
-#include "pugixml.hpp"
-#undef PUGIXML_HEADER_ONLY
+#include <pugixml.hpp>

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

 		if (value >= 0)
 		{
 			// Signal other waiter to wake up or to restore sign bit
-			futex(&m_value.raw(), FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
+			futex(&m_value, FUTEX_WAKE_PRIVATE, 1);
 			return;
 		}

-		futex(&m_value.raw(), FUTEX_WAIT_PRIVATE, value, nullptr, nullptr, 0);
+		futex(&m_value, FUTEX_WAIT_PRIVATE, value);
 	}
 #endif
 }
@@ -65,24 +67,10 @@ void semaphore_base::imp_post(s32 _old)
 #ifdef _WIN32
 	NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
 #else
-	futex(&m_value.raw(), FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
+	futex(&m_value, FUTEX_WAKE_PRIVATE, 1);
 #endif
 }

-bool semaphore_base::try_wait()
-{
-	// Conditional decrement
-	const s32 value = m_value.fetch_op([](s32& value)
-	{
-		if (value > 0)
-		{
-			value -= 1;
-		}
-	});
-
-	return value > 0;
-}
-
 bool semaphore_base::try_post(s32 _max)
 {
 	// Conditional increment
@@ -1,5 +1,6 @@
 #pragma once

+#include <mutex>
 #include "types.h"
 #include "Atomic.h"

@@ -13,8 +14,6 @@ class semaphore_base

 	void imp_post(s32 _old);

-	friend class semaphore_lock;
-
 protected:
 	explicit constexpr semaphore_base(s32 value)
 		: m_value{value}
@@ -33,7 +32,10 @@ protected:
 		}
 	}

-	bool try_wait();
+	bool try_wait()
+	{
+		return m_value.try_dec(0);
+	}

 	void post(s32 _max)
 	{
@@ -73,36 +75,36 @@ class semaphore final : public semaphore_base
 public:
 	// Default constructor (recommended)
 	constexpr semaphore()
-		: base{Def}
+		: base(Def)
 	{
 	}

 	// Explicit value constructor (not recommended)
 	explicit constexpr semaphore(s32 value)
-		: base{value}
+		: base(value)
 	{
 	}

 	// Obtain a semaphore
-	void wait()
+	void lock()
 	{
 		return base::wait();
 	}

 	// Try to obtain a semaphore
-	explicit_bool_t try_wait()
+	bool try_lock()
 	{
 		return base::try_wait();
 	}

 	// Return a semaphore
-	void post()
+	void unlock()
 	{
 		return base::post(Max);
 	}

 	// Try to return a semaphore
-	explicit_bool_t try_post()
+	bool try_unlock()
 	{
 		return base::try_post(Max);
 	}
@@ -113,34 +115,3 @@ public:
 		return Max;
 	}
 };
-
-class semaphore_lock
-{
-	semaphore_base& m_base;
-
-	void lock()
-	{
-		m_base.wait();
-	}
-
-	void unlock()
-	{
-		m_base.post(INT32_MAX);
-	}
-
-	friend class cond_variable;
-
-public:
-	explicit semaphore_lock(const semaphore_lock&) = delete;
-
-	semaphore_lock(semaphore_base& sema)
-		: m_base(sema)
-	{
-		lock();
-	}
-
-	~semaphore_lock()
-	{
-		unlock();
-	}
-};
@@ -17,6 +17,7 @@
 #include <unistd.h>
 #else
 #endif
+#include <algorithm>
 #include <ctime>
 #include <chrono>
 #include <mutex>
@@ -24,10 +25,12 @@
 #include <unordered_map>

 #ifdef _WIN32
-DYNAMIC_IMPORT("ntdll.dll", NtSetTimerResolution, NTSTATUS(ULONG DesiredResolution, BOOLEAN SetResolution, PULONG CurrentResolution));
 DYNAMIC_IMPORT("ntdll.dll", NtWaitForKeyedEvent, NTSTATUS(HANDLE Handle, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout));
 DYNAMIC_IMPORT("ntdll.dll", NtReleaseKeyedEvent, NTSTATUS(HANDLE Handle, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout));
 DYNAMIC_IMPORT("ntdll.dll", NtDelayExecution, NTSTATUS(BOOLEAN Alertable, PLARGE_INTEGER DelayInterval));
+inline utils::dynamic_import<BOOL(volatile VOID* Address, PVOID CompareAddress, SIZE_T AddressSize, DWORD dwMilliseconds)> OptWaitOnAddress("kernel32.dll", "WaitOnAddress");
+inline utils::dynamic_import<VOID(PVOID Address)> OptWakeByAddressSingle("kernel32.dll", "WakeByAddressSingle");
+inline utils::dynamic_import<VOID(PVOID Address)> OptWakeByAddressAll("kernel32.dll", "WakeByAddressAll");
 #endif

 #ifndef __linux__
@@ -46,37 +49,37 @@ enum
 };
 #endif

-inline int futex(int* uaddr, int futex_op, int val, const timespec* timeout, int* uaddr2, int val3)
+inline int futex(volatile void* uaddr, int futex_op, uint val, const timespec* timeout = nullptr, uint mask = 0)
 {
 #ifdef __linux__
-	return syscall(SYS_futex, uaddr, futex_op, val, timeout, uaddr, val3);
+	return syscall(SYS_futex, uaddr, futex_op, static_cast<int>(val), timeout, nullptr, static_cast<int>(mask));
 #else
-	static struct futex_map
+	static struct futex_manager
 	{
 		struct waiter
 		{
-			 int val;
+			 uint val;
 			 uint mask;
 			 std::condition_variable cv;
 		};

 		std::mutex mutex;
-		std::unordered_multimap<int*, waiter*, pointer_hash<int>> map;
+		std::unordered_multimap<volatile void*, waiter*, pointer_hash<volatile void, alignof(int)>> map;

-		int operator()(int* uaddr, int futex_op, int val, const timespec* timeout, int*, uint val3)
+		int operator()(volatile void* uaddr, int futex_op, uint val, const timespec* timeout, uint mask)
 		{
-			std::unique_lock<std::mutex> lock(mutex);
+			std::unique_lock lock(mutex);

 			switch (futex_op)
 			{
-			case FUTEX_WAIT:
+			case FUTEX_WAIT_PRIVATE:
 			{
-				val3 = -1;
-				// Fallthrough
+				mask = -1;
+				[[fallthrough]];
 			}
-			case FUTEX_WAIT_BITSET:
+			case FUTEX_WAIT_BITSET_PRIVATE:
 			{
-				if (*(volatile int*)uaddr != val)
+				if (*reinterpret_cast<volatile uint*>(uaddr) != val)
 				{
 					errno = EAGAIN;
 					return -1;
@@ -84,7 +87,7 @@ inline int futex(int* uaddr, int futex_op, int val, const timespec* timeout, int

 				waiter rec;
 				rec.val = val;
-				rec.mask = val3;
+				rec.mask = mask;
 				const auto& ref = *map.emplace(uaddr, &rec);

 				int res = 0;
@@ -107,25 +110,25 @@ inline int futex(int* uaddr, int futex_op, int val, const timespec* timeout, int
 				{
 					// TODO
 				}
-				
+
 				map.erase(std::find(map.find(uaddr), map.end(), ref));
 				return res;
 			}

-			case FUTEX_WAKE:
+			case FUTEX_WAKE_PRIVATE:
 			{
-				val3 = -1;
-				// Fallthrough
+				mask = -1;
+				[[fallthrough]];
 			}
-			case FUTEX_WAKE_BITSET:
+			case FUTEX_WAKE_BITSET_PRIVATE:
 			{
 				int res = 0;

 				for (auto range = map.equal_range(uaddr); val && range.first != range.second; range.first++)
 				{
 					auto& entry = *range.first->second;
-					
-					if (entry.mask & val3)
+
+					if (entry.mask & mask)
 					{
 						entry.cv.notify_one();
 						entry.mask = 0;
@@ -143,6 +146,149 @@ inline int futex(int* uaddr, int futex_op, int val, const timespec* timeout, int
 		}
 	} g_futex;

-	return g_futex(uaddr, futex_op, val, timeout, uaddr2, val3);
+	return g_futex(uaddr, futex_op, val, timeout, mask);
+#endif
+}
+
+template <typename T, typename Pred>
+bool balanced_wait_until(atomic_t<T>& var, u64 usec_timeout, Pred&& pred)
+{
+	static_assert(sizeof(T) == 4 || sizeof(T) == 8);
+
+	const bool is_inf = usec_timeout > u64{UINT32_MAX / 1000} * 1000000;
+
+	// Optional second argument indicates that the predicate should try to retire
+	auto test_pred = [&](T& _new, auto... args)
+	{
+		T old = var.load();
+
+		while (true)
+		{
+			_new = old;
+
+			// Zero indicates failure without modifying the value
+			// Negative indicates failure but modifies the value
+			auto ret = std::invoke(std::forward<Pred>(pred), _new, args...);
+
+			if (LIKELY(!ret || var.compare_exchange(old, _new)))
+			{
+				return ret > 0;
+			}
+		}
+	};
+
+	T value;
+
+#ifdef _WIN32
+	if (OptWaitOnAddress)
+	{
+		while (!test_pred(value))
+		{
+			if (OptWaitOnAddress(&var, &value, sizeof(T), is_inf ? INFINITE : usec_timeout / 1000))
+			{
+				if (!test_pred(value, nullptr))
+				{
+					return false;
+				}
+
+				break;
+			}
+
+			if (GetLastError() == ERROR_TIMEOUT)
+			{
+				// Retire
+				return test_pred(value, nullptr);
+			}
+		}
+
+		return true;
+	}
+
+	LARGE_INTEGER timeout;
+	timeout.QuadPart = usec_timeout * -10;
+
+	if (!usec_timeout || NtWaitForKeyedEvent(nullptr, &var, false, is_inf ? nullptr : &timeout))
+	{
+		// Timed out: retire
+		if (!test_pred(value, nullptr))
+		{
+			return false;
+		}
+
+		// Signaled in the last moment: restore balance
+		NtWaitForKeyedEvent(nullptr, &var, false, nullptr);
+		return true;
+	}
+
+	if (!test_pred(value, nullptr))
+	{
+		// Stolen notification: restore balance
+		NtReleaseKeyedEvent(nullptr, &var, false, nullptr);
+		return false;
+	}
+
+	return true;
+#else
+	struct timespec timeout;
+	timeout.tv_sec  = usec_timeout / 1000000;
+	timeout.tv_nsec = (usec_timeout % 1000000) * 1000;
+
+	while (!test_pred(value))
+	{
+		if (futex(&var, FUTEX_WAIT_PRIVATE, static_cast<u32>(value), is_inf ? nullptr : &timeout) == 0)
+		{
+			if (!test_pred(value, nullptr))
+			{
+				return false;
+			}
+
+			break;
+		}
+
+		switch (errno)
+		{
+		case EAGAIN: break;
+		case ETIMEDOUT: return test_pred(value, nullptr);
+		default: verify("Unknown futex error" HERE), 0;
+		}
+	}
+
+	return true;
+#endif
+}
+
+template <bool All = false, typename T>
+void balanced_awaken(atomic_t<T>& var, u32 weight)
+{
+	static_assert(sizeof(T) == 4 || sizeof(T) == 8);
+
+#ifdef _WIN32
+	if (OptWaitOnAddress)
+	{
+		if (All || weight > 3)
+		{
+			OptWakeByAddressAll(&var);
+			return;
+		}
+
+		for (u32 i = 0; i < weight; i++)
+		{
+			OptWakeByAddressSingle(&var);
+		}
+
+		return;
+	}
+
+	for (u32 i = 0; i < weight; i++)
+	{
+		NtReleaseKeyedEvent(nullptr, &var, false, nullptr);
+	}
+#else
+	if (All || weight)
+	{
+		futex(&var, FUTEX_WAKE_PRIVATE, All ? INT_MAX : std::min<u32>(INT_MAX, weight));
+	}
+
+	return;
 #endif
 }
@@ -13,29 +13,40 @@ bool utils::has_ssse3()
 	return g_value;
 }

+bool utils::has_sse41()
+{
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x80000;
+	return g_value;
+}
+
 bool utils::has_avx()
 {
-	static const bool g_value = get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x10000000;
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x10000000 && (get_cpuid(1, 0)[2] & 0x0C000000) == 0x0C000000 && (get_xgetbv(0) & 0x6) == 0x6;
 	return g_value;
 }

 bool utils::has_avx2()
 {
-	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && get_cpuid(7, 0)[1] & 0x20;
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && get_cpuid(7, 0)[1] & 0x20 && (get_cpuid(1, 0)[2] & 0x0C000000) == 0x0C000000 && (get_xgetbv(0) & 0x6) == 0x6;
 	return g_value;
 }

 bool utils::has_rtm()
 {
-	// Check RTM and MPX extensions in order to filter out TSX on Haswell CPUs
-	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && (get_cpuid(7, 0)[1] & 0x4800) == 0x4800;
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && (get_cpuid(7, 0)[1] & 0x800) == 0x800;
+	return g_value;
+}
+
+bool utils::has_mpx()
+{
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && (get_cpuid(7, 0)[1] & 0x4000) == 0x4000;
 	return g_value;
 }

 bool utils::has_512()
 {
 	// Check AVX512F, AVX512CD, AVX512DQ, AVX512BW, AVX512VL extensions (Skylake-X level support)
-	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && (get_cpuid(7, 0)[1] & 0xd0030000) == 0xd0030000;
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && (get_cpuid(7, 0)[1] & 0xd0030000) == 0xd0030000 && (get_cpuid(1,0)[2] & 0x0C000000) == 0x0C000000 && (get_xgetbv(0) & 0xe6) == 0xe6;
 	return g_value;
 }

@@ -62,8 +73,9 @@ std::string utils::get_system_info()
 		brand = "Unknown CPU";
 	}

-	brand.erase(0, brand.find_first_not_of(' '));
+	brand.erase(brand.find_last_not_of('\0') + 1);
 	brand.erase(brand.find_last_not_of(' ') + 1);
+	brand.erase(0, brand.find_first_not_of(' '));

 	while (auto found = brand.find("  ") + 1)
 	{
@@ -108,6 +120,10 @@ std::string utils::get_system_info()
 	if (has_rtm())
 	{
 		result += " | TSX";
+		if (!has_mpx())
+		{
+			result += " disabled by default";
+		}
 	}

 	return result;
@@ -16,35 +16,32 @@ namespace utils
 		return {0u+regs[0], 0u+regs[1], 0u+regs[2], 0u+regs[3]};
 	}

+	inline u64 get_xgetbv(u32 xcr)
+	{
+#ifdef _MSC_VER
+		return _xgetbv(xcr);
+#else
+		u32 eax, edx;
+		__asm__ volatile( "xgetbv" : "=a"(eax), "=d"(edx) : "c"(xcr));
+		return eax | (u64(edx) << 32);
+#endif
+	}
+
 	bool has_ssse3();

+	bool has_sse41();
+
 	bool has_avx();

 	bool has_avx2();

 	bool has_rtm();

+	bool has_mpx();
+
 	bool has_512();

 	bool has_xop();

-	inline bool transaction_enter()
-	{
-		while (true)
-		{
-			const auto status = _xbegin();
-
-			if (status == _XBEGIN_STARTED)
-			{
-				return true;
-			}
-
-			if (!(status & _XABORT_RETRY))
-			{
-				return false;
-			}
-		}
-	}
-
 	std::string get_system_info();
 }
@@ -9,9 +9,11 @@
 #include <emmintrin.h>

 #include <cstdint>
+#include <cstddef>
 #include <type_traits>
 #include <utility>
 #include <chrono>
+#include <limits>
 #include <array>

 // Assume little-endian
@@ -19,31 +21,42 @@
 #define IS_BE_MACHINE 0

 #ifdef _MSC_VER
-#define ASSUME(cond) __assume(cond)
+
+#define ASSUME(...) __assume(__VA_ARGS__) // MSVC __assume ignores side-effects
 #define LIKELY
 #define UNLIKELY
 #define SAFE_BUFFERS __declspec(safebuffers)
 #define NEVER_INLINE __declspec(noinline)
 #define FORCE_INLINE __forceinline
-#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)
+
+#else // not _MSC_VER
+
+#ifdef __clang__
+#if defined(__has_builtin) && __has_builtin(__builtin_assume)
+#pragma clang diagnostic ignored "-Wassume" // ignore the clang "side-effects ignored" warning
+#define ASSUME(...) __builtin_assume(!!(__VA_ARGS__)) // __builtin_assume (supported by modern clang) ignores side-effects
+#endif
+#endif
+
+#ifndef ASSUME // gcc and old clang
+#define ASSUME(...) do { if (!(__VA_ARGS__)) __builtin_unreachable(); } while (0)  // note: the compiler will generate code to evaluate "cond" if the expression is opaque
+#endif
+
+#define LIKELY(...) __builtin_expect(!!(__VA_ARGS__), 1)
+#define UNLIKELY(...) __builtin_expect(!!(__VA_ARGS__), 0)
 #define SAFE_BUFFERS
 #define NEVER_INLINE __attribute__((noinline))
 #define FORCE_INLINE __attribute__((always_inline)) inline
-#endif
+
+#endif // _MSC_VER

 #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)

-// Return 32 bit sizeof() to avoid widening/narrowing conversions with size_t
-#define SIZE_32(...) static_cast<u32>(sizeof(__VA_ARGS__))
-
-// Return 32 bit alignof() to avoid widening/narrowing conversions with size_t
-#define ALIGN_32(...) static_cast<u32>(alignof(__VA_ARGS__))
+// Variant pattern matching helper
+#define MATCH(arg, ...) constexpr(std::is_same_v<std::decay_t<decltype(arg)>, __VA_ARGS__>)

 #define CONCATENATE_DETAIL(x, y) x ## y
 #define CONCATENATE(x, y) CONCATENATE_DETAIL(x, y)
@@ -53,14 +66,20 @@

 #define HERE "\n(in file " __FILE__ ":" STRINGIZE(__LINE__) ")"

-// Ensure that the expression evaluates to true. Obsolete.
-//#define EXPECTS(...) do { if (!(__VA_ARGS__)) fmt::raw_error("Precondition failed: " #__VA_ARGS__ HERE); } while (0)
-//#define ENSURES(...) do { if (!(__VA_ARGS__)) fmt::raw_error("Postcondition failed: " #__VA_ARGS__ HERE); } while (0)
-
 #define DECLARE(...) decltype(__VA_ARGS__) __VA_ARGS__

 #define STR_CASE(...) case __VA_ARGS__: return #__VA_ARGS__

+
+#define ASSERT(...) do { if(!(__VA_ARGS__)) fmt::raw_error("Assertion failed: " STRINGIZE(__VA_ARGS__) HERE); } while(0)
+
+#if defined(_DEBUG) || defined(_AUDIT)
+#define AUDIT(...) ASSERT(__VA_ARGS__)
+#else
+#define AUDIT(...) ((void)0)
+#endif
+
+
 using schar  = signed char;
 using uchar  = unsigned char;
 using ushort = unsigned short;
@@ -69,7 +88,11 @@ using ulong  = unsigned long;
 using ullong = unsigned long long;
 using llong  = long long;

+#if __APPLE__
+using uptr = std::uint64_t;
+#else
 using uptr = std::uintptr_t;
+#endif

 using u8  = std::uint8_t;
 using u16 = std::uint16_t;
@@ -87,7 +110,7 @@ using steady_clock = std::conditional<

 namespace gsl
 {
-	enum class byte : u8;
+	using std::byte;
 }

 // Formatting helper, type-specific preprocessing for improving safety and functionality
@@ -111,64 +134,9 @@ struct se_storage;
 template <typename T, bool Se = true, std::size_t Align = alignof(T)>
 class se_t;

-template <typename T, std::size_t Size = sizeof(T)>
-struct atomic_storage;
-
-template <typename T1, typename T2, typename = void>
-struct atomic_add;
-
-template <typename T1, typename T2, typename = void>
-struct atomic_sub;
-
-template <typename T1, typename T2, typename = void>
-struct atomic_and;
-
-template <typename T1, typename T2, typename = void>
-struct atomic_or;
-
-template <typename T1, typename T2, typename = void>
-struct atomic_xor;
-
-template <typename T, typename = void>
-struct atomic_pre_inc;
-
-template <typename T, typename = void>
-struct atomic_post_inc;
-
-template <typename T, typename = void>
-struct atomic_pre_dec;
-
-template <typename T, typename = void>
-struct atomic_post_dec;
-
-template <typename T1, typename T2, typename = void>
-struct atomic_test_and_set;
-
-template <typename T1, typename T2, typename = void>
-struct atomic_test_and_reset;
-
-template <typename T1, typename T2, typename = void>
-struct atomic_test_and_complement;
-
 template <typename T>
 class atomic_t;

-#ifdef _MSC_VER
-using std::void_t;
-#else
-namespace void_details
-{
-	template <typename...>
-	struct make_void
-	{
-		using type = void;
-	};
-}
-
-template <typename... T>
-using void_t = typename void_details::make_void<T...>::type;
-#endif
-
 // Extract T::simple_type if available, remove cv qualifiers
 template <typename T, typename = void>
 struct simple_type_helper
@@ -177,7 +145,7 @@ struct simple_type_helper
 };

 template <typename T>
-struct simple_type_helper<T, void_t<typename T::simple_type>>
+struct simple_type_helper<T, std::void_t<typename T::simple_type>>
 {
 	using type = typename T::simple_type;
 };
@@ -204,22 +172,6 @@ public:
 	}
 };

-// Bool wrapper for restricting bool result conversions
-struct explicit_bool_t
-{
-	const bool value;
-
-	constexpr explicit_bool_t(bool value)
-		: value(value)
-	{
-	}
-
-	explicit constexpr operator bool() const
-	{
-		return value;
-	}
-};
-
 #ifndef _MSC_VER
 using u128 = __uint128_t;
 using s128 = __int128_t;
@@ -435,14 +387,6 @@ CHECK_SIZE_ALIGN(f16, 2, 2);
 using f32 = float;
 using f64 = double;

-struct ignore
-{
-	template <typename T>
-	ignore(T)
-	{
-	}
-};
-
 template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
 constexpr T align(const T& value, ullong align)
 {
@@ -471,7 +415,7 @@ struct offset32_array
 	template <typename Arg>
 	static inline u32 index32(const Arg& arg)
 	{
-		return SIZE_32(std::remove_extent_t<T>) * static_cast<u32>(arg);
+		return u32{sizeof(std::remove_extent_t<T>)} * static_cast<u32>(arg);
 	}
 };

@@ -481,7 +425,7 @@ struct offset32_array<std::array<T, N>>
 	template <typename Arg>
 	static inline u32 index32(const Arg& arg)
 	{
-		return SIZE_32(T) * static_cast<u32>(arg);
+		return u32{sizeof(T)} * static_cast<u32>(arg);
 	}
 };

@@ -514,46 +458,6 @@ struct offset32_detail<T3 T4::*>
 	}
 };

-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_clzll(arg) - 32 : 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_ctzll(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
-}
-
 // Helper function, used by ""_u16, ""_u32, ""_u64
 constexpr u8 to_u8(char c)
 {
@@ -725,7 +629,7 @@ struct narrow_impl<From, To, std::enable_if_t<std::is_signed<From>::value && std

 // Simple type enabled (TODO: allow for To as well)
 template <typename From, typename To>
-struct narrow_impl<From, To, void_t<typename From::simple_type>>
+struct narrow_impl<From, To, std::void_t<typename From::simple_type>>
 	: narrow_impl<simple_t<From>, To>
 {
 };
@@ -757,42 +661,6 @@ constexpr u32 size32(const T (&)[Size], const char* msg = nullptr)
 	return static_cast<u32>(Size);
 }

-template <typename T1, typename = std::enable_if_t<std::is_integral<T1>::value>>
-constexpr bool test(const T1& value)
-{
-	return value != 0;
-}
-
-template <typename T1, typename T2, typename = std::enable_if_t<std::is_integral<T1>::value && std::is_integral<T2>::value>>
-constexpr bool test(const T1& lhs, const T2& rhs)
-{
-	return (lhs & rhs) != 0;
-}
-
-template <typename T, typename T2, typename = std::enable_if_t<std::is_integral<T>::value && std::is_integral<T2>::value>>
-inline bool test_and_set(T& lhs, const T2& rhs)
-{
-	const bool result = (lhs & rhs) != 0;
-	lhs |= rhs;
-	return result;
-}
-
-template <typename T, typename T2, typename = std::enable_if_t<std::is_integral<T>::value && std::is_integral<T2>::value>>
-inline bool test_and_reset(T& lhs, const T2& rhs)
-{
-	const bool result = (lhs & rhs) != 0;
-	lhs &= ~rhs;
-	return result;
-}
-
-template <typename T, typename T2, typename = std::enable_if_t<std::is_integral<T>::value && std::is_integral<T2>::value>>
-inline bool test_and_complement(T& lhs, const T2& rhs)
-{
-	const bool result = (lhs & rhs) != 0;
-	lhs ^= rhs;
-	return result;
-}
-
 // Simplified hash algorithm for pointers. May be used in std::unordered_(map|set).
 template <typename T, std::size_t Align = alignof(T)>
 struct pointer_hash
@@ -817,7 +685,7 @@ struct value_hash
 template <template <typename> class TT, std::size_t S, std::size_t A = S>
 struct alignas(A) any_pod
 {
-	std::aligned_storage_t<S, A> data;
+	alignas(A) std::byte data[S];

 	any_pod() = default;

@@ -900,35 +768,6 @@ struct cmd64 : any64

 static_assert(sizeof(cmd64) == 8 && std::is_pod<cmd64>::value, "Incorrect cmd64 type");

-// Allows to define integer convertible to multiple types
-template <typename T, T Value, typename T1 = void, typename... Ts>
-struct multicast : multicast<T, Value, Ts...>
-{
-	constexpr multicast()
-		: multicast<T, Value, Ts...>()
-	{
-	}
-
-	// Implicit conversion to desired type
-	constexpr operator T1() const
-	{
-		return static_cast<T1>(Value);
-	}
-};
-
-// Recursion terminator
-template <typename T, T Value>
-struct multicast<T, Value, void>
-{
-	constexpr multicast() = default;
-
-	// Explicit conversion to base type
-	explicit constexpr operator T() const
-	{
-		return Value;
-	}
-};
-
 // Error code type (return type), implements error reporting. Could be a template.
 struct error_code
 {
@@ -953,26 +792,23 @@ struct error_code
 	};

 	template<typename ET>
-	struct is_error<ET, void_t<decltype(ET::__not_an_error)>> : std::false_type
+	struct is_error<ET, std::enable_if_t<sizeof(ET::__not_an_error) != 0>> : std::false_type
 	{
 	};

-	// Not an error constructor
-	template<typename ET, typename = decltype(ET::__not_an_error)>
-	error_code(const ET& value, std::nullptr_t = nullptr)
+	// Common constructor
+	template<typename ET>
+	error_code(const ET& value)
 		: value(static_cast<s32>(value))
 	{
-	}
-
-	// Error constructor
-	template<typename ET, typename = std::enable_if_t<is_error<ET>::value>>
-	error_code(const ET& value)
-		: value(error_report(fmt::get_type_info<fmt_unveil_t<ET>>(), fmt_unveil<ET>::get(value), nullptr, 0))
-	{
+		if constexpr(is_error<ET>::value)
+		{
+			this->value = error_report(fmt::get_type_info<fmt_unveil_t<ET>>(), fmt_unveil<ET>::get(value), nullptr, 0);
+		}
 	}

 	// Error constructor (2 args)
-	template<typename ET, typename T2, typename = std::enable_if_t<is_error<ET>::value>>
+	template<typename ET, typename T2>
 	error_code(const ET& value, const T2& value2)
 		: value(error_report(fmt::get_type_info<fmt_unveil_t<ET>>(), fmt_unveil<ET>::get(value), fmt::get_type_info<fmt_unveil_t<T2>>(), fmt_unveil<T2>::get(value2)))
 	{
@@ -992,93 +828,8 @@ constexpr FORCE_INLINE error_code::not_an_error not_an_error(const T& value)
 }

 // Synchronization helper (cache-friendly busy waiting)
-inline void busy_wait(std::size_t count = 100)
+inline void busy_wait(std::size_t cycles = 3000)
 {
-	while (count--) _mm_pause();
+	const u64 s = __rdtsc();
+	do _mm_pause(); while (__rdtsc() - s < cycles);
 }
-
-// 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
@@ -1,980 +0,0 @@
-#ifndef MAPBOX_UTIL_VARIANT_HPP
-#define MAPBOX_UTIL_VARIANT_HPP
-
-#include <cassert>
-#include <cstddef>   // size_t
-#include <new>       // operator new
-#include <stdexcept> // runtime_error
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <typeinfo>
-#include <utility>
-
-#include "recursive_wrapper.hpp"
-#include "variant_visitor.hpp"
-
-// clang-format off
-// [[deprecated]] is only available in C++14, use this for the time being
-#if __cplusplus <= 201103L
-# ifdef __GNUC__
-#  define MAPBOX_VARIANT_DEPRECATED __attribute__((deprecated))
-# elif defined(_MSC_VER)
-#  define MAPBOX_VARIANT_DEPRECATED __declspec(deprecated)
-# else
-#  define MAPBOX_VARIANT_DEPRECATED
-# endif
-#else
-#  define MAPBOX_VARIANT_DEPRECATED [[deprecated]]
-#endif
-
-
-#ifdef _MSC_VER
-// https://msdn.microsoft.com/en-us/library/bw1hbe6y.aspx
-# ifdef NDEBUG
-#  define VARIANT_INLINE __forceinline
-# else
-#  define VARIANT_INLINE //__declspec(noinline)
-# endif
-#else
-# ifdef NDEBUG
-#  define VARIANT_INLINE //inline __attribute__((always_inline))
-# else
-#  define VARIANT_INLINE __attribute__((noinline))
-# endif
-#endif
-// clang-format on
-
-// Exceptions
-#if defined( __EXCEPTIONS) || defined( _MSC_VER)
-#define HAS_EXCEPTIONS
-#endif
-
-#define VARIANT_MAJOR_VERSION 1
-#define VARIANT_MINOR_VERSION 1
-#define VARIANT_PATCH_VERSION 0
-
-#define VARIANT_VERSION (VARIANT_MAJOR_VERSION * 100000) + (VARIANT_MINOR_VERSION * 100) + (VARIANT_PATCH_VERSION)
-
-//namespace mapbox {
-//	namespace util {
-namespace std {
-
-		// XXX This should derive from std::logic_error instead of std::runtime_error.
-		//     See https://github.com/mapbox/variant/issues/48 for details.
-		class bad_variant_access : public std::runtime_error
-		{
-
-		public:
-			explicit bad_variant_access(const std::string& what_arg)
-				: runtime_error(what_arg) {}
-
-			explicit bad_variant_access(const char* what_arg)
-				: runtime_error(what_arg) {}
-
-		}; // class bad_variant_access
-
-		namespace detail {
-
-			static constexpr std::size_t invalid_value = std::size_t(-1);
-
-			template <typename T, typename... Types>
-			struct direct_type;
-
-			template <typename T, typename First, typename... Types>
-			struct direct_type<T, First, Types...>
-			{
-				static constexpr std::size_t index = std::is_same<T, First>::value
-					? sizeof...(Types)
-					: direct_type<T, Types...>::index;
-			};
-
-			template <typename T>
-			struct direct_type<T>
-			{
-				static constexpr std::size_t index = invalid_value;
-			};
-
-#if __cpp_lib_logical_traits >= 201510L
-
-			using std::disjunction;
-
-#else
-
-			template <typename...>
-			struct disjunction : std::false_type {};
-
-			template <typename B1>
-			struct disjunction<B1> : B1 {};
-
-			template <typename B1, typename B2>
-			struct disjunction<B1, B2> : std::conditional<B1::value, B1, B2>::type {};
-
-			template <typename B1, typename... Bs>
-			struct disjunction<B1, Bs...> : std::conditional<B1::value, B1, disjunction<Bs...>>::type {};
-
-#endif
-
-			template <typename T, typename... Types>
-			struct convertible_type;
-
-			template <typename T, typename First, typename... Types>
-			struct convertible_type<T, First, Types...>
-			{
-				static constexpr std::size_t index = std::is_convertible<T, First>::value
-					? disjunction<std::is_convertible<T, Types>...>::value ? invalid_value : sizeof...(Types)
-					: convertible_type<T, Types...>::index;
-			};
-
-			template <typename T>
-			struct convertible_type<T>
-			{
-				static constexpr std::size_t index = invalid_value;
-			};
-
-			template <typename T, typename... Types>
-			struct value_traits
-			{
-				using value_type = typename std::remove_const<typename std::remove_reference<T>::type>::type;
-				static constexpr std::size_t direct_index = direct_type<value_type, Types...>::index;
-				static constexpr bool is_direct = direct_index != invalid_value;
-				static constexpr std::size_t index = is_direct ? direct_index : convertible_type<value_type, Types...>::index;
-				static constexpr bool is_valid = index != invalid_value;
-				static constexpr std::size_t tindex = is_valid ? sizeof...(Types)-index : 0;
-				using target_type = typename std::tuple_element<tindex, std::tuple<void, Types...>>::type;
-			};
-
-			template <typename T, typename R = void>
-			struct enable_if_type
-			{
-				using type = R;
-			};
-
-			template <typename F, typename V, typename Enable = void>
-			struct result_of_unary_visit
-			{
-				using type = typename std::result_of<F(V&)>::type;
-			};
-
-			template <typename F, typename V>
-			struct result_of_unary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
-			{
-				using type = typename F::result_type;
-			};
-
-			template <typename F, typename V, typename Enable = void>
-			struct result_of_binary_visit
-			{
-				using type = typename std::result_of<F(V&, V&)>::type;
-			};
-
-			template <typename F, typename V>
-			struct result_of_binary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
-			{
-				using type = typename F::result_type;
-			};
-
-			template <std::size_t arg1, std::size_t... others>
-			struct static_max;
-
-			template <std::size_t arg>
-			struct static_max<arg>
-			{
-				static const std::size_t value = arg;
-			};
-
-			template <std::size_t arg1, std::size_t arg2, std::size_t... others>
-			struct static_max<arg1, arg2, others...>
-			{
-				static const std::size_t value = arg1 >= arg2 ? static_max<arg1, others...>::value : static_max<arg2, others...>::value;
-			};
-
-			template <typename... Types>
-			struct variant_helper;
-
-			template <typename T, typename... Types>
-			struct variant_helper<T, Types...>
-			{
-				VARIANT_INLINE static void destroy(const std::size_t type_index, void* data)
-				{
-					if (type_index == sizeof...(Types))
-					{
-						reinterpret_cast<T*>(data)->~T();
-					}
-					else
-					{
-						variant_helper<Types...>::destroy(type_index, data);
-					}
-				}
-
-				VARIANT_INLINE static void move(const std::size_t old_type_index, void* old_value, void* new_value)
-				{
-					if (old_type_index == sizeof...(Types))
-					{
-						new (new_value) T(std::move(*reinterpret_cast<T*>(old_value)));
-					}
-					else
-					{
-						variant_helper<Types...>::move(old_type_index, old_value, new_value);
-					}
-				}
-
-				VARIANT_INLINE static void copy(const std::size_t old_type_index, const void* old_value, void* new_value)
-				{
-					if (old_type_index == sizeof...(Types))
-					{
-						new (new_value) T(*reinterpret_cast<const T*>(old_value));
-					}
-					else
-					{
-						variant_helper<Types...>::copy(old_type_index, old_value, new_value);
-					}
-				}
-			};
-
-			template <>
-			struct variant_helper<>
-			{
-				VARIANT_INLINE static void destroy(const std::size_t, void*) {}
-				VARIANT_INLINE static void move(const std::size_t, void*, void*) {}
-				VARIANT_INLINE static void copy(const std::size_t, const void*, void*) {}
-			};
-
-			template <typename T>
-			struct unwrapper
-			{
-				static T const& apply_const(T const& obj) { return obj; }
-				static T& apply(T& obj) { return obj; }
-			};
-
-			template <typename T>
-			struct unwrapper<recursive_wrapper<T>>
-			{
-				static auto apply_const(recursive_wrapper<T> const& obj)
-					-> typename recursive_wrapper<T>::type const&
-				{
-					return obj.get();
-				}
-				static auto apply(recursive_wrapper<T>& obj)
-					-> typename recursive_wrapper<T>::type&
-				{
-					return obj.get();
-				}
-			};
-
-			template <typename T>
-			struct unwrapper<std::reference_wrapper<T>>
-			{
-				static auto apply_const(std::reference_wrapper<T> const& obj)
-					-> typename std::reference_wrapper<T>::type const&
-				{
-					return obj.get();
-				}
-				static auto apply(std::reference_wrapper<T>& obj)
-					-> typename std::reference_wrapper<T>::type&
-				{
-					return obj.get();
-				}
-			};
-
-			template <typename F, typename V, typename R, typename... Types>
-			struct dispatcher;
-
-			template <typename F, typename V, typename R, typename T, typename... Types>
-			struct dispatcher<F, V, R, T, Types...>
-			{
-				VARIANT_INLINE static R apply_const(V const& v, F&& f)
-				{
-					if (v.template is<T>())
-					{
-						return f(unwrapper<T>::apply_const(v.template get_unchecked<T>()));
-					}
-					else
-					{
-						return dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
-					}
-				}
-
-				VARIANT_INLINE static R apply(V& v, F&& f)
-				{
-					if (v.template is<T>())
-					{
-						return f(unwrapper<T>::apply(v.template get_unchecked<T>()));
-					}
-					else
-					{
-						return dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
-					}
-				}
-			};
-
-			template <typename F, typename V, typename R, typename T>
-			struct dispatcher<F, V, R, T>
-			{
-				VARIANT_INLINE static R apply_const(V const& v, F&& f)
-				{
-					return f(unwrapper<T>::apply_const(v.template get_unchecked<T>()));
-				}
-
-				VARIANT_INLINE static R apply(V& v, F&& f)
-				{
-					return f(unwrapper<T>::apply(v.template get_unchecked<T>()));
-				}
-			};
-
-			template <typename F, typename V, typename R, typename T, typename... Types>
-			struct binary_dispatcher_rhs;
-
-			template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
-			struct binary_dispatcher_rhs<F, V, R, T0, T1, Types...>
-			{
-				VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
-				{
-					if (rhs.template is<T1>()) // call binary functor
-					{
-						return f(unwrapper<T0>::apply_const(lhs.template get_unchecked<T0>()),
-							unwrapper<T1>::apply_const(rhs.template get_unchecked<T1>()));
-					}
-					else
-					{
-						return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
-					}
-				}
-
-				VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
-				{
-					if (rhs.template is<T1>()) // call binary functor
-					{
-						return f(unwrapper<T0>::apply(lhs.template get_unchecked<T0>()),
-							unwrapper<T1>::apply(rhs.template get_unchecked<T1>()));
-					}
-					else
-					{
-						return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
-					}
-				}
-			};
-
-			template <typename F, typename V, typename R, typename T0, typename T1>
-			struct binary_dispatcher_rhs<F, V, R, T0, T1>
-			{
-				VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
-				{
-					return f(unwrapper<T0>::apply_const(lhs.template get_unchecked<T0>()),
-						unwrapper<T1>::apply_const(rhs.template get_unchecked<T1>()));
-				}
-
-				VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
-				{
-					return f(unwrapper<T0>::apply(lhs.template get_unchecked<T0>()),
-						unwrapper<T1>::apply(rhs.template get_unchecked<T1>()));
-				}
-			};
-
-			template <typename F, typename V, typename R, typename T, typename... Types>
-			struct binary_dispatcher_lhs;
-
-			template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
-			struct binary_dispatcher_lhs<F, V, R, T0, T1, Types...>
-			{
-				VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
-				{
-					if (lhs.template is<T1>()) // call binary functor
-					{
-						return f(unwrapper<T1>::apply_const(lhs.template get_unchecked<T1>()),
-							unwrapper<T0>::apply_const(rhs.template get_unchecked<T0>()));
-					}
-					else
-					{
-						return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
-					}
-				}
-
-				VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
-				{
-					if (lhs.template is<T1>()) // call binary functor
-					{
-						return f(unwrapper<T1>::apply(lhs.template get_unchecked<T1>()),
-							unwrapper<T0>::apply(rhs.template get_unchecked<T0>()));
-					}
-					else
-					{
-						return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
-					}
-				}
-			};
-
-			template <typename F, typename V, typename R, typename T0, typename T1>
-			struct binary_dispatcher_lhs<F, V, R, T0, T1>
-			{
-				VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
-				{
-					return f(unwrapper<T1>::apply_const(lhs.template get_unchecked<T1>()),
-						unwrapper<T0>::apply_const(rhs.template get_unchecked<T0>()));
-				}
-
-				VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
-				{
-					return f(unwrapper<T1>::apply(lhs.template get_unchecked<T1>()),
-						unwrapper<T0>::apply(rhs.template get_unchecked<T0>()));
-				}
-			};
-
-			template <typename F, typename V, typename R, typename... Types>
-			struct binary_dispatcher;
-
-			template <typename F, typename V, typename R, typename T, typename... Types>
-			struct binary_dispatcher<F, V, R, T, Types...>
-			{
-				VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
-				{
-					if (v0.template is<T>())
-					{
-						if (v1.template is<T>())
-						{
-							return f(unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
-								unwrapper<T>::apply_const(v1.template get_unchecked<T>())); // call binary functor
-						}
-						else
-						{
-							return binary_dispatcher_rhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
-						}
-					}
-					else if (v1.template is<T>())
-					{
-						return binary_dispatcher_lhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
-					}
-					return binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
-				}
-
-				VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
-				{
-					if (v0.template is<T>())
-					{
-						if (v1.template is<T>())
-						{
-							return f(unwrapper<T>::apply(v0.template get_unchecked<T>()),
-								unwrapper<T>::apply(v1.template get_unchecked<T>())); // call binary functor
-						}
-						else
-						{
-							return binary_dispatcher_rhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
-						}
-					}
-					else if (v1.template is<T>())
-					{
-						return binary_dispatcher_lhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
-					}
-					return binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
-				}
-			};
-
-			template <typename F, typename V, typename R, typename T>
-			struct binary_dispatcher<F, V, R, T>
-			{
-				VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
-				{
-					return f(unwrapper<T>::apply_const(v0.template get_unchecked<T>()),
-						unwrapper<T>::apply_const(v1.template get_unchecked<T>())); // call binary functor
-				}
-
-				VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
-				{
-					return f(unwrapper<T>::apply(v0.template get_unchecked<T>()),
-						unwrapper<T>::apply(v1.template get_unchecked<T>())); // call binary functor
-				}
-			};
-
-			// comparator functors
-			struct equal_comp
-			{
-				template <typename T>
-				bool operator()(T const& lhs, T const& rhs) const
-				{
-					return lhs == rhs;
-				}
-			};
-
-			struct less_comp
-			{
-				template <typename T>
-				bool operator()(T const& lhs, T const& rhs) const
-				{
-					return lhs < rhs;
-				}
-			};
-
-			template <typename Variant, typename Comp>
-			class comparer
-			{
-			public:
-				explicit comparer(Variant const& lhs) noexcept
-					: lhs_(lhs) {}
-				comparer& operator=(comparer const&) = delete;
-				// visitor
-				template <typename T>
-				bool operator()(T const& rhs_content) const
-				{
-					T const& lhs_content = lhs_.template get_unchecked<T>();
-					return Comp()(lhs_content, rhs_content);
-				}
-
-			private:
-				Variant const& lhs_;
-			};
-
-		} // namespace detail
-
-		struct no_init
-		{
-		};
-
-		template <typename... Types>
-		class variant
-		{
-			static_assert(sizeof...(Types) > 0, "Template parameter type list of variant can not be empty");
-			static_assert(!detail::disjunction<std::is_reference<Types>...>::value, "Variant can not hold reference types. Maybe use std::reference_wrapper?");
-
-		private:
-			static const std::size_t data_size = detail::static_max<sizeof(Types)...>::value;
-			static const std::size_t data_align = detail::static_max<alignof(Types)...>::value;
-
-			using first_type = typename std::tuple_element<0, std::tuple<Types...>>::type;
-			using data_type = typename std::aligned_storage<data_size, data_align>::type;
-			using helper_type = detail::variant_helper<Types...>;
-
-			std::size_t type_index;
-			data_type data;
-
-		public:
-			VARIANT_INLINE variant() noexcept(std::is_nothrow_default_constructible<first_type>::value)
-				: type_index(sizeof...(Types)-1)
-			{
-				static_assert(std::is_default_constructible<first_type>::value, "First type in variant must be default constructible to allow default construction of variant");
-				new (&data) first_type();
-			}
-
-			VARIANT_INLINE variant(no_init) noexcept
-				: type_index(detail::invalid_value) {}
-
-			// http://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers
-			template <typename T, typename Traits = detail::value_traits<T, Types...>,
-				typename Enable = typename std::enable_if<Traits::is_valid>::type>
-				VARIANT_INLINE variant(T&& val) noexcept(std::is_nothrow_constructible<typename Traits::target_type, T&&>::value)
-				: type_index(Traits::index)
-			{
-				new (&data) typename Traits::target_type(std::forward<T>(val));
-			}
-
-			VARIANT_INLINE variant(variant<Types...> const& old)
-				: type_index(old.type_index)
-			{
-				helper_type::copy(old.type_index, &old.data, &data);
-			}
-
-			VARIANT_INLINE variant(variant<Types...>&& old) noexcept(std::is_nothrow_move_constructible<std::tuple<Types...>>::value)
-				: type_index(old.type_index)
-			{
-				helper_type::move(old.type_index, &old.data, &data);
-			}
-
-		private:
-			VARIANT_INLINE void copy_assign(variant<Types...> const& rhs)
-			{
-				helper_type::destroy(type_index, &data);
-				type_index = detail::invalid_value;
-				helper_type::copy(rhs.type_index, &rhs.data, &data);
-				type_index = rhs.type_index;
-			}
-
-			VARIANT_INLINE void move_assign(variant<Types...>&& rhs)
-			{
-				helper_type::destroy(type_index, &data);
-				type_index = detail::invalid_value;
-				helper_type::move(rhs.type_index, &rhs.data, &data);
-				type_index = rhs.type_index;
-			}
-
-		public:
-			VARIANT_INLINE variant<Types...>& operator=(variant<Types...>&& other)
-			{
-				move_assign(std::move(other));
-				return *this;
-			}
-
-			VARIANT_INLINE variant<Types...>& operator=(variant<Types...> const& other)
-			{
-				copy_assign(other);
-				return *this;
-			}
-
-			// conversions
-			// move-assign
-			template <typename T>
-			VARIANT_INLINE variant<Types...>& operator=(T&& rhs) noexcept
-			{
-				variant<Types...> temp(std::forward<T>(rhs));
-				move_assign(std::move(temp));
-				return *this;
-			}
-
-			// copy-assign
-			template <typename T>
-			VARIANT_INLINE variant<Types...>& operator=(T const& rhs)
-			{
-				variant<Types...> temp(rhs);
-				copy_assign(temp);
-				return *this;
-			}
-
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE bool is() const
-			{
-				return type_index == detail::direct_type<T, Types...>::index;
-			}
-
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE bool is() const
-			{
-				return type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index;
-			}
-
-			VARIANT_INLINE bool valid() const
-			{
-				return type_index != detail::invalid_value;
-			}
-
-			template <typename T, typename... Args>
-			VARIANT_INLINE void set(Args&&... args)
-			{
-				helper_type::destroy(type_index, &data);
-				type_index = detail::invalid_value;
-				new (&data) T(std::forward<Args>(args)...);
-				type_index = detail::direct_type<T, Types...>::index;
-			}
-
-			// get_unchecked<T>()
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T& get_unchecked()
-			{
-				return *reinterpret_cast<T*>(&data);
-			}
-
-#ifdef HAS_EXCEPTIONS
-			// get<T>()
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T& get()
-			{
-				if (type_index == detail::direct_type<T, Types...>::index)
-				{
-					return *reinterpret_cast<T*>(&data);
-				}
-				else
-				{
-					throw bad_variant_access("in get<T>()");
-				}
-			}
-#endif
-
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T const& get_unchecked() const
-			{
-				return *reinterpret_cast<T const*>(&data);
-			}
-
-#ifdef HAS_EXCEPTIONS
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T const& get() const
-			{
-				if (type_index == detail::direct_type<T, Types...>::index)
-				{
-					return *reinterpret_cast<T const*>(&data);
-				}
-				else
-				{
-					throw bad_variant_access("in get<T>()");
-				}
-			}
-#endif
-
-			// get_unchecked<T>() - T stored as recursive_wrapper<T>
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T& get_unchecked()
-			{
-				return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
-			}
-
-#ifdef HAS_EXCEPTIONS
-			// get<T>() - T stored as recursive_wrapper<T>
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T& get()
-			{
-				if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
-				{
-					return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
-				}
-				else
-				{
-					throw bad_variant_access("in get<T>()");
-				}
-			}
-#endif
-
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T const& get_unchecked() const
-			{
-				return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
-			}
-
-#ifdef HAS_EXCEPTIONS
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T const& get() const
-			{
-				if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
-				{
-					return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
-				}
-				else
-				{
-					throw bad_variant_access("in get<T>()");
-				}
-			}
-#endif
-
-			// get_unchecked<T>() - T stored as std::reference_wrapper<T>
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T& get_unchecked()
-			{
-				return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
-			}
-
-#ifdef HAS_EXCEPTIONS
-			// get<T>() - T stored as std::reference_wrapper<T>
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T& get()
-			{
-				if (type_index == detail::direct_type<std::reference_wrapper<T>, Types...>::index)
-				{
-					return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
-				}
-				else
-				{
-					throw bad_variant_access("in get<T>()");
-				}
-			}
-#endif
-
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T const& get_unchecked() const
-			{
-				return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
-			}
-
-#ifdef HAS_EXCEPTIONS
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE T const& get() const
-			{
-				if (type_index == detail::direct_type<std::reference_wrapper<T const>, Types...>::index)
-				{
-					return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
-				}
-				else
-				{
-					throw bad_variant_access("in get<T>()");
-				}
-			}
-#endif
-
-			// This function is deprecated because it returns an internal index field.
-			// Use which() instead.
-			MAPBOX_VARIANT_DEPRECATED VARIANT_INLINE std::size_t get_type_index() const
-			{
-				return type_index;
-			}
-
-			VARIANT_INLINE int which() const noexcept
-			{
-				return static_cast<int>(sizeof...(Types)-type_index - 1);
-			}
-
-			template <typename T, typename std::enable_if<
-				(detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
-				VARIANT_INLINE static constexpr int which() noexcept
-			{
-				return static_cast<int>(sizeof...(Types)-detail::direct_type<T, Types...>::index - 1);
-			}
-
-			// visitor
-			// unary
-			template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
-			auto VARIANT_INLINE static visit(V const& v, F&& f)
-				-> decltype(detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f)))
-			{
-				return detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
-			}
-			// non-const
-			template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
-			auto VARIANT_INLINE static visit(V& v, F&& f)
-				-> decltype(detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f)))
-			{
-				return detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
-			}
-
-			// binary
-			// const
-			template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
-			auto VARIANT_INLINE static binary_visit(V const& v0, V const& v1, F&& f)
-				-> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f)))
-			{
-				return detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
-			}
-			// non-const
-			template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
-			auto VARIANT_INLINE static binary_visit(V& v0, V& v1, F&& f)
-				-> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f)))
-			{
-				return detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
-			}
-
-			// match
-			// unary
-			template <typename... Fs>
-			auto VARIANT_INLINE match(Fs&&... fs) const
-			-> decltype(variant::visit(*this, ::std::make_visitor(std::forward<Fs>(fs)...)))
-			{
-				return variant::visit(*this, ::std::make_visitor(std::forward<Fs>(fs)...));
-			}
-			// non-const
-			template <typename... Fs>
-			auto VARIANT_INLINE match(Fs&&... fs)
-			-> decltype(variant::visit(*this, ::std::make_visitor(std::forward<Fs>(fs)...)))
-			{
-				return variant::visit(*this, ::std::make_visitor(std::forward<Fs>(fs)...));
-			}
-
-			~variant() noexcept // no-throw destructor
-			{
-				helper_type::destroy(type_index, &data);
-			}
-
-			// comparison operators
-			// equality
-			VARIANT_INLINE bool operator==(variant const& rhs) const
-			{
-				assert(valid() && rhs.valid());
-				if (this->which() != rhs.which())
-				{
-					return false;
-				}
-				detail::comparer<variant, detail::equal_comp> visitor(*this);
-				return visit(rhs, visitor);
-			}
-
-			VARIANT_INLINE bool operator!=(variant const& rhs) const
-			{
-				return !(*this == rhs);
-			}
-
-			// less than
-			VARIANT_INLINE bool operator<(variant const& rhs) const
-			{
-				assert(valid() && rhs.valid());
-				if (this->which() != rhs.which())
-				{
-					return this->which() < rhs.which();
-				}
-				detail::comparer<variant, detail::less_comp> visitor(*this);
-				return visit(rhs, visitor);
-			}
-			VARIANT_INLINE bool operator>(variant const& rhs) const
-			{
-				return rhs < *this;
-			}
-			VARIANT_INLINE bool operator<=(variant const& rhs) const
-			{
-				return !(*this > rhs);
-			}
-			VARIANT_INLINE bool operator>=(variant const& rhs) const
-			{
-				return !(*this < rhs);
-			}
-		};
-
-		// unary visitor interface
-		// const
-		template <typename F, typename V>
-		auto VARIANT_INLINE apply_visitor(F&& f, V const& v) -> decltype(V::visit(v, std::forward<F>(f)))
-		{
-			return V::visit(v, std::forward<F>(f));
-		}
-
-		// non-const
-		template <typename F, typename V>
-		auto VARIANT_INLINE apply_visitor(F&& f, V& v) -> decltype(V::visit(v, std::forward<F>(f)))
-		{
-			return V::visit(v, std::forward<F>(f));
-		}
-
-		// binary visitor interface
-		// const
-		template <typename F, typename V>
-		auto VARIANT_INLINE apply_visitor(F&& f, V const& v0, V const& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
-		{
-			return V::binary_visit(v0, v1, std::forward<F>(f));
-		}
-
-		// non-const
-		template <typename F, typename V>
-		auto VARIANT_INLINE apply_visitor(F&& f, V& v0, V& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
-		{
-			return V::binary_visit(v0, v1, std::forward<F>(f));
-		}
-
-		// getter interface
-
-#ifdef HAS_EXCEPTIONS
-		template <typename ResultType, typename T>
-		auto get(T& var)->decltype(var.template get<ResultType>())
-		{
-			return var.template get<ResultType>();
-		}
-#endif
-
-		template <typename ResultType, typename T>
-		ResultType& get_unchecked(T& var)
-		{
-			return var.template get_unchecked<ResultType>();
-		}
-
-#ifdef HAS_EXCEPTIONS
-		template <typename ResultType, typename T>
-		auto get(T const& var)->decltype(var.template get<ResultType>())
-		{
-			return var.template get<ResultType>();
-		}
-#endif
-
-		template <typename ResultType, typename T>
-		ResultType const& get_unchecked(T const& var)
-		{
-			return var.template get_unchecked<ResultType>();
-		}
-	}
-//	} // namespace util
-//} // namespace mapbox
-
-#endif // MAPBOX_UTIL_VARIANT_HPP
@@ -1,45 +0,0 @@
-#ifndef MAPBOX_UTIL_VARIANT_VISITOR_HPP
-#define MAPBOX_UTIL_VARIANT_VISITOR_HPP
-
-#include <utility>
-
-//namespace mapbox {
-//namespace util {
-namespace std {
-
-template <typename... Fns>
-struct visitor;
-
-template <typename Fn>
-struct visitor<Fn> : Fn
-{
-    using Fn::operator();
-
-    template<typename T>
-    visitor(T&& fn) : Fn(std::forward<T>(fn)) {}
-};
-
-template <typename Fn, typename... Fns>
-struct visitor<Fn, Fns...> : Fn, visitor<Fns...>
-{
-    using Fn::operator();
-    using visitor<Fns...>::operator();
-
-    template<typename T, typename... Ts>
-    visitor(T&& fn, Ts&&... fns)
-        : Fn(std::forward<T>(fn))
-        , visitor<Fns...>(std::forward<Ts>(fns)...) {}
-};
-
-template <typename... Fns>
-visitor<typename std::decay<Fns>::type...> make_visitor(Fns&&... fns)
-{
-    return visitor<typename std::decay<Fns>::type...>
-        (std::forward<Fns>(fns)...);
-}
-
-}
-//} // namespace util
-//} // namespace mapbox
-
-#endif // MAPBOX_UTIL_VARIANT_VISITOR_HPP
@@ -1,8 +1,4 @@
-if(WIN32 AND NOT VULKAN_PREBUILT)
-set(BUILD_TESTS OFF CACHE BOOL "Build tests" FORCE)
-set(BUILD_DEMOS OFF CACHE BOOL "Build demos" FORCE)
-set(BUILD_LAYERS OFF CACHE BOOL "Build demos" FORCE)
-set(BUILD_VKJSON OFF CACHE BOOL "Build demos" FORCE)
-add_subdirectory( Vulkan-LoaderAndValidationLayers )
-add_subdirectory( glslang )
-endif()
+set(SKIP_GLSLANG_INSTALL ON CACHE BOOL "Skip installation" FORCE)
+set(ENABLE_GLSLANG_BINARIES OFF CACHE BOOL "Builds glslangValidator and spirv-remap" FORCE)
+set(ENABLE_HLSL OFF CACHE BOOL "Enables HLSL input support" FORCE)
+add_subdirectory(glslang)
@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.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>{58B40697-B15E-429E-B325-D52C28AEBCBF}</ProjectGuid>
-    <Keyword>MakeFileProj</Keyword>
-    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Makefile</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="Shared">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </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'">
-    <NMakeBuildCommandLine>start /W /B pre-build.bat
-cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Release /m</NMakeBuildCommandLine>
-    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Release /m</NMakeCleanCommandLine>
-    <NMakeReBuildCommandLine>start /W /B pre-build.bat
-cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Release /m
-    </NMakeReBuildCommandLine>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <NMakeBuildCommandLine>start /W /B pre-build.bat
-cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Debug /m</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>start /W /B pre-build.bat
-cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Debug /m</NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
-msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Debug /m</NMakeCleanCommandLine>
-  </PropertyGroup>
-  <ItemDefinitionGroup>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" />
@@ -1,13 +0,0 @@
-@ECHO OFF
-
-REM Setting up dummy git helper
-MKDIR ..\Vulkan-LoaderAndValidationLayers\external\glslang\External\spirv-tools
-SET header="@ECHO off"
-SET content="ECHO unused"
-ECHO %header:"=% > git.bat
-ECHO %content:"=% >> git.bat
-COPY /Y git.bat ..\Vulkan-LoaderAndValidationLayers\external\glslang\External\spirv-tools\git.bat
-
-REM Set up gitignore
-SET ignored="*"
-ECHO %ignored:"=% > ..\Vulkan-LoaderAndValidationLayers\external\glslang\External\spirv-tools\.gitignore
@@ -19,12 +19,12 @@
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>Makefile</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>Makefile</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
@@ -39,24 +39,24 @@
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
+    <NMakeBuildCommandLine>cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
 msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Release /m</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
+    <NMakeReBuildCommandLine>cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
 msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Release /m</NMakeReBuildCommandLine>
-    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
+    <NMakeCleanCommandLine>cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
 msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Release /m</NMakeCleanCommandLine>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <NMakeBuildCommandLine>
-      cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
+      cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
      msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Debug /m
    </NMakeBuildCommandLine>
    <NMakeReBuildCommandLine>
-      cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
+      cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
      msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Debug /m
    </NMakeReBuildCommandLine>
    <NMakeCleanCommandLine>
-      cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
+      cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ../glslang
      msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Debug /m
    </NMakeCleanCommandLine>
  </PropertyGroup>
--- a/Show More
+++ b/Show More