Test

Fix VS2017 compile by clienthax (PPUAnalyser.cpp).

.clang-format

@@ -11,11 +11,11 @@ BreakConstructorInitializersBeforeComma: true
 BreakBeforeBinaryOperators: false
 BreakBeforeTernaryOperators: false
 AlwaysBreakTemplateDeclarations: true
-AllowShortIfStatementsOnASingleLine: false
-AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: true
+AllowShortBlocksOnASingleLine: true
 AllowShortCaseLabelsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
+AllowShortLoopsOnASingleLine: true
 Cpp11BracedListStyle: true
 IndentCaseLabels: false
 SortIncludes: false
@@ -29,3 +29,5 @@ BinPackParameters: true
 AlwaysBreakAfterReturnType: None
 KeepEmptyLinesAtTheStartOfBlocks: true
 IndentWrappedFunctionNames: false
+
+#SpaceAfterTemplateKeyword: false

.editorconfig

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

.gitignore

@@ -31,6 +31,7 @@
 *.wav
 
 /build
+/bin
 /lib
 /tmp
 /ipch
@@ -40,15 +41,21 @@
 /Vulkan/Vulkan-build
 /Vulkan/glslang-build
 
-!/bin
-/bin/*
-
 # Themes
 !/bin/GuiConfigs/
 /bin/GuiConfigs/*.ini
-/bin/GuiConfigs/*.ini.*
-/bin/GuiConfigs/*.dat
-/bin/GuiConfigs/*.dat.*
+
+/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
 
 # Visual Studio Files
 .vs/*
@@ -58,13 +65,24 @@
 *.psess
 *.VC.*
 *.vcxproj.user
-enc_temp_folder/*
-CMakeSettings.json
+
+# 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/*
 
 # Ignore other system generated files
+bin/dev_hdd0/*.txt
 x64/*
 rpcs3/x64/*
-rpcs3/git-version.h
+rpcs3-tests/x64/*
 
 # cmake
 Makefile
@@ -82,18 +100,6 @@ rpcs3/rpcs3_*_cotire.cmake
 
 # Qt
 moc_*.cpp
-qrc_*.cpp
+qrc_resources.cpp
 rpcs3_automoc.cpp
 ui_*.h
-rpcs3/rpcs3_autogen/*
-
-# QtCreator
-CMakeLists.txt.user
-
-# CLion
-/.idea/*
-/cmake-build-*/
-
-# macOS
-.DS_Store
-

.gitmodules

@@ -1,50 +1,48 @@
 [submodule "rpcs3-ffmpeg"]
 	path = 3rdparty/ffmpeg
 	url = https://github.com/hrydgard/ppsspp-ffmpeg
-	ignore = dirty
 [submodule "asmjit"]
 	path = asmjit
 	url = https://github.com/kobalicek/asmjit
 	ignore = dirty
 [submodule "llvm"]
 	path = llvm
-	url = https://github.com/RPCS3/llvm
+	url = https://github.com/llvm-mirror/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/Zangetsu38/libpng
 	ignore = dirty
 [submodule "Vulkan/glslang"]
 	path = Vulkan/glslang
 	url = https://github.com/KhronosGroup/glslang.git
-	ignore = dirty
+[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
 [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
+	url = https://github.com/Zangetsu38/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
+[submodule "polly"]
+	path = polly
+	url = https://github.com/llvm-mirror/polly
+	branch = release_60

.travis.yml

@@ -1,37 +1,118 @@
 language: cpp
+sudo: required
+
+os:
+  - linux
+  #- osx
+
+# osx_image: xcode6.4
+
+compiler:
+  - clang
+  - gcc
+
+cache:
+  ccache: true
+  directories:
+    - $HOME/hombebrew_cache
+
 matrix:
-    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
-        
+  exclude:
+    - os: osx
+      compiler: gcc
+
 git:
   depth: false # Unshallow clone to obtain proper GIT_VERSION
   submodules: false
+
+env:
+    - QTVER=5.10.1
+  
+before_install:
+  - if [ "$TRAVIS_OS_NAME" = "linux" ] && [ "$CXX" = "g++" ]; then
+      export CXX="g++-5" CC="gcc-5" CXXFLAGS="-Wno-format-security";
+    fi;
+
+install:
+  # 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/${QTVER}/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;
+
+script:
+  - ninja
+    
+after_script:
+  - cd build
+  - # AppImage generation
+  - if [ -n "$UPLOAD_URL" ] && [ "$TRAVIS_BRANCH" = "master" ] && [ "$CC" = "clang" ] && [ "$TRAVIS_PULL_REQUEST" = false ]; then
+      source /opt/qt510/bin/qt510-env.sh ;
+      echo $LD_LIBRARY_PATH ;
+      export LD_LIBRARY_PATH=/opt/qt510/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/$QTVER/gcc_64/bin/:${PATH} ;
+      ./linuxdeployqt*.AppImage --appimage-extract ;
+      ./linuxdeployqt*.AppImage ./appdir/usr/share/applications/*.desktop -bundle-non-qt-libs ;
+      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 ;
+      COMM_TAG="$(git describe --tags $(git rev-list --tags --max-count=1))" ;
+      COMM_COUNT="$(git rev-list --count HEAD)" ;
+      curl "${UPLOAD_URL}${TRAVIS_COMMIT:0:8}&t=${COMM_TAG}&a=${COMM_COUNT}" --upload-file ./RPCS3*.AppImage;
+   fi;
+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.
+      - sourceline: 'ppa:beineri/opt-qt-5.10.1-trusty' # <<WARNING>>: This needs to be updated manually whenever the QT Version changes. Add QT PPA since the installer is quite bad.
+    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
+      # From the beineri PPA
+      - qt510-meta-minimal # <<WARNING>>: This needs to be updated manually whenever the QT Version changes.
+      - libudev-dev
+      - libevdev-dev
+      - libpulse-dev

.travis/build-linux.bash

@@ -1,35 +0,0 @@
-#!/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

.travis/build-mac.bash

@@ -1,26 +0,0 @@
-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

.travis/deploy-linux.bash

@@ -1,53 +0,0 @@
-#!/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

.travis/travis.env

@@ -1,9 +0,0 @@
-# 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

3rdparty/CMakeLists.txt

@@ -1,363 +0,0 @@
-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)

3rdparty/OpenAL/include/alext.h

@@ -97,31 +97,6 @@ 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
@@ -420,16 +395,6 @@ ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device);
 
 #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
@@ -494,21 +459,6 @@ AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index);
 #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

3rdparty/OpenAL/libs/Win64/OpenAL32.def

@@ -1,35 +1,72 @@
 EXPORTS
+    alAuxiliaryEffectSlotf
+    alAuxiliaryEffectSlotfv
+    alAuxiliaryEffectSloti
+    alAuxiliaryEffectSlotiv
     alBuffer3f
     alBuffer3i
     alBufferData
+    alBufferSamplesSOFT
+    alBufferSubDataSOFT
+    alBufferSubSamplesSOFT
     alBufferf
     alBufferfv
     alBufferi
     alBufferiv
+    alDeferUpdatesSOFT
+    alDeleteAuxiliaryEffectSlots
     alDeleteBuffers
+    alDeleteEffects
+    alDeleteFilters
     alDeleteSources
     alDisable
     alDistanceModel
     alDopplerFactor
     alDopplerVelocity
+    alEffectf
+    alEffectfv
+    alEffecti
+    alEffectiv
     alEnable
+    alFilterf
+    alFilterfv
+    alFilteri
+    alFilteriv
+    alGenAuxiliaryEffectSlots
     alGenBuffers
+    alGenEffects
+    alGenFilters
     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
     alGetInteger
+    alGetInteger64SOFT
+    alGetInteger64vSOFT
     alGetIntegerv
     alGetListener3f
     alGetListener3i
@@ -38,16 +75,27 @@ EXPORTS
     alGetListeneri
     alGetListeneriv
     alGetProcAddress
+    alGetSource3dSOFT
     alGetSource3f
     alGetSource3i
+    alGetSource3i64SOFT
+    alGetSourcedSOFT
+    alGetSourcedvSOFT
     alGetSourcef
     alGetSourcefv
     alGetSourcei
+    alGetSourcei64SOFT
+    alGetSourcei64vSOFT
     alGetSourceiv
     alGetString
+    alGetStringiSOFT
+    alIsAuxiliaryEffectSlot
     alIsBuffer
+    alIsBufferFormatSupportedSOFT
+    alIsEffect
     alIsEnabled
     alIsExtensionPresent
+    alIsFilter
     alIsSource
     alListener3f
     alListener3i
@@ -55,8 +103,11 @@ EXPORTS
     alListenerfv
     alListeneri
     alListeneriv
+    alProcessUpdatesSOFT
+    alSource3dSOFT
     alSource3f
     alSource3i
+    alSource3i64SOFT
     alSourcePause
     alSourcePausev
     alSourcePlay
@@ -67,9 +118,13 @@ EXPORTS
     alSourceStop
     alSourceStopv
     alSourceUnqueueBuffers
+    alSourcedSOFT
+    alSourcedvSOFT
     alSourcef
     alSourcefv
     alSourcei
+    alSourcei64SOFT
+    alSourcei64vSOFT
     alSourceiv
     alSpeedOfSound
     alcCaptureCloseDevice
@@ -80,17 +135,26 @@ EXPORTS
     alcCloseDevice
     alcCreateContext
     alcDestroyContext
+    alcDevicePauseSOFT
+    alcDeviceResumeSOFT
     alcGetContextsDevice
     alcGetCurrentContext
     alcGetEnumValue
     alcGetError
+    alcGetInteger64vSOFT
     alcGetIntegerv
     alcGetProcAddress
     alcGetString
+    alcGetStringiSOFT
     alcGetThreadContext
+    alcIsAmbisonicFormatSupportedSOFT
     alcIsExtensionPresent
+    alcIsRenderFormatSupportedSOFT
+    alcLoopbackOpenDeviceSOFT
     alcMakeContextCurrent
     alcOpenDevice
     alcProcessContext
+    alcRenderSamplesSOFT
+    alcResetDeviceSOFT
     alcSetThreadContext
     alcSuspendContext

3rdparty/discord-rpc/include/discord_register.h

@@ -1,26 +0,0 @@
-#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

3rdparty/discord-rpc/include/discord_rpc.h

@@ -1,87 +0,0 @@
-#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

3rdparty/libpng.vcxproj

@@ -1,142 +0,0 @@
-<?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>

3rdparty/llvm.cmake

@@ -1,65 +0,0 @@
-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()

3rdparty/pnglibconf.vcxproj

@@ -1,64 +0,0 @@
-<?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>

3rdparty/qt5.cmake

@@ -1,49 +0,0 @@
-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)

3rdparty/xxhash.vcxproj

@@ -1,59 +0,0 @@
-<?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>

3rdparty/zlib.vcxproj

@@ -1,106 +0,0 @@
-<?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>

CMakeLists.txt

@@ -1,41 +1,21 @@
-cmake_minimum_required(VERSION 3.8.2)
-
-project(rpcs3)
+cmake_minimum_required(VERSION 3.1)
 
 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)
+option(VULKAN_PREBUILT "" OFF)
 
 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()
@@ -46,23 +26,34 @@ if (CCACHE_FOUND)
 	set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
 endif()
 
-if(WIN32)
-	add_definitions(-DUNICODE)
-	add_definitions(-D_WIN32_WINNT=0x0602)
-endif()
+add_definitions(-DCMAKE_BUILD)
 
-if(APPLE)
-	include_directories(/opt/local/include)
-	link_directories(/opt/local/lib)
-endif()
+# 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)
 
-add_subdirectory(Vulkan EXCLUDE_FROM_ALL)
-add_subdirectory(asmjitsrc EXCLUDE_FROM_ALL)
-add_subdirectory(3rdparty)
+# Select the version of libpng to use, default is builtin
+if (NOT USE_SYSTEM_LIBPNG)
+	add_subdirectory( 3rdparty/libpng )
+endif()
 
 # 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(rpcs3)
+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()

README.md

@@ -4,26 +4,17 @@ 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 free and open-source PlayStation 3 emulator/debugger, written in C++ for Windows and Linux.
+The world's first open-source PlayStation 3 emulator/debugger written in C++ for Windows and Linux.
 
-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).
+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).
 
 [**Support Lead Developers Nekotekina and kd-11 on Patreon**](https://www.patreon.com/Nekotekina)
 
 
-## Contributing
+## Development
 
-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.
+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.
 
 
 ## Dependencies
@@ -31,66 +22,88 @@ You should also contact any of the developers in the forums or in the Discord se
 ### Windows
 * [Visual Studio 2017](https://www.visualstudio.com/en/downloads/)
 * [Visual C++ Redistributable Packages for Visual Studio 2017](https://go.microsoft.com/fwlink/?LinkId=746572)
-* [CMake 3.8.2+](https://www.cmake.org/download/) (add to PATH)
-* [Python 3.3+](https://www.python.org/downloads/) (add to PATH)
-* [Vulkan SDK](https://vulkan.lunarg.com/sdk/home) (See "Install the SDK" [here](https://vulkan.lunarg.com/doc/sdk/latest/windows/getting_started.html))
-* [Qt 5.10+](https://www.qt.io/download-open-source/) (Avoid 5.11.1, due to a bug)
-
-
-**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)**
+* [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.10+](https://www.qt.io/download-open-source/) (required; add QTDIR environment variable if you do not want to use the Visual Studio Qt Plugin: e.g. `<QtInstallFolder>\5.10.1\msvc2017_64\`)
+* [Visual Studio Qt Plugin](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.QtVisualStudioTools2015) (optional; see above)
 
 ### Linux
-* [Qt 5.10+](https://www.qt.io/download-open-source/) (Avoid 5.11.1, due to a bug)
-* GCC 7.3+ or Clang 5.0+
-* CMake 3.8.2+
-* Debian & Ubuntu: `sudo apt-get install cmake build-essential libasound2-dev libpulse-dev libopenal-dev libglew-dev zlib1g-dev libedit-dev libvulkan-dev libudev-dev git qt5-default libevdev-dev`
-* Arch: `sudo pacman -S glew openal cmake vulkan-validation-layers qt5-base qt5-declarative`
-* Fedora: `sudo dnf install alsa-lib-devel cmake glew glew-devel libatomic libevdev-devel libudev-devel openal-devel qt5-devel vulkan-devel`
+* [Qt 5.10+](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`
 * 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.**
 
-**If you have an 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`
 
 
-## Building
+## Building on Windows:
+To initialize the repository don't forget to execute `git submodule update --init` to pull the submodules.
 
-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).
+### Configuring Qt
 
-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*.
+*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 e.g `<QtInstallFolder>\5.10.1\msvc2017_64\` </br>
 
 
-`Build > Build Solution`
+Open `rpcs3.sln`
 
 
-### Linux
+*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.10.1\msvc2017_64`. </br>
+2) While selecting the rpcs3qt project, go to Qt5->Project Setting and select the version you added. 
 
-While still in the project root:
+### 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).
 
-1) `cd .. && mkdir rpcs3_build && cd rpcs3_build`
-2) `cmake ../rpcs3/ && make GitVersion && make`
-3) Run RPCS3 with `./bin/rpcs3`
+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).
 
 When using GDB, configure it to ignore SIGSEGV signal (`handle SIGSEGV nostop noprint`).
-If desired, use the various build options in [CMakeLists](https://github.com/RPCS3/rpcs3/blob/master/CMakeLists.txt).
+
+
+## CMake Build Options (Linux & Mac 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.
+
+- ```-DUSE_NATIVE_INSTRUCTIONS=ON/OFF``` (default = *ON*)  
+This builds rpcs3 with -march=native, which is useful for local builds, but not good for packages.
 
 ## 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.

Utilities/BEType.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "types.h"
-#include <cstring>
 
 // 128-bit vector type and also se_storage<> storage type
 union alignas(16) v128
@@ -308,7 +307,7 @@ struct offset32_array<v128::masked_array_t<T, N, M>>
 	template <typename Arg>
 	static inline u32 index32(const Arg& arg)
 	{
-		return u32{sizeof(T)} * (static_cast<u32>(arg) ^ static_cast<u32>(M));
+		return SIZE_32(T) * (static_cast<u32>(arg) ^ static_cast<u32>(M));
 	}
 };
 
@@ -335,10 +334,7 @@ inline v128 operator~(const v128& other)
 template <typename T, std::size_t Align, std::size_t Size>
 struct se_storage
 {
-	struct type
-	{
-		alignas(Align) std::byte data[Size];
-	};
+	using type = std::aligned_storage_t<Size, Align>;
 
 	// Unoptimized generic byteswap for unaligned data
 	static void reverse(u8* dst, const u8* src)
@@ -362,6 +358,16 @@ 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>
@@ -388,6 +394,11 @@ 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>
@@ -414,6 +425,11 @@ 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>
@@ -440,6 +456,11 @@ 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>
@@ -462,6 +483,11 @@ 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
@@ -524,41 +550,31 @@ 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(init(value))
+		: m_data(reinterpret_cast<const stype&>(value))
 	{
 	}
 
 	type value() const
 	{
-		type result;
-		std::memcpy(&result, &m_data, sizeof(result));
-		return result;
+		return storage::copy(reinterpret_cast<const type&>(m_data));
 	}
 
 	se_t& operator=(const se_t& value) = default;
 
 	se_t& operator=(type value)
 	{
-		std::memcpy(&m_data, &value, sizeof(m_data));
-		return *this;
+		return m_data = reinterpret_cast<const stype&>(value), *this;
 	}
 
 	using simple_type = simple_t<T>;
 
 	operator type() const
 	{
-		return value();
+		return storage::copy(reinterpret_cast<const type&>(m_data));
 	}
 };
 

Utilities/CPUStats.h

@@ -1,243 +0,0 @@
-#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
-	}
-};

Utilities/Config.cpp

@@ -7,6 +7,8 @@
 
 namespace cfg
 {
+	logs::channel cfg("CFG");
+
 	_base::_base(type _type)
 		: m_type(_type)
 	{
@@ -65,19 +67,19 @@ bool cfg::try_to_int64(s64* out, const std::string& value, s64 min, s64 max)
 	}
 	catch (const std::exception& e)
 	{
-		if (out) LOG_ERROR(GENERAL, "cfg::try_to_int('%s'): exception: %s", value, e.what());
+		if (out) cfg.error("cfg::try_to_int('%s'): exception: %s", value, e.what());
 		return false;
 	}
 
 	if (pos != value.size())
 	{
-		if (out) LOG_ERROR(GENERAL, "cfg::try_to_int('%s'): unexpected characters (pos=%zu)", value, pos);
+		if (out) cfg.error("cfg::try_to_int('%s'): unexpected characters (pos=%zu)", value, pos);
 		return false;
 	}
 
 	if (result < min || result > max)
 	{
-		if (out) LOG_ERROR(GENERAL, "cfg::try_to_int('%s'): out of bounds (%lld..%lld)", value, min, max);
+		if (out) cfg.error("cfg::try_to_int('%s'): out of bounds (%lld..%lld)", value, min, max);
 		return false;
 	}
 
@@ -117,13 +119,13 @@ bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) f
 
 		if (pos != value.size())
 		{
-			if (out) LOG_ERROR(GENERAL, "cfg::try_to_enum_value('%s'): unexpected characters (pos=%zu)", value, pos);
+			if (out) cfg.error("cfg::try_to_enum_value('%s'): unexpected characters (pos=%zu)", value, pos);
 			return false;
 		}
 
 		if (val > max)
 		{
-			if (out) LOG_ERROR(GENERAL, "cfg::try_to_enum_value('%s'): out of bounds(0..%u)", value, max);
+			if (out) cfg.error("cfg::try_to_enum_value('%s'): out of bounds(0..%u)", value, max);
 			return false;
 		}
 
@@ -132,7 +134,7 @@ bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) f
 	}
 	catch (const std::exception& e)
 	{
-		if (out) LOG_ERROR(GENERAL, "cfg::try_to_enum_value('%s'): invalid enum value: %s", value, e.what());
+		if (out) cfg.error("cfg::try_to_enum_value('%s'): invalid enum value: %s", value, e.what());
 		return false;
 	}
 }
@@ -298,7 +300,7 @@ bool cfg::node::from_string(const std::string& value) try
 }
 catch (const std::exception& e)
 {
-	LOG_FATAL(GENERAL, "%s thrown: %s", typeid(e).name(), e.what());
+	cfg.fatal("%s thrown: %s", typeid(e).name(), e.what());
 	return false;
 }
 

Utilities/Config.h

@@ -49,10 +49,9 @@ 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; }
 
@@ -133,11 +132,6 @@ namespace cfg
 			return m_value;
 		}
 
-		bool get() const
-		{
-			return m_value;
-		}
-
 		void from_default() override;
 
 		std::string to_string() const override
@@ -184,11 +178,6 @@ namespace cfg
 			return m_value;
 		}
 
-		T get() const
-		{
-			return m_value;
-		}
-
 		void from_default() override
 		{
 			m_value = def;
@@ -247,11 +236,6 @@ namespace cfg
 			return m_value;
 		}
 
-		int_type get() const
-		{
-			return m_value;
-		}
-
 		void from_default() override
 		{
 			m_value = def;

Utilities/File.cpp

@@ -9,7 +9,6 @@
 #include <cstring>
 #include <cerrno>
 #include <typeinfo>
-#include <map>
 
 using namespace std::literals::string_literals;
 
@@ -135,10 +134,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)
@@ -217,7 +216,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)
 {
-	std::lock_guard lock(m_mutex);
+	writer_lock lock(m_mutex);
 
 	return m_map[name] = device;
 }
@@ -284,7 +283,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 = info.mtime;
+	info.ctime = to_time(attrs.ftCreationTime);
 #else
 	struct ::stat file_info;
 	if (::stat(path.c_str(), &file_info) != 0)
@@ -298,12 +297,9 @@ 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 = info.mtime;
+	info.ctime = file_info.st_ctime;
 #endif
 
-	if (info.atime < info.mtime)
-		info.atime = info.mtime;
-
 	return true;
 }
 
@@ -499,30 +495,18 @@ bool fs::create_dir(const std::string& path)
 
 bool fs::create_path(const std::string& path)
 {
-	const std::string parent = get_parent_dir(path);
+	const auto& parent = get_parent_dir(path);
 
-	if (!parent.empty() && !create_path(parent))
+	if (!parent.empty() && !is_dir(parent) && !create_path(parent))
 	{
 		return false;
 	}
 
-	if (!create_dir(path) && g_tls_error != error::exist)
-	{
-		return false;
-	}
-
-	return true;
+	return create_dir(path);
 }
 
 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);
@@ -549,13 +533,6 @@ 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))
@@ -633,7 +610,7 @@ bool fs::copy_file(const std::string& from, const std::string& to, bool overwrit
 	}
 
 	return true;
-#elif defined(__APPLE__) || defined(__linux__) || defined(__sun)
+#else
 	/* 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);
@@ -657,13 +634,17 @@ 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
-#error "Native file copy implementation is missing"
+#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)
 #endif
 	{
 		const int err = errno;
@@ -676,31 +657,6 @@ 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
 }
@@ -824,13 +780,6 @@ 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))
@@ -844,34 +793,29 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 
 #ifdef _WIN32
 	DWORD access = 0;
-	if (mode & fs::read) access |= GENERIC_READ;
-	if (mode & fs::write) access |= DELETE | (mode & fs::append ? FILE_APPEND_DATA : GENERIC_WRITE);
+	if (test(mode & fs::read)) access |= GENERIC_READ;
+	if (test(mode & fs::write)) access |= test(mode & fs::append) ? FILE_APPEND_DATA : GENERIC_WRITE;
 
 	DWORD disp = 0;
-	if (mode & fs::create)
+	if (test(mode & fs::create))
 	{
 		disp =
-			mode & fs::excl ? CREATE_NEW :
-			mode & fs::trunc ? CREATE_ALWAYS : OPEN_ALWAYS;
+			test(mode & fs::excl) ? CREATE_NEW :
+			test(mode & fs::trunc) ? CREATE_ALWAYS : OPEN_ALWAYS;
 	}
 	else
 	{
-		if (mode & fs::excl)
+		if (test(mode & fs::excl))
 		{
 			g_tls_error = error::inval;
 			return;
 		}
 
-		disp = mode & fs::trunc ? TRUNCATE_EXISTING : OPEN_EXISTING;
+		disp = test(mode & fs::trunc) ? TRUNCATE_EXISTING : OPEN_EXISTING;
 	}
 
-	DWORD share = 0;
-	if (!(mode & fs::unread) || !(mode & fs::write))
-	{
-		share |= FILE_SHARE_READ;
-	}
-
-	if (!(mode & (fs::lock + fs::unread)) || !(mode & fs::write))
+	DWORD share = FILE_SHARE_READ;
+	if (!test(mode & fs::unshare))
 	{
 		share |= FILE_SHARE_WRITE | FILE_SHARE_DELETE;
 	}
@@ -910,10 +854,7 @@ 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 = info.mtime;
-
-			if (info.atime < info.mtime)
-				info.atime = info.mtime;
+			info.ctime = to_time(basic_info.CreationTime);
 
 			return info;
 		}
@@ -997,23 +938,16 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 #else
 	int flags = 0;
 
-	if (mode & fs::read && mode & fs::write) flags |= O_RDWR;
-	else if (mode & fs::read) flags |= O_RDONLY;
-	else if (mode & fs::write) flags |= O_WRONLY;
+	if (test(mode & fs::read) && test(mode & fs::write)) flags |= O_RDWR;
+	else if (test(mode & fs::read)) flags |= O_RDONLY;
+	else if (test(mode & fs::write)) flags |= O_WRONLY;
 
-	if (mode & fs::append) flags |= O_APPEND;
-	if (mode & fs::create) flags |= O_CREAT;
-	if (mode & fs::trunc && !(mode & (fs::lock + fs::unread))) flags |= O_TRUNC;
-	if (mode & fs::excl) flags |= O_EXCL;
+	if (test(mode & fs::append)) flags |= O_APPEND;
+	if (test(mode & fs::create)) flags |= O_CREAT;
+	if (test(mode & fs::trunc)) flags |= O_TRUNC;
+	if (test(mode & fs::excl)) flags |= O_EXCL;
 
-	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);
+	const int fd = ::open(path.c_str(), flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 
 	if (fd == -1)
 	{
@@ -1021,19 +955,13 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 		return;
 	}
 
-	if (mode & fs::write && mode & (fs::lock + fs::unread) && ::flock(fd, LOCK_EX | LOCK_NB) != 0)
+	if (test(mode & fs::unshare) && ::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;
@@ -1060,10 +988,7 @@ 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 = info.mtime;
-
-			if (info.atime < info.mtime)
-				info.atime = info.mtime;
+			info.ctime = file_info.st_ctime;
 
 			return info;
 		}
@@ -1227,13 +1152,6 @@ 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))
@@ -1270,10 +1188,7 @@ 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 = info.mtime;
-
-			if (info.atime < info.mtime)
-				info.atime = info.mtime;
+			info.ctime = to_time(found.ftCreationTime);
 
 			m_entries.emplace_back(std::move(info));
 		}
@@ -1356,10 +1271,7 @@ 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 = info.mtime;
-
-			if (info.atime < info.mtime)
-				info.atime = info.mtime;
+			info.ctime = file_info.st_ctime;
 
 			return true;
 		}
@@ -1384,9 +1296,8 @@ const std::string& fs::get_config_dir()
 		std::string dir;
 
 #ifdef _WIN32
-		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)
+		wchar_t buf[2048];
+		if (GetModuleFileName(NULL, buf, ::size32(buf)) - 1 >= ::size32(buf) - 1)
 		{
 			MessageBoxA(0, fmt::format("GetModuleFileName() failed: error %u.", GetLastError()).c_str(), "fs::get_config_dir()", MB_ICONERROR);
 			return dir; // empty
@@ -1398,22 +1309,16 @@ const std::string& fs::get_config_dir()
 
 		dir.resize(dir.rfind('/') + 1);
 #else
-
-#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;
+		if (const char* home = ::getenv("XDG_CONFIG_HOME"))
+			dir = home;
 		else if (const char* home = ::getenv("HOME"))
 			dir = home + "/.config"s;
-#endif
 		else // Just in case
 			dir = "./config";
 
 		dir += "/rpcs3/";
 
-		if (!create_path(dir))
+		if (!is_dir(dir) && !create_path(dir))
 		{
 			std::printf("Failed to create configuration directory '%s' (%d).\n", dir.c_str(), errno);
 		}
@@ -1425,42 +1330,76 @@ const std::string& fs::get_config_dir()
 	return s_dir;
 }
 
-const std::string& fs::get_cache_dir()
+std::string fs::get_data_dir(const std::string& prefix, const std::string& location, const std::string& suffix)
 {
 	static const std::string s_dir = []
 	{
-		std::string dir;
+		const std::string& dir = get_config_dir() + "data/";
 
-#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))
+		if (!is_dir(dir) && !create_path(dir))
 		{
-			std::printf("Failed to create configuration directory '%s' (%d).\n", dir.c_str(), errno);
+			return get_config_dir();
 		}
-#endif
 
 		return dir;
 	}();
 
-	return s_dir;
+	std::vector<u8> buf;
+	buf.reserve(location.size() + 1);
+
+	// Normalize location
+	for (char c : location)
+	{
+#ifdef _WIN32
+		if (c == '/' || c == '\\')
+#else
+		if (c == '/')
+#endif
+		{
+			if (buf.empty() || buf.back() != '/')
+			{
+				buf.push_back('/');
+			}
+
+			continue;
+		}
+
+		buf.push_back(c);
+	}
+
+	// Calculate hash
+	u8 hash[20];
+	sha1(buf.data(), buf.size(), hash);
+
+	// Concatenate
+	std::string&& result = fmt::format("%s%s/%016llx%08x-%s/", s_dir, prefix, reinterpret_cast<be_t<u64>&>(hash[0]), reinterpret_cast<be_t<u32>&>(hash[8]), suffix);
+
+	if (!is_dir(result))
+	{
+		// Create dir if necessary
+		if (create_path(result))
+		{
+			// Acknowledge original location
+			file(result + ".location", rewrite).write(buf);
+		}
+	}
+
+	return result;
+}
+
+std::string fs::get_data_dir(const std::string& prefix, const std::string& path)
+{
+#ifdef _WIN32
+	const auto& delim = "/\\";
+#else
+	const auto& delim = "/";
+#endif
+
+	// Extract file name and location
+	const std::string& location = fs::get_parent_dir(path);
+	const std::size_t name_pos = path.find_first_not_of(delim, location.size());
+
+	return fs::get_data_dir(prefix, location, name_pos == -1 ? std::string{} : path.substr(name_pos));
 }
 
 void fs::remove_all(const std::string& path, bool remove_root)
@@ -1514,122 +1453,6 @@ 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)
 {

Utilities/File.h

@@ -25,8 +25,7 @@ namespace fs
 		create,
 		trunc,
 		excl,
-		lock,
-		unread,
+		unshare,
 
 		__bitset_enum_max
 	};
@@ -37,8 +36,7 @@ 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 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 unshare = +open_mode::unshare; // Prevent opening the file twice
 
 	constexpr auto rewrite = open_mode::write + open_mode::create + open_mode::trunc;
 
@@ -187,7 +185,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);
@@ -402,7 +400,7 @@ namespace fs
 		{
 			m_dir = std::move(ptr);
 		}
-
+		
 		std::unique_ptr<dir_base> release()
 		{
 			return std::move(m_dir);
@@ -484,8 +482,11 @@ namespace fs
 	// Get configuration directory
 	const std::string& get_config_dir();
 
-	// Get common cache directory
-	const std::string& get_cache_dir();
+	// Get data/cache directory for specified prefix and suffix
+	std::string get_data_dir(const std::string& prefix, const std::string& location, const std::string& suffix);
+
+	// Get data/cache directory for specified prefix and path (suffix will be filename)
+	std::string get_data_dir(const std::string& prefix, const std::string& path);
 
 	// Delete directory and all its contents recursively
 	void remove_all(const std::string& path, bool remove_root = true);
@@ -616,12 +617,10 @@ namespace fs
 		if (fs::file f{path, mode})
 		{
 			// Write args sequentially
-			(f.write(args), ...);
+			int seq[]{ (f.write(args), 0)... };
 			return true;
 		}
 
 		return false;
 	}
-
-	file make_gather(std::vector<file>);
 }

Utilities/GDBDebugServer.cpp

@@ -4,7 +4,7 @@
 #include "GDBDebugServer.h"
 #include "Log.h"
 #include <algorithm>
-#include "Emu/Memory/vm.h"
+#include "Emu/Memory/Memory.h"
 #include "Emu/System.h"
 #include "Emu/IdManager.h"
 #include "Emu/CPU/CPUThread.h"
@@ -19,7 +19,7 @@
 extern void ppu_set_breakpoint(u32 addr);
 extern void ppu_remove_breakpoint(u32 addr);
 
-LOG_CHANNEL(gdbDebugServer);
+logs::channel gdbDebugServer("gdbDebugServer");
 
 int sock_init(void)
 {
@@ -338,7 +338,6 @@ bool GDBDebugServer::select_thread(u64 id)
 		selected_thread = ppu.ptr;
 		return true;
 	}
-	gdbDebugServer.warning("Unable to select thread! Is the emulator running?");
 	return false;
 }
 
@@ -541,7 +540,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, 1, vm::page_allocated | vm::page_readable)) {
+		if (vm::check_addr(addr, 1, vm::page_info_t::page_readable)) {
 			result += to_hexbyte(vm::read8(addr + i));
 		} else {
 			break;
@@ -567,7 +566,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, 1, vm::page_allocated | vm::page_writable)) {
+		if (vm::check_addr(addr + i, 1, vm::page_info_t::page_writable)) {
 			u8 val;
 			int res = sscanf_s(data_ptr, "%02hhX", &val);
 			if (!res) {
@@ -829,7 +828,7 @@ void GDBDebugServer::on_stop()
 	this->stop = true;
 	//just in case we are waiting for breakpoint
 	this->notify();
-	old_thread::on_stop();
+	named_thread::on_stop();
 }
 
 void GDBDebugServer::pause_from(cpu_thread* t) {

Utilities/GDBDebugServer.h

@@ -40,8 +40,8 @@ public:
 const u64 ALL_THREADS = 0xffffffffffffffff;
 const u64 ANY_THREAD = 0;
 
-class GDBDebugServer
-{
+class GDBDebugServer : public named_thread {
+
 	socket_t server_socket;
 	socket_t client_socket;
 	std::weak_ptr<cpu_thread> selected_thread;
@@ -60,8 +60,8 @@ class GDBDebugServer
 	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
@@ -112,16 +112,29 @@ class GDBDebugServer
 	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:
 	bool from_breakpoint = true;
 	bool stop = false;
 	bool paused = false;
 	u64 pausedBy;
 
-	void operator()();
+	virtual std::string get_name() const;
+	virtual void on_stop() override final;
 	void pause_from(cpu_thread* t);
 };
 
 extern u32 g_gdb_debugger_id;
 
+template <>
+struct id_manager::on_stop<GDBDebugServer> {
+	static inline void func(GDBDebugServer* ptr)
+	{
+		if (ptr) ptr->on_stop();
+	}
+};
+
 #endif

Utilities/GSL.h

@@ -4,7 +4,7 @@
 
 #pragma push_macro("new")
 #undef new
-#include <gsl/gsl>
+#include <gsl.h>
 #pragma pop_macro("new")
 #undef Expects
 #undef Ensures

Utilities/JIT.cpp

@@ -1,214 +1,3 @@
-#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>
@@ -218,6 +7,14 @@ void asmjit::build_transaction_abort(asmjit::X86Assembler& c, unsigned char code
 #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
@@ -237,6 +34,8 @@ void asmjit::build_transaction_abort(asmjit::X86Assembler& c, unsigned char code
 #include <sys/mman.h>
 #endif
 
+#include "JIT.h"
+
 // Memory manager mutex
 shared_mutex s_mutex;
 
@@ -273,7 +72,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::pair<u8*, std::size_t>> s_unfire;
+static std::deque<std::tuple<u8*, u64, std::size_t>> s_unfire;
 #endif
 
 // Reset memory manager
@@ -290,9 +89,27 @@ 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)
 	{
-		llvm::RTDyldMemoryManager::deregisterEHFramesInProcess(t.first, t.second);
+		mem.deregisterEHFrames(std::get<0>(t), std::get<1>(t), std::get<2>(t));
 	}
 
 	s_unfire.clear();
@@ -346,7 +163,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
-			std::lock_guard lock(s_mutex);
+			writer_lock lock(s_mutex);
 
 			// Allocate memory for trampolines
 			if (!m_tramps)
@@ -382,7 +199,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 	u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
 	{
 		// Lock memory manager
-		std::lock_guard lock(s_mutex);
+		writer_lock lock(s_mutex);
 
 		// Simple allocation
 		const u64 next = ::align((u64)s_next + size, 4096);
@@ -403,7 +220,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
-		std::lock_guard lock(s_mutex);
+		writer_lock lock(s_mutex);
 
 		// Simple allocation
 		const u64 next = ::align((u64)s_next + size, 4096);
@@ -416,6 +233,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 
 		if (!is_ro)
 		{
+			LOG_ERROR(GENERAL, "LLVM: Writeable data section not supported!");
 		}
 
 		utils::memory_commit(s_next, size);
@@ -427,7 +245,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 	bool finalizeMemory(std::string* = nullptr) override
 	{
 		// Lock memory manager
-		std::lock_guard lock(s_mutex);
+		writer_lock lock(s_mutex);
 
 		// TODO: make only read-only sections read-only
 //#ifdef _WIN32
@@ -445,7 +263,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 	{
 #ifdef _WIN32
 		// Lock memory manager
-		std::lock_guard lock(s_mutex);
+		writer_lock lock(s_mutex);
 
 		// Use s_memory as a BASE, compute the difference
 		const u64 unwind_diff = (u64)addr - (u64)s_memory;
@@ -469,42 +287,17 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 			s_unwind.emplace_back(std::move(pdata));
 		}
 #else
-		s_unfire.push_front(std::make_pair(addr, size));
+		s_unfire.push_front(std::make_tuple(addr, load_addr, size));
 #endif
 
 		return RTDyldMemoryManager::registerEHFrames(addr, load_addr, size);
 	}
 
-	void deregisterEHFrames() override
+	virtual 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
 {
@@ -543,7 +336,7 @@ struct EventListener : llvm::JITEventListener
 				}
 
 				// Lock memory manager
-				std::lock_guard lock(s_mutex);
+				writer_lock 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;
@@ -580,15 +373,15 @@ public:
 		std::string name = m_path;
 		name.append(module->getName());
 		fs::file(name, fs::rewrite).write(obj.getBufferStart(), obj.getBufferSize());
-		LOG_NOTICE(GENERAL, "LLVM: Created module: %s", module->getName().data());
+		LOG_SUCCESS(GENERAL, "LLVM: Created module: %s", module->getName().data());
 	}
 
-	static std::unique_ptr<llvm::MemoryBuffer> load(const std::string& path)
+	static std::unique_ptr<llvm::WritableMemoryBuffer> load(const std::string& path)
 	{
 		if (fs::file cached{path, fs::read})
 		{
 			auto buf = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(cached.size());
-			cached.read(buf->getBufferStart(), buf->getBufferSize());
+			cached.read(const_cast<char*>(buf->getBufferStart()), buf->getBufferSize());
 			return buf;
 		}
 
@@ -602,7 +395,7 @@ public:
 
 		if (auto buf = load(path))
 		{
-			LOG_NOTICE(GENERAL, "LLVM: Loaded module: %s", module->getName().data());
+			LOG_SUCCESS(GENERAL, "LLVM: Loaded module: %s", module->getName().data());
 			return buf;
 		}
 
@@ -610,10 +403,10 @@ public:
 	}
 };
 
-std::string jit_compiler::cpu(const std::string& _cpu)
+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 m_cpu = _cpu;
-
 	if (m_cpu.empty())
 	{
 		m_cpu = llvm::sys::getHostCPUName();
@@ -624,35 +417,15 @@ std::string jit_compiler::cpu(const std::string& _cpu)
 			m_cpu == "broadwell" ||
 			m_cpu == "skylake" ||
 			m_cpu == "skylake-avx512" ||
-			m_cpu == "cannonlake" ||
-			m_cpu == "icelake")
+			m_cpu == "cannonlake")
 		{
-			// 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())
@@ -660,10 +433,8 @@ jit_compiler::jit_compiler(const std::unordered_map<std::string, u64>& _link, co
 		// Auxiliary JIT (does not use custom memory manager, only writes the objects)
 		m_engine.reset(llvm::EngineBuilder(std::make_unique<llvm::Module>("null_", m_context))
 			.setErrorStr(&result)
-			.setEngineKind(llvm::EngineKind::JIT)
-			.setMCJITMemoryManager(std::make_unique<MemoryManager2>())
 			.setOptLevel(llvm::CodeGenOpt::Aggressive)
-			.setCodeModel(large ? llvm::CodeModel::Large : llvm::CodeModel::Small)
+			.setCodeModel(llvm::CodeModel::Small)
 			.setMCPU(m_cpu)
 			.create());
 	}
@@ -675,10 +446,9 @@ jit_compiler::jit_compiler(const std::unordered_map<std::string, u64>& _link, co
 
 		m_engine.reset(llvm::EngineBuilder(std::make_unique<llvm::Module>("null", m_context))
 			.setErrorStr(&result)
-			.setEngineKind(llvm::EngineKind::JIT)
 			.setMCJITMemoryManager(std::move(mem))
 			.setOptLevel(llvm::CodeGenOpt::Aggressive)
-			.setCodeModel(large ? llvm::CodeModel::Large : llvm::CodeModel::Small)
+			.setCodeModel(llvm::CodeModel::Small)
 			.setMCPU(m_cpu)
 			.create());
 
@@ -698,25 +468,6 @@ 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};
@@ -734,19 +485,6 @@ 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()));
@@ -762,4 +500,33 @@ 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

Utilities/JIT.h

@@ -1,97 +1,9 @@
 #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"
@@ -128,7 +40,7 @@ class jit_compiler final
 	std::string m_cpu;
 
 public:
-	jit_compiler(const std::unordered_map<std::string, u64>& _link, const std::string& _cpu, bool large = false);
+	jit_compiler(const std::unordered_map<std::string, u64>& _link, std::string _cpu);
 	~jit_compiler();
 
 	// Get LLVM context
@@ -137,20 +49,9 @@ 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);
 
@@ -160,8 +61,14 @@ 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
-	static std::string cpu(const std::string& _cpu);
+	const std::string& cpu() const
+	{
+		return m_cpu;
+	}
 
 	// Check JIT purpose
 	bool is_primary() const

Utilities/Log.cpp

@@ -6,13 +6,10 @@
 #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;
 
@@ -21,7 +18,6 @@ using namespace std::literals::chrono_literals;
 #include <Windows.h>
 #else
 #include <sys/mman.h>
-#include <sys/stat.h>
 #endif
 
 #include <zlib.h>
@@ -75,7 +71,7 @@ namespace logs
 #endif
 		uchar* m_fptr{};
 		z_stream m_zs{};
-		shared_mutex m_m;
+		semaphore<> 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
@@ -183,14 +179,14 @@ namespace logs
 	channel SPU("SPU");
 
 	// Channel registry mutex
-	shared_mutex g_mutex;
+	semaphore<> g_mutex;
 
 	// Must be set to true in main()
 	atomic_t<bool> g_init{false};
 
 	void reset()
 	{
-		std::lock_guard lock(g_mutex);
+		semaphore_lock lock(g_mutex);
 
 		for (auto&& pair : get_logger()->channels)
 		{
@@ -200,7 +196,7 @@ namespace logs
 
 	void set_level(const std::string& ch_name, level value)
 	{
-		std::lock_guard lock(g_mutex);
+		semaphore_lock lock(g_mutex);
 
 		get_logger()->channels[ch_name].set_level(value);
 	}
@@ -210,7 +206,7 @@ namespace logs
 	{
 		if (!g_init)
 		{
-			std::lock_guard lock(g_mutex);
+			semaphore_lock lock(g_mutex);
 			get_logger()->messages.clear();
 			g_init = true;
 		}
@@ -226,7 +222,7 @@ void logs::listener::add(logs::listener* _new)
 	// Get first (main) listener
 	listener* lis = get_logger();
 
-	std::lock_guard lock(g_mutex);
+	semaphore_lock 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))
@@ -241,7 +237,7 @@ void logs::listener::add(logs::listener* _new)
 	}
 }
 
-void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, ...) const
+void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u64* args)
 {
 	// Get timestamp
 	const u64 stamp = get_stamp();
@@ -249,7 +245,7 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, ...) co
 	// Register channel
 	if (ch->enabled == level::_uninit)
 	{
-		std::lock_guard lock(g_mutex);
+		semaphore_lock lock(g_mutex);
 
 		auto& info = get_logger()->channels[ch->name];
 
@@ -270,23 +266,9 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, ...) co
 		}
 	}
 
-	// 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());
+	// Get text
+	thread_local std::string text; text.clear();
+	fmt::raw_append(text, fmt, sup, args);
 	std::string prefix = g_tls_log_prefix();
 
 	// Get first (main) listener
@@ -294,7 +276,7 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, ...) co
 
 	if (!g_init)
 	{
-		std::lock_guard lock(g_mutex);
+		semaphore_lock lock(g_mutex);
 
 		if (!g_init)
 		{
@@ -322,12 +304,12 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, ...) co
 logs::file_writer::file_writer(const std::string& name)
 	: m_name(name)
 {
-	const std::string log_name = fs::get_cache_dir() + name + ".log";
-	const std::string buf_name = fs::get_cache_dir() + name + ".buf";
+	const std::string log_name = fs::get_config_dir() + name + ".log";
+	const std::string buf_name = fs::get_config_dir() + name + ".buf";
 
 	try
 	{
-		if (!m_file.open(buf_name, fs::read + fs::rewrite + fs::lock))
+		if (!m_file.open(buf_name, fs::read + fs::write + fs::create + fs::trunc + fs::unshare))
 		{
 			if (fs::g_tls_error == fs::error::acces)
 			{
@@ -352,7 +334,7 @@ logs::file_writer::file_writer(const std::string& name)
 
 		// Check free space
 		fs::device_stat stats{};
-		if (!fs::statfs(fs::get_cache_dir(), stats) || stats.avail_free < s_log_size * 8)
+		if (!fs::statfs(fs::get_config_dir(), stats) || stats.avail_free < s_log_size * 8)
 		{
 			fmt::throw_exception("Not enough free space (%f KB)", stats.avail_free / 1000000.);
 		}
@@ -372,25 +354,18 @@ logs::file_writer::file_writer(const std::string& name)
 		verify(name.c_str()), m_fptr;
 
 		// Rotate backups (TODO)
-		fs::remove_file(fs::get_cache_dir() + name + "1.log.gz");
-		fs::create_dir(fs::get_cache_dir() + "old_logs");
-		fs::rename(fs::get_cache_dir() + m_name + ".log.gz", fs::get_cache_dir() + "old_logs/" + m_name + ".log.gz", true);
+		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);
 
 		// Actual log file (allowed to fail)
 		m_fout.open(log_name, fs::rewrite);
 
-		// Compressed log, make it inaccessible (foolproof)
-		if (!m_fout2.open(log_name + ".gz", fs::rewrite + fs::unread) || deflateInit2(&m_zs, 9, Z_DEFLATED, 16 + 15, 9, Z_DEFAULT_STRATEGY) != Z_OK)
+		// 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)
 		{
 			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)
 	{
@@ -468,23 +443,16 @@ 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)
 {
-	std::lock_guard lock(m_m);
+	semaphore_lock lock(m_m);
 
 	const u64 st  = +m_out;
 	const u64 end = std::min<u64>((st + s_log_size) & ~(s_log_size - 1), bufv >> 24);
@@ -623,7 +591,7 @@ void logs::file_listener::log(u64 stamp, const logs::message& msg, const std::st
 	case level::_uninit: text = u8"·  "; break;
 	}
 
-	// Print µs timestamp
+	// Print miscosecond timestamp
 	const u64 hours = stamp / 3600'000'000;
 	const u64 mins = (stamp % 3600'000'000) / 60'000'000;
 	const u64 secs = (stamp % 60'000'000) / 1'000'000;

Utilities/Log.h

@@ -23,17 +23,14 @@ namespace logs
 
 	struct channel;
 
-	// Message information
+	// Message information (temporary data)
 	struct message
 	{
 		channel* ch;
 		level sev;
 
-	private:
 		// Send log message to global logger instance
-		void broadcast(const char*, const fmt_type_info*, ...) const;
-
-		friend struct channel;
+		void broadcast(const char*, const fmt_type_info*, const u64*);
 	};
 
 	class listener
@@ -70,16 +67,21 @@ 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)\
-		const message msg_##_sev{this, level::_sev};\
-		template <typename... Args>\
-		void _sev(const char* fmt, const Args&... args)\
+		template<typename... Args>\
+		SAFE_BUFFERS void _sev(const char* fmt, const Args&... 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)}...);\
-			}\
+			return format<Args...>(level::_sev, fmt, args...);\
 		}
 
 		GEN_LOG_METHOD(fatal)
@@ -110,8 +112,6 @@ 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__)

Utilities/StrFmt.cpp

@@ -4,7 +4,6 @@
 #include "cfmt.h"
 
 #include <algorithm>
-#include <string_view>
 
 #ifdef _WIN32
 #include <Windows.h>
@@ -24,81 +23,34 @@ 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)
 {
-	fmt::append(out, "%p", arg);
+	if (arg)
+	{
+		fmt::append(out, "%p", reinterpret_cast<const void*>(static_cast<std::uintptr_t>(arg)));
+	}
+	else
+	{
+		out += "(NULL)";		
+	}
 }
 
 void fmt_class_string<const char*>::format(std::string& out, u64 arg)
 {
 	if (arg)
 	{
-		out += reinterpret_cast<const char*>(arg);
+		out += reinterpret_cast<const char*>(static_cast<std::uintptr_t>(arg));
 	}
 	else
 	{
-		out += "(NULLSTR)";
+		out += "(NULL)";
 	}
 }
 
 template <>
 void fmt_class_string<std::string>::format(std::string& out, u64 arg)
 {
-	out += get_object(arg);
-}
-
-template <>
-void fmt_class_string<std::string_view>::format(std::string& out, u64 arg)
-{
-	out += get_object(arg);
+	out += get_object(arg).c_str(); // TODO?
 }
 
 template <>
@@ -423,14 +375,6 @@ 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;

Utilities/StrFmt.h

@@ -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 = std::add_const_t<T>*;
+	using type = const T*;
 
-	static inline u64 get(type arg)
+	static inline u64 get(const T* 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 = std::add_const_t<T>*;
+	using type = const T*;
 
-	static inline u64 get(type arg)
+	static inline u64 get(const T* arg)
 	{
 		return reinterpret_cast<std::uintptr_t>(arg);
 	}
@@ -250,38 +250,15 @@ 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<fmt_unveil_t<Args>>()...};
+		static constexpr fmt_type_info result[sizeof...(Args) + 1]{fmt_type_info::make<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;
 
@@ -289,8 +266,7 @@ namespace fmt
 	template <typename... Args>
 	SAFE_BUFFERS FORCE_INLINE void append(std::string& out, const char* fmt, const Args&... args)
 	{
-		static constexpr fmt_type_info type_list[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
-		raw_append(out, fmt, type_list, fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+		raw_append(out, fmt, fmt::get_type_info<fmt_unveil_t<Args>...>(), fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
 	}
 
 	// Formatting function
@@ -310,7 +286,6 @@ namespace fmt
 	template <typename T = std::runtime_error, typename... Args>
 	[[noreturn]] SAFE_BUFFERS FORCE_INLINE void throw_exception(const char* fmt, const Args&... args)
 	{
-		static constexpr fmt_type_info type_list[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
-		raw_throw_exception<T>(fmt, type_list, fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
+		raw_throw_exception<T>(fmt, fmt::get_type_info<fmt_unveil_t<Args>...>(), fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
 	}
 }

Utilities/StrUtil.h

@@ -5,7 +5,6 @@
 #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>
@@ -101,10 +100,10 @@ namespace fmt
 		auto end = source.end();
 		for (--end; it != end; ++it)
 		{
-			result += std::string{*it} + separator;
+			result += *it + separator;
 		}
 
-		return result + std::string{source.back()};
+		return result + source.back();
 	}
 
 	template <typename T>
@@ -135,7 +134,6 @@ 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);
 }

Utilities/Thread.cpp

@@ -1,5 +1,5 @@
 #include "stdafx.h"
-#include "Emu/Memory/vm.h"
+#include "Emu/Memory/Memory.h"
 #include "Emu/System.h"
 #include "Emu/IdManager.h"
 #include "Emu/Cell/RawSPUThread.h"
@@ -14,7 +14,6 @@
 #include <Windows.h>
 #include <Psapi.h>
 #include <process.h>
-#include <sysinfoapi.h>
 #else
 #ifdef __APPLE__
 #define _XOPEN_SOURCE
@@ -32,16 +31,13 @@
 #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()
 {
@@ -51,11 +47,11 @@ extern thread_local std::string(*g_tls_log_prefix)();
 	}
 	catch (const std::exception& e)
 	{
-		report_fatal_error("{" + g_tls_log_prefix() + "} Unhandled exception of type '"s + typeid(e).name() + "': "s + e.what());
+		report_fatal_error("Unhandled exception of type '"s + typeid(e).name() + "': "s + e.what());
 	}
 	catch (...)
 	{
-		report_fatal_error("{" + g_tls_log_prefix() + "} Unhandled exception (unknown)");
+		report_fatal_error("Unhandled exception (unknown)");
 	}
 }
 
@@ -841,7 +837,7 @@ static const decltype(_REG_RAX) reg_table[] =
 
 #else
 
-static const int reg_table[] =
+static const decltype(REG_RAX) 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
@@ -1092,42 +1088,16 @@ 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)
+	if (rsx::g_access_violation_handler && rsx::g_access_violation_handler(addr, is_writing))
 	{
-		bool handled = false;
+		g_tls_fault_rsx++;
 
-		try
+		if (cpu)
 		{
-			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;
+			cpu->test_state();
 		}
 
-		if (handled)
-		{
-			g_tls_fault_rsx++;
-			if (cpu && cpu->test_stopped())
-			{
-				//
-			}
-
-			return true;
-		}
+		return true;
 	}
 
 	auto code = (const u8*)RIP(context);
@@ -1168,7 +1138,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<named_thread<spu_thread>>(spu_thread::find_raw_spu((addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET));
+		auto thread = idm::get<RawSPUThread>((addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET);
 
 		if (!thread)
 		{
@@ -1263,9 +1233,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 && cpu->test_stopped())
+		if (cpu)
 		{
-			//
+			cpu->test_state();
 		}
 
 		return true;
@@ -1273,8 +1243,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 
 	if (cpu)
 	{
-		// TODO: Only PPU thread page fault notifications are supported
-		if (cpu->id_type() == 1 && fxm::check<page_fault_notification_entries>())
+		if (fxm::check<page_fault_notification_entries>())
 		{
 			for (const auto& entry : fxm::get<page_fault_notification_entries>()->entries)
 			{
@@ -1290,16 +1259,16 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 
 					auto pf_entries = fxm::get_always<page_fault_event_entries>();
 					{
-						std::lock_guard pf_lock(pf_entries->pf_mutex);
+						semaphore_lock 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.
-					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;
+					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;
 
 					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");
@@ -1327,19 +1296,9 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 		}
 
 		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();
+		LOG_FATAL(MEMORY, "Access violation %s location 0x%x", is_writing ? "writing" : "reading", addr);
+		cpu->state += cpu_flag::dbg_pause;
+		cpu->check_state();
 	}
 
 	return true;
@@ -1424,6 +1383,7 @@ static LONG exception_handler(PEXCEPTION_POINTERS pExp)
 			return EXCEPTION_CONTINUE_EXECUTION;
 		}
 	}
+
 	return EXCEPTION_CONTINUE_SEARCH;
 }
 
@@ -1588,26 +1548,66 @@ 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_base::start(native_entry entry)
+void thread_ctrl::start(const std::shared_ptr<thread_ctrl>& ctrl, task_stack task)
 {
 #ifdef _WIN32
-	m_thread = ::_beginthreadex(nullptr, 0, entry, this, CREATE_SUSPENDED, nullptr);
-	verify("thread_ctrl::start" HERE), m_thread, ::ResumeThread(reinterpret_cast<HANDLE>(+m_thread)) != -1;
+	using thread_result = uint;
+	using thread_type = thread_result(__stdcall*)(void* arg);
 #else
-	verify("thread_ctrl::start" HERE), pthread_create(reinterpret_cast<pthread_t*>(&m_thread.raw()), nullptr, entry, this) == 0;
+	using thread_result = void*;
+	using thread_type = thread_result(*)(void* arg);
 #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_base::initialize()
+void thread_ctrl::initialize()
 {
 	// Initialize TLS variable
-	thread_ctrl::g_tls_this_thread = this;
+	g_tls_this_thread = this;
 
 	g_tls_log_prefix = []
 	{
-		return thread_ctrl::g_tls_this_thread->m_name.get();
+		return g_tls_this_thread->m_name;
 	};
 
 	++g_thread_count;
@@ -1626,7 +1626,7 @@ void thread_base::initialize()
 	{
 		THREADNAME_INFO info;
 		info.dwType = 0x1000;
-		info.szName = m_name.get().c_str();
+		info.szName = m_name.c_str();
 		info.dwThreadID = -1;
 		info.dwFlags = 0;
 
@@ -1641,20 +1641,21 @@ void thread_base::initialize()
 #endif
 
 #if defined(__APPLE__)
-	pthread_setname_np(m_name.get().substr(0, 15).c_str());
+	pthread_setname_np(m_name.substr(0, 15).c_str());
 #elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
-	pthread_set_name_np(pthread_self(), m_name.get().c_str());
+	pthread_set_name_np(pthread_self(), m_name.c_str());
 #elif defined(__NetBSD__)
-	pthread_setname_np(pthread_self(), "%s", (void*)m_name.get().c_str());
+	pthread_setname_np(pthread_self(), "%s", (void*)m_name.c_str());
 #elif !defined(_WIN32)
-	pthread_setname_np(pthread_self(), m_name.get().substr(0, 15).c_str());
+	pthread_setname_np(pthread_self(), m_name.substr(0, 15).c_str());
 #endif
 }
 
-bool thread_base::finalize(int) noexcept
+void thread_ctrl::finalize(std::exception_ptr eptr) noexcept
 {
-	// Report pending errors
-	error_code::error_report(0, 0, 0, 0);
+	// Run atexit functions
+	m_task.invoke();
+	m_task.reset();
 
 #ifdef _WIN32
 	ULONG64 cycles{};
@@ -1674,7 +1675,7 @@ bool thread_base::finalize(int) noexcept
 
 	g_tls_log_prefix = []
 	{
-		return thread_ctrl::g_tls_this_thread->m_name.get();
+		return g_tls_this_thread->m_name;
 	};
 
 	LOG_NOTICE(GENERAL, "Thread time: %fs (%fGc); Faults: %u [rsx:%u, spu:%u];",
@@ -1684,31 +1685,47 @@ bool thread_base::finalize(int) noexcept
 		g_tls_fault_rsx,
 		g_tls_fault_spu);
 
-	// Return true if need to delete thread object
-	const bool result = m_state.exchange(thread_state::finished) == thread_state::detached;
+	--g_thread_count;
 
-	// Signal waiting threads
-	m_mutex.lock_unlock();
+	// Untangle circular reference, set exception
+	semaphore_lock{m_mutex}, m_self.reset(), m_exception = eptr;
+
+	// Signal joining waiters
 	m_jcv.notify_all();
-	return result;
 }
 
-void thread_base::finalize() noexcept
+void thread_ctrl::_push(task_stack task)
 {
-	g_tls_log_prefix = []() -> std::string { return {}; };
-	thread_ctrl::g_tls_this_thread = nullptr;
-	--g_thread_count;
+	g_tls_this_thread->m_task.push(std::move(task));
 }
 
 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;
@@ -1722,31 +1739,57 @@ bool thread_ctrl::_wait_for(u64 usec)
 			return false;
 		}
 
-		_this->m_mutex.lock();
+		// Lock (semaphore)
+		_this->m_mutex.wait();
 
 		// 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.unlock();
+				_this->m_mutex.post();
 				return true;
 			}
 		}
 	}
-	while (_this->m_cond.wait_unlock(std::exchange(usec, usec > cond_variable::max_timeout ? -1 : 0), _this->m_mutex));
+	while (_this->m_cond.wait(_lock, std::exchange(usec, usec > cond_variable::max_timeout ? -1 : 0)));
 
 	// Timeout
 	return false;
 }
 
-thread_base::thread_base(std::string_view name)
-	: m_name(name)
+[[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()
+thread_ctrl::~thread_ctrl()
 {
 	if (m_thread)
 	{
@@ -1758,65 +1801,70 @@ thread_base::~thread_base()
 	}
 }
 
-void thread_base::join() const
+std::exception_ptr thread_ctrl::get_exception() const
 {
-	if (m_state == thread_state::finished)
+	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)
 	{
-		return;
+		m_signal |= 2;
+		m_cond.notify_one();
 	}
-
-	std::unique_lock lock(m_mutex);
-
-	while (m_state != thread_state::finished)
+	else
 	{
-		m_jcv.wait(lock);
+		m_signal &= ~2;
 	}
 }
 
-void thread_base::notify()
+void thread_ctrl::join()
+{
+#ifdef _WIN32
+	//verify("thread_ctrl::join" HERE), WaitForSingleObjectEx((HANDLE)m_thread.load(), -1, false) == WAIT_OBJECT_0;
+#endif
+
+	semaphore_lock lock(m_mutex);
+
+	while (m_self)
+	{
+		m_jcv.wait(lock);
+	}
+
+	if (UNLIKELY(m_exception && !std::uncaught_exception()))
+	{
+		std::rethrow_exception(m_exception);
+	}
+}
+
+void thread_ctrl::notify()
 {
 	if (!(m_signal & 1))
 	{
 		m_signal |= 1;
-		m_mutex.lock_unlock();
-		m_cond.notify_one();
+		_notify(&thread_ctrl::m_cond);
 	}
 }
 
-u64 thread_base::get_cycles()
+void thread_ctrl::test()
 {
-	u64 cycles;
+	const auto _this = g_tls_this_thread;
 
-#ifdef _WIN32
-	if (QueryThreadCycleTime((HANDLE)m_thread.load(), &cycles))
+	if (_this->m_signal & 2)
 	{
-#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->m_mutex.wait();
+
+		if (_this->m_exception)
 		{
-			return cycles - old_cycles;
+			_this->_throw();
 		}
 
-		// Report 0 the first time this function is called
-		return 0;
-	}
-	else
-	{
-		return m_cycles;
+		_this->m_mutex.post();
 	}
 }
 
@@ -1830,52 +1878,9 @@ void thread_ctrl::detect_cpu_layout()
 	{
 		g_native_core_layout.store(native_core_arrangement::amd_ccx);
 	}
-	else if (system_id.find("Intel") != std::string::npos)
+	else if (system_id.find("i3") != std::string::npos || system_id.find("i7") != std::string::npos)
 	{
-#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
+		g_native_core_layout.store(native_core_arrangement::intel_ht);
 	}
 }
 
@@ -1896,32 +1901,34 @@ u16 thread_ctrl::get_affinity_mask(thread_class group)
 		}
 		case native_core_arrangement::amd_ccx:
 		{
-			u16 spu_mask, ppu_mask, rsx_mask;
+			u16 spu_mask, ppu_mask, rsx_mask, general;
 			if (thread_count >= 16)
 			{
 				// Threadripper, R7
-				// Assign threads 8-16
+				// Assign threads 1-16
 				// It appears some windows code is bound to lower core addresses, binding 8-16 is alot faster than 0-7
 				ppu_mask = spu_mask = 0b1111111100000000;
-				rsx_mask = all_cores_mask;
+				rsx_mask = 0b11110000;
+				general = 0b00001111;
 			}
 			else if (thread_count == 12)
 			{
 				// 1600/2600 (x)
 				ppu_mask = spu_mask = 0b111111000000;
-				rsx_mask = all_cores_mask;
+				rsx_mask = 0b111000;
+				general = 0b000111;
 			}
 			else
 			{
 				// R5 & R3 don't seem to improve performance no matter how these are shuffled
-				ppu_mask = spu_mask = rsx_mask = 0b11111111 & all_cores_mask;
+				ppu_mask = spu_mask = rsx_mask = general = 0b11111111;
 			}
 
 			switch (group)
 			{
 			default:
 			case thread_class::general:
-				return all_cores_mask;
+				return general = all_cores_mask;
 			case thread_class::rsx:
 				return rsx_mask;
 			case thread_class::ppu:
@@ -1932,7 +1939,6 @@ 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
@@ -1947,7 +1953,6 @@ u16 thread_ctrl::get_affinity_mask(thread_class group)
 					return all_cores_mask;
 				}
 			}
-			*/
 
 			return all_cores_mask;
 		}
@@ -2014,3 +2019,45 @@ 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()
+{
+}

Utilities/Thread.h

@@ -3,13 +3,12 @@
 #include "types.h"
 #include "Atomic.h"
 
+#include <exception>
 #include <string>
 #include <memory>
-#include <string_view>
 
-#include "mutex.h"
+#include "sema.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&);
@@ -34,82 +33,92 @@ enum class thread_class : u32
 	ppu
 };
 
-enum class thread_state
+// Simple list of void() functors
+class task_stack
 {
-	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()
+	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)))
 	{
-		return reinterpret_cast<T*>(&data);
 	}
 
-	const T* get() const
+	void push(task_stack stack)
 	{
-		return reinterpret_cast<const T*>(&data);
+		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);
 	}
 
-	void destroy() noexcept
+	void reset()
 	{
-		get()->~T();
+		m_stack.reset();
+	}
+
+	void invoke() const
+	{
+		if (m_stack)
+		{
+			m_stack->invoke();
+		}
 	}
 };
 
-template <>
-struct result_storage<void>
+// Thread control class
+class thread_ctrl final
 {
-	static constexpr bool empty = true;
+	// Current thread
+	static thread_local thread_ctrl* g_tls_this_thread;
 
-	using type = void;
-};
+	// Target cpu core layout
+	static atomic_t<native_core_arrangement> g_native_core_layout;
 
-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
+	// Self pointer
+	std::shared_ptr<thread_ctrl> m_self;
 
 	// Thread handle (platform-specific)
 	atomic_t<std::uintptr_t> m_thread{0};
 
 	// Thread mutex
-	mutable shared_mutex m_mutex;
+	mutable semaphore<> m_mutex;
 
 	// Thread condition variable
 	cond_variable m_cond;
@@ -118,123 +127,77 @@ class thread_base
 	atomic_t<u32> m_signal{0};
 
 	// Thread joining condition variable
-	mutable cond_variable m_jcv;
+	cond_variable m_jcv;
 
-	// Thread state
-	atomic_t<thread_state> m_state = thread_state::created;
+	// Remotely set or caught exception
+	std::exception_ptr m_exception;
 
-	// Thread name
-	lf_value<std::string> m_name;
+	// Thread initial task or atexit task
+	task_stack m_task;
 
-	//
-	atomic_t<u64> m_cycles = 0;
+	// Fixed name
+	std::string m_name;
 
 	// Start thread
-	void start(native_entry);
+	static void start(const std::shared_ptr<thread_ctrl>&, task_stack);
 
 	// Called at the thread start
 	void initialize();
 
-	// Called at the thread end, returns true if needs destruction
-	bool finalize(int) noexcept;
+	// Called at the thread end
+	void finalize(std::exception_ptr) noexcept;
 
-	// 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;
+	// Add task (atexit)
+	static void _push(task_stack);
 
 	// Internal waiting function, may throw. Infinite value is -1.
 	static bool _wait_for(u64 usec);
 
-	friend class thread_base;
+	// Internal throwing function. Mutex must be locked and will be unlocked.
+	[[noreturn]] void _throw();
+
+	// Internal notification function
+	void _notify(cond_variable thread_ctrl::*);
 
 public:
-	// Get current thread name
-	static std::string_view get_name()
-	{
-		return g_tls_this_thread->m_name.get();
-	}
+	thread_ctrl(std::string&& name);
+
+	thread_ctrl(const thread_ctrl&) = delete;
+
+	~thread_ctrl();
 
 	// Get thread name
-	template <typename T>
-	static std::string_view get_name(const named_thread<T>& thread)
+	const std::string& get_name() const
 	{
-		return static_cast<const thread_base&>(thread).m_name.get();
+		return m_name;
 	}
 
-	// Set current thread name (not recommended)
-	static void set_name(std::string_view name)
-	{
-		g_tls_this_thread->m_name.assign(name);
-	}
+	// Get exception
+	std::exception_ptr get_exception() const;
 
-	// 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);
-	}
+	// Set exception
+	void set_exception(std::exception_ptr ptr);
 
-	template <typename T>
-	static u64 get_cycles(named_thread<T>& thread)
-	{
-		return static_cast<thread_base&>(thread).get_cycles();
-	}
+	// Get thread result (may throw, simultaneous joining allowed)
+	void join();
 
-	template <typename T>
-	static void notify(named_thread<T>& thread)
-	{
-		static_cast<thread_base&>(thread).notify();
-	}
+	// Notify the thread
+	void notify();
 
-	// Read current state
-	static inline thread_state state()
-	{
-		return g_tls_this_thread->m_state;
-	}
-
-	// Wait once with timeout. May spuriously return false.
+	// Wait once with timeout. Abortable, may throw. May spuriously return false.
 	static inline bool wait_for(u64 usec)
 	{
 		return _wait_for(usec);
 	}
 
-	// Wait.
+	// Wait. Abortable, may throw.
 	static inline void wait()
 	{
 		_wait_for(-1);
 	}
 
-	// Wait until pred().
-	template <typename F, typename RT = std::invoke_result_t<F>>
+	// Wait until pred(). Abortable, may throw.
+	template<typename F, typename RT = std::result_of_t<F()>>
 	static inline RT wait(F&& pred)
 	{
 		while (true)
@@ -248,12 +211,49 @@ 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_base* get_current()
+	static thread_ctrl* 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,166 +265,91 @@ 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));
-	}
 };
 
-// Derived from the callable object Context, possibly a lambda
-template <class Context>
-class named_thread final : public Context, result_storage_t<Context>, thread_base
+class named_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;
+	// Pointer to managed resource (shared with actual thread)
+	std::shared_ptr<thread_ctrl> m_thread;
 
 public:
-	// 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);
-	}
+	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);
-	}
+	virtual ~named_thread();
 
+	// Deleted copy/move constructors + copy/move operators
 	named_thread(const named_thread&) = delete;
 
-	named_thread& operator=(const named_thread&) = delete;
+	// Get thread name
+	virtual std::string get_name() const;
 
-	// Wait for the completion and access result (if not void)
-	[[nodiscard]] decltype(auto) operator()()
+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)
 	{
-		thread::join();
-
-		if constexpr (!result::empty)
-		{
-			return *result::get();
-		}
+		return start_thread(_this);
 	}
 
-	// Wait for the completion and access result (if not void)
-	[[nodiscard]] decltype(auto) operator()() const
+	// ID finalization
+	virtual void on_stop()
 	{
-		thread::join();
-
-		if constexpr (!result::empty)
-		{
-			return *result::get();
-		}
+		m_thread->join();
 	}
 
-	// Access thread state
-	operator thread_state() const
+	// Access thread_ctrl
+	thread_ctrl* get() const
 	{
-		return thread::m_state.load();
+		return m_thread.get();
 	}
 
-	// Try to abort/detach
-	named_thread& operator=(thread_state s)
+	void join() const
 	{
-		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;
+		return m_thread->join();
 	}
 
-	// Context type doesn't need virtual destructor
-	~named_thread()
+	void notify() const
 	{
-		*this = thread_state::aborting;
-		thread::join();
-
-		if constexpr (!result::empty)
-		{
-			result::destroy();
-		}
+		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();
 	}
 };

Utilities/Timer.h

@@ -49,11 +49,4 @@ 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();
-	}
 };

Utilities/VirtualMemory.cpp

@@ -7,27 +7,10 @@
 #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)
@@ -80,7 +63,7 @@ namespace utils
 #ifdef _WIN32
 		verify(HERE), ::VirtualAlloc(pointer, size, MEM_COMMIT, +prot);
 #else
-		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), size + ((u64)pointer & 4095), +prot) != -1;
+		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), ::align(size, 4096), +prot) != -1;
 #endif
 	}
 
@@ -93,186 +76,13 @@ 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
-		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;
-		}
+		DWORD old;
+		verify(HERE), ::VirtualProtect(pointer, size, +prot, &old);
 #else
-		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), size + ((u64)pointer & 4095), +prot) != -1;
-#endif
-	}
-
-	shm::shm(u32 size)
-		: m_size(::align(size, 0x10000))
-	{
-#ifdef _WIN32
-		m_handle = ::CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, 0, m_size, NULL);
-		verify(HERE), m_handle != INVALID_HANDLE_VALUE;
-#elif __linux__
-		m_file = ::memfd_create_("", 0);
-		verify(HERE), m_file >= 0;
-		verify(HERE), ::ftruncate(m_file, m_size) >= 0;
-#else
-		while ((m_file = ::shm_open("/rpcs3-mem1", O_RDWR | O_CREAT | O_EXCL, S_IWUSR | S_IRUSR)) == -1)
-		{
-			if (m_file == -1 && errno == EMFILE)
-			{
-				fmt::throw_exception("Too many open files. Raise the limit and try again.");
-			}
-
-			verify(HERE), errno == EEXIST;
-		}
-
-		verify(HERE), ::shm_unlink("/rpcs3-mem1") >= 0;
-		verify(HERE), ::ftruncate(m_file, m_size) >= 0;
-#endif
-	}
-
-	shm::~shm()
-	{
-#ifdef _WIN32
-		::CloseHandle(m_handle);
-#else
-		::close(m_file);
-#endif
-	}
-
-	u8* shm::map(void* ptr, protection prot) const
-	{
-#ifdef _WIN32
-		DWORD access = FILE_MAP_WRITE;
-		switch (prot)
-		{
-		case protection::rw:
-		case protection::ro:
-		case protection::no:
-			break;
-		case protection::wx:
-		case protection::rx:
-			access |= FILE_MAP_EXECUTE;
-			break;
-		}
-
-		if (auto ret = static_cast<u8*>(::MapViewOfFileEx(m_handle, access, 0, 0, m_size, ptr)))
-		{
-			if (prot != protection::rw && prot != protection::wx)
-			{
-				DWORD old;
-				if (!::VirtualProtect(ret, m_size, +prot, &old))
-				{
-					::UnmapViewOfFile(ret);
-					return nullptr;
-				}
-			}
-
-			return ret;
-		}
-
-		return nullptr;
-#else
-		return static_cast<u8*>(::mmap((void*)((u64)ptr & -0x10000), m_size, +prot, MAP_SHARED | (ptr ? MAP_FIXED : 0), m_file, 0));
-#endif
-	}
-
-	u8* shm::map_critical(void* ptr, protection prot)
-	{
-		const auto target = (u8*)((u64)ptr & -0x10000);
-
-#ifdef _WIN32
-		::MEMORY_BASIC_INFORMATION mem;
-		if (!::VirtualQuery(target, &mem, sizeof(mem)) || mem.State != MEM_RESERVE || !::VirtualFree(mem.AllocationBase, 0, MEM_RELEASE))
-		{
-			return nullptr;
-		}
-
-		const auto base = (u8*)mem.AllocationBase;
-		const auto size = mem.RegionSize + (target - base);
-
-		if (base < target && !::VirtualAlloc(base, target - base, MEM_RESERVE, PAGE_NOACCESS))
-		{
-			return nullptr;
-		}
-
-		if (target + m_size < base + size && !::VirtualAlloc(target + m_size, base + size - target - m_size, MEM_RESERVE, PAGE_NOACCESS))
-		{
-			return nullptr;
-		}
-#endif
-
-		return this->map(target, prot);
-	}
-
-	void shm::unmap(void* ptr) const
-	{
-#ifdef _WIN32
-		::UnmapViewOfFile(ptr);
-#else
-		::munmap(ptr, m_size);
-#endif
-	}
-
-	void shm::unmap_critical(void* ptr)
-	{
-		const auto target = (u8*)((u64)ptr & -0x10000);
-
-		this->unmap(target);
-
-#ifdef _WIN32
-		::MEMORY_BASIC_INFORMATION mem, mem2;
-		if (!::VirtualQuery(target - 1, &mem, sizeof(mem)) || !::VirtualQuery(target + m_size, &mem2, sizeof(mem2)))
-		{
-			return;
-		}
-
-		if (mem.State == MEM_RESERVE && !::VirtualFree(mem.AllocationBase, 0, MEM_RELEASE))
-		{
-			return;
-		}
-
-		if (mem2.State == MEM_RESERVE && !::VirtualFree(mem2.AllocationBase, 0, MEM_RELEASE))
-		{
-			return;
-		}
-
-		const auto size1 = mem.State == MEM_RESERVE ? target - (u8*)mem.AllocationBase : 0;
-		const auto size2 = mem2.State == MEM_RESERVE ? mem2.RegionSize : 0;
-
-		if (!::VirtualAlloc(mem.State == MEM_RESERVE ? mem.AllocationBase : target, m_size + size1 + size2, MEM_RESERVE, PAGE_NOACCESS))
-		{
-			return;
-		}
+		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), ::align(size, 4096), +prot) != -1;
 #endif
 	}
 }

Utilities/VirtualMemory.h

@@ -25,52 +25,11 @@ 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;
-		}
-	};
 }

Utilities/address_range.h

@@ -1,590 +0,0 @@
-#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 };
-		}
-	};
-};

Utilities/asm.h

@@ -1,185 +0,0 @@
-#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

Utilities/bin_patch.cpp

@@ -1,5 +1,5 @@
 #include "bin_patch.h"
-#include <yaml-cpp/yaml.h>
+#include "yaml-cpp/yaml.h"
 #include "File.h"
 #include "Config.h"
 

Utilities/cfmt.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "types.h"
-#include "asm.h"
 #include <climits>
 #include <string>
 #include <vector>
@@ -57,7 +56,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 - (utils::cntlz64(value | 1, true) + 2) / 3), '0');
+		out.resize(out.size() + std::max<u64>(min_num, 66 / 3 - (cntlz64(value | 1, true) + 2) / 3), '0');
 
 		// Write in reversed order
 		for (auto i = out.rbegin(); value; i++, value /= 8)
@@ -68,8 +67,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 - utils::cntlz64(value | 1, true) / 4), '0');
-
+		out.resize(out.size() + std::max<u64>(min_num, 64 / 4 - cntlz64(value | 1, true) / 4), '0');
+		
 		// Write in reversed order
 		for (auto i = out.rbegin(); value; i++, value /= 16)
 		{
@@ -142,7 +141,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
 		{
 			ctx.width = read_decimal(ch - '0');
 		}
-
+		
 		break;
 	}
 
@@ -158,7 +157,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
 			ctx.width = std::abs(warg);
 			ctx.left |= warg < 0;
 		}
-
+		
 		break;
 	}
 
@@ -308,7 +307,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
@@ -577,7 +576,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;

Utilities/cond.cpp

@@ -1,6 +1,5 @@
 #include "cond.h"
 #include "sync.h"
-#include "lockless.h"
 
 #include <limits.h>
 
@@ -10,286 +9,100 @@
 
 bool cond_variable::imp_wait(u32 _old, u64 _timeout) noexcept
 {
-	verify("cond_variable overflow" HERE), (_old & 0xffff) != 0xffff; // Very unlikely: it requires 65535 distinct threads to wait simultaneously
-
-	return balanced_wait_until(m_value, _timeout, [&](u32& value, auto... ret) -> int
-	{
-		if (value >> 16)
-		{
-			// Success
-			value -= 0x10001;
-			return +1;
-		}
-
-		if constexpr (sizeof...(ret))
-		{
-			// Retire
-			value -= 1;
-			return -1;
-		}
-
-		return 0;
-	});
+	verify(HERE), _old != -1; // Very unlikely: it requires 2^32 distinct threads to wait simultaneously
+	const bool is_inf = _timeout > max_timeout;
 
 #ifdef _WIN32
-	if (_old >= 0x10000 && !OptWaitOnAddress && m_value)
+	LARGE_INTEGER timeout;
+	timeout.QuadPart = _timeout * -10;
+
+	if (HRESULT rc = NtWaitForKeyedEvent(nullptr, &m_value, false, is_inf ? nullptr : &timeout))
 	{
-		// Workaround possibly stolen signal
-		imp_wake(1);
+		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;
 	}
 #endif
 }
 
 void cond_variable::imp_wake(u32 _count) noexcept
 {
-	// TODO (notify_one)
-	balanced_awaken<true>(m_value, m_value.atomic_op([&](u32& value) -> u32
+#ifdef _WIN32
+	// Try to subtract required amount of waiters
+	const u32 count = m_value.atomic_op([=](u32& value)
 	{
-		// 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)
+		if (value > _count)
 		{
-			value += count;
-			return true;
+			value -= _count;
+			return _count;
 		}
 
-		return false;
+		return std::exchange(value, 0);
 	});
-}
 
-void notifier::imp_unlock(u32 count)
-{
-	const u32 counter = m_counter.sub_fetch(count);
-
-	if (UNLIKELY(counter % (max_readers + 1)))
+	for (u32 i = count; i > 0; i--)
 	{
-		return;
+		NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
 	}
-
-	if (counter)
+#else
+	for (u32 i = _count; i > 0; std::this_thread::yield())
 	{
-		const u32 _old = m_counter.atomic_op([](u32& value) -> u32
+		const u32 value = m_value;
+
+		// Constrain remaining amount with imaginary waiter count
+		if (i > value)
 		{
-			if (value % (max_readers + 1))
-			{
-				return 0;
-			}
+			i = value;
+		}
 
-			return std::exchange(value, 0) / (max_readers + 1);
-		});
-
-		const u32 wc = m_cond.m_value;
-
-		if (_old && wc)
+		if (!value || i == 0)
 		{
-			m_cond.imp_wake(_old > wc ? wc : _old);
+			// 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;
 		}
 	}
-}
-
-u32 notifier::imp_notify(u32 count)
-{
-	return m_counter.atomic_op([&](u32& value) -> u32
-	{
-		if (const u32 add = value % (max_readers + 1))
-		{
-			// Mutex is locked
-			const u32 result = add > count ? count : add;
-			value += result * (max_readers + 1);
-			return result;
-		}
-		else
-		{
-			// Mutex is unlocked
-			value = 0;
-			return count;
-		}
-	});
-}
-
-bool notifier::wait(u64 usec_timeout)
-{
-	const u32 _old = m_cond.m_value.fetch_add(1);
-
-	if (max_readers < m_counter.fetch_op([](u32& value)
-	{
-		if (value > max_readers)
-		{
-			value -= max_readers;
-		}
-
-		value -= 1;
-	}))
-	{
-		// Return without waiting
-		m_cond.imp_wait(_old, 0);
-		return true;
-	}
-
-	const bool res = m_cond.imp_wait(_old, usec_timeout);
-
-	while (!try_lock_shared())
-	{
-		// TODO
-		busy_wait();
-	}
-
-	return res;
-}
-
-bool cond_one::imp_wait(u64 _timeout) noexcept
-{
-	// State transition: c_sig -> c_lock \ c_lock -> c_wait
-	const u32 _old = m_value.fetch_sub(1);
-	if (LIKELY(_old == c_sig))
-		return true;
-
-	return balanced_wait_until(m_value, _timeout, [&](u32& value, auto... ret) -> int
-	{
-		if (value == c_sig)
-		{
-			value = c_lock;
-			return +1;
-		}
-
-		if constexpr (sizeof...(ret))
-		{
-			value = c_lock;
-			return -1;
-		}
-
-		return 0;
-	});
-}
-
-void cond_one::imp_notify() noexcept
-{
-	auto [old, ok] = m_value.fetch_op([](u32& v)
-	{
-		if (UNLIKELY(v > 0 && v < c_sig))
-		{
-			v = c_sig;
-			return true;
-		}
-
-		return false;
-	});
-
-	verify(HERE), old <= c_sig;
-
-	if (LIKELY(!ok || old == c_lock))
-	{
-		return;
-	}
-
-	balanced_awaken(m_value, 1);
-}
-
-bool cond_x16::imp_wait(u32 slot, u64 _timeout) noexcept
-{
-	const u32 wait_bit = c_wait << slot;
-	const u32 lock_bit = c_lock << slot;
-
-	// Change state from c_lock to c_wait
-	const u32 old_ = m_cvx16.fetch_op([=](u32& cvx16)
-	{
-		if (cvx16 & wait_bit)
-		{
-			// c_sig -> c_lock
-			cvx16 &= ~wait_bit;
-		}
-		else
-		{
-			cvx16 |= wait_bit;
-			cvx16 &= ~lock_bit;
-		}
-	});
-
-	if (old_ & wait_bit)
-	{
-		// Already signaled, return without waiting
-		return true;
-	}
-
-	return balanced_wait_until(m_cvx16, _timeout, [&](u32& cvx16, auto... ret) -> int
-	{
-		if (cvx16 & lock_bit)
-		{
-			// c_sig -> c_lock
-			cvx16 &= ~wait_bit;
-			return +1;
-		}
-
-		if constexpr (sizeof...(ret))
-		{
-			// Retire
-			cvx16 |= lock_bit;
-			cvx16 &= ~wait_bit;
-			return -1;
-		}
-
-		return 0;
-	});
-}
-
-void cond_x16::imp_notify() noexcept
-{
-	auto [old, ok] = m_cvx16.fetch_op([](u32& v)
-	{
-		const u32 lock_mask = v >> 16;
-		const u32 wait_mask = v & 0xffff;
-
-		if (const u32 sig_mask = lock_mask ^ wait_mask)
-		{
-			v |= sig_mask | sig_mask << 16;
-			return true;
-		}
-
-		return false;
-	});
-
-	// Determine if some waiters need a syscall notification
-	const u32 wait_mask = old & (~old >> 16);
-
-	if (UNLIKELY(!ok || !wait_mask))
-	{
-		return;
-	}
-
-	balanced_awaken<true>(m_cvx16, utils::popcnt16(wait_mask));
-}
-
-bool lf_queue_base::wait(u64 _timeout)
-{
-	return balanced_wait_until(m_head, _timeout, [](std::uintptr_t& head, auto... ret) -> int
-	{
-		if (head != 1)
-		{
-			return +1;
-		}
-
-		if constexpr (sizeof...(ret))
-		{
-			head = 0;
-			return -1;
-		}
-
-		return 0;
-	});
-}
-
-void lf_queue_base::imp_notify()
-{
-	balanced_awaken(m_head, 1);
+#endif
 }

Utilities/cond.h

@@ -2,8 +2,6 @@
 
 #include "types.h"
 #include "Atomic.h"
-#include <shared_mutex>
-#include "asm.h"
 
 // Lightweight condition variable
 class cond_variable
@@ -11,8 +9,6 @@ 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;
@@ -25,7 +21,7 @@ public:
 
 	// Intrusive wait algorithm for lockable objects
 	template <typename T>
-	bool wait(T& object, u64 usec_timeout = -1)
+	explicit_bool_t wait(T& object, u64 usec_timeout = -1)
 	{
 		const u32 _old = m_value.fetch_add(1); // Increment waiter counter
 		object.unlock();
@@ -34,15 +30,6 @@ 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
 	{
@@ -57,209 +44,9 @@ public:
 	{
 		if (m_value)
 		{
-			imp_wake(65535);
+			imp_wake(-1);
 		}
 	}
 
 	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();
-	}
-};

Utilities/date_time.h

@@ -1,32 +0,0 @@
-#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;
-	}
-}

Utilities/dynamic_library.h

@@ -63,30 +63,18 @@ namespace utils
 		{
 		}
 
-		void init()
+		// Caller
+		R operator()(Args... args)
 		{
 			if (!ptr)
 			{
 				// TODO: atomic
 				ptr = reinterpret_cast<R(*)(Args...)>(get_proc_address(lib, name));
 			}
-		}
-
-		operator bool()
-		{
-			init();
-
-			return ptr;
-		}
-
-		// Caller
-		R operator()(Args... args)
-		{
-			init();
 
 			return ptr(args...);
 		}
 	};
 }
 
-#define DYNAMIC_IMPORT(lib, name, ...) inline utils::dynamic_import<__VA_ARGS__> name(lib, #name);
+#define DYNAMIC_IMPORT(lib, name, ...) static utils::dynamic_import<__VA_ARGS__> name(lib, #name);

Utilities/event.h

@@ -71,7 +71,7 @@ public:
 	}
 
 	// Conditionally set state (optimized)
-	bool state_test_and_set(T expected, T state)
+	explicit_bool_t 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)
-	bool state_test_and_set(std::initializer_list<T> expected, T state)
+	explicit_bool_t state_test_and_set(std::initializer_list<T> expected, T state)
 	{
 		T _old;
 
@@ -111,10 +111,9 @@ public:
 	// Unconditionally set next state
 	void state_next()
 	{
-		T _old, state = m_value.atomic_op([&](T& value)
+		T _old, state = m_value.op_fetch([&](T& value)
 		{
 			_old = value++;
-			return value;
 		});
 
 		(static_cast<CRT*>(this)->*transition_get(state))(_old);
@@ -123,10 +122,9 @@ public:
 	// Unconditionally set previous state
 	void state_prev()
 	{
-		T _old, state = m_value.atomic_op([&](T& value)
+		T _old, state = m_value.op_fetch([&](T& value)
 		{
 			_old = value--;
-			return value;
 		});
 
 		(static_cast<CRT*>(this)->*transition_get(state))(_old);

Utilities/geometry.h

@@ -976,77 +976,62 @@ 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>;

Utilities/git-version-gen.cmd

@@ -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^=8 HEAD') do set GIT_VERSION=%%I
-
+	for /F %%I IN ('call %GIT% rev-parse --short HEAD') do set GIT_VERSION=%%I
+	
 ) else (
 	rem // Get last commit (shortened) and concat after commit count in GIT_VERSION
-	for /F %%I IN ('call %GIT% rev-parse --short^=8 HEAD') do set GIT_VERSION=%COMMIT_COUNT%-%%I
-
+	for /F %%I IN ('call %GIT% rev-parse --short HEAD') do set GIT_VERSION=%COMMIT_COUNT%-%%I
+	
 	for /F %%I IN ('call %GIT% rev-parse --abbrev-ref HEAD') do set GIT_BRANCH=%%I
 )
 

Utilities/hash.h

@@ -9,43 +9,19 @@ namespace rpcs3
 		return static_cast<size_t>(value);
 	}
 
-	template<typename T, typename U>
-	static size_t hash_struct_base(const T& value)
+	template<typename T>
+	static size_t hash_struct(const T& value)
 	{
 		// FNV 64-bit
 		size_t result = 14695981039346656037ull;
-		const U *bits = reinterpret_cast<const U*>(&value);
+		const unsigned char *bytes = reinterpret_cast<const unsigned char*>(&value);
 
-		for (size_t n = 0; n < (sizeof(T) / sizeof(U)); ++n)
+		for (size_t n = 0; n < sizeof(T); ++n)
 		{
-			result ^= bits[n];
+			result ^= bytes[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);
-	}
 }

Utilities/lockless.h

@@ -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,347 +146,185 @@ public:
 	}
 };
 
-// Helper type, linked list element
-template <typename T>
-class lf_queue_item final
+// Fixed-size single-producer single-consumer queue
+template <typename T, std::uint32_t N>
+class lf_spsc
 {
-	lf_queue_item* m_link = nullptr;
+	// 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");
 
-	T m_data;
-
-	template <typename U>
-	friend class lf_queue_iterator;
-
-	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)...)
-	{
-	}
+protected:
+	volatile std::uint32_t m_push{0};
+	volatile std::uint32_t m_pop{0};
+	T m_data[N]{};
 
 public:
-	lf_queue_item(const lf_queue_item&) = delete;
+	constexpr lf_spsc() = default;
 
-	lf_queue_item& operator=(const lf_queue_item&) = delete;
-
-	~lf_queue_item()
+	// Try to push (producer only)
+	template <typename T2>
+	bool try_push(T2&& data)
 	{
-		for (lf_queue_item* ptr = m_link; ptr;)
+		const std::uint32_t pos = m_push;
+
+		if (pos - m_pop >= N)
 		{
-			delete std::exchange(ptr, std::exchange(ptr->m_link, nullptr));
-		}
-	}
-};
-
-// 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 false;
 		}
 
-		return *this;
+		_mm_lfence();
+		m_data[pos % N] = std::forward<T2>(data);
+		_mm_sfence();
+		m_push = pos + 1;
+		return true;
 	}
 
-	~lf_queue_slice()
+	// Try to get push pointer (producer only)
+	operator T*()
 	{
-		delete m_head;
+		const std::uint32_t pos = m_push;
+
+		if (pos - m_pop >= N)
+		{
+			return nullptr;
+		}
+
+		_mm_lfence();
+		return m_data + (pos % N);
 	}
 
-	T& operator *() const
+	// Increment push counter (producer only)
+	void end_push()
 	{
-		return m_head->m_data;
+		const std::uint32_t pos = m_push;
+
+		if (pos - m_pop < N)
+		{
+			_mm_sfence();
+			m_push = pos + 1;
+		}
 	}
 
-	T* operator ->() const
+	// Unsafe access
+	T& get_push(std::size_t i)
 	{
-		return &m_head->m_data;
+		_mm_lfence();
+		return m_data[(m_push + i) % N];
 	}
 
-	explicit operator bool() const
+	// Try to pop (consumer only)
+	template <typename T2>
+	bool try_pop(T2& out)
 	{
-		return m_head != nullptr;
+		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;
 	}
 
-	T* get() const
+	// Increment pop counter (consumer only)
+	void end_pop()
 	{
-		return m_head ? &m_head->m_data : nullptr;
+		const std::uint32_t pos = m_pop;
+
+		if (m_push - pos > 0)
+		{
+			_mm_sfence();
+			m_pop = pos + 1;
+		}
 	}
 
-	lf_queue_iterator<T> begin() const
+	// Get size (consumer only)
+	std::uint32_t size() const
 	{
-		lf_queue_iterator<T> result;
-		result.m_ptr = m_head;
-		return result;
+		return m_push - m_pop;
 	}
 
-	lf_queue_iterator<T> end() const
+	// Direct access (consumer only)
+	T& operator [](std::size_t i)
 	{
-		return {};
-	}
-
-	lf_queue_slice& pop_front()
-	{
-		delete std::exchange(m_head, std::exchange(m_head->m_link, nullptr));
-		return *this;
+		_mm_lfence();
+		return m_data[(m_pop + i) % N];
 	}
 };
 
-class lf_queue_base
+// Fixed-size multi-producer single-consumer queue
+template <typename T, std::uint32_t N>
+class lf_mpsc : lf_spsc<T, N>
 {
 protected:
-	atomic_t<std::uintptr_t> m_head = 0;
+	using lf_spsc<T, N>::m_push;
+	using lf_spsc<T, N>::m_pop;
+	using lf_spsc<T, N>::m_data;
 
-	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
+	enum : std::uint64_t
 	{
-		if (auto* head = m_head.load() ? reinterpret_cast<lf_queue_item<T>*>(m_head.exchange(0)) : nullptr)
+		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)
 		{
-			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;
+			_mm_sfence();
+			m_push += value % c_rel;
+			m_lock.compare_and_swap_test(value, 0);
 		}
-
-		return nullptr;
 	}
 
 public:
-	constexpr lf_queue() = default;
+	constexpr lf_mpsc() = default;
 
-	~lf_queue()
+	// Try to get push pointer
+	operator T*()
 	{
-		delete reinterpret_cast<T*>(m_head.load());
-	}
+		const std::uint64_t old = m_lock.fetch_add(c_ack);
+		const std::uint32_t pos = m_push;
 
-	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)))
+		if (old % N >= N || pos - m_pop >= N - (old % N))
 		{
-			item->m_link = _old & 1 ? nullptr : reinterpret_cast<lf_queue_item<T>*>(_old);
+			release(m_lock.sub_fetch(c_ack));
+			return nullptr;
 		}
 
-		if (_old & 1)
-		{
-			lf_queue_base::imp_notify();
-		}
+		return m_data + ((pos + old) % N);
 	}
 
-	// Withdraw the list, supports range-for loop: for (auto&& x : y.pop_all()) ...
-	lf_queue_slice<T> pop_all()
+	// Increment push counter (producer only)
+	void end_push()
 	{
-		lf_queue_slice<T> result;
-		result.m_head = reverse();
-		return result;
+		release(m_lock.add_fetch(c_rel));
 	}
 
-	// Apply func(data) to each element, return the total length
-	template <typename F>
-	std::size_t apply(F&& func)
+	// Try to push
+	template <typename T2>
+	bool try_push(T2&& data)
 	{
-		std::size_t count = 0;
-
-		for (auto slice = pop_all(); slice; slice.pop_front())
+		if (T* ptr = *this)
 		{
-			std::invoke(std::forward<F>(func), *slice);
+			*ptr = std::forward<T2>(data);
+			end_push();
+			return true;
 		}
 
-		return count;
+		return false;
 	}
 
-	// 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));
-	}
+	// Enable consumer methods
+	using lf_spsc<T, N>::try_pop;
+	using lf_spsc<T, N>::end_pop;
+	using lf_spsc<T, N>::size;
+	using lf_spsc<T, N>::operator [];
 };

Utilities/mutex.cpp

@@ -2,159 +2,333 @@
 #include "sync.h"
 
 #include <climits>
+#include <vector>
+#include <algorithm>
 
-void shared_mutex::imp_lock_shared(u32 val)
+// TLS variable for tracking owned mutexes
+thread_local std::vector<shared_mutex*> g_tls_locks;
+
+void shared_mutex::imp_lock_shared(s64 _old)
 {
-	verify("shared_mutex underflow" HERE), val < c_err;
+	verify("shared_mutex overflow" HERE), _old <= c_max;
 
 	for (int i = 0; i < 10; i++)
 	{
 		busy_wait();
 
-		if (try_lock_shared())
+		const s64 value = m_value.load();
+
+		if (value >= c_min && m_value.compare_and_swap_test(value, value - c_min))
 		{
 			return;
 		}
 	}
 
-	// Acquire writer lock and downgrade
-	const u32 old = m_value.fetch_add(c_one);
+#ifdef _WIN32
+	// Acquire writer lock
+	imp_wait(m_value.load());
 
-	if (old == 0)
+	// Convert to reader lock
+	s64 value = m_value.fetch_add(c_one - c_min);
+
+	// Proceed exclusively
+	return;
+
+	if (value != 0)
 	{
-		lock_downgrade();
-		return;
+		imp_unlock(value);
 	}
 
-	verify("shared_mutex overflow" HERE), (old % c_sig) + c_one < c_sig;
-	imp_wait();
-	lock_downgrade();
+	// 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(u32 old)
+void shared_mutex::imp_unlock_shared(s64 _old)
 {
-	verify("shared_mutex underflow" HERE), old - 1 < c_err;
+	verify("shared_mutex overflow" HERE), _old + c_min <= c_max;
 
 	// Check reader count, notify the writer if necessary
-	if ((old - 1) % c_one == 0)
+	if ((_old + c_min) % c_one == 0)
 	{
-		imp_signal();
+#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()
+void shared_mutex::imp_wait(s64)
 {
-	while (!balanced_wait_until(m_value, -1, [&](u32& value, auto...)
+#ifdef _WIN32
+	if (m_value.sub_fetch(c_one))
 	{
-		if (value >= c_sig)
+		NtWaitForKeyedEvent(nullptr, &m_value, false, nullptr);
+	}
+#else
+	if (!m_value.sub_fetch(c_one))
+	{
+		// Return immediately if locked
+		return;
+	}
+
+	while (true)
+	{
+		// Load new value, try to acquire c_sig
+		const s64 value = m_value.fetch_op([](s64& value)
 		{
-			value -= c_sig;
-			return true;
+			if (value <= c_one - c_sig)
+			{
+				value += c_sig;
+			}
+		});
+
+		if (value <= c_one - c_sig)
+		{
+			return;
 		}
 
-		return false;
-	}))
-	{
+		futex((int*)&m_value.raw() + IS_LE_MACHINE, FUTEX_WAIT_BITSET_PRIVATE, int(value >> 32), nullptr, nullptr, u32(c_sig >> 32));
 	}
+#endif
 }
 
-void shared_mutex::imp_signal()
+void shared_mutex::imp_lock(s64 _old)
 {
-	m_value += c_sig;
-	balanced_awaken(m_value, 1);
-}
-
-void shared_mutex::imp_lock(u32 val)
-{
-	verify("shared_mutex underflow" HERE), val < c_err;
+	verify("shared_mutex overflow" HERE), _old <= c_max;
 
 	for (int i = 0; i < 10; i++)
 	{
 		busy_wait();
 
-		if (!m_value && try_lock())
+		const s64 value = m_value.load();
+
+		if (value == c_one && m_value.compare_and_swap_test(c_one, 0))
 		{
 			return;
 		}
 	}
 
-	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();
+	imp_wait(m_value.load());
 }
 
-void shared_mutex::imp_unlock(u32 old)
+void shared_mutex::imp_unlock(s64 _old)
 {
-	verify("shared_mutex underflow" HERE), old - c_one < c_err;
+	verify("shared_mutex overflow" HERE), _old + c_one <= c_max;
 
 	// 1) Notify the next writer if necessary
-	// 2) Notify all readers otherwise if necessary (currently indistinguishable from writers)
-	if (old - c_one)
+	// 2) Notify all readers otherwise if necessary
+#ifdef _WIN32
+	if (_old + c_one <= 0)
 	{
-		imp_signal();
+		NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
 	}
+	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()
 {
-	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();
+	// TODO
+	unlock_shared();
+	lock();
 }
 
-void shared_mutex::imp_lock_unlock()
+void shared_mutex::imp_lock_degrade()
 {
-	u32 _max = 1;
+	// TODO
+	unlock();
+	lock_shared();
+}
 
-	for (int i = 0; i < 30; i++)
+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)
 	{
-		const u32 val = m_value;
+		m_is_owned = true;
 
-		if (val % c_one == 0 && (val / c_one < _max || val >= c_sig))
+		if (m_is_owned)
 		{
-			// 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)
+			m_mutex.lock_shared();
+			g_tls_locks.emplace_back(&m_mutex);
 			return;
 		}
 
-		_max = val / c_one;
-
-		busy_wait(1500);
+		// TODO: order locks
 	}
+}
 
-	// Lock and unlock
-	if (!m_value.fetch_add(c_one))
+safe_reader_lock::~safe_reader_lock()
+{
+	if (m_is_owned)
 	{
-		unlock();
+		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;
 	}
 
-	imp_wait();
-	unlock();
+	// 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();
+			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
 }

Utilities/mutex.h

@@ -1,108 +1,65 @@
 #pragma once
 
-#include <mutex>
 #include "types.h"
 #include "Atomic.h"
 
-// Shared mutex with small size (u32).
+// Shared mutex.
 class shared_mutex final
 {
-	enum : u32
+	enum : s64
 	{
-		c_one = 1u << 14, // Fixed-point 1.0 value (one writer, max_readers = c_one - 1)
-		c_sig = 1u << 30,
-		c_err = 1u << 31,
+		c_one = 1ull << 31, // Fixed-point 1.0 value (one writer)
+		c_min = 0x00000001, // Fixed-point 1.0/max_readers value
+		c_sig = 1ull << 62,
+		c_max = c_one
 	};
 
-	atomic_t<u32> m_value{};
+	atomic_t<s64> m_value{c_one}; // Semaphore-alike counter
+
+	void imp_lock_shared(s64 _old);
+	void imp_unlock_shared(s64 _old);
+	void imp_wait(s64 _old);
+	void imp_lock(s64 _old);
+	void imp_unlock(s64 _old);
 
-	void imp_lock_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_unlock();
+	void imp_lock_degrade();
 
 public:
 	constexpr shared_mutex() = default;
 
-	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);
-	}
+	bool try_lock_shared();
 
 	void lock_shared()
 	{
-		const u32 value = m_value.load();
+		const s64 value = m_value.load();
 
-		if (UNLIKELY(value >= c_one - 1 || !m_value.compare_and_swap_test(value, value + 1)))
+		// Fast path: decrement if positive
+		if (UNLIKELY(value < c_min || value > c_one || !m_value.compare_and_swap_test(value, value - c_min)))
 		{
 			imp_lock_shared(value);
 		}
 	}
 
-	void 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 decrement (can result in broken state)
-		const u32 value = m_value.fetch_sub(1);
+		// Unconditional increment
+		const s64 value = m_value.fetch_add(c_min);
 
-		if (UNLIKELY(value >= c_one))
+		if (value < 0 || value > c_one - c_min)
 		{
 			imp_unlock_shared(value);
 		}
 	}
 
-	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);
-	}
+	bool try_lock();
 
 	void lock()
 	{
-		const u32 value = m_value.compare_and_swap(0, c_one);
+		// Try to lock
+		const s64 value = m_value.compare_and_swap(c_one, 0);
 
-		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)))
+		if (value != c_one)
 		{
 			imp_lock(value);
 		}
@@ -110,66 +67,38 @@ public:
 
 	void unlock()
 	{
-		// Unconditional decrement (can result in broken state)
-		const u32 value = m_value.fetch_sub(c_one);
+		// Unconditional increment
+		const s64 value = m_value.fetch_add(c_one);
 
-		if (UNLIKELY(value != c_one))
+		if (value != 0)
 		{
 			imp_unlock(value);
 		}
 	}
 
-	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);
-	}
+	bool try_lock_upgrade();
 
 	void lock_upgrade()
 	{
-		if (UNLIKELY(!try_lock_upgrade()))
+		if (!m_value.compare_and_swap_test(c_one - c_min, 0))
 		{
 			imp_lock_upgrade();
 		}
 	}
 
-	void lock_downgrade()
-	{
-		// Convert to reader lock (can result in broken state)
-		m_value -= c_one - 1;
-	}
+	bool try_lock_degrade();
 
-	// Optimized wait for lockability without locking, relaxed
-	void lock_unlock()
+	void lock_degrade()
 	{
-		if (UNLIKELY(m_value != 0))
+		if (!m_value.compare_and_swap_test(0, c_one - c_min))
 		{
-			imp_lock_unlock();
+			imp_lock_degrade();
 		}
 	}
 
-	// Check whether can immediately obtain an exclusive (writer) lock
-	bool is_free() const
+	bool is_reading() const
 	{
-		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;
+		return (m_value.load() % c_one) != 0;
 	}
 };
 
@@ -179,18 +108,28 @@ 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)
 	{
-		m_mutex.lock_shared();
+		lock();
 	}
 
-	// One-way lock upgrade; note that the observed state could have been changed
+	// One-way lock upgrade
 	void upgrade()
 	{
 		if (!m_upgraded)
@@ -200,14 +139,93 @@ 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()
 	{
-		m_upgraded ? m_mutex.unlock() : m_mutex.unlock_shared();
+		unlock();
 	}
 };
+
+// Simplified exclusive (writer) lock implementation.
+class writer_lock final
+{
+	shared_mutex& m_mutex;
+
+	void lock()
+	{
+		m_mutex.lock();
+	}
+
+	void unlock()
+	{
+		m_mutex.unlock();
+	}
+
+	friend class cond_variable;
+
+public:
+	writer_lock(const writer_lock&) = delete;
+
+	explicit writer_lock(shared_mutex& mutex)
+		: m_mutex(mutex)
+	{
+		lock();
+	}
+
+	~writer_lock()
+	{
+		unlock();
+	}
+};
+
+// 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();
+};

Utilities/rXml.h

@@ -1,6 +1,10 @@
 #pragma once
 
-#include <pugixml.hpp>
+#ifndef PUGIXML_HEADER_ONLY
+#define PUGIXML_HEADER_ONLY 1
+#endif // !PUGIXML_HEADER_ONLY
+#include "pugixml.hpp"
+#undef PUGIXML_HEADER_ONLY
 
 struct rXmlNode
 {

Utilities/recursive_wrapper.hpp

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

Utilities/sema.cpp

@@ -26,7 +26,7 @@ void semaphore_base::imp_wait()
 	while (true)
 	{
 		// Try hard way
-		const s32 value = m_value.atomic_op([](s32& value)
+		const s32 value = m_value.op_fetch([](s32& value)
 		{
 			// Use sign bit to acknowledge waiter presence
 			if (value && value > INT32_MIN)
@@ -44,18 +44,16 @@ 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, FUTEX_WAKE_PRIVATE, 1);
+			futex(&m_value.raw(), FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
 			return;
 		}
 
-		futex(&m_value, FUTEX_WAIT_PRIVATE, value);
+		futex(&m_value.raw(), FUTEX_WAIT_PRIVATE, value, nullptr, nullptr, 0);
 	}
 #endif
 }
@@ -67,10 +65,24 @@ void semaphore_base::imp_post(s32 _old)
 #ifdef _WIN32
 	NtReleaseKeyedEvent(nullptr, &m_value, false, nullptr);
 #else
-	futex(&m_value, FUTEX_WAKE_PRIVATE, 1);
+	futex(&m_value.raw(), FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
 #endif
 }
 
+bool semaphore_base::try_wait()
+{
+	// Conditional decrement
+	const s32 value = m_value.fetch_op([](s32& value)
+	{
+		if (value > 0)
+		{
+			value -= 1;
+		}
+	});
+
+	return value > 0;
+}
+
 bool semaphore_base::try_post(s32 _max)
 {
 	// Conditional increment

Utilities/sema.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <mutex>
 #include "types.h"
 #include "Atomic.h"
 
@@ -14,6 +13,8 @@ class semaphore_base
 
 	void imp_post(s32 _old);
 
+	friend class semaphore_lock;
+
 protected:
 	explicit constexpr semaphore_base(s32 value)
 		: m_value{value}
@@ -32,10 +33,7 @@ protected:
 		}
 	}
 
-	bool try_wait()
-	{
-		return m_value.try_dec(0);
-	}
+	bool try_wait();
 
 	void post(s32 _max)
 	{
@@ -75,36 +73,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 lock()
+	void wait()
 	{
 		return base::wait();
 	}
 
 	// Try to obtain a semaphore
-	bool try_lock()
+	explicit_bool_t try_wait()
 	{
 		return base::try_wait();
 	}
 
 	// Return a semaphore
-	void unlock()
+	void post()
 	{
 		return base::post(Max);
 	}
 
 	// Try to return a semaphore
-	bool try_unlock()
+	explicit_bool_t try_post()
 	{
 		return base::try_post(Max);
 	}
@@ -115,3 +113,34 @@ 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();
+	}
+};

Utilities/sync.h

@@ -17,7 +17,6 @@
 #include <unistd.h>
 #else
 #endif
-#include <algorithm>
 #include <ctime>
 #include <chrono>
 #include <mutex>
@@ -25,12 +24,10 @@
 #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__
@@ -49,37 +46,37 @@ enum
 };
 #endif
 
-inline int futex(volatile void* uaddr, int futex_op, uint val, const timespec* timeout = nullptr, uint mask = 0)
+inline int futex(int* uaddr, int futex_op, int val, const timespec* timeout, int* uaddr2, int val3)
 {
 #ifdef __linux__
-	return syscall(SYS_futex, uaddr, futex_op, static_cast<int>(val), timeout, nullptr, static_cast<int>(mask));
+	return syscall(SYS_futex, uaddr, futex_op, val, timeout, uaddr, val3);
 #else
-	static struct futex_manager
+	static struct futex_map
 	{
 		struct waiter
 		{
-			 uint val;
+			 int val;
 			 uint mask;
 			 std::condition_variable cv;
 		};
 
 		std::mutex mutex;
-		std::unordered_multimap<volatile void*, waiter*, pointer_hash<volatile void, alignof(int)>> map;
+		std::unordered_multimap<int*, waiter*, pointer_hash<int>> map;
 
-		int operator()(volatile void* uaddr, int futex_op, uint val, const timespec* timeout, uint mask)
+		int operator()(int* uaddr, int futex_op, int val, const timespec* timeout, int*, uint val3)
 		{
-			std::unique_lock lock(mutex);
+			std::unique_lock<std::mutex> lock(mutex);
 
 			switch (futex_op)
 			{
-			case FUTEX_WAIT_PRIVATE:
+			case FUTEX_WAIT:
 			{
-				mask = -1;
-				[[fallthrough]];
+				val3 = -1;
+				// Fallthrough
 			}
-			case FUTEX_WAIT_BITSET_PRIVATE:
+			case FUTEX_WAIT_BITSET:
 			{
-				if (*reinterpret_cast<volatile uint*>(uaddr) != val)
+				if (*(volatile int*)uaddr != val)
 				{
 					errno = EAGAIN;
 					return -1;
@@ -87,7 +84,7 @@ inline int futex(volatile void* uaddr, int futex_op, uint val, const timespec* t
 
 				waiter rec;
 				rec.val = val;
-				rec.mask = mask;
+				rec.mask = val3;
 				const auto& ref = *map.emplace(uaddr, &rec);
 
 				int res = 0;
@@ -110,25 +107,25 @@ inline int futex(volatile void* uaddr, int futex_op, uint val, const timespec* t
 				{
 					// TODO
 				}
-
+				
 				map.erase(std::find(map.find(uaddr), map.end(), ref));
 				return res;
 			}
 
-			case FUTEX_WAKE_PRIVATE:
+			case FUTEX_WAKE:
 			{
-				mask = -1;
-				[[fallthrough]];
+				val3 = -1;
+				// Fallthrough
 			}
-			case FUTEX_WAKE_BITSET_PRIVATE:
+			case FUTEX_WAKE_BITSET:
 			{
 				int res = 0;
 
 				for (auto range = map.equal_range(uaddr); val && range.first != range.second; range.first++)
 				{
 					auto& entry = *range.first->second;
-
-					if (entry.mask & mask)
+					
+					if (entry.mask & val3)
 					{
 						entry.cv.notify_one();
 						entry.mask = 0;
@@ -146,149 +143,6 @@ inline int futex(volatile void* uaddr, int futex_op, uint val, const timespec* t
 		}
 	} g_futex;
 
-	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;
+	return g_futex(uaddr, futex_op, val, timeout, uaddr2, val3);
 #endif
 }

Utilities/sysinfo.cpp

@@ -13,40 +13,29 @@ 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 && (get_cpuid(1, 0)[2] & 0x0C000000) == 0x0C000000 && (get_xgetbv(0) & 0x6) == 0x6;
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x10000000;
 	return g_value;
 }
 
 bool utils::has_avx2()
 {
-	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;
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && get_cpuid(7, 0)[1] & 0x20;
 	return g_value;
 }
 
 bool utils::has_rtm()
 {
-	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;
+	// 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;
 	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 && (get_cpuid(1,0)[2] & 0x0C000000) == 0x0C000000 && (get_xgetbv(0) & 0xe6) == 0xe6;
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && (get_cpuid(7, 0)[1] & 0xd0030000) == 0xd0030000;
 	return g_value;
 }
 
@@ -73,9 +62,8 @@ std::string utils::get_system_info()
 		brand = "Unknown CPU";
 	}
 
-	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(' '));
+	brand.erase(brand.find_last_not_of(' ') + 1);
 
 	while (auto found = brand.find("  ") + 1)
 	{
@@ -120,10 +108,6 @@ std::string utils::get_system_info()
 	if (has_rtm())
 	{
 		result += " | TSX";
-		if (!has_mpx())
-		{
-			result += " disabled by default";
-		}
 	}
 
 	return result;

Utilities/sysinfo.h

@@ -16,32 +16,35 @@ 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();
 }

Utilities/types.h

@@ -9,11 +9,9 @@
 #include <emmintrin.h>
 
 #include <cstdint>
-#include <cstddef>
 #include <type_traits>
 #include <utility>
 #include <chrono>
-#include <limits>
 #include <array>
 
 // Assume little-endian
@@ -21,42 +19,31 @@
 #define IS_BE_MACHINE 0
 
 #ifdef _MSC_VER
-
-#define ASSUME(...) __assume(__VA_ARGS__) // MSVC __assume ignores side-effects
+#define ASSUME(cond) __assume(cond)
 #define LIKELY
 #define UNLIKELY
 #define SAFE_BUFFERS __declspec(safebuffers)
 #define NEVER_INLINE __declspec(noinline)
 #define FORCE_INLINE __forceinline
-
-#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)
+#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)
 #define SAFE_BUFFERS
 #define NEVER_INLINE __attribute__((noinline))
 #define FORCE_INLINE __attribute__((always_inline)) inline
-
-#endif // _MSC_VER
+#endif
 
 #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)
 
-// Variant pattern matching helper
-#define MATCH(arg, ...) constexpr(std::is_same_v<std::decay_t<decltype(arg)>, __VA_ARGS__>)
+// 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__))
 
 #define CONCATENATE_DETAIL(x, y) x ## y
 #define CONCATENATE(x, y) CONCATENATE_DETAIL(x, y)
@@ -66,20 +53,14 @@
 
 #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;
@@ -88,11 +69,7 @@ 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;
@@ -110,7 +87,7 @@ using steady_clock = std::conditional<
 
 namespace gsl
 {
-	using std::byte;
+	enum class byte : u8;
 }
 
 // Formatting helper, type-specific preprocessing for improving safety and functionality
@@ -134,9 +111,64 @@ 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
@@ -145,7 +177,7 @@ struct simple_type_helper
 };
 
 template <typename T>
-struct simple_type_helper<T, std::void_t<typename T::simple_type>>
+struct simple_type_helper<T, void_t<typename T::simple_type>>
 {
 	using type = typename T::simple_type;
 };
@@ -172,6 +204,22 @@ 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;
@@ -387,6 +435,14 @@ 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)
 {
@@ -415,7 +471,7 @@ struct offset32_array
 	template <typename Arg>
 	static inline u32 index32(const Arg& arg)
 	{
-		return u32{sizeof(std::remove_extent_t<T>)} * static_cast<u32>(arg);
+		return SIZE_32(std::remove_extent_t<T>) * static_cast<u32>(arg);
 	}
 };
 
@@ -425,7 +481,7 @@ struct offset32_array<std::array<T, N>>
 	template <typename Arg>
 	static inline u32 index32(const Arg& arg)
 	{
-		return u32{sizeof(T)} * static_cast<u32>(arg);
+		return SIZE_32(T) * static_cast<u32>(arg);
 	}
 };
 
@@ -458,6 +514,46 @@ 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)
 {
@@ -629,7 +725,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, std::void_t<typename From::simple_type>>
+struct narrow_impl<From, To, void_t<typename From::simple_type>>
 	: narrow_impl<simple_t<From>, To>
 {
 };
@@ -661,6 +757,42 @@ 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
@@ -685,7 +817,7 @@ struct value_hash
 template <template <typename> class TT, std::size_t S, std::size_t A = S>
 struct alignas(A) any_pod
 {
-	alignas(A) std::byte data[S];
+	std::aligned_storage_t<S, A> data;
 
 	any_pod() = default;
 
@@ -768,6 +900,35 @@ 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
 {
@@ -792,23 +953,26 @@ struct error_code
 	};
 
 	template<typename ET>
-	struct is_error<ET, std::enable_if_t<sizeof(ET::__not_an_error) != 0>> : std::false_type
+	struct is_error<ET, void_t<decltype(ET::__not_an_error)>> : std::false_type
 	{
 	};
 
-	// Common constructor
-	template<typename ET>
-	error_code(const ET& value)
+	// Not an error constructor
+	template<typename ET, typename = decltype(ET::__not_an_error)>
+	error_code(const ET& value, std::nullptr_t = nullptr)
 		: value(static_cast<s32>(value))
 	{
-		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
+	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))
+	{
 	}
 
 	// Error constructor (2 args)
-	template<typename ET, typename T2>
+	template<typename ET, typename T2, typename = std::enable_if_t<is_error<ET>::value>>
 	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)))
 	{
@@ -828,8 +992,93 @@ 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 cycles = 3000)
+inline void busy_wait(std::size_t count = 100)
 {
-	const u64 s = __rdtsc();
-	do _mm_pause(); while (__rdtsc() - s < cycles);
+	while (count--) _mm_pause();
 }
+
+// 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

Utilities/variant.hpp

@@ -0,0 +1,980 @@
+#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

Utilities/variant_visitor.hpp

@@ -0,0 +1,45 @@
+#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

Vulkan/CMakeLists.txt

@@ -1,4 +1,8 @@
-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)
+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()

Vulkan/Vulkan-build/Vulkan-build.vcxproj

@@ -0,0 +1,67 @@
+<?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>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</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 15 2017 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 15 2017 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 15 2017 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 15 2017 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 15 2017 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 15 2017 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>

Vulkan/Vulkan-build/Vulkan-build.vcxproj.filters

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" />

Vulkan/Vulkan-build/pre-build.bat

@@ -0,0 +1,13 @@
+@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

appveyor.yml

@@ -4,26 +4,22 @@ version: '{build}'
 image: Visual Studio 2017
 
 environment:
-  QTDIR: C:\Qt\5.11\msvc2017_64
-  LLVMLIBS: https://github.com/RPCS3/llvm/releases/download/continuous-master/llvmlibs.7z
-  GLSLANG: https://drive.google.com/uc?export=download&id=1nJK_NEeRzJ_r_u4zWLySwLmMrV8ZO_wL
+  QTDIR: C:\Qt\5.10\msvc2017_64
+  LLVMLIBS: https://drive.google.com/uc?export=download&id=0B8A6NaxhQAGRY2k3Q2Yya05lcm8
+  VULKAN: https://drive.google.com/uc?export=download&id=1A2eOMmCO714i0U7J0qI4aEMKnuWl8l_R
   COMPATDB: https://rpcs3.net/compatibility?api=v1&export
-  VULKAN_SDK: "C:\\VulkanSDK\\1.1.73.0"
-  VULKAN_SDK_URL: https://sdk.lunarg.com/sdk/download/1.1.73.0/windows/VulkanSDK-1.1.73.0-Installer.exe
-  VULKAN_SDK_MIRROR: https://obk.ee/rpcs3/VulkanSDK-1.1.73.0-Installer.exe
-  VULKAN_SDK_SHA: a5d193f97db4de97e6b4fdd81f00ff6a603f66bb17dc3cf8ac0fe9aec58497c7
 
 cache:
-- glslang.7z -> appveyor.yml
+- llvmlibs.7z -> appveyor.yml
+- vulkan.7z -> appveyor.yml
 - compat_database.dat
-- vulkan-sdk.exe -> appveyor.yml
 
 install:
 - ps: | # set env vars for versioning
     $env:COMM_TAG = $(git describe --tags $(git rev-list --tags --max-count=1))
     $env:COMM_COUNT = $(git rev-list --count HEAD)
-    $env:COMM_HASH = $(git rev-parse --short=8 HEAD)
-
+    $env:COMM_HASH = $env:APPVEYOR_REPO_COMMIT.Substring(0,8)
+    
     if ($env:APPVEYOR_PULL_REQUEST_NUMBER) {
         $env:BUILD = "rpcs3-{0}-{1}_win64.7z" -f $env:COMM_TAG, $env:COMM_HASH
         $env:AVVER = "{0}-{1}" -f $env:COMM_TAG.TrimStart("v"), $env:COMM_HASH
@@ -49,12 +45,13 @@ install:
       3rdparty/GSL `
       3rdparty/hidapi `
       3rdparty/libpng `
+      3rdparty/Optional `
       3rdparty/pugixml `
-      3rdparty/xxHash `
-      3rdparty/yaml-cpp `
       3rdparty/zlib `
       asmjit `
-      Vulkan/glslang
+      Utilities/yaml-cpp `
+      Vulkan/glslang `
+      Vulkan/Vulkan-LoaderAndValidationLayers
 
 platform: x64
 
@@ -66,32 +63,11 @@ build:
   verbosity: normal
 
 before_build:
-- ps: | # initialize mirror arrays and fetch precompiled build dependencies
-    $VULKAN_SDK_URLS = @(
-        $env:VULKAN_SDK_MIRROR;
-        $env:VULKAN_SDK_URL;
-        "$($env:VULKAN_SDK_URL)?Human=true";
-    )
+- ps: | # fetch precompiled build dependencies
     if (!(test-path llvmlibs.7z)) { irm $env:LLVMLIBS -outfile llvmlibs.7z }
-    if (!(test-path glslang.7z)) { irm $env:GLSLANG -outfile glslang.7z }
+    if (!(test-path vulkan.7z)) { irm $env:VULKAN -outfile vulkan.7z }
     7z x llvmlibs.7z -aos -o"." | out-null
-    7z x glslang.7z -aos -o".\lib\$env:CONFIGURATION-$env:PLATFORM" | out-null
-    if (!(test-path vulkan-sdk.exe))
-    {
-        foreach ($url in $VULKAN_SDK_URLS) {
-            irm $url -outfile vulkan-sdk.exe
-            if ($env:VULKAN_SDK_SHA -eq $(Get-FileHash .\vulkan-sdk.exe).Hash)
-            {
-                echo "Successfully downloaded and verified vulkan-sdk.exe!"
-                break
-            }
-            else
-            {
-                echo "Invalid file hash, Vulkan SDK Setup was possibly tampered with, retrying with a different mirror..."
-            }
-        }
-    }
-    .\vulkan-sdk.exe /S
+    7z x vulkan.7z -aos -o".\lib\$env:CONFIGURATION-$env:PLATFORM" | out-null
 
 after_build:
 - ps: | # remove unnecessary files
@@ -108,11 +84,9 @@ after_build:
     7z a -m0=LZMA2 -mx9 $env:BUILD .\bin\*
     7z a -m0=LZMA2 -mx9 openssl_win64.7z C:\OpenSSL-Win64\bin\libeay32.dll `
       C:\OpenSSL-Win64\bin\ssleay32.dll
-    $env:FILESIZEMB = (Get-Item $env:BUILD).length/1MB
 
 - ps: | # generate sha256 hashes
     (get-filehash $env:BUILD -algorithm SHA256).Hash | out-file ("{0}.sha256" -f $env:BUILD) -encoding ascii
-    $env:SHA256SUM = (get-filehash $env:BUILD -algorithm SHA256).Hash
     (get-filehash openssl_win64.7z -algorithm SHA256).Hash | out-file "openssl_win64.7z.sha256" -encoding ascii
 
 test: off
@@ -127,23 +101,6 @@ artifacts:
 - path: openssl_win64.7z.sha256
   name: openssl sha256 hash
 
-deploy:
-    provider: GitHub
-    # Description is a semi-colon seperated list for easy parsing
-    description: "$(SHA256SUM);$(FILESIZEMB)MB"
-    tag: build-$(APPVEYOR_REPO_COMMIT)
-    release: $(AVVER)
-    artifact: $(BUILD)
-    repository: RPCS3/rpcs3-binaries-win
-    draft: false
-    prerelease: false
-    force_update: true
-    auth_token:
-        secure: gTZqN6J9QNQTv9vu2qtExWk1x4o9dSfyTH/y86Yhe3qu+2w6Mly1MaDFMaXgrN1e
-    on:
-        branch: master
-        appveyor_repo_name: RPCS3/rpcs3
-
-on_success:
+on_finish: 
 - ps: | # update appveyor build version, done last to prevent webhook breakage
     update-appveyorbuild -version $env:AVVER

asmjitsrc/CMakeLists.txt

@@ -1,17 +0,0 @@
-set(ASMJIT_EMBED TRUE)
-set(ASMJIT_STATIC TRUE)
-set(ASMJIT_BUILD_X86 TRUE)
-set(ASMJIT_BUILD_ARM FALSE)
-set(ASMJIT_BUILD_TEST FALSE)
-set(ASMJIT_DIR "${CMAKE_SOURCE_DIR}/asmjit" CACHE PATH "Location of 'asmjit'")
-
-include("${ASMJIT_DIR}/CMakeLists.txt")
-
-add_library(asmjit ${ASMJIT_SRC})
-target_include_directories(asmjit PUBLIC ${ASMJIT_DIR}/src)
-target_link_libraries(asmjit PRIVATE ${ASMJIT_DEPS})
-
-# ASMJIT should have a option for disabling installing and this wouldnt
-# be required to avoid installing ASMJIT...
-
-add_library(3rdparty::asmjit ALIAS asmjit)

bin/GuiConfigs/Classic (Bright).qss

@@ -1,133 +0,0 @@
-/*
-Classic Bright Theme for RPCS3
-by Megamouse @ https://github.com/Megamouse
-*/
-
-/* toolbar color stylesheet */
-QLineEdit#mw_searchbar {
-	margin-left:14px;
-	background-color:rgba(227,227,227,255);
-}
-QToolBar#mw_toolbar {
-	background-color:rgba(227,227,227,255);
-}
-QToolBar#mw_toolbar QSlider {
-	background-color:rgba(227,227,227,255);
-}
-QToolBar#mw_toolbar::separator {
-	background-color:rgba(207,207,207,255);
-	width:1px;
-	margin-top:2px;
-	margin-bottom: 2px;
-}
-QSlider#sizeSlider::groove:horizontal {
-	border: 0em solid transparent;
-	height: .3em;
-	background: #fff;
-}
-QSlider#sizeSlider::handle:horizontal {
-	width: 1em;
-	margin: -.8em 0;
-}
-
-/* toolbar icon color stylesheet */
-QLabel#toolbar_icon_color {
-	color: rgba(64,64,64,255);
-}
-/* thumbnail icon color stylesheet */
-QLabel#thumbnail_icon_color {
-	color: rgba(0,100,231,255);
-}
-/* gamelist icon color stylesheet */
-QLabel#gamelist_icon_background_color {
-	color: rgba(209,209,209,255);
-}
-
-/* game grid stylesheet */
-QTableWidget#game_grid {
-	font-weight:600;
-	font-size:8pt;
-	font-family:Lucida Grande;
-	color: rgba(51,51,51,255);
-}
-QTableWidget#game_grid::item:selected:active {
-	selection-background-color: #0078D7;
-}
-QTableWidget#game_grid::item:selected:!active {
-	selection-background-color: #008cff;
-}
-
-/* log stylesheet */
-QTextEdit#tty_frame {
-	background-color:#ffffff;
-}
-QLabel#tty_text {
-	color:#000000;
-}
-QTextEdit#log_frame {
-	background-color:#ffffff;
-}
-QLabel#log_level_always {
-	color:#107896;
-}
-QLabel#log_level_fatal {
-	color:#ff00ff;
-}
-QLabel#log_level_error {
-	color:#C02F1D;
-}
-QLabel#log_level_todo {
-	color:#ff6000;
-}
-QLabel#log_level_success {
-	color:#008000;
-}
-QLabel#log_level_warning {
-	color:#BA8745;
-}
-QLabel#log_level_notice {
-	color:#000000;
-}
-QLabel#log_level_trace {
-	color:#808080;
-}
-QLabel#log_stack {
-	color: #000000;
-}
-
-/* other objects' stylesheet */
-QWidget#header_section {
-	background-color:#ffffff;
-}
-QDialog#kernel_explorer {
-	background-color:rgba(240,240,240,255);
-}
-QDialog#memory_viewer {
-	background-color:rgba(240,240,240,255);
-}
-QLabel#memory_viewer_address_panel {
-	color:rgba(75,135,150,255);
-	background-color:rgba(240,240,240,255);
-}
-QLabel#memory_viewer_hex_panel {
-	color:#000000;
-	background-color:rgba(240,240,240,255);
-}
-QLabel#memory_viewer_ascii_panel {
-	color:#000000;
-	background-color:rgba(240,240,240,255);
-}
-QLabel#debugger_frame_breakpoint {
-	color:#000000;
-	background-color:#ffff00;
-}
-QLabel#debugger_frame_pc {
-	color:#000000;
-	background-color:#00ff00;
-}
-QLabel#rsx_debugger_display_buffer {
-	background-color:rgba(240,240,240,255);
-}
-QLabel#l_controller {
-	color:#434343;
-}

bin/GuiConfigs/Darker Style by TheMitoSan.qss

@@ -198,32 +198,18 @@ QLabel#l_controller {
 }
 
 /* Game Grid Font */
-QTableWidget#game_grid {
+QLabel#gamegrid_font {
 	font-weight: 600;
 	font-size: 8pt;
 	font-family: Lucida Grande;
 	color: #FFF;
 }
-QTableWidget#game_grid::item:selected:!active {
-	selection-background-color: #313f4e;
-}
 
 /* Slider on toolbar */
 QWidget#sizeSliderContainer {
 	background: transparent;
 }
 
-QSlider#sizeSlider::groove:horizontal {
-	border: 0em solid transparent;
-	height: .3em;
-	background: #fff;
-}
-
-QSlider#sizeSlider::handle:horizontal {
-	width: 1em;
-	margin: -.8em 0;
-}
-
 /* Debug UI Settings buttons */
 QLabel#color_button {
 	background: transparent;
@@ -238,6 +224,7 @@ QLineEdit#mw_searchbar {
 /* Uniform colors in Toolbar */
 QToolButton {
 	background: transparent;
+	color: transparent;
 	border-radius: 0.125em;
 	padding: 0.09375em;
 	margin-left: 0.125em;

bin/GuiConfigs/Kuroi (Dark) by Ani.qss

@@ -1,42 +1,40 @@
-/*
-Kuroi (Dark) Theme for RPCS3
-also compatible with Dolphin
+/* 
+Kuroi (Dark) Theme for RPCS3 
 by Ani @ https://github.com/AniLeo
-r2 (2018.05.07)
----
-
-Color Scheme
-(Darker to Lighter)
-
-Black
-> 292929
-> 323232
-> 333333
-> 3d3d3d
-> 404040
-> 444444
-
-Light Grey
-> 828790
-> bdc3c7
-> ecf0f1
-> e6e6e6
-
-> b1b1b1
-> 7f8c8d
-
-Green
-> 2ecc71
-
-Red
-> e74c3c
+r1 (2017.08.15)
 */
 
+/* 
+Color Scheme
+(Darker to Lighter)
+  
+  Black 
+   > 292929
+   > 323232
+   > 333333
+   > 3d3d3d
+   > 404040
+   > 444444
+   
+  Light Grey
+   > 828790
+   > bdc3c7
+   > ecf0f1
+   
+   > b1b1b1
+   > 7f8c8d
+   
+  Green
+   > 2ecc71
+   
+  Red
+   > e74c3c
+*/
 
 /* Every widget */
 QWidget {
-	background-color: transparent;
-	color: #e6e6e6;
+	background-color: #323232;
+	color: #bdc3c7;
 	alternate-background-color: #3d3d3d;
 }
 
@@ -47,93 +45,24 @@ QToolTip {
 	color: #ecf0f1;
 }
 
-/* Define background on QDialog and QMainWindow */
-QDialog, QMainWindow {
-	background-color: #323232;
-}
-
-/* Top Menu Bar */
-QMenuBar::item:selected {
-	background: #444444;
-}
-QMenu {
-	background-color: #323232;
-}
-QMenu::item {
-	padding-left: 1.5em;
-	padding-right: 0.75em;
-	padding-top: 0.25em;
-	padding-bottom: 0.25em;
-}
-QMenu::item:selected {
-	background: #444444;
-	border: 0.05em solid #bdc3c7;
-}
-QMenu::item:disabled {
-	background-color: #444444;
-	color: #828790;
-}
-
-/* Tool Button (Toolbar) */
-QToolButton::disabled {
-	background-color: #444444;
-	color: #828790;
-}
-QToolButton::hover {
-	background-color: #3d3d3d;
-}
-
-/* Dock Widget */
-QDockWidget {
-	color: #e6e6e6;
-	font-weight: 500;
-}
-QDockWidget::title {
-	background: #3d3d3d;
-	padding-top: 0.20em;
-	padding-left: 0.10em;
-}
-/* Dock Buttons: For visibility */
-QDockWidget::close-button, QDockWidget::float-button {
-	background-color: #bdc3c7;
-	border: 0.05em solid #000;
-	border-radius: 0.3em;
-}
-
-/* Push Buttons */
-QPushButton {
-	background-color: #404040;
-}
-QPushButton::disabled {
-	background-color: #828790;
-}
-
 /* Table headers */
 QHeaderView::section {
-	background-color: #222;
+	background-color: #323232;
+	color: #ecf0f1;
 	padding-left: 0.2em;
 	border: 0.05em solid #323232;
 }
 
-/* Tab Widgets: Disable ugly borders */
-QTabWidget::pane {
-	border: 0em;
-}
-
-/* Text Edit: Log and Debugger borders */
-QTextEdit {
-	border: 0.05em solid #828790;
-}
-
-/* QTabBar (Settings Dialog) */
+/* Settings Dialog: Tabs */
 QTabBar::tab {
+	color: #ecf0f1;
 	border: 0.05em solid #444;
 	border-bottom-style: none;
 	background-color: #333333;
-	padding-left: 1em;
-	padding-right: 1em;
-	padding-top: 0.25em;
-	padding-bottom: 0.25em;
+	padding-left: 0.9em;
+	padding-right: 0.9em;
+	padding-top: 0.2em;
+	padding-bottom: 0.2em;
 	margin-right: -0.2em;
 }
 QTabBar::tab:last {
@@ -150,19 +79,6 @@ QTabBar::tab:hover {
 	color: #ecf0f1;
 }
 
-/* Group Boxes (Settings Dialog) */
-QGroupBox {
-	margin-top: 1em;
-	font-size: 8pt;
-	border: 0.05em solid #bdc3c7;
-}
-QGroupBox::title {
-	subcontrol-origin: margin;
-	subcontrol-position: top;
-	padding: 0.3em 0.5em 0.3em 0.5em;
-	color: #fff;
-}
-
 /* Checkboxes */
 QCheckBox::indicator {
 	border-radius: 0.1em;
@@ -183,11 +99,11 @@ QCheckBox::indicator::disabled {
 
 /* Radio Buttons */
 QRadioButton::indicator {
-	border-radius: 0.4em;
-	border: 0.05em solid;
-	border-color: white;
-	width: 0.8em;
-	height: 0.8em;
+  border-radius: 0.4em; 
+  border: 0.05em solid;  
+  border-color: white; 
+  width: 0.8em; 
+  height: 0.8em; 
 }
 QRadioButton::indicator:checked {
 	background-color: #2ecc71; /* Green */
@@ -213,14 +129,66 @@ QComboBox::disabled {
 	color: #fff;
 }
 
-/* Spin Boxes */
-QSpinBox, QDoubleSpinBox {
-	background: transparent;
-	border: 0.05em solid #4d4940;
-	border-radius: 0.10em;
+/* Group Boxes (Settings Dialog) */
+QGroupBox {
+	margin-top: 1em;
+	font-size: 8pt;
+	border: 0.05em solid #bdc3c7;
+	border-radius: 0.3em;
+}
+QGroupBox::title {
+	subcontrol-origin: margin;
+	subcontrol-position: top;
+	padding: 0.3em 0.5em 0.3em 0.5em;
+	color: #fff;
 }
 
-/* List Widget */
+/* Buttons */
+QPushButton {
+	background-color: #404040;
+}
+QPushButton::disabled {
+	background-color: #444444;
+	color: #828790;
+}
+
+/* Log and Debugger borders */
+QTextEdit {
+	border: 0.05em solid #828790;
+}
+
+/* For dock buttons to be visible */
+QDockWidget::close-button, QDockWidget::float-button {
+	background-color: #bdc3c7;
+	border: 0.05em solid #000;
+	border-radius: 0.3em;
+}
+
+/* Disable ugly borders */
+QTabWidget::pane {
+	border: 0em solid #828790;
+}
+
+/* Top menu bar */
+QMenuBar::item:selected {
+	background: #444444;
+}
+QMenu::item {
+	padding-left: 1.5em;
+	padding-right: 0.75em;
+	padding-top: 0.25em;
+	padding-bottom: 0.25em;
+}
+QMenu::item:selected {
+	background: #444444;
+	border: 0.05em solid #bdc3c7;
+}
+QMenu::item:disabled {
+	background-color: #444444;
+	color: #828790;
+}
+
+/* Libraries list */
 QListWidget::item:selected {
 	background-color: #3d3d3d;
 	color: #ecf0f1;
@@ -230,48 +198,45 @@ QListWidget::item:hover {
 	color: #ecf0f1;
 }
 
-
-/*** RPCS3 Specifics ***/
-
-/* Define background on Setting Widgets,
-CG Disasm, Trophy Manager, RSX Debugger
-which are neither QDialog nor QMainWindow */
-QWidget#coreTab, QWidget#gpuTab, QWidget#audioTab,
-QWidget#inputTab, QWidget#systemTab, QWidget#networkTab,
-QWidget#emulatorTab, QWidget#debugTab,
-QWidget#cg_disasm, QWidget#trophy_manager {
-	background-color: #323232;
-}
-
-/* Trophy Notification Popup */
-QWidget#trophy_notification_frame {
-	background-color: #323232;
-	color: #e6e6e6;
+/* Pad Settings: Controller Image */
+QLabel#l_controller { 
+	color: #bdc3c7;
 }
 
 /* Game Grid Font */
-QTableWidget#game_grid {
+QLabel#gamegrid_font {
 	font-weight: 600;
 	font-size: 8pt;
 	font-family: Lucida Grande;
-	selection-color: #e6e6e6;
-}
-QTableWidget#game_grid::item:selected:active {
-	selection-background-color: #4c4b4b;
-}
-QTableWidget#game_grid::item:selected:!active {
-	selection-background-color: #3d3d3d;
+	color: #ecf0f1;
 }
 
-/* Set Toolbar Slider Size */
-QSlider#sizeSlider::groove:horizontal {
-	border: 0em solid transparent;
-	height: .3em;
-	background: #fff;
+/* Slider on toolbar */
+QWidget#sizeSliderContainer {
+	background: transparent;
 }
-QSlider#sizeSlider::handle:horizontal {
-	width: 1em;
-	margin: -.8em 0;
+
+/* Debug UI Settings buttons */
+QLabel#color_button {
+	background: transparent;
+}
+
+/* Seachbar on main toolbar */
+QLineEdit#mw_searchbar { 
+	margin-left: 0.7em; 
+	color: #ecf0f1;
+}
+
+/* Uniform colors in Toolbar */
+QToolButton {
+	background: transparent;
+	color: transparent;
+}
+QToolButton::disabled {
+	background-color: #828790;
+}
+QToolButton::hover {
+	background-color: #444444;
 }
 
 /* Set Theme UI colors */
@@ -279,32 +244,11 @@ QLabel#gamelist_icon_background_color {
 	color: transparent;
 }
 
-/* Set Taskbar Thumbnail colors */
+/* Set Windows Taskbar Thumbnail colors */
 QLabel#thumbnail_icon_color {
 	color: #444444;
 }
 
-/* Memory Viewer */
-QLabel#memory_viewer_address_panel {
-	color: #00cbff; /* Font Color: Blue */
-}
-QLabel#memory_viewer_hex_panel {
-	color: #bdc3c7; /* Font Color: Grey */
-}
-QLabel#memory_viewer_ascii_panel {
-	color: #bdc3c7; /* Font Color: Grey */
-}
-
-/* Debugger colors */
-QLabel#debugger_frame_breakpoint {
-	color: #000000; /* Font Color: Black */
-	background-color: #ffff00; /* Yellow */
-}
-QLabel#debugger_frame_pc {
-	color: #000000; /* Font Color: Black */
-	background-color: #00ff00; /* Green */
-}
-
 /* Set Log colors */
 QTextEdit#log_frame {
 	background-color: #000000; /* Black */
@@ -336,6 +280,7 @@ QLabel#log_level_trace {
 QLabel#log_stack {
 	color: #ffffff; /* White */
 }
+
 /* Set TTY colors */
 QTextEdit#tty_frame {
 	background-color: #000000; /* Black */
@@ -343,3 +288,40 @@ QTextEdit#tty_frame {
 QLabel#tty_text {
 	color: #ffffff; /* White */
 }
+
+/* RSX Debugger */
+QLabel#rsx_debugger_display_buffer {
+	background-color: #323232;
+}
+
+/* Kernel Explorer */
+QDialog#kernel_explorer {
+	background-color: #323232;
+}
+
+/* Memory Viewer */
+QDialog#memory_viewer {
+	background-color: #323232;
+}
+QLabel#memory_viewer_address_panel {
+	color: #00cbff; /* Font Color: Blue */
+	background-color: #323232;
+}
+QLabel#memory_viewer_hex_panel {
+	color: #bdc3c7; /* Font Color: Grey */
+	background-color: #323232;
+}
+QLabel#memory_viewer_ascii_panel {
+	color: #bdc3c7; /* Font Color: Grey */
+	background-color: #323232;
+}
+
+/* Debugger colors */
+QLabel#debugger_frame_breakpoint {
+	color: #000000; /* Font Color: Black */
+	background-color: #ffff00; /* Yellow */
+}
+QLabel#debugger_frame_pc {
+	color: #000000; /* Font Color: Black */
+	background-color: #00ff00; /* Green */
+}

bin/GuiConfigs/ModernBlue Theme by TheMitoSan.qss

@@ -195,32 +195,18 @@ QLabel#l_controller {
 }
 
 /* Game Grid Font */
-QTableWidget#game_grid {
+QLabel#gamegrid_font {
 	font-weight: 600;
 	font-size: 8pt;
 	font-family: Lucida Grande;
 	color: #fff;
 }
-QTableWidget#game_grid::item:selected:!active {
-	selection-background-color: #354454;
-}
 
 /* Slider on toolbar */
 QWidget#sizeSliderContainer {
 	background: transparent;
 }
 
-QSlider#sizeSlider::groove:horizontal {
-	border: 0em solid transparent;
-	height: .3em;
-	background: #fff;
-}
-
-QSlider#sizeSlider::handle:horizontal {
-	width: 1em;
-	margin: -.8em 0;
-}
-
 /* Debug UI Settings buttons */
 QLabel#color_button {
 	background: transparent;
@@ -235,6 +221,7 @@ QLineEdit#mw_searchbar {
 /* Uniform colors in Toolbar */
 QToolButton {
 	background: transparent;
+	color: transparent;
 	border-radius: 0.125em;
 	padding: 0.09375em;
 	margin-left: 0.125em;