Merge branch 'master' into master

Game list: improve deduplication logic
SPU ASMJIT: rewrite 128-bit shifts by bit
2018-02-09 12:34:50 +00:00 · 2018-02-08 21:10:03 +03:00 · 2018-02-08 21:10:03 +03:00 · 2018-02-08 21:10:03 +03:00 · 2018-02-08 21:10:03 +03:00 · 2018-02-08 21:10:03 +03:00
465 changed files with 50460 additions and 19271 deletions
@@ -0,0 +1,24 @@
+<!---
+
+THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
+https://forums.rpcs3.net
+or our discord:
+https://discord.me/RPCS3
+
+PLEASE READ THE GUIDELINES BEFORE OPENING AN ISSUE:
+https://github.com/RPCS3/rpcs3/blob/master/CONTRIBUTING.md
+
+====================================================
+
+When submitting an issue, please check the following:
+
+- You have read the above.
+- You have provided the version (commit hash) of RPCS3 you are using.
+- You have provided sufficient detail for the issue to be reproduced.
+- You have provided system specs.
+- Please also provide:
+  - For crashes, a backtrace.
+  - For graphical issues, comparison screenshots with real hardware.
+
+Remember that the GitHub Issue Tracker is not the place to ask for support or to submit Game Compatibility reports. You must use our forums for that.
+--->
@@ -41,6 +41,10 @@
 /Vulkan/Vulkan-build
 /Vulkan/glslang-build

+# Themes
+!/bin/GuiConfigs/
+/bin/GuiConfigs/*.ini
+
 /bin/rpcs3.ini
 /bin/rpcs3.ipdb
 /bin/rpcs3.iobj
@@ -70,6 +74,7 @@ rpcs3/git-version.h
 !/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
@@ -7,11 +7,8 @@
 	ignore = dirty
 [submodule "llvm"]
 	path = llvm
-	url = https://github.com/llvm-mirror/llvm
-	branch = release_40
-[submodule "rsx_program_decompiler"]
-	path = rsx_program_decompiler
-	url = https://github.com/RPCS3/rsx_program_decompiler
+	url = https://github.com/RPCS3/llvm
+	branch = release_60
 [submodule "GSL"]
 	path = 3rdparty/GSL
 	url = https://github.com/Microsoft/GSL.git
@@ -28,19 +25,20 @@
 [submodule "Utilities/yaml-cpp"]
 	path = Utilities/yaml-cpp
 	url = https://github.com/RPCS3/yaml-cpp
-[submodule "3rdparty/pugixml"]
-	path = 3rdparty/pugixml
-	url = https://github.com/RPCS3/pugixml
 [submodule "3rdparty/cereal"]
 	path = 3rdparty/cereal
 	url = https://github.com/USCiLab/cereal.git
-[submodule "rsx-debugger"]
-	path = rsx-debugger
-	url = https://github.com/RPCS3/rsx-debugger.git
 [submodule "3rdparty/zlib"]
 	path = 3rdparty/zlib
 	url = https://github.com/madler/zlib
 [submodule "3rdparty/hidapi"]
 	path = 3rdparty/hidapi
 	url = https://github.com/RPCS3/hidapi
-	branch = master
+	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
@@ -1,6 +1,5 @@
 language: cpp
 sudo: required
-dist: trusty

 os:
  - linux
@@ -17,75 +16,68 @@ cache:
  directories:
    - $HOME/hombebrew_cache

-env:
-  global:
-    - secure: BXyNziNYFLqLtY6Q58BDEUpRJr81HUtHpxf2Sr646bDcbG0Rf2rb2utqHZJ1Om926WdH7RqHuoVti4dr2X1lh4nHMkLD7MrIrfIkNN5T9aZdk19uw9IyMtz/cXon7/wqVo24tVqtBI0UghFxKii/GTDJEvRKgfpPp1e1vKSNGa4=
-    # Which Travis environment to run Coverity on
-    - coverity_scan_run_condition='"$TRAVIS_OS_NAME" = linux -a "$CC" = gcc'
-    # Test mode is for testing if it's working with Coverity. Change to true if testing, to avoid reaching the quota.
-    - coverity_scan_script_test_mode=false
-
 matrix:
  exclude:
    - os: osx
      compiler: gcc
-  

 git:
+  depth: false # Unshallow clone to obtain proper GIT_VERSION
  submodules: false

 before_install:
-  - if [ "$CC" = "clang" ]; then
-      export CXX="clang++-4.0" CC="clang-4.0";
-    fi;    
  - if [ "$TRAVIS_OS_NAME" = "linux" ] && [ "$CXX" = "g++" ]; then
      export CXX="g++-5" CC="gcc-5" CXXFLAGS="-Wno-format-security";
-      export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01';
    fi;
  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
      wget http://download.qt.io/official_releases/online_installers/qt-unified-linux-x64-online.run ;
      chmod a+x ./qt-unified-linux-x64-online.run ;
      export QT_QPA_PLATFORM=minimal ;
-      ./qt-unified-linux-x64-online.run --script qt-installer-noninteractive.qs --no-force-installations ;
+      travis_wait 60 ./qt-unified-linux-x64-online.run --script qt-installer-noninteractive.qs --no-force-installations --verbose ;
    fi;
-  
-  # Add coverall for C++ so coverall.io could be triggered. Even it should be --coverage and gcov.
+
  # Install updated libglew-dev since the version provided by trusty is outdated
  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      pip install --user cpp-coveralls requests[security];
-      wget http://mirrors.kernel.org/ubuntu/pool/main/g/glew/libglew-dev_1.13.0-2_amd64.deb;
-      wget http://mirrors.kernel.org/ubuntu/pool/main/g/glew/libglew1.13_1.13.0-2_amd64.deb;
-      wget http://mirrors.kernel.org/ubuntu/pool/universe/v/vulkan/libvulkan1_1.0.42.0+dfsg1-1ubuntu1~16.04.1_amd64.deb;
-      wget http://mirrors.kernel.org/ubuntu/pool/universe/v/vulkan/libvulkan-dev_1.0.42.0+dfsg1-1ubuntu1~16.04.1_amd64.deb;
-      sudo dpkg -i libglew1.13_1.13.0-2_amd64.deb libglew-dev_1.13.0-2_amd64.deb libvulkan1_1.0.42.0+dfsg1-1ubuntu1~16.04.1_amd64.deb libvulkan-dev_1.0.42.0+dfsg1-1ubuntu1~16.04.1_amd64.deb;
+      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 update;
+      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 Vulkan/glslang Vulkan/Vulkan-LoaderAndValidationLayers
+  - git submodule update --init asmjit 3rdparty/ffmpeg 3rdparty/pugixml 3rdparty/GSL 3rdparty/libpng Utilities/yaml-cpp 3rdparty/cereal 3rdparty/hidapi 3rdparty/Optional Vulkan/glslang Vulkan/Vulkan-LoaderAndValidationLayers
  - mkdir build
  - cd build
-  - export CMAKE_PREFIX_PATH=~/Qt/5.9.1/gcc_64/lib/cmake
-  - cmake .. -DCMAKE_INSTALL_PREFIX=/usr;
-  - make -j 3
+  - export CMAKE_PREFIX_PATH=~/Qt/5.10.0/gcc_64/lib/cmake
+  - export CXXFLAGS="$CXXFLAGS -DTRAVIS=true";
+  - if [ "$TRAVIS_PULL_REQUEST" = false ]; then
+      export CXXFLAGS="$CXXFLAGS -DBRANCH=$TRAVIS_REPO_SLUG/$TRAVIS_BRANCH";
+    else
+      export CXXFLAGS="$CXXFLAGS -DBRANCH=$TRAVIS_REPO_SLUG/$TRAVIS_BRANCH/#$TRAVIS_PULL_REQUEST";
+    fi;
+  - cmake .. -DCMAKE_INSTALL_PREFIX=/usr -G Ninja;
+  - ninja
  - # AppImage generation
-  - if [ "$TRAVIS_BRANCH" = "master" ] && [ "$CC" = "clang-4.0" ] && [ "$TRAVIS_PULL_REQUEST" = false ]; then
-      export LD_LIBRARY_PATH=~/Qt/5.9.1/gcc_64/lib;
-      make DESTDIR=appdir install ; find appdir/ ;
+  - if [ -n "$UPLOAD_URL" ] && [ "$TRAVIS_BRANCH" = "master" ] && [ "$CC" = "clang" ] && [ "$TRAVIS_PULL_REQUEST" = false ]; then
+      export LD_LIBRARY_PATH=~/Qt/5.10.0/gcc_64/lib;
+      DESTDIR=appdir ninja install ; find appdir/ ;
      find ../bin ;
-      wget -c "https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage" ; 
+      wget -c "https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage" ;
      chmod a+x linuxdeployqt*.AppImage ;
-      export PATH=~/Qt/5.9.1/gcc_64/bin/:${PATH} ;
+      export PATH=~/Qt/5.10.0/gcc_64/bin/:${PATH} ;
      ./linuxdeployqt*.AppImage --appimage-extract ;
      ./linuxdeployqt*.AppImage ./appdir/usr/share/applications/*.desktop -bundle-non-qt-libs ;
-      mkdir ./appdir/usr/plugins/xcbglintegrations/ ; 
+      mkdir ./appdir/usr/plugins/xcbglintegrations/ ;
      mkdir ./appdir/usr/plugins/imageformats/ ;
-      cp ~/Qt/5.9.1/gcc_64/lib/libQt5Svg.so.5 ./appdir/usr/lib/ ;
-      cp ~/Qt/5.9.1/gcc_64/plugins/xcbglintegrations/* ./appdir/usr/plugins/xcbglintegrations/ ;
-      cp ~/Qt/5.9.1/gcc_64/plugins/imageformats/* ./appdir/usr/plugins/imageformats/ ;
-      cp ~/Qt/5.9.1/gcc_64/plugins/platforms/* ./appdir/usr/plugins/platforms/ ;
+      cp ~/Qt/5.10.0/gcc_64/lib/libQt5Svg.so.5 ./appdir/usr/lib/ ;
+      cp ~/Qt/5.10.0/gcc_64/plugins/xcbglintegrations/* ./appdir/usr/plugins/xcbglintegrations/ ;
+      cp ~/Qt/5.10.0/gcc_64/plugins/imageformats/* ./appdir/usr/plugins/imageformats/ ;
+      cp ~/Qt/5.10.0/gcc_64/plugins/platforms/* ./appdir/usr/plugins/platforms/ ;
+      rm ./appdir/usr/lib/libfreetype.so.6 ;
      export PATH=${TRAVIS_BUILD_DIR}/build/squashfs-root/usr/bin/:${PATH} ;
      ./squashfs-root/usr/bin/appimagetool ${TRAVIS_BUILD_DIR}/build/appdir ;
      find ./appdir -executable -type f -exec ldd {} \; | grep " => /usr" | cut -d " " -f 2-3 | sort | uniq ;
@@ -97,15 +89,17 @@ script:
  #- echo "--Shell Export Lists START--" ; export -p; echo "--Shell Export Lists STOP--";
  # And to ensure the versions of toolchain
  - echo "--CXX version?"; "$CXX" --version; echo "--CXX version confirmed";
-  #- if [ "$COVERITY_SCAN_BRANCH" != 1 ]; then make -j 3; fi

 addons:
  apt:
    sources:
      - ubuntu-toolchain-r-test
      - llvm-toolchain-trusty-4.0
+      - sourceline: 'ppa:jonathonf/binutils' # We need to update binutils to a newer version to link against the ffmpeg libs on.
    packages:
+      - binutils
      - cmake
+      - ninja-build
      - libasound2-dev
      - libopenal-dev
      - freeglut3-dev
@@ -115,24 +109,16 @@ addons:
      - libc6-dev
      - llvm-4.0
      - llvm-4.0-dev
-      - clang-4.0
+      # Clang 5.0 is now bundled in travis, so we no longer need the ppa version.
+      #- clang-4.0
      - libedit-dev
      - g++-5
      - gcc-5
      - libstdc++-5-dev
      - lib32stdc++6
      - zlib1g-dev
-      # We need to install qt 5.9.1 manually because the version trusty provides is too old.
+      # We need to install qt 5.10.0 manually because the version trusty provides is too old.
      #- qtbase5-dev
      - libudev-dev
      - libevdev-dev
-  coverity_scan:
-    project:
-      name: $TRAVIS_REPO_SLUG
-      description: "PS3 emulator/debugger"
-    notification_email: nekotekina@gmail.com
-    build_command: "make -j 3"
-    branch_pattern: coverity_scan
-
-after_success:
-  - if [ "$COVERITY_SCAN_BRANCH" != 1 ] && [ "$TRAVIS_OS_NAME" = linux ]; then coveralls --extension .c --extension .cpp --extension .h; fi
+      - libpulse-dev
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0.2)
+cmake_minimum_required(VERSION 3.1)

 option(WITH_GDB "WITH_GDB" OFF)
 option(WITHOUT_LLVM "WITHOUT_LLVM" OFF)
@@ -1,6 +1,6 @@
 # Getting Started

-Before getting started using the emulator, read the [Quickstart Guide](https://rpcs3.net/quickstart) and the [FAQ](https://rpcs3.net/faq). After reading those, if you need support, visit our [Forums](http://www.emunewz.net/forum/forumdisplay.php?fid=172). 
+Before getting started using the emulator, read the [Quickstart Guide](https://rpcs3.net/quickstart) and the [FAQ](https://rpcs3.net/faq). After reading those, if you need support, visit our [Forums](https://forums.rpcs3.net). 

 # Issue Reporting

@@ -13,7 +13,7 @@ Before getting started using the emulator, read the [Quickstart Guide](https://r
 - Use understandable English. It doesn't need to be perfect, but clear enough to understand your message.
 - While reporting issues, don't forget to include details about your system (OS, CPU, GPU, etc.), as well as the RPCS3.log file.

-Submitting your test results for Commercial Games must be done on our forums' [Commercial Games](http://www.emunewz.net/forum/forumdisplay.php?fid=193) section. If there's already a thread for the game you want to report post in it, otherwise please make a new thread following the [Guidelines for submitting new games](http://www.emunewz.net/forum/showthread.php?tid=174376).
+Submitting your test results for Commercial Games must be done on our forums. Please read the [Game Compatibility](https://github.com/RPCS3/rpcs3/wiki/Game-Compatibility) wiki page before doing so.

 # Contributing

@@ -3,14 +3,13 @@ RPCS3

 [![Build Status](https://travis-ci.org/RPCS3/rpcs3.svg?branch=master)](https://travis-ci.org/RPCS3/rpcs3)
 [![Build status](https://ci.appveyor.com/api/projects/status/411c4clmiohtx7eo/branch/master?svg=true)](https://ci.appveyor.com/project/rpcs3/rpcs3/branch/master)
-[![Coverity Status](https://img.shields.io/coverity/scan/3960.svg)](https://scan.coverity.com/projects/3960)

 The world's first open-source PlayStation 3 emulator/debugger written in C++ for Windows and Linux.

 You can find some basic information in our [**website**](https://rpcs3.net/). 
-For discussion about this emulator and PS3 emulation please visit our [**forums**](http://www.emunewz.net/forum/forumdisplay.php?fid=172) and our [**Discord server**](https://discord.me/RPCS3).
+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 Developer Nekotekina on Patreon**](https://www.patreon.com/Nekotekina)
+[**Support Lead Developers Nekotekina and kd-11 on Patreon**](https://www.patreon.com/Nekotekina)


 ## Development
@@ -21,24 +20,26 @@ If you want to contribute please take a look at the [Coding Style](https://githu
 ## Dependencies

 ### Windows
-* [Visual Studio 2015](https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx)
+* [Visual Studio 2015](https://www.visualstudio.com/vs/older-downloads/)
 * [Visual C++ Redistributable Packages for Visual Studio 2015](http://www.microsoft.com/en-us/download/details.aspx?id=48145)
 * [Cmake 3.1.0+](https://www.cmake.org/download/) (required; add to PATH)
 * [Python 3.3+](https://www.python.org/downloads/) (required; add to PATH)
-* [Qt 5.7+](https://www.qt.io/download-open-source/) (required; add QTDIR `<QtInstallFolder>\5.7\msvc2015_64\` environment variable if you do not want to use the Visual Studio Qt Plugin)
+* [Qt 5.8+](https://www.qt.io/download-open-source/) (required; add QTDIR `<QtInstallFolder>\5.8\msvc2015_64\` environment variable if you do not want to use the Visual Studio Qt Plugin)
 * [Visual Studio Qt Plugin](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.QtVisualStudioTools2015) (optional; see above)

 ### Linux
 * [Qt 5.7+](https://www.qt.io/download-open-source/)
 * GCC 5.1+ or Clang 3.5.0+ ([not GCC 6.1](https://github.com/RPCS3/rpcs3/issues/1691))
-* Debian & Ubuntu: `sudo apt-get install cmake build-essential libasound2-dev libopenal-dev libglew-dev zlib1g-dev libedit-dev libvulkan-dev libudev-dev git qt5-default`
+* 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 qt5-devel vulkan-devel libGLEW`
+* 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.**

-### Mac OSX 
-Mac OSX is not supported at this moment because it doesn't meet system requirements (OpenGL 4.3)
+### 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`
+* Install with Homebrew: `brew install glew llvm qt cmake`


 ## Building on Windows:
@@ -47,38 +48,58 @@ To initialize the repository don't forget to execute `git submodule update --ini
 ### Configuring Qt

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

 *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.7\msvc2015_64`. </br>
+1) Go to the Qt5 menu and edit Qt5 options. Add the path to your Qt installation with compiler e.g. `C:\Qt\5.8\msvc2015_64`. </br>
 2) While selecting the rpcs3qt project, go to Qt5->Project Setting and select the version you added. 

 ### Building the projects
-1) Build the projects in *__BUILD_BEFORE* folder: right-click on every project > *Build*. </br>
-2) Press *BUILD* > *Build Solution* or *Rebuild Solution*. </br>
+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).
+
+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 OSX:
+
+## 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) `cmake CMakeLists.txt && make GitVersion && make` </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 OSX and want to build with llvm don't forget to add `-DLLVM_DIR=...` (or wherever llvm brew was installed) to cmake invocation.
+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`).


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

- ```-DUSE_SYSTEM_LIBPNG=ON/OFF``` (default = *OFF*) </br>
+- ```-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*) </br>
+- ```-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.

 ## License

@@ -470,7 +470,7 @@ struct se_storage<T, 16, 16>

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

 	static inline v128 to(const T& src)
@@ -3,6 +3,8 @@

 #include "yaml-cpp/yaml.h"

+#include <typeinfo>
+
 namespace cfg
 {
 	logs::channel cfg("CFG");
@@ -48,6 +50,11 @@ namespace cfg
 	static void decode(const YAML::Node& data, class _base& rhs);
 }

+std::vector<std::string> cfg::make_int_range(s64 min, s64 max)
+{
+	return {std::to_string(min), std::to_string(max)};
+}
+
 bool cfg::try_to_int64(s64* out, const std::string& value, s64 min, s64 max)
 {
 	// TODO: this could be rewritten without exceptions (but it should be as safe as possible and provide logs)
@@ -82,6 +89,8 @@ bool cfg::try_to_int64(s64* out, const std::string& value, s64 min, s64 max)

 bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) func, const std::string& value)
 {
+	u64 max = -1;
+
 	for (u64 i = 0;; i++)
 	{
 		std::string var;
@@ -99,6 +108,8 @@ bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) f
 		{
 			break;
 		}
+
+		max = i;
 	}

 	try
@@ -108,14 +119,22 @@ bool cfg::try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) f

 		if (pos != value.size())
 		{
+			if (out) cfg.error("cfg::try_to_enum_value('%s'): unexpected characters (pos=%zu)", value, pos);
+			return false;
+		}
+
+		if (val > max)
+		{
+			if (out) cfg.error("cfg::try_to_enum_value('%s'): out of bounds(0..%u)", value, max);
 			return false;
 		}

 		if (out) *out = val;
 		return true;
 	}
-	catch (...)
+	catch (const std::exception& e)
 	{
+		if (out) cfg.error("cfg::try_to_enum_value('%s'): invalid enum value: %s", value, e.what());
 		return false;
 	}
 }
@@ -183,9 +202,12 @@ void cfg::encode(YAML::Emitter& out, const cfg::_base& rhs)
 		out << YAML::EndMap;
 		return;
 	}
+	default:
+	{
+		out << rhs.to_string();
+		return;
+	}
 	}
-
-	out << rhs.to_string();
 }

 void cfg::decode(const YAML::Node& data, cfg::_base& rhs)
@@ -268,14 +290,19 @@ std::string cfg::node::to_string() const
 	YAML::Emitter out;
 	cfg::encode(out, *this);

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

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

 void cfg::node::from_default()
 {
@@ -12,6 +12,9 @@

 namespace cfg
 {
+	// Format min and max values
+	std::vector<std::string> make_int_range(s64 min, s64 max);
+
 	// Convert string to signed integer
 	bool try_to_int64(s64* out, const std::string& value, s64 min, s64 max);

@@ -115,7 +118,7 @@ namespace cfg
 		bool m_value;

 	public:
-		const bool def;
+		bool def;

 		_bool(node* owner, const std::string& name, bool def = false)
 			: _base(type::_bool, owner, name)
@@ -147,6 +150,11 @@ namespace cfg

 			return true;
 		}
+
+		void set(const bool& value)
+		{
+			m_value = value;
+		}
 	};

 	// Value node with fixed set of possible values, each maps to an enum value of type T.
@@ -214,7 +222,7 @@ namespace cfg
 		int_type m_value;

 	public:
-		const int_type def;
+		int_type def;

 		_int(node* owner, const std::string& name, int_type def = std::min<int_type>(Max, std::max<int_type>(Min, 0)))
 			: _base(type::_int, owner, name)
@@ -249,6 +257,16 @@ namespace cfg

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

 	// Alias for 32 bit int
@@ -263,7 +281,7 @@ namespace cfg
 		std::string m_value;

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

 		string(node* owner, const std::string& name, const std::string& def = {})
 			: _base(type::string, owner, name)
@@ -8,6 +8,7 @@
 #include <algorithm>
 #include <cstring>
 #include <cerrno>
+#include <typeinfo>

 using namespace std::literals::string_literals;

@@ -74,10 +75,25 @@ static time_t to_time(const FILETIME& ft)

 static FILETIME from_time(s64 _time)
 {
-	const ullong wtime = (_time + 11644473600ULL) * 10000000ULL;
 	FILETIME result;
-	result.dwLowDateTime = static_cast<DWORD>(wtime);
-	result.dwHighDateTime = static_cast<DWORD>(wtime >> 32);
+
+	if (_time <= -11644473600ll)
+	{
+		result.dwLowDateTime = 0;
+		result.dwHighDateTime = 0;
+	}
+	else if (_time > INT64_MAX / 10000000ll - 11644473600ll)
+	{
+		result.dwLowDateTime = 0xffffffff;
+		result.dwHighDateTime = 0x7fffffff;
+	}
+	else
+	{
+		const ullong wtime = (_time + 11644473600ull) * 10000000ull;
+		result.dwLowDateTime = static_cast<DWORD>(wtime);
+		result.dwHighDateTime = static_cast<DWORD>(wtime >> 32);
+	}
+
 	return result;
 }

@@ -93,6 +109,10 @@ static fs::error to_error(DWORD e)
 	case ERROR_NEGATIVE_SEEK: return fs::error::inval;
 	case ERROR_DIRECTORY: return fs::error::inval;
 	case ERROR_INVALID_NAME: return fs::error::inval;
+	case ERROR_SHARING_VIOLATION: return fs::error::acces;
+	case ERROR_DIR_NOT_EMPTY: return fs::error::notempty;
+	case ERROR_NOT_READY: return fs::error::noent;
+	//case ERROR_INVALID_PARAMETER: return fs::error::inval;
 	default: fmt::throw_exception("Unknown Win32 error: %u.", e);
 	}
 }
@@ -103,6 +123,7 @@ static fs::error to_error(DWORD e)
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/statvfs.h>
+#include <sys/file.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <libgen.h>
@@ -127,6 +148,7 @@ static fs::error to_error(int e)
 	case EEXIST: return fs::error::exist;
 	case EINVAL: return fs::error::inval;
 	case EACCES: return fs::error::acces;
+	case ENOTEMPTY: return fs::error::notempty;
 	default: fmt::throw_exception("Unknown system error: %d.", e);
 	}
 }
@@ -509,7 +531,7 @@ bool fs::remove_dir(const std::string& path)
 #endif
 }

-bool fs::rename(const std::string& from, const std::string& to)
+bool fs::rename(const std::string& from, const std::string& to, bool overwrite)
 {
 	const auto device = get_virtual_device(from);

@@ -524,14 +546,43 @@ bool fs::rename(const std::string& from, const std::string& to)
 	}

 #ifdef _WIN32
-	if (!MoveFileW(to_wchar(from).get(), to_wchar(to).get()))
+	const auto ws1 = to_wchar(from);
+	const auto ws2 = to_wchar(to);
+
+	if (!MoveFileExW(ws1.get(), ws2.get(), overwrite ? MOVEFILE_REPLACE_EXISTING : 0))
 	{
-		g_tls_error = to_error(GetLastError());
+		DWORD error1 = GetLastError();
+
+		if (overwrite && error1 == ERROR_ACCESS_DENIED && is_dir(from) && is_dir(to))
+		{
+			if (RemoveDirectoryW(ws2.get()))
+			{
+				if (MoveFileW(ws1.get(), ws2.get()))
+				{
+					return true;
+				}
+
+				error1 = GetLastError();
+				CreateDirectoryW(ws2.get(), NULL); // TODO
+			}
+			else
+			{
+				error1 = GetLastError();
+			}
+		}
+
+		g_tls_error = to_error(error1);
 		return false;
 	}

 	return true;
 #else
+	if (!overwrite && exists(to))
+	{
+		g_tls_error = fs::error::exist;
+		return false;
+	}
+
 	if (::rename(from.c_str(), to.c_str()) != 0)
 	{
 		g_tls_error = to_error(errno);
@@ -645,18 +696,17 @@ bool fs::truncate_file(const std::string& path, u64 length)

 #ifdef _WIN32
 	// Open the file
-	const auto handle = CreateFileW(to_wchar(path).get(), GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	const auto handle = CreateFileW(to_wchar(path).get(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 	if (handle == INVALID_HANDLE_VALUE)
 	{
 		g_tls_error = to_error(GetLastError());
 		return false;
 	}

-	LARGE_INTEGER distance;
-	distance.QuadPart = length;
+	FILE_END_OF_FILE_INFO _eof;
+	_eof.EndOfFile.QuadPart = length;

-	// Seek and truncate
-	if (!SetFilePointerEx(handle, distance, NULL, FILE_BEGIN) || !SetEndOfFile(handle))
+	if (!SetFileInformationByHandle(handle, FileEndOfFileInfo, &_eof, sizeof(_eof)))
 	{
 		g_tls_error = to_error(GetLastError());
 		CloseHandle(handle);
@@ -685,7 +735,7 @@ bool fs::utime(const std::string& path, s64 atime, s64 mtime)

 #ifdef _WIN32
 	// Open the file
-	const auto handle = CreateFileW(to_wchar(path).get(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	const auto handle = CreateFileW(to_wchar(path).get(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 	if (handle == INVALID_HANDLE_VALUE)
 	{
 		g_tls_error = to_error(GetLastError());
@@ -764,7 +814,13 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 		disp = test(mode & fs::trunc) ? TRUNCATE_EXISTING : OPEN_EXISTING;
 	}

-	const HANDLE handle = CreateFileW(to_wchar(path).get(), access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
+	DWORD share = FILE_SHARE_READ;
+	if (!test(mode & fs::unshare))
+	{
+		share |= FILE_SHARE_WRITE | FILE_SHARE_DELETE;
+	}
+
+	const HANDLE handle = CreateFileW(to_wchar(path).get(), access, share, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);

 	if (handle == INVALID_HANDLE_VALUE)
 	{
@@ -772,7 +828,7 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 		return;
 	}

-	class windows_file final : public file_base
+	class windows_file final : public file_base, public get_native_handle
 	{
 		const HANDLE m_handle;

@@ -810,23 +866,15 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)

 		bool trunc(u64 length) override
 		{
-			LARGE_INTEGER old, pos;
+			FILE_END_OF_FILE_INFO _eof;
+			_eof.EndOfFile.QuadPart = length;

-			pos.QuadPart = 0;
-			if (!SetFilePointerEx(m_handle, pos, &old, FILE_CURRENT)) // get old position
+			if (!SetFileInformationByHandle(m_handle, FileEndOfFileInfo, &_eof, sizeof(_eof)))
 			{
 				g_tls_error = to_error(GetLastError());
 				return false;
 			}

-			pos.QuadPart = length;
-			if (!SetFilePointerEx(m_handle, pos, NULL, FILE_BEGIN)) // set new position
-			{
-				g_tls_error = to_error(GetLastError());
-				return false;
-			}
-
-			verify("file::trunc" HERE), SetEndOfFile(m_handle), SetFilePointerEx(m_handle, old, NULL, FILE_BEGIN);
 			return true;
 		}

@@ -879,6 +927,11 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)

 			return size.QuadPart;
 		}
+
+		native_handle get() override
+		{
+			return m_handle;
+		}
 	};

 	m_file = std::make_unique<windows_file>(handle);
@@ -902,7 +955,14 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 		return;
 	}

-	class unix_file final : public file_base
+	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;
+	}
+
+	class unix_file final : public file_base, public get_native_handle
 	{
 		const int m_fd;

@@ -974,7 +1034,7 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
 				(fmt::throw_exception("Invalid whence (0x%x)" HERE, whence), 0);

 			const auto result = ::lseek(m_fd, offset, mode);
-			
+
 			if (result == -1)
 			{
 				g_tls_error = to_error(errno);
@@ -991,6 +1051,11 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)

 			return file_info.st_size;
 		}
+
+		native_handle get() override
+		{
+			return m_fd;
+		}
 	};

 	m_file = std::make_unique<unix_file>(fd);
@@ -1066,6 +1131,20 @@ fs::file::file(const void* ptr, std::size_t size)
 	m_file = std::make_unique<memory_stream>(ptr, size);
 }

+fs::native_handle fs::file::get_handle() const
+{
+	if (auto getter = dynamic_cast<get_native_handle*>(m_file.get()))
+	{
+		return getter->get();
+	}
+
+#ifdef _WIN32
+	return INVALID_HANDLE_VALUE;
+#else
+	return -1;
+#endif
+}
+
 void fs::dir::xnull() const
 {
 	fmt::throw_exception<std::logic_error>("fs::dir is null");
@@ -1179,7 +1258,12 @@ bool fs::dir::open(const std::string& path)
 			}

 			struct ::stat file_info;
-			verify("dir::read" HERE), ::fstatat(::dirfd(m_dd), found->d_name, &file_info, 0) == 0;
+
+			if (::fstatat(::dirfd(m_dd), found->d_name, &file_info, 0) != 0)
+			{
+				//failed metadata (broken symlink?), ignore and skip to next file
+				return read(info);
+			}

 			info.name = found->d_name;
 			info.is_directory = S_ISDIR(file_info.st_mode);
@@ -1279,7 +1363,7 @@ std::string fs::get_data_dir(const std::string& prefix, const std::string& locat

 			continue;
 		}
-		
+
 		buf.push_back(c);
 	}

@@ -1398,6 +1482,7 @@ void fmt_class_string<fs::error>::format(std::string& out, u64 arg)
 		case fs::error::noent: return "Not found";
 		case fs::error::exist: return "Already exists";
 		case fs::error::acces: return "Access violation";
+		case fs::error::notempty: return "Not empty";
 		}

 		return unknown;
@@ -10,6 +10,12 @@

 namespace fs
 {
+#ifdef _WIN32
+	using native_handle = void*;
+#else
+	using native_handle = int;
+#endif
+
 	// File open mode flags
 	enum class open_mode : u32
 	{
@@ -19,6 +25,7 @@ namespace fs
 		create,
 		trunc,
 		excl,
+		unshare,

 		__bitset_enum_max
 	};
@@ -29,6 +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 unshare = +open_mode::unshare; // Prevent opening the file twice

 	constexpr auto rewrite = open_mode::write + open_mode::create + open_mode::trunc;

@@ -55,6 +63,12 @@ namespace fs
 		s64 ctime;
 	};

+	// Native handle getter
+	struct get_native_handle
+	{
+		virtual native_handle get() = 0;
+	};
+
 	// File handle base
 	struct file_base
 	{
@@ -145,7 +159,7 @@ namespace fs
 	bool create_path(const std::string& path);

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

 	// Copy file contents
 	bool copy_file(const std::string& from, const std::string& to, bool overwrite);
@@ -347,6 +361,9 @@ namespace fs
 			if (seek(0), !read(result)) xfail();
 			return result;
 		}
+
+		// Get native handle if available
+		native_handle get_handle() const;
 	};

 	class dir final
@@ -405,7 +422,7 @@ namespace fs

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

 		public:
@@ -415,7 +432,7 @@ namespace fs
 				from_current
 			};

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

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

@@ -451,14 +468,14 @@ namespace fs
 			}
 		};

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

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

@@ -485,6 +502,7 @@ namespace fs
 		noent,
 		exist,
 		acces,
+		notempty,
 	};

 	// Error code returned
@@ -30,6 +30,8 @@

 #ifdef _WIN32
 #include <Windows.h>
+#else
+#include <sys/mman.h>
 #endif

 #include "JIT.h"
@@ -47,6 +49,11 @@ static void* const s_memory = []() -> void*
 	llvm::InitializeNativeTargetAsmPrinter();
 	LLVMLinkInMCJIT();

+#ifdef MAP_32BIT
+	auto ptr = ::mmap(nullptr, s_memory_size, PROT_NONE, MAP_ANON | MAP_PRIVATE | MAP_32BIT, -1, 0);
+	if (ptr != MAP_FAILED)
+		return ptr;
+#else
 	for (u64 addr = 0x10000000; addr <= 0x80000000 - s_memory_size; addr += 0x1000000)
 	{
 		if (auto ptr = utils::memory_reserve(s_memory_size, (void*)addr))
@@ -54,6 +61,7 @@ static void* const s_memory = []() -> void*
 			return ptr;
 		}
 	}
+#endif

 	return utils::memory_reserve(s_memory_size);
 }();
@@ -63,6 +71,8 @@ static void* s_next = s_memory;
 #ifdef _WIN32
 static std::deque<std::vector<RUNTIME_FUNCTION>> s_unwater;
 static std::vector<std::vector<RUNTIME_FUNCTION>> s_unwind; // .pdata
+#else
+static std::deque<std::tuple<u8*, u64, std::size_t>> s_unfire;
 #endif

 // Reset memory manager
@@ -79,7 +89,30 @@ extern void jit_finalize()

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

 	utils::memory_decommit(s_memory, s_memory_size);
@@ -90,13 +123,13 @@ extern void jit_finalize()
 // Helper class
 struct MemoryManager : llvm::RTDyldMemoryManager
 {
-	std::unordered_map<std::string, std::uintptr_t>& m_link;
+	std::unordered_map<std::string, u64>& m_link;

 	std::array<u8, 16>* m_tramps{};

 	u8* m_code_addr{}; // TODO

-	MemoryManager(std::unordered_map<std::string, std::uintptr_t>& table)
+	MemoryManager(std::unordered_map<std::string, u64>& table)
 		: m_link(table)
 	{
 	}
@@ -163,7 +196,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 		return {addr, llvm::JITSymbolFlags::Exported};
 	}

-	virtual u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
+	u8* allocateCodeSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name) override
 	{
 		// Lock memory manager
 		writer_lock lock(s_mutex);
@@ -184,7 +217,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 		return (u8*)std::exchange(s_next, (void*)next);
 	}

-	virtual u8* allocateDataSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name, bool is_ro) override
+	u8* allocateDataSection(std::uintptr_t size, uint align, uint sec_id, llvm::StringRef sec_name, bool is_ro) override
 	{
 		// Lock memory manager
 		writer_lock lock(s_mutex);
@@ -209,7 +242,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 		return (u8*)std::exchange(s_next, (void*)next);
 	}

-	virtual bool finalizeMemory(std::string* = nullptr) override
+	bool finalizeMemory(std::string* = nullptr) override
 	{
 		// Lock memory manager
 		writer_lock lock(s_mutex);
@@ -226,7 +259,7 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 		return false;
 	}

-	virtual void registerEHFrames(u8* addr, u64 load_addr, std::size_t size) override
+	void registerEHFrames(u8* addr, u64 load_addr, std::size_t size) override
 	{
 #ifdef _WIN32
 		// Lock memory manager
@@ -253,16 +286,15 @@ struct MemoryManager : llvm::RTDyldMemoryManager
 		{
 			s_unwind.emplace_back(std::move(pdata));
 		}
+#else
+		s_unfire.push_front(std::make_tuple(addr, load_addr, size));
 #endif

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

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

@@ -276,7 +308,7 @@ struct EventListener : llvm::JITEventListener
 	{
 	}

-	virtual void NotifyObjectEmitted(const llvm::object::ObjectFile& obj, const llvm::RuntimeDyld::LoadedObjectInfo& inf) override
+	void NotifyObjectEmitted(const llvm::object::ObjectFile& obj, const llvm::RuntimeDyld::LoadedObjectInfo& inf) override
 	{
 #ifdef _WIN32
 		for (auto it = obj.section_begin(), end = obj.section_end(); it != end; ++it)
@@ -371,8 +403,8 @@ public:
 	}
 };

-jit_compiler::jit_compiler(const std::unordered_map<std::string, std::uintptr_t>& _link, std::string _cpu)
-	: m_link(std::move(_link))
+jit_compiler::jit_compiler(const std::unordered_map<std::string, u64>& _link, std::string _cpu)
+	: m_link(_link)
 	, m_cpu(std::move(_cpu))
 {
 	if (m_cpu.empty())
@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,265 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ * 
+ * The MIT License (MIT)
+ * 
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "LUrlParser.h"
+
+#include <algorithm>
+#include <cstring>
+#include <stdlib.h>
+
+// check if the scheme name is valid
+static bool IsSchemeValid( const std::string& SchemeName )
+{
+	for ( auto c : SchemeName  )
+	{
+		if ( !isalpha( c ) && c != '+' && c != '-' && c != '.' ) return false;
+	}
+
+	return true;
+}
+
+bool LUrlParser::clParseURL::GetPort( int* OutPort ) const
+{
+	if ( !IsValid() ) { return false; }
+
+	int Port = atoi( m_Port.c_str() );
+
+	if ( Port <= 0 || Port > 65535 ) { return false; }
+
+	if ( OutPort ) { *OutPort = Port; }
+
+	return true;
+}
+
+// based on RFC 1738 and RFC 3986
+LUrlParser::clParseURL LUrlParser::clParseURL::ParseURL( const std::string& URL )
+{
+	LUrlParser::clParseURL Result;
+
+	const char* CurrentString = URL.c_str();
+
+	/*
+	 *	<scheme>:<scheme-specific-part>
+	 *	<scheme> := [a-z\+\-\.]+
+	 *	For resiliency, programs interpreting URLs should treat upper case letters as equivalent to lower case in scheme names
+	 */
+
+	// try to read scheme
+	{
+		const char* LocalString = strchr( CurrentString, ':' );
+
+		if ( !LocalString )
+		{
+			return clParseURL( LUrlParserError_NoUrlCharacter );
+		}
+
+		// save the scheme name
+		Result.m_Scheme = std::string( CurrentString, LocalString - CurrentString );
+
+		if ( !IsSchemeValid( Result.m_Scheme ) )
+		{
+			return clParseURL( LUrlParserError_InvalidSchemeName );
+		}
+
+		// scheme should be lowercase
+		std::transform( Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower );
+
+		// skip ':'
+		CurrentString = LocalString+1;
+	}
+
+	/*
+	 *	//<user>:<password>@<host>:<port>/<url-path>
+	 *	any ":", "@" and "/" must be normalized
+	 */
+
+	// skip "//"
+	if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+	if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+
+	// check if the user name and password are specified
+	bool bHasUserName = false;
+
+	const char* LocalString = CurrentString;
+
+	while ( *LocalString )
+	{
+		if ( *LocalString == '@' )
+		{
+			// user name and password are specified
+			bHasUserName = true;
+			break;
+		}
+		else if ( *LocalString == '/' )
+		{
+			// end of <host>:<port> specification
+			bHasUserName = false;
+			break;
+		}
+
+		LocalString++;
+	}
+
+	// user name and password
+	LocalString = CurrentString;
+
+	if ( bHasUserName )
+	{
+		// read user name
+		while ( *LocalString && *LocalString != ':' && *LocalString != '@' ) LocalString++;
+
+		Result.m_UserName = std::string( CurrentString, LocalString - CurrentString );
+
+		// proceed with the current pointer
+		CurrentString = LocalString;
+
+		if ( *CurrentString == ':' )
+		{
+			// skip ':'
+			CurrentString++;
+
+			// read password
+			LocalString = CurrentString;
+
+			while ( *LocalString && *LocalString != '@' ) LocalString++;
+
+			Result.m_Password = std::string( CurrentString, LocalString - CurrentString );
+
+			CurrentString = LocalString;
+		}
+
+		// skip '@'
+		if ( *CurrentString != '@' )
+		{
+			return clParseURL( LUrlParserError_NoAtSign );
+		}
+
+		CurrentString++;
+	}
+
+	bool bHasBracket = ( *CurrentString == '[' );
+
+	// go ahead, read the host name
+	LocalString = CurrentString;
+
+	while ( *LocalString )
+	{
+		if ( bHasBracket && *LocalString == ']' )
+		{
+			// end of IPv6 address
+			LocalString++;
+			break;
+		}
+		else if ( !bHasBracket && ( *LocalString == ':' || *LocalString == '/' ) )
+		{
+			// port number is specified
+			break;
+		}
+
+		LocalString++;
+	}
+
+	Result.m_Host = std::string( CurrentString, LocalString - CurrentString );
+
+	CurrentString = LocalString;
+
+	// is port number specified?
+	if ( *CurrentString == ':' )
+	{
+		CurrentString++;
+
+		// read port number
+		LocalString = CurrentString;
+
+		while ( *LocalString && *LocalString != '/' ) LocalString++;
+
+		Result.m_Port = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	// end of string
+	if ( !*CurrentString )
+	{
+		Result.m_ErrorCode = LUrlParserError_Ok;
+
+		return Result;
+	}
+
+	// skip '/'
+	if ( *CurrentString != '/' )
+	{
+		return clParseURL( LUrlParserError_NoSlash );
+	}
+
+	CurrentString++;
+
+	// parse the path
+	LocalString = CurrentString;
+
+	while ( *LocalString && *LocalString != '#' && *LocalString != '?' ) LocalString++;
+
+	Result.m_Path = std::string( CurrentString, LocalString - CurrentString );
+
+	CurrentString = LocalString;
+
+	// check for query
+	if ( *CurrentString == '?' )
+	{
+		// skip '?'
+		CurrentString++;
+
+		// read query
+		LocalString = CurrentString;
+
+		while ( *LocalString && *LocalString != '#' ) LocalString++;
+
+		Result.m_Query = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	// check for fragment
+	if ( *CurrentString == '#' )
+	{
+		// skip '#'
+		CurrentString++;
+
+		// read fragment
+		LocalString = CurrentString;
+
+		while ( *LocalString ) LocalString++;
+
+		Result.m_Fragment = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	Result.m_ErrorCode = LUrlParserError_Ok;
+
+	return Result;
+}
@@ -0,0 +1,78 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ * 
+ * The MIT License (MIT)
+ * 
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace LUrlParser
+{
+	enum LUrlParserError
+	{
+		LUrlParserError_Ok = 0,
+		LUrlParserError_Uninitialized = 1,
+		LUrlParserError_NoUrlCharacter = 2,
+		LUrlParserError_InvalidSchemeName = 3,
+		LUrlParserError_NoDoubleSlash = 4,
+		LUrlParserError_NoAtSign = 5,
+		LUrlParserError_UnexpectedEndOfLine = 6,
+		LUrlParserError_NoSlash = 7,
+	};
+
+	class clParseURL
+	{
+	public:
+		LUrlParserError m_ErrorCode;
+		std::string m_Scheme;
+		std::string m_Host;
+		std::string m_Port;
+		std::string m_Path;
+		std::string m_Query;
+		std::string m_Fragment;
+		std::string m_UserName;
+		std::string m_Password;
+
+		clParseURL()
+			: m_ErrorCode( LUrlParserError_Uninitialized )
+		{}
+
+		/// return 'true' if the parsing was successful
+		bool IsValid() const { return m_ErrorCode == LUrlParserError_Ok; }
+
+		/// helper to convert the port number to int, return 'true' if the port is valid (within the 0..65535 range)
+		bool GetPort( int* OutPort ) const;
+
+		/// parse the URL
+		static clParseURL ParseURL( const std::string& URL );
+
+	private:
+		explicit clParseURL( LUrlParserError ErrorCode )
+			: m_ErrorCode( ErrorCode )
+		{}
+	};
+
+} // namespace LUrlParser
@@ -3,16 +3,25 @@
 #include "StrFmt.h"
 #include "sema.h"

+#include "Utilities/sysinfo.h"
+#include "Utilities/Thread.h"
 #include "rpcs3_version.h"
 #include <string>
 #include <unordered_map>
+#include <thread>
+#include <chrono>
+
+using namespace std::literals::chrono_literals;

 #ifdef _WIN32
+#define NOMINMAX
 #include <Windows.h>
 #else
-#include <chrono>
+#include <sys/mman.h>
 #endif

+#include <zlib.h>
+
 static std::string empty_string()
 {
 	return {};
@@ -36,6 +45,7 @@ void fmt_class_string<logs::level>::format(std::string& out, u64 arg)
 		case logs::level::warning: return "Warning";
 		case logs::level::notice: return "Notice";
 		case logs::level::trace: return "Trace";
+		case logs::level::_uninit: return unknown;
 		}

 		return unknown;
@@ -44,38 +54,86 @@ void fmt_class_string<logs::level>::format(std::string& out, u64 arg)

 namespace logs
 {
+	// Memory-mapped buffer size
+	constexpr u64 s_log_size = 32 * 1024 * 1024;
+
 	class file_writer
 	{
-		// Could be memory-mapped file
 		fs::file m_file;
+		std::string m_name;
+		std::thread m_writer;
+		fs::file m_fout;
+		fs::file m_fout2;
+		u64 m_max_size;
+
+#ifdef _WIN32
+		::HANDLE m_fmap;
+#endif
+		uchar* m_fptr{};
+		z_stream m_zs{};
+		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
+
+		uchar m_zout[65536];
+
+		// Write buffered logs immediately
+		bool flush(u64 bufv);

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

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

 		// Append raw data
-		void log(const char* text, std::size_t size);
+		void log(logs::level sev, const char* text, std::size_t size);
+	};
+
+	struct channel_info
+	{
+		channel* pointer = nullptr;
+		level enabled = level::notice;
+
+		void set_level(level value)
+		{
+			enabled = value;
+
+			if (pointer)
+			{
+				pointer->enabled = value;
+			}
+		}
+	};
+
+	struct stored_message
+	{
+		message m;
+		u64 stamp;
+		std::string prefix;
+		std::string text;
 	};

 	struct file_listener : public file_writer, public listener
 	{
-		file_listener(const std::string& name)
-			: file_writer(name)
-			, listener()
-		{
-			const std::string& start = fmt::format("\xEF\xBB\xBF" "RPCS3 v%s\n", rpcs3::version.to_string());
-			file_writer::log(start.data(), start.size());
-		}
+		file_listener(const std::string& name);
+
+		virtual ~file_listener() = default;

 		// Encode level, current thread name, channel name and write log message
 		virtual void log(u64 stamp, const message& msg, const std::string& prefix, const std::string& text) override;
+
+		// Channel registry
+		std::unordered_map<std::string, channel_info> channels;
+
+		// Messages for delayed listener initialization
+		std::vector<stored_message> messages;
 	};

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

@@ -121,33 +179,17 @@ namespace logs
 	channel SPU("SPU");
 	channel ARMv7("ARMv7");

-	struct channel_info
-	{
-		channel* pointer = nullptr;
-		level enabled = level::notice;
-
-		void set_level(level value)
-		{
-			enabled = value;
-
-			if (pointer)
-			{
-				pointer->enabled = value;
-			}
-		}
-	};
-
 	// Channel registry mutex
 	semaphore<> g_mutex;

-	// Channel registry
-	std::unordered_map<std::string, channel_info> g_channels;
+	// Must be set to true in main()
+	atomic_t<bool> g_init{false};

 	void reset()
 	{
 		semaphore_lock lock(g_mutex);

-		for (auto&& pair : g_channels)
+		for (auto&& pair : get_logger()->channels)
 		{
 			pair.second.set_level(level::notice);
 		}
@@ -157,7 +199,18 @@ namespace logs
 	{
 		semaphore_lock lock(g_mutex);

-		g_channels[ch_name].set_level(value);
+		get_logger()->channels[ch_name].set_level(value);
+	}
+
+	// Must be called in main() to stop accumulating messages in g_messages
+	void set_init()
+	{
+		if (!g_init)
+		{
+			semaphore_lock lock(g_mutex);
+			get_logger()->messages.clear();
+			g_init = true;
+		}
 	}
 }

@@ -170,11 +223,19 @@ void logs::listener::add(logs::listener* _new)
 	// Get first (main) listener
 	listener* lis = get_logger();

+	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))
 	{
 		lis = lis->m_next;
 	}
+
+	// Send initial messages
+	for (const auto& msg : get_logger()->messages)
+	{
+		_new->log(msg.stamp, msg.m, msg.prefix, msg.text);
+	}
 }

 void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u64* args)
@@ -187,7 +248,7 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u
 	{
 		semaphore_lock lock(g_mutex);

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

 		if (info.pointer && info.pointer != ch)
 		{
@@ -207,13 +268,30 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u
 	}

 	// Get text
-	std::string 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
 	listener* lis = get_logger();
-	
+
+	if (!g_init)
+	{
+		semaphore_lock lock(g_mutex);
+
+		if (!g_init)
+		{
+			while (lis)
+			{
+				lis->log(stamp, *this, prefix, text);
+				lis = lis->m_next;
+			}
+
+			// Store message additionally
+			get_logger()->messages.emplace_back(stored_message{*this, stamp, std::move(prefix), text});
+		}
+	}
+
 	// Send message to all listeners
 	while (lis)
 	{
@@ -225,28 +303,280 @@ void logs::message::broadcast(const char* fmt, const fmt_type_info* sup, const u
 [[noreturn]] extern void catch_all_exceptions();

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

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

 void logs::file_listener::log(u64 stamp, const logs::message& msg, const std::string& prefix, const std::string& _text)
 {
-	std::string text; text.reserve(prefix.size() + _text.size() + 200);
+	thread_local std::string text;

 	// Used character: U+00B7 (Middle Dot)
 	switch (msg.sev)
@@ -259,6 +589,7 @@ void logs::file_listener::log(u64 stamp, const logs::message& msg, const std::st
 	case level::warning: text = u8"·W "; break;
 	case level::notice:  text = u8"·! "; break;
 	case level::trace:   text = u8"·T "; break;
+	case level::_uninit: text = u8"·  "; break;
 	}

 	// Print miscosecond timestamp
@@ -274,8 +605,8 @@ void logs::file_listener::log(u64 stamp, const logs::message& msg, const std::st
 		text += prefix;
 		text += "} ";
 	}
-	
-	if ('\0' != *msg.ch->name)
+
+	if (msg.ch && '\0' != *msg.ch->name)
 	{
 		text += msg.ch->name;
 		text += msg.sev == level::todo ? " TODO: " : ": ";
@@ -284,9 +615,9 @@ void logs::file_listener::log(u64 stamp, const logs::message& msg, const std::st
 	{
 		text += "TODO: ";
 	}
-	
+
 	text += _text;
 	text += '\n';

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

 	void skip(std::size_t extra)
 	{
-		++sup += extra;
-		++args += extra;
+		sup += extra + 1;
+		args += extra + 1;
 	}

 	std::size_t fmt_string(std::string& out, std::size_t extra) const
@@ -24,6 +24,12 @@ inline void strcpy_trunc(char (&dst)[N], const char (&src)[N2])
 	dst[count] = '\0';
 }

+template <std::size_t N>
+inline bool ends_with(const std::string& src, const char (&end)[N])
+{
+	return src.size() >= N - 1 && src.compare(src.size() - (N - 1), N - 1, end, N - 1) == 0;
+}
+
 namespace fmt
 {
 	std::string replace_first(const std::string& src, const std::string& from, const std::string& to);
@@ -3,7 +3,12 @@
 #include "Emu/System.h"
 #include "Emu/IdManager.h"
 #include "Emu/Cell/RawSPUThread.h"
+#include "Emu/Cell/lv2/sys_mmapper.h"
+#include "Emu/Cell/lv2/sys_event.h"
 #include "Thread.h"
+#include "sysinfo.h"
+#include <typeinfo>
+#include <thread>

 #ifdef _WIN32
 #include <Windows.h>
@@ -13,6 +18,12 @@
 #ifdef __APPLE__
 #define _XOPEN_SOURCE
 #define __USE_GNU
+#include <mach/thread_act.h>
+#include <mach/thread_policy.h>
+#endif
+#if defined(__DragonFly__) || defined(__FreeBSD__)
+#include <pthread_np.h>
+#define cpu_set_t cpuset_t
 #endif
 #include <errno.h>
 #include <signal.h>
@@ -28,20 +39,6 @@ thread_local u64 g_tls_fault_all = 0;
 thread_local u64 g_tls_fault_rsx = 0;
 thread_local u64 g_tls_fault_spu = 0;

-static void report_fatal_error(const std::string& msg)
-{
-	std::string _msg = msg + "\n"
-		"HOW TO REPORT ERRORS: Check the FAQ, README, other sources.\n"
-		"Please, don't send incorrect reports. Thanks for understanding.\n";
-
-#ifdef _WIN32
-	_msg += "Press (Ctrl+C) to copy this message.";
-	MessageBoxA(0, _msg.c_str(), "Fatal error", MB_ICONERROR); // TODO: unicode message
-#else
-	std::printf("Fatal error: \n%s", _msg.c_str());
-#endif
-}
-
 [[noreturn]] void catch_all_exceptions()
 {
 	try
@@ -56,8 +53,6 @@ static void report_fatal_error(const std::string& msg)
 	{
 		report_fatal_error("Unhandled exception (unknown)");
 	}
-
-	std::abort();
 }

 enum x64_reg_t : u32
@@ -970,8 +965,8 @@ bool put_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, u64 v
 		// save the value into x64 register
 		switch (d_size)
 		{
-		case 1: *X64REG(context, reg - X64R_RAX) = value & 0xff | *X64REG(context, reg - X64R_RAX) & 0xffffff00; return true;
-		case 2: *X64REG(context, reg - X64R_RAX) = value & 0xffff | *X64REG(context, reg - X64R_RAX) & 0xffff0000; return true;
+		case 1: *X64REG(context, reg - X64R_RAX) = (value & 0xff) | (*X64REG(context, reg - X64R_RAX) & 0xffffff00); return true;
+		case 2: *X64REG(context, reg - X64R_RAX) = (value & 0xffff) | (*X64REG(context, reg - X64R_RAX) & 0xffff0000); return true;
 		case 4: *X64REG(context, reg - X64R_RAX) = value & 0xffffffff; return true;
 		case 8: *X64REG(context, reg - X64R_RAX) = value; return true;
 		}
@@ -1236,7 +1231,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 		return true;
 	}

-	if (vm::check_addr(addr, std::max<std::size_t>(1, d_size)))
+	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)
 		{
@@ -1246,9 +1241,60 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 		return true;
 	}

-	// TODO: allow recovering from a page fault as a feature of PS3 virtual memory
 	if (cpu)
 	{
+		if (fxm::check<page_fault_notification_entries>())
+		{
+			for (const auto& entry : fxm::get<page_fault_notification_entries>()->entries)
+			{
+				auto mem = vm::get(vm::any, entry.start_addr);
+				if (!mem)
+				{
+					continue;
+				}
+				if (entry.start_addr <= addr && addr <= addr + mem->size - 1)
+				{
+					// Place the page fault event onto table so that other functions [sys_mmapper_free_address and ppu pagefault funcs] 
+					// know that this thread is page faulted and where.
+
+					auto pf_entries = fxm::get_always<page_fault_event_entries>();
+					{
+						semaphore_lock pf_lock(pf_entries->pf_mutex);
+						page_fault_event pf_event{ cpu->id, addr };
+						pf_entries->events.emplace_back(pf_event);
+					}
+
+					// Now, we notify the game that a page fault occurred so it can rectify it.
+					// Note, for data3, were the memory readable AND we got a page fault, it must be due to a write violation since reads are allowed.
+					be_t<u64> data1 = addr;
+					be_t<u64> data2 = (SYS_MEMORY_PAGE_FAULT_TYPE_PPU_THREAD << 32) + cpu->id; // TODO: fix hack for now that assumes PPU thread always.
+					be_t<u64> data3 = vm::check_addr(addr, a_size, vm::page_readable) ? SYS_MEMORY_PAGE_FAULT_CAUSE_READ_ONLY : SYS_MEMORY_PAGE_FAULT_CAUSE_NON_MAPPED;
+
+					LOG_ERROR(MEMORY, "Page_fault %s location 0x%x because of %s memory", is_writing ? "writing" : "reading",
+						addr, data3 == SYS_MEMORY_PAGE_FAULT_CAUSE_READ_ONLY ? "writing read-only" : "using unmapped");
+
+					error_code sending_error = sys_event_port_send(entry.port_id, data1, data2, data3);
+					
+					// If we fail due to being busy, wait a bit and try again.
+					while (sending_error == CELL_EBUSY)
+					{
+						lv2_obj::sleep(*cpu, 1000);
+						thread_ctrl::wait_for(1000);
+						sending_error = sys_event_port_send(entry.port_id, data1, data2, data3);
+					}
+					
+					if (sending_error)
+					{
+						fmt::throw_exception("Unknown error %x while trying to pass page fault.", sending_error.value);
+					}
+
+					lv2_obj::sleep(*cpu);
+					thread_ctrl::wait();
+					return true;
+				}
+			}
+		}
+
 		LOG_FATAL(MEMORY, "Access violation %s location 0x%x", is_writing ? "writing" : "reading", addr);
 		cpu->state += cpu_flag::dbg_pause;
 		cpu->check_state();
@@ -1425,13 +1471,11 @@ const bool s_exception_handler_set = []() -> bool
 	if (!AddVectoredExceptionHandler(1, (PVECTORED_EXCEPTION_HANDLER)exception_handler))
 	{
 		report_fatal_error("AddVectoredExceptionHandler() failed.");
-		std::abort();
 	}

 	if (!SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)exception_filter))
 	{
 		report_fatal_error("SetUnhandledExceptionFilter() failed.");
-		std::abort();
 	}

 	return true;
@@ -1478,7 +1522,6 @@ static void signal_handler(int sig, siginfo_t* info, void* uct)

 	// TODO (debugger interaction)
 	report_fatal_error(fmt::format("Segfault %s location %p at %p.", cause, info->si_addr, RIP(context)));
-	std::abort();
 }

 const bool s_exception_handler_set = []() -> bool
@@ -1506,6 +1549,8 @@ thread_local DECLARE(thread_ctrl::g_tls_this_thread) = nullptr;

 extern thread_local std::string(*g_tls_log_prefix)();

+DECLARE(thread_ctrl::g_native_core_layout) { native_core_arrangement::undefined };
+
 void thread_ctrl::start(const std::shared_ptr<thread_ctrl>& ctrl, task_stack task)
 {
 #ifdef _WIN32
@@ -1702,7 +1747,7 @@ bool thread_ctrl::_wait_for(u64 usec)
 			}
 		}
 	}
-	while (_this->m_cond.wait(_lock, std::exchange(usec, usec == -1 ? -1 : 0)));
+	while (_this->m_cond.wait(_lock, std::exchange(usec, usec > cond_variable::max_timeout ? -1 : 0)));

 	// Timeout
 	return false;
@@ -1812,38 +1857,156 @@ void thread_ctrl::test()
 	}
 }

+void thread_ctrl::detect_cpu_layout()
+{
+	if (!g_native_core_layout.compare_and_swap_test(native_core_arrangement::undefined, native_core_arrangement::generic))
+		return;
+
+	const auto system_id = utils::get_system_info();
+	if (system_id.find("Ryzen") != std::string::npos)
+	{
+		g_native_core_layout.store(native_core_arrangement::amd_ccx);
+	}
+	else if (system_id.find("i3") != std::string::npos || system_id.find("i7") != std::string::npos)
+	{
+		g_native_core_layout.store(native_core_arrangement::intel_ht);
+	}
+}
+
+u16 thread_ctrl::get_affinity_mask(thread_class group)
+{
+	detect_cpu_layout();
+
+	if (const auto thread_count = std::thread::hardware_concurrency())
+	{
+		const u16 all_cores_mask = thread_count < 16 ? (u16)(~(UINT16_MAX << thread_count)): UINT16_MAX;
+
+		switch (g_native_core_layout)
+		{
+		default:
+		case native_core_arrangement::generic:
+		{
+			return all_cores_mask;
+		}
+		case native_core_arrangement::amd_ccx:
+		{
+			u16 spu_mask, ppu_mask, rsx_mask;
+			if (thread_count >= 16)
+			{
+				// Threadripper, R7
+				// Assign threads 8-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;
+			}
+			else if (thread_count == 12)
+			{
+				// 1600/2600 (x)
+				ppu_mask = spu_mask = 0b111111000000;
+				rsx_mask = all_cores_mask;
+			}
+			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;
+			}
+
+			switch (group)
+			{
+			default:
+			case thread_class::general:
+				return all_cores_mask;
+			case thread_class::rsx:
+				return rsx_mask;
+			case thread_class::ppu:
+				return ppu_mask;
+			case thread_class::spu:
+				return spu_mask;
+			}
+		}
+		case native_core_arrangement::intel_ht:
+		{
+			if (thread_count <= 4)
+			{
+				//i3 or worse
+				switch (group)
+				{
+				case thread_class::rsx:
+				case thread_class::ppu:
+					return (0b0101 & all_cores_mask);
+				case thread_class::spu:
+					return (0b1010 & all_cores_mask);
+				case thread_class::general:
+					return all_cores_mask;
+				}
+			}
+
+			return all_cores_mask;
+		}
+		}
+	}
+
+	return UINT16_MAX;
+}
+
 void thread_ctrl::set_native_priority(int priority)
 {
 #ifdef _WIN32
 	HANDLE _this_thread = GetCurrentThread();
 	INT native_priority = THREAD_PRIORITY_NORMAL;

-	switch (priority)
-	{
-	default:
-	case 0:
-		break;
-	case 1:
+	if (priority > 0)
 		native_priority = THREAD_PRIORITY_ABOVE_NORMAL;
-		break;
-	case -1:
+	if (priority < 0)
 		native_priority = THREAD_PRIORITY_BELOW_NORMAL;
-		break;
-	}

-	SetThreadPriority(_this_thread, native_priority);
+	if (!SetThreadPriority(_this_thread, native_priority))
+	{
+		LOG_ERROR(GENERAL, "SetThreadPriority() failed: 0x%x", GetLastError());
+	}
+#else
+	int policy;
+	struct sched_param param;
+
+	pthread_getschedparam(pthread_self(), &policy, &param);
+
+	if (priority > 0)
+		param.sched_priority = sched_get_priority_max(policy);
+	if (priority < 0)
+		param.sched_priority = sched_get_priority_min(policy);
+
+	if (int err = pthread_setschedparam(pthread_self(), policy, &param))
+	{
+		LOG_ERROR(GENERAL, "pthraed_setschedparam() failed: %d", err);
+	}
 #endif
 }

-void thread_ctrl::set_ideal_processor_core(int core)
+void thread_ctrl::set_thread_affinity_mask(u16 mask)
 {
 #ifdef _WIN32
 	HANDLE _this_thread = GetCurrentThread();
-	SetThreadIdealProcessor(_this_thread, core);
+	SetThreadAffinityMask(_this_thread, (DWORD_PTR)mask);
+#elif __APPLE__
+	thread_affinity_policy_data_t policy = { static_cast<integer_t>(mask) };
+	thread_port_t mach_thread = pthread_mach_thread_np(pthread_self());
+	thread_policy_set(mach_thread, THREAD_AFFINITY_POLICY, (thread_policy_t)&policy, 1);
+#elif defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__)
+	cpu_set_t cs;
+	CPU_ZERO(&cs);
+
+	for (u32 core = 0; core < 16u; ++core)
+	{
+		if ((u32)mask & (1u << core))
+		{
+			CPU_SET(core, &cs);
+		}
+	}
+
+	pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cs);
 #endif
 }

-
 named_thread::named_thread()
 {
 }
@@ -10,9 +10,29 @@
 #include "sema.h"
 #include "cond.h"

+// Report error and call std::abort(), defined in main.cpp
+[[noreturn]] void report_fatal_error(const std::string&);
+
 // Will report exception and call std::abort() if put in catch(...)
 [[noreturn]] void catch_all_exceptions();

+// Hardware core layout
+enum class native_core_arrangement : u32
+{
+	undefined,
+	generic,
+	intel_ht,
+	amd_ccx
+};
+
+enum class thread_class : u32
+{
+	general,
+	rsx,
+	spu,
+	ppu
+};
+
 // Simple list of void() functors
 class task_stack
 {
@@ -88,6 +108,9 @@ class thread_ctrl final
 	// Current thread
 	static thread_local thread_ctrl* g_tls_this_thread;

+	// Target cpu core layout
+	static atomic_t<native_core_arrangement> g_native_core_layout;
+
 	// Self pointer
 	std::shared_ptr<thread_ctrl> m_self;

@@ -231,8 +254,17 @@ public:
 		thread_ctrl::start(out, std::forward<F>(func));
 	}

+	// Detect layout
+	static void detect_cpu_layout();
+
+	// Returns a core affinity mask. Set whether to generate the high priority set or not
+	static u16 get_affinity_mask(thread_class group);
+
+	// Sets the native thread priority
 	static void set_native_priority(int priority);
-	static void set_ideal_processor_core(int core);
+
+	// Sets the preferred affinity mask for this thread
+	static void set_thread_affinity_mask(u16 mask);
 };

 class named_thread
@@ -70,7 +70,7 @@ namespace utils
 	void memory_decommit(void* pointer, std::size_t size)
 	{
 #ifdef _WIN32
-		verify(HERE), ::VirtualFree(pointer, 0, MEM_DECOMMIT);
+		verify(HERE), ::VirtualFree(pointer, size, MEM_DECOMMIT);
 #else
 		verify(HERE), ::mmap(pointer, size, PROT_NONE, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
 #endif
@@ -10,6 +10,7 @@ void fmt_class_string<patch_type>::format(std::string& out, u64 arg)
 	{
 		switch (value)
 		{
+		case patch_type::load: return "load";
 		case patch_type::byte: return "byte";
 		case patch_type::le16: return "le16";
 		case patch_type::le32: return "le32";
@@ -31,13 +32,23 @@ void patch_engine::append(const std::string& patch)
 {
 	if (fs::file f{patch})
 	{
-		auto root = YAML::Load(f.to_string());
+		YAML::Node root;
+
+		try
+		{
+			root = YAML::Load(f.to_string());
+		}
+		catch (const std::exception& e)
+		{
+			LOG_FATAL(GENERAL, "Failed to load patch file %s\n%s thrown: %s", patch, typeid(e).name(), e.what());
+			return;
+		}

 		for (auto pair : root)
 		{
 			auto& name = pair.first.Scalar();
 			auto& data = m_map[name];
-			
+
 			for (auto patch : pair.second)
 			{
 				u64 type64 = 0;
@@ -45,10 +56,33 @@ void patch_engine::append(const std::string& patch)

 				struct patch info{};
 				info.type   = static_cast<patch_type>(type64);
-				info.offset = patch[1].as<u32>();
+				info.offset = patch[1].as<u32>(0);

 				switch (info.type)
 				{
+				case patch_type::load:
+				{
+					// Special syntax: copy named sequence (must be loaded before)
+					const auto found = m_map.find(patch[1].Scalar());
+
+					if (found != m_map.end())
+					{
+						// Address modifier (optional)
+						const u32 mod = patch[2].as<u32>(0);
+
+						for (const auto& rd : found->second)
+						{
+							info = rd;
+							info.offset += mod;
+							data.emplace_back(info);
+						}
+
+						continue;
+					}
+
+					// TODO: error
+					break;
+				}
 				case patch_type::bef32:
 				case patch_type::lef32:
 				{
@@ -67,7 +101,7 @@ void patch_engine::append(const std::string& patch)
 					break;
 				}
 				}
-				
+
 				data.emplace_back(info);
 			}
 		}
@@ -90,6 +124,11 @@ std::size_t patch_engine::apply(const std::string& name, u8* dst) const

 		switch (p.type)
 		{
+		case patch_type::load:
+		{
+			// Invalid in this context
+			break;
+		}
 		case patch_type::byte:
 		{
 			*ptr = static_cast<u8>(p.value);
@@ -7,6 +7,7 @@

 enum class patch_type
 {
+	load,
 	byte,
 	le16,
 	le32,
@@ -10,12 +10,13 @@
 bool cond_variable::imp_wait(u32 _old, u64 _timeout) noexcept
 {
 	verify(HERE), _old != -1; // Very unlikely: it requires 2^32 distinct threads to wait simultaneously
+	const bool is_inf = _timeout > max_timeout;

 #ifdef _WIN32
 	LARGE_INTEGER timeout;
 	timeout.QuadPart = _timeout * -10;

-	if (HRESULT rc = NtWaitForKeyedEvent(nullptr, &m_value, false, _timeout == -1 ? nullptr : &timeout))
+	if (HRESULT rc = NtWaitForKeyedEvent(nullptr, &m_value, false, is_inf ? nullptr : &timeout))
 	{
 		verify(HERE), rc == WAIT_TIMEOUT;

@@ -37,12 +38,12 @@ bool cond_variable::imp_wait(u32 _old, u64 _timeout) noexcept

 	for (u32 value = _old + 1;; value = m_value)
 	{
-		const int err = futex((int*)&m_value.raw(), FUTEX_WAIT_PRIVATE, value, _timeout == -1 ? nullptr : &timeout, nullptr, 0) == 0
+		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 || (_timeout != -1 && err == ETIMEDOUT))
+		if (!err || (!is_inf && err == ETIMEDOUT))
 		{
 			// Cleanup (remove waiter)
 			verify(HERE), m_value--;
@@ -47,4 +47,6 @@ public:
 			imp_wake(-1);
 		}
 	}
+
+	static constexpr u64 max_timeout = u64{UINT32_MAX} / 1000 * 1000000;
 };
@@ -1,10 +0,0 @@
-Copyright (C) 2011-2012 Andrzej Krzemienski
-
-Distributed under the Boost Software License, Version 1.0
-(see accompanying file LICENSE_1_0.txt or a copy at
-http://www.boost.org/LICENSE_1_0.txt)
-
-The idea and interface is based on Boost.Optional library
-authored by Fernando Luis Cacciola Carballal
-
-Home at https://github.com/akrzemi1/Optional
@@ -731,9 +731,9 @@ struct area_base
 	{
 		return{ x1 * size.width, y1 * size.height, x2 * size.width, y2 * size.height };
 	}
-	constexpr area_base operator * (const T& value) const
+	constexpr area_base operator * (const f32& value) const
 	{
-		return{ x1 * value, y1 * value, x2 * value, y2 * value };
+		return{ (T)(x1 * value), (T)(y1 * value), (T)(x2 * value), (T)(y2 * value) };
 	}

 	template<typename NT>
@@ -13,9 +13,10 @@ rem // A copy of the GPL 2.0 should have been included with the program.
 rem // If not, see http://www.gnu.org/licenses/

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

 setlocal ENABLEDELAYEDEXPANSION
+setlocal ENABLEEXTENSIONS

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

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

 rem // Don't modify the file if it already has the current version.
 if exist "%GIT_VERSION_FILE%" (
@@ -67,6 +94,7 @@ if exist "%GIT_VERSION_FILE%" (
 echo // This is a generated file. > "%GIT_VERSION_FILE%"
 echo. >> "%GIT_VERSION_FILE%"
 echo #define RPCS3_GIT_VERSION "%GIT_VERSION%" >> "%GIT_VERSION_FILE%"
+echo #define RPCS3_GIT_BRANCH ^"%GIT_BRANCH%^" >> "%GIT_VERSION_FILE%"
 echo. >> "%GIT_VERSION_FILE%"
 echo // If you don't want this file to update/recompile, change to 1. >> "%GIT_VERSION_FILE%"
 echo #define RPCS3_GIT_VERSION_NO_UPDATE 0 >> "%GIT_VERSION_FILE%"
@@ -0,0 +1,27 @@
+#pragma once
+#include <stdint.h>
+
+namespace rpcs3
+{
+	template<typename T>
+	static size_t hash_base(T value)
+	{
+		return static_cast<size_t>(value);
+	}
+
+	template<typename T>
+	static size_t hash_struct(const T& value)
+	{
+		// FNV 64-bit
+		size_t result = 14695981039346656037ull;
+		const unsigned char *bytes = reinterpret_cast<const unsigned char*>(&value);
+
+		for (size_t n = 0; n < sizeof(T); ++n)
+		{
+			result ^= bytes[n];
+			result *= 1099511628211ull;
+		}
+
+		return result;
+	}
+}
@@ -1,7 +1,12 @@
 #include "mutex.h"
 #include "sync.h"

-#include <limits.h>
+#include <climits>
+#include <vector>
+#include <algorithm>
+
+// TLS variable for tracking owned mutexes
+thread_local std::vector<shared_mutex*> g_tls_locks;

 void shared_mutex::imp_lock_shared(s64 _old)
 {
@@ -217,12 +222,14 @@ void shared_mutex::imp_unlock(s64 _old)

 void shared_mutex::imp_lock_upgrade()
 {
+	// TODO
 	unlock_shared();
 	lock();
 }

 void shared_mutex::imp_lock_degrade()
 {
+	// TODO
 	unlock();
 	lock_shared();
 }
@@ -250,3 +257,78 @@ bool shared_mutex::try_lock_degrade()
 	// TODO
 	return m_value.compare_and_swap_test(0, c_one - c_min);
 }
+
+safe_reader_lock::safe_reader_lock(shared_mutex& mutex)
+	: m_mutex(mutex)
+	, m_is_owned(false)
+{
+	if (std::count(g_tls_locks.cbegin(), g_tls_locks.cend(), &m_mutex) == 0)
+	{
+		m_is_owned = true;
+
+		if (m_is_owned)
+		{
+			m_mutex.lock_shared();
+			g_tls_locks.emplace_back(&m_mutex);
+			return;
+		}
+
+		// TODO: order locks
+	}
+}
+
+safe_reader_lock::~safe_reader_lock()
+{
+	if (m_is_owned)
+	{
+		m_mutex.unlock_shared();
+		g_tls_locks.erase(std::remove(g_tls_locks.begin(), g_tls_locks.end(), &m_mutex), g_tls_locks.cend());
+		return;
+	}
+
+	// TODO: order locks
+}
+
+safe_writer_lock::safe_writer_lock(shared_mutex& mutex)
+	: m_mutex(mutex)
+	, m_is_owned(false)
+	, m_is_upgraded(false)
+{
+	if (std::count(g_tls_locks.cbegin(), g_tls_locks.cend(), &m_mutex) == 0)
+	{
+		m_is_owned = true;
+
+		if (m_is_owned)
+		{
+			m_mutex.lock_shared();
+			g_tls_locks.emplace_back(&m_mutex);
+			return;
+		}
+
+		// TODO: order locks
+	}
+
+	if (m_mutex.is_reading())
+	{
+		m_is_upgraded = true;
+		m_mutex.lock_upgrade();
+	}
+}
+
+safe_writer_lock::~safe_writer_lock()
+{
+	if (m_is_upgraded)
+	{
+		m_mutex.lock_degrade();
+		return;
+	}
+
+	if (m_is_owned)
+	{
+		m_mutex.unlock();
+		g_tls_locks.erase(std::remove(g_tls_locks.begin(), g_tls_locks.end(), &m_mutex), g_tls_locks.cend());
+		return;
+	}
+
+	// TODO: order locks
+}
@@ -95,6 +95,11 @@ public:
 			imp_lock_degrade();
 		}
 	}
+
+	bool is_reading() const
+	{
+		return (m_value.load() % c_one) != 0;
+	}
 };

 // Simplified shared (reader) lock implementation.
@@ -171,3 +176,56 @@ public:
 		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();
+};
@@ -61,10 +61,9 @@ rXmlDocument::rXmlDocument() : handle()
 {
 }

-void rXmlDocument::Load(const std::string & path)
+void rXmlDocument::Read(const std::string& data)
 {
-	// TODO: Unsure of use of c_str.
-	handle.load_file(path.c_str());
+	handle.load_buffer(data.data(), data.size());
 }

 std::shared_ptr<rXmlNode> rXmlDocument::GetRoot()
@@ -24,7 +24,7 @@ struct rXmlDocument
 	rXmlDocument();
 	rXmlDocument(const rXmlDocument& other) = delete;
 	rXmlDocument &operator=(const rXmlDocument& other) = delete;
-	void Load(const std::string & path);
+	void Read(const std::string& data);
 	std::shared_ptr<rXmlNode> GetRoot();

 	pugi::xml_document handle;
@@ -7,6 +7,44 @@
 #include <unistd.h>
 #endif

+bool utils::has_ssse3()
+{
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x200;
+	return g_value;
+}
+
+bool utils::has_avx()
+{
+	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;
+	return g_value;
+}
+
+bool utils::has_rtm()
+{
+	// Check RTM and MPX extensions in order to filter out TSX on Haswell CPUs
+	static const bool g_value = get_cpuid(0, 0)[0] >= 0x7 && (get_cpuid(7, 0)[1] & 0x4800) == 0x4800;
+	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;
+	return g_value;
+}
+
+bool utils::has_xop()
+{
+	static const bool g_value = has_avx() && get_cpuid(0x80000001, 0)[2] & 0x800;
+	return g_value;
+}
+
 std::string utils::get_system_info()
 {
 	std::string result;
@@ -50,6 +88,21 @@ std::string utils::get_system_info()
 	if (has_avx())
 	{
 		result += " | AVX";
+
+		if (has_avx2())
+		{
+			result += '+';
+		}
+
+		if (has_512())
+		{
+			result += '+';
+		}
+
+		if (has_xop())
+		{
+			result += 'x';
+		}
 	}

 	if (has_rtm())
@@ -8,29 +8,25 @@ namespace utils
 	inline std::array<u32, 4> get_cpuid(u32 func, u32 subfunc)
 	{
 		int regs[4];
-#ifdef _MSC_VER 
+#ifdef _MSC_VER
 		__cpuidex(regs, func, subfunc);
-#else 
+#else
 		__asm__ volatile("cpuid" : "=a" (regs[0]), "=b" (regs[1]), "=c" (regs[2]), "=d" (regs[3]) : "a" (func), "c" (subfunc));
-#endif 
+#endif
 		return {0u+regs[0], 0u+regs[1], 0u+regs[2], 0u+regs[3]};
 	}

-	inline bool has_ssse3()
-	{
-		return get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x200;
-	}
+	bool has_ssse3();

-	inline bool has_avx()
-	{
-		return get_cpuid(0, 0)[0] >= 0x1 && get_cpuid(1, 0)[2] & 0x10000000;
-	}
+	bool has_avx();

-	inline bool has_rtm()
-	{
-		// Check RTM and MPX extensions in order to filter out TSX on Haswell CPUs
-		return get_cpuid(0, 0)[0] >= 0x7 && (get_cpuid(7, 0)[1] & 0x4800) == 0x4800;
-	}
+	bool has_avx2();
+
+	bool has_rtm();
+
+	bool has_512();
+
+	bool has_xop();

 	inline bool transaction_enter()
 	{
@@ -32,7 +32,6 @@
 #define SAFE_BUFFERS
 #define NEVER_INLINE __attribute__((noinline))
 #define FORCE_INLINE __attribute__((always_inline)) inline
-#define thread_local __thread
 #endif

 #define CHECK_SIZE(type, size) static_assert(sizeof(type) == size, "Invalid " #type " type size")
@@ -49,7 +48,7 @@
 #define CONCATENATE_DETAIL(x, y) x ## y
 #define CONCATENATE(x, y) CONCATENATE_DETAIL(x, y)

-#define STRINGIZE_DETAIL(x) #x
+#define STRINGIZE_DETAIL(x) #x ""
 #define STRINGIZE(x) STRINGIZE_DETAIL(x)

 #define HERE "\n(in file " __FILE__ ":" STRINGIZE(__LINE__) ")"
@@ -535,6 +534,26 @@ inline u64 cntlz64(u64 arg, bool nonzero = false)
 #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)
 {
@@ -919,7 +938,7 @@ struct error_code
 	error_code() = default;

 	// Implementation must be provided specially
-	static s32 error_report(const fmt_type_info* sup, u64 arg);
+	static s32 error_report(const fmt_type_info* sup, u64 arg, const fmt_type_info* sup2, u64 arg2);

 	// Helper type
 	enum class not_an_error : s32
@@ -940,7 +959,7 @@ struct error_code

 	// Not an error constructor
 	template<typename ET, typename = decltype(ET::__not_an_error)>
-	error_code(const ET& value, int = 0)
+	error_code(const ET& value, std::nullptr_t = nullptr)
 		: value(static_cast<s32>(value))
 	{
 	}
@@ -948,7 +967,14 @@ struct error_code
 	// 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)))
+		: value(error_report(fmt::get_type_info<fmt_unveil_t<ET>>(), fmt_unveil<ET>::get(value), nullptr, 0))
+	{
+	}
+
+	// Error constructor (2 args)
+	template<typename ET, typename T2, typename = std::enable_if_t<is_error<ET>::value>>
+	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)))
 	{
 	}

@@ -12,6 +12,7 @@
 #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
@@ -849,6 +850,22 @@ namespace std {
 				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);
@@ -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
@@ -39,18 +39,22 @@
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
+    <NMakeBuildCommandLine>start /W /B pre-build.bat
+cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Release /m</NMakeBuildCommandLine>
    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Release /m</NMakeCleanCommandLine>
-    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
+    <NMakeReBuildCommandLine>start /W /B pre-build.bat
+cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Release /m
    </NMakeReBuildCommandLine>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
+    <NMakeBuildCommandLine>start /W /B pre-build.bat
+cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Debug /m</NMakeBuildCommandLine>
-    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
+    <NMakeReBuildCommandLine>start /W /B pre-build.bat
+cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Debug /m</NMakeReBuildCommandLine>
    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DBUILD_TESTS=OFF -DBUILD_DEMOS=OFF -DBUILD_LAYERS=OFF -DBUILD_VKJSON=OFF ../Vulkan-LoaderAndValidationLayers
 msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Debug /m</NMakeCleanCommandLine>
@@ -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
@@ -1,41 +1,100 @@
-version: '0.0.3-{build}'

-os: Visual Studio 2015
-platform: x64
-clone_folder: C:\rpcs3
-clone_depth: 3
-test: off
+version: '{build}'

-configuration:
-# Release
- - ReleaseLLVM
+image: Visual Studio 2015

-before_build:
- - ps: $env:Date="$(git show -s --date=short --format='%ad')"
- - git submodule update --init 3rdparty/ffmpeg 3rdparty/pugixml asmjit 3rdparty/GSL 3rdparty/libpng Vulkan/glslang Vulkan/Vulkan-LoaderAndValidationLayers Utilities/yaml-cpp 3rdparty/cereal 3rdparty/zlib 3rdparty/hidapi
- - 7z x zlib.7z -aos -oC:\rpcs3\ > null
- - 7z x vulkan.7z -aos -oC:\rpcs3\Vulkan > null
- - if %configuration%==Release (cmake -G "Visual Studio 14 Win64" -DZLIB_ROOT=C:/rpcs3/zlib/ -DVULKAN_PREBUILT=ON)
-   else (7z x llvmlibs.7z -aos -oC:\rpcs3 > null && cmake -G "Visual Studio 14 Win64" -DLLVM_DIR=C:/rpcs3/llvm_build/lib/cmake/llvm -DZLIB_ROOT=C:/rpcs3/zlib/ -DVULKAN_PREBUILT=ON)
-
-build_script:
- - cmake --build . --config Release -- /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
-
-install:
- - if not exist llvmlibs.7z appveyor DownloadFile "https://drive.google.com/uc?export=download&id=0B8A6NaxhQAGRY2k3Q2Yya05lcm8" -FileName llvmlibs.7z
- - if not exist vulkan.7z appveyor DownloadFile "https://drive.google.com/uc?export=download&id=0B8A6NaxhQAGRaHYxV3VOS2d0a0U" -FileName vulkan.7z
- - if not exist zlib.7z appveyor DownloadFile "https://drive.google.com/uc?export=download&id=0B-HVE3xvheVFX05lRFdnZlh5aUU" -FileName zlib.7z
- - set QTDIR=C:\Qt\5.8\msvc2015_64
- - set OPENALDIR=C:\rpcs3\3rdparty\OpenAL
- - set PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%QTDIR%;%PATH%
- - set COMMIT_SHA=%APPVEYOR_REPO_COMMIT:~0,8%
-
-artifacts:
- - path: bin
-   name: 'rpcs3-v0.0.3-$(Date)-$(COMMIT_SHA)_win64'
-   type: zip
+environment:
+  QTDIR: C:\Qt\5.10.0\msvc2015_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

 cache:
- - llvmlibs.7z -> appveyor.yml
- - vulkan.7z -> appveyor.yml
- - zlib.7z -> appveyor.yml
+- llvmlibs.7z -> appveyor.yml
+- vulkan.7z -> appveyor.yml
+- compat_database.dat
+
+install:
+- ps: | # set env vars for versioning
+    $commDate = $env:APPVEYOR_REPO_COMMIT_TIMESTAMP.Substring(0,10)
+    $commSha = $env:APPVEYOR_REPO_COMMIT.Substring(0,8)
+    $commTag = $(git describe --tags $(git rev-list --tags --max-count=1))
+    
+    $env:AVVER = "{0}-{1}" -f $commTag.TrimStart("v"), $env:APPVEYOR_BUILD_NUMBER
+    $env:BUILD = "rpcs3-{0}-{1}-{2}_win64.7z" -f $commTag, $commDate, $commSha
+
+- ps: | # used for experimental build warnings for pr builds
+    $env:BRANCH = "{0}/{1}/#{2}" -f $env:APPVEYOR_REPO_NAME, `
+      $env:APPVEYOR_REPO_BRANCH, $env:APPVEYOR_PULL_REQUEST_NUMBER
+    $env:BRANCH = $env:BRANCH -replace "/#$"
+
+- ps: | # misc global settings
+    $env:PATH += $env:QTDIR
+    [net.servicepointmanager]::securityprotocol = "tls12, tls11, tls"
+
+- ps: | # update and init submodules
+    git submodule -q update --init `
+      3rdparty/cereal `
+      3rdparty/ffmpeg `
+      3rdparty/GSL `
+      3rdparty/hidapi `
+      3rdparty/libpng `
+      3rdparty/Optional `
+      3rdparty/pugixml `
+      3rdparty/zlib `
+      asmjit `
+      Utilities/yaml-cpp `
+      Vulkan/glslang `
+      Vulkan/Vulkan-LoaderAndValidationLayers
+
+platform: x64
+
+configuration: Release - LLVM
+
+build:
+  parallel: true
+  project: rpcs3.sln
+  verbosity: normal
+
+before_build:
+- ps: | # fetch precompiled build dependencies
+    if (!(test-path llvmlibs.7z)) { irm $env:LLVMLIBS -outfile llvmlibs.7z }
+    if (!(test-path vulkan.7z)) { irm $env:VULKAN -outfile vulkan.7z }
+    7z x llvmlibs.7z -aos -o"." | out-null
+    7z x vulkan.7z -aos -o".\lib\$env:CONFIGURATION-$env:PLATFORM" | out-null
+
+after_build:
+- ps: | # remove unnecessary files
+    rm .\bin\rpcs3.exp, .\bin\rpcs3.lib, .\bin\rpcs3.pdb
+
+- ps: | # prepare compatibility database for packaging
+    $db = irm $env:COMPATDB -erroraction silentlycontinue
+    if ($db -and $db.return_code -eq 0) {
+      $db | convertto-json -compress | out-file compat_database.dat -encoding utf8
+    }
+    copy-item compat_database.dat .\bin\GuiConfigs\compat_database.dat
+
+- ps: | # package artifacts
+    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
+
+- ps: | # generate sha256 hashes
+    (Get-FileHash $env:BUILD -Algorithm SHA256).Hash | Out-File -encoding ASCII "$($env:BUILD).sha256"
+    (Get-FileHash openssl_win64.7z -Algorithm SHA256).Hash | Out-File -encoding ASCII "openssl_win64.7z.sha256"
+
+test: off
+
+artifacts:
+- path: $(BUILD)
+  name: rpcs3
+- path: $(BUILD).sha256
+  name: rpcs3 sha256 hash
+- path: openssl_win64.7z
+  name: openssl
+- path: openssl_win64.7z.sha256
+  name: openssl sha256 hash
+
+on_finish: 
+- ps: | # update appveyor build version, done last to prevent webhook breakage
+    update-appveyorbuild -version $env:AVVER
@@ -0,0 +1,332 @@
+/* 
+TheMitoSan Dark-Theme for RPCS3 
+Based on Kuroi (Dark) by Ani
+by themitosan @ twitter.com/themitosan
+Ani @ https://github.com/AniLeo
+(2017.11.14)
+*/
+
+/* Every widget */
+QWidget {
+	background-color: #131313;
+	color: #FFF;
+	alternate-background-color: #212121;
+}
+
+/* Mouse tooltips */
+QToolTip {
+	padding: 0.125em;
+	border: 0.0625em #444;
+	background-color: #222;
+	color: #FFF;
+}
+
+/* Table headers */
+QHeaderView::section {
+	background-color: #010101;
+	color: #ecf0f1;
+	padding-left: 0.25em;
+	border: 0.0525em solid #FFF;
+}
+
+/* Settings Dialog: Tabs */
+QTabBar::tab {
+	color: #ecf0f1;
+	border: 0.0625em solid #444;
+	border-bottom-style: none;
+	background-color: #353535;
+	padding-left: 1em;
+	padding-right: 1em;
+	padding-top: 0.25em;
+	padding-bottom: 0.25em;
+	margin-right: -0.125em;
+	border-top-left-radius: 0.25em;
+	border-top-right-radius: 0.25em;
+}
+QTabBar::tab:last {
+	margin-right: 0em;
+}
+QTabBar::tab:!selected {
+	color: #888;
+	border-bottom-style: solid;
+	margin-top: 0.1875em;
+	background-color: #111;
+}
+QTabBar::tab:hover {
+	background-color: #353535;
+	color: #FFF;
+}
+
+/* Checkboxes */
+QCheckBox::indicator {
+	border-radius: 0.125em;
+	border-top-right-radius: 0em;
+	border-bottom-left-radius: 0em;
+	border: 0.0625em solid #FFF;
+	width: 0.8em;
+	height: 0.8em;
+	margin-top: 0.0625em;
+}
+QCheckBox::indicator:checked {
+	background-color: #FFF; /* White */
+}
+QCheckBox::indicator:unchecked {
+	background-color: #000; /* Black */
+}
+QCheckBox::indicator::disabled {
+	background-color: #af4949; /* Red */
+}
+
+/* Radio Buttons */
+QRadioButton::indicator {
+	border: 0.0625em solid #FFF;
+	width: 0.8em;
+	height: 0.8em;
+	margin-top: 0.0625em;
+	border-radius: 0.270em;
+}
+QRadioButton::indicator:checked {
+	background-color: #FFF; /* Green */
+}
+QRadioButton::indicator:unchecked {
+	background-color: #000; /* Red */
+}
+QRadioButton::indicator::disabled {
+	background-color: #af4949; /* Gray */
+}
+
+/* Combo Boxes */
+QComboBox {
+	background-color: #404040;
+	color: #fff;
+	border: 0.0625em solid #1e1e1e;
+	border-radius: 0.25em;
+	padding-bottom: 0.125em;
+	padding-left: 0.25em;
+}
+QComboBox::disabled {
+	background-color: #252525;
+	color: #fff;
+}
+
+/* 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;
+}
+
+/* Buttons */
+QPushButton {
+	background-color: #404040;
+	color: #fff;
+}
+
+QPushButton::disabled {
+	background-color: #353535;
+	color: #FFF;
+}
+
+QPushButton::pressed {
+	background-color: #333; 
+}
+
+/* Log and Debugger borders */
+QTextEdit {
+	border: 0.05em solid #353535;
+}
+
+/* For dock buttons to be visible */
+QDockWidget::close-button, QDockWidget::float-button {
+	background-color: #bdc3c7;
+	border: 0.05em solid #000;
+	border-radius: 0.25em;
+	width: auto;
+}
+
+/* Disable ugly borders */
+QTabWidget::pane {
+	border: 0em solid #353535;
+}
+
+/* Top menu bar */
+QMenuBar::item:selected {
+	background: #454545;
+	border-radius: 0.25em;
+}
+QMenu::item {
+	padding-left: 1.5em;
+	padding-right: 0.75em;
+	padding-top: 0.25em;
+	padding-bottom: 0.25em;
+	border-radius: 0.25em;
+	margin-bottom: 0.125em;
+}
+QMenu::item:selected {
+	background: #444;
+	border: 0.05em solid #bdc3c7;
+	border-radius: 0.25em;
+}
+QMenu::item:disabled {
+	background-color: #313131;
+	color: #888888;
+	border-radius: 0.25em;
+}
+
+/* Libraries list */
+QListWidget::item:selected {
+	background-color: #3d3d3d;
+	color: #ecf0f1;
+	border-radius: 0.125em;
+}
+QListWidget::item:hover {
+	background-color: #4c4b4b;
+	color: #ecf0f1;
+	border-radius: 0.25em;
+}
+
+/* Pad Settings: Controller Image */
+QLabel#l_controller { 
+	color: #FFF;
+}
+
+/* Game Grid Font */
+QLabel#gamegrid_font {
+	font-weight: 600;
+	font-size: 8pt;
+	font-family: Lucida Grande;
+	color: #FFF;
+}
+
+/* Slider on toolbar */
+QWidget#sizeSliderContainer {
+	background: transparent;
+}
+
+/* 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;
+	border-radius: 0.125em;
+	padding: 0.09375em;
+	margin-left: 0.125em;
+	margin-top: 0.125em;
+	margin-bottom: 0.125em;
+	min-width: 0.063em;
+	width: auto;
+}
+QToolButton::disabled {
+	background-color: #353535;
+}
+QToolButton::hover {
+	background-color: #555;
+}
+
+/* Set Theme UI colors */
+QLabel#gamelist_icon_background_color {
+	color: transparent;
+}
+QLabel#gamelist_toolbar_icon_color {
+	color: #828790;
+}
+
+/* Set Windows Taskbar Thumbnail colors */
+QLabel#thumbnail_icon_color {
+	color: #262626;
+}
+
+/* Set Log colors */
+QTextEdit#log_frame {
+	background-color: #000; /* Black */
+}
+QLabel#log_level_always {
+	color: #00ffff; /* Cyan */
+}
+QLabel#log_level_fatal {
+	color: #ff00ff; /* Fuchsia */
+}
+QLabel#log_level_error {
+	color: #ff0000; /* Red */
+}
+QLabel#log_level_todo {
+	color: #ff6000; /* Orange */
+}
+QLabel#log_level_success {
+	color: #00ff00; /* Green */
+}
+QLabel#log_level_warning {
+	color: #ffff00; /* Yellow */
+}
+QLabel#log_level_notice {
+	color: #ffffff; /* White */
+}
+QLabel#log_level_trace {
+	color: #808080; /* Gray */
+}
+QLabel#log_stack {
+	color: #ffffff; /* White */
+}
+
+/* Set TTY colors */
+QTextEdit#tty_frame {
+	background-color: #000; /* Black */
+}
+QLabel#tty_text {
+	color: #fff; /* White */
+}
+
+/* RSX Debugger */
+QLabel#rsx_debugger_display_buffer {
+	background-color: #131313;
+}
+
+/* Kernel Explorer */
+QDialog#kernel_explorer {
+	background-color: #131313;
+}
+
+/* Memory Viewer */
+QDialog#memory_viewer {
+	background-color: #131313;
+	color: #FFF;
+}
+QLabel#memory_viewer_address_panel {
+	color: #00cbff; /* Font Color: Blue */
+	background-color: #131313;
+}
+QLabel#memory_viewer_hex_panel {
+	color: #FFF; /* Font Color: White */
+	background-color: #131313;
+}
+QLabel#memory_viewer_ascii_panel {
+	color: #FFF; /* Font Color: White */
+	background-color: #131313;
+}
+
+/* Debugger colors */
+QLabel#debugger_frame_breakpoint {
+	color: #000; /* Font Color: Black */
+	background-color: #ffff00; /* Yellow */
+}
+QLabel#debugger_frame_pc {
+	color: #000; /* Font Color: Black */
+	background-color: #00ff00; /* Green */
+}
@@ -0,0 +1,330 @@
+/* 
+Kuroi (Dark) Theme for RPCS3 
+by Ani @ https://github.com/AniLeo
+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: #323232;
+	color: #bdc3c7;
+	alternate-background-color: #3d3d3d;
+}
+
+/* Mouse tooltips */
+QToolTip {
+	border: 0.05em solid #323232;
+	background-color: #323232;
+	color: #ecf0f1;
+}
+
+/* Table headers */
+QHeaderView::section {
+	background-color: #323232;
+	color: #ecf0f1;
+	padding-left: 0.2em;
+	border: 0.05em solid #323232;
+}
+
+/* Settings Dialog: Tabs */
+QTabBar::tab {
+	color: #ecf0f1;
+	border: 0.05em solid #444;
+	border-bottom-style: none;
+	background-color: #333333;
+	padding-left: 0.9em;
+	padding-right: 0.9em;
+	padding-top: 0.2em;
+	padding-bottom: 0.2em;
+	margin-right: -0.2em;
+}
+QTabBar::tab:last {
+	margin-right: 0em;
+}
+QTabBar::tab:!selected {
+	color: #b1b1b1;
+	border-bottom-style: solid;
+	margin-top: 0.15em;
+	background-color: #292929;
+}
+QTabBar::tab:hover {
+	background-color: #333333;
+	color: #ecf0f1;
+}
+
+/* Checkboxes */
+QCheckBox::indicator {
+	border-radius: 0.1em;
+	border: 0.05em solid #ecf0f1;
+	margin-top: 0.05em;
+	width: 0.8em;
+	height: 0.8em;
+}
+QCheckBox::indicator:checked {
+	background-color: #2ecc71; /* Green */
+}
+QCheckBox::indicator:unchecked {
+	background-color: #e74c3c; /* Red */
+}
+QCheckBox::indicator::disabled {
+	background-color: #7f8c8d; /* Gray */
+}
+
+/* Radio Buttons */
+QRadioButton::indicator {
+  border-radius: 0.4em; 
+  border: 0.05em solid;  
+  border-color: white; 
+  width: 0.8em; 
+  height: 0.8em; 
+}
+QRadioButton::indicator:checked {
+	background-color: #2ecc71; /* Green */
+}
+QRadioButton::indicator:unchecked {
+	background-color: #e74c3c; /* Red */
+}
+QRadioButton::indicator::disabled {
+	background-color: #7f8c8d; /* Gray */
+}
+
+/* Combo Boxes */
+QComboBox {
+	background-color: #404040;
+	color: #fff;
+	border: 0.05em solid #1e1e1e;
+	border-radius: 0.15em;
+	padding-bottom: 0.2em;
+	padding-left: 0.4em;
+}
+QComboBox::disabled {
+	background-color: #828790;
+	color: #fff;
+}
+
+/* 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;
+}
+
+/* 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;
+}
+QListWidget::item:hover {
+	background-color: #4c4b4b;
+	color: #ecf0f1;
+}
+
+/* Pad Settings: Controller Image */
+QLabel#l_controller { 
+	color: #bdc3c7;
+}
+
+/* Game Grid Font */
+QLabel#gamegrid_font {
+	font-weight: 600;
+	font-size: 8pt;
+	font-family: Lucida Grande;
+	color: #ecf0f1;
+}
+
+/* Slider on toolbar */
+QWidget#sizeSliderContainer {
+	background: transparent;
+}
+
+/* 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 */
+QLabel#gamelist_icon_background_color {
+	color: transparent;
+}
+QLabel#gamelist_toolbar_icon_color {
+	color: #828790;
+}
+
+/* Set Windows Taskbar Thumbnail colors */
+QLabel#thumbnail_icon_color {
+	color: #444444;
+}
+
+/* Set Log colors */
+QTextEdit#log_frame {
+	background-color: #000000; /* Black */
+}
+QLabel#log_level_always {
+	color: #00ffff; /* Cyan */
+}
+QLabel#log_level_fatal {
+	color: #ff00ff; /* Fuchsia */
+}
+QLabel#log_level_error {
+	color: #ff0000; /* Red */
+}
+QLabel#log_level_todo {
+	color: #ff6000; /* Orange */
+}
+QLabel#log_level_success {
+	color: #00ff00; /* Green */
+}
+QLabel#log_level_warning {
+	color: #ffff00; /* Yellow */
+}
+QLabel#log_level_notice {
+	color: #ffffff; /* White */
+}
+QLabel#log_level_trace {
+	color: #808080; /* Gray */
+}
+QLabel#log_stack {
+	color: #ffffff; /* White */
+}
+
+/* Set TTY colors */
+QTextEdit#tty_frame {
+	background-color: #000000; /* Black */
+}
+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 */
+}
@@ -0,0 +1,329 @@
+/* 
+ModernBlue Theme for RPCS3 
+by themitosan @ twitter.com/themitosan
+(2017.12.12)
+*/
+
+/* Every widget */
+QWidget {
+	background-color: #232e3a;
+	color: #fff;
+	alternate-background-color: #141e28;
+}
+
+/* Mouse tooltips */
+QToolTip {
+	padding: 0.125em;
+	border: 0.0625em #444;
+	background-color: #181d24;
+	color: #fff;
+}
+
+/* Table headers */
+QHeaderView::section {
+	background-color: #333b44;
+	color: #ecf0f1;
+	padding-left: 0.25em;
+	border: 0.0425em solid #fff;
+}
+
+/* Settings Dialog: Tabs */
+QTabBar::tab {
+	color: #ecf0f1;
+	border: 0.0625em solid #feffff;
+	border-bottom-style: none;
+	background-color: #232e3a;
+	padding-left: 1em;
+	padding-right: 1em;
+	padding-top: 0.25em;
+	padding-bottom: 0.25em;
+	margin-right: -0.125em;
+	border-top-left-radius: 0.25em;
+	border-top-right-radius: 0.25em;
+}
+QTabBar::tab:last {
+	margin-right: 0em;
+}
+QTabBar::tab:!selected {
+	color: #666;
+	border-bottom-style: solid;
+	margin-top: 0.1875em;
+	background-color: #1b242f;
+}
+QTabBar::tab:hover {
+	background-color: #232e3a;
+	color: #fff;
+}
+
+/* Checkboxes */
+QCheckBox::indicator {
+	border-radius: 0.125em;
+	border-top-right-radius: 0em;
+	border-bottom-left-radius: 0em;
+	border: 0.0625em solid #fff;
+	width: 0.8em;
+	height: 0.8em;
+	margin-top: 0.0625em;
+}
+QCheckBox::indicator:checked {
+	background-color: #849ad2; /* Green */
+}
+QCheckBox::indicator:unchecked {
+	background-color: #203042; /* Red */
+}
+QCheckBox::indicator::disabled {
+	background-color: red; /* Gray */
+}
+
+/* Radio Buttons */
+QRadioButton::indicator {
+	border: 0.0625em solid #fff;
+	width: 0.8em;
+	height: 0.8em;
+	margin-top: 0.0625em;
+	border-radius: 0.270em;
+}
+QRadioButton::indicator:checked {
+	background-color: #849ad2; /* Green */
+}
+QRadioButton::indicator:unchecked {
+	background-color: #203042; /* Red */
+}
+QRadioButton::indicator::disabled {
+	background-color: red; /* Gray */
+}
+
+/* Combo Boxes */
+QComboBox {
+	background-color: #323c47;
+	color: #fff;
+	border: 0.0625em solid #ddd;
+	border-radius: 0.25em;
+	padding-bottom: 0.125em;
+	padding-left: 0.25em;
+}
+QComboBox::disabled {
+	background-color: #11182b;
+	color: #fff;
+}
+
+/* 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;
+}
+
+/* Buttons */
+QPushButton {
+	background-color: #46598b;
+	color: #fff; 
+}
+
+QPushButton::disabled {
+	background-color: #20283c;
+	color: #fff;
+}
+
+QPushButton::pressed {
+	background-color: #172038; 
+}
+
+/* Log and Debugger borders */
+QTextEdit {
+	border: 0.05em solid #ddd;
+}
+
+/* For dock buttons to be visible */
+QDockWidget::close-button, QDockWidget::float-button {
+	background-color: #bdc3c7;
+	border: 0.05em solid #777;
+	border-radius: 0.25em;
+}
+
+/* Disable ugly borders */
+QTabWidget::pane {
+	border: 0em solid #333b44;
+}
+
+/* Top menu bar */
+QMenuBar::item:selected {
+	background: #353e48;
+	border-radius: 0.25em;
+}
+QMenu::item {
+	padding-left: 1.5em;
+	padding-right: 0.75em;
+	padding-top: 0.25em;
+	padding-bottom: 0.25em;
+	border-radius: 0.25em;
+	margin-bottom: 0.125em;
+}
+QMenu::item:selected {
+	background: #354454;
+	border: 0.05em solid #bdc3c7;
+	border-radius: 0.25em;
+}
+QMenu::item:disabled {
+	background-color: #181d24;
+	color: #fff;
+	border-radius: 0.25em;
+}
+
+/* Libraries list */
+QListWidget::item:selected {
+	background-color: #3d3d3d;
+	color: #ecf0f1;
+	border-radius: 0.125em;
+}
+QListWidget::item:hover {
+	background-color: #4c4b4b;
+	color: #ecf0f1;
+	border-radius: 0.25em;
+}
+
+/* Pad Settings: Controller Image */
+QLabel#l_controller { 
+	color: #fff;
+}
+
+/* Game Grid Font */
+QLabel#gamegrid_font {
+	font-weight: 600;
+	font-size: 8pt;
+	font-family: Lucida Grande;
+	color: #fff;
+}
+
+/* Slider on toolbar */
+QWidget#sizeSliderContainer {
+	background: transparent;
+}
+
+/* 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;
+	border-radius: 0.125em;
+	padding: 0.09375em;
+	margin-left: 0.125em;
+	margin-top: 0.125em;
+	margin-bottom: 0.125em;
+	min-width: 0.063em;
+	width: auto;
+}
+QToolButton::disabled {
+	background-color: #11182b;
+}
+QToolButton::hover {
+	background-color: #3d475e;
+}
+
+/* Set Theme UI colors */
+QLabel#gamelist_icon_background_color {
+	color: transparent;
+}
+QLabel#gamelist_toolbar_icon_color {
+	color: #828790;
+}
+
+/* Set Windows Taskbar Thumbnail colors */
+QLabel#thumbnail_icon_color {
+	color: #262626;
+}
+
+/* Set Log colors */
+QTextEdit#log_frame {
+	background-color: #181d24; /* Black */
+}
+QLabel#log_level_always {
+	color: #74ffda; /* Cyan */
+}
+QLabel#log_level_fatal {
+	color: #ff35ff; /* Fuchsia */
+}
+QLabel#log_level_error {
+	color: #ff2424; /* Red */
+}
+QLabel#log_level_todo {
+	color: #ff8c46; /* Orange */
+}
+QLabel#log_level_success {
+	color: #7aff7a; /* Green */
+}
+QLabel#log_level_warning {
+	color: #f7ff74; /* Yellow */
+}
+QLabel#log_level_notice {
+	color: #fff; /* White */
+}
+QLabel#log_level_trace {
+	color: #808080; /* Gray */
+}
+QLabel#log_stack {
+	color: #fff; /* White */
+}
+
+/* Set TTY colors */
+QTextEdit#tty_frame {
+	background-color: #181d24; /* Black */
+}
+QLabel#tty_text {
+	color: #fff; /* White */
+}
+
+/* RSX Debugger */
+QLabel#rsx_debugger_display_buffer {
+	background-color: #181d24;
+}
+
+/* Kernel Explorer */
+QDialog#kernel_explorer {
+	background-color: #333b44;
+}
+
+/* Memory Viewer */
+QDialog#memory_viewer {
+	background-color: #333b44;
+	color: #fff;
+}
+QLabel#memory_viewer_address_panel {
+	color: #00cbff; /* Font Color: Blue */
+	background-color: #333b44;
+}
+QLabel#memory_viewer_hex_panel {
+	color: #fff; /* Font Color: Grey */
+	background-color: #333b44;
+}
+QLabel#memory_viewer_ascii_panel {
+	color: #fff; /* Font Color: Grey */
+	background-color: #333b44;
+}
+
+/* Debugger colors */
+QLabel#debugger_frame_breakpoint {
+	color: #000; /* Font Color: Black */
+	background-color: #333b44; /* Yellow */
+}
+QLabel#debugger_frame_pc {
+	color: #000; /* Font Color: Black */
+	background-color: #333b44; /* Green */
+}
@@ -9,7 +9,8 @@ function Controller() {
 }

 Controller.prototype.WelcomePageCallback = function() {
-    gui.clickButton(buttons.NextButton);
+    // Wait 10 seconds to load licenses and such.
+    gui.clickButton(buttons.NextButton, 10000);
 }

 Controller.prototype.CredentialsPageCallback = function() {
@@ -32,7 +33,7 @@ Controller.prototype.ComponentSelectionPageCallback = function() {
    var widget = gui.currentPageWidget();

    widget.deselectAll();
-    widget.selectComponent("qt.591.gcc_64");
+    widget.selectComponent("qt.qt5.5100.gcc_64");

    gui.clickButton(buttons.NextButton);
 }
@@ -1,43 +1,47 @@
-cmake_minimum_required(VERSION 3.0.2)
+cmake_minimum_required(VERSION 3.1)

 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake_modules")
 set(RES_FILES "")
 set(CMAKE_CXX_STANDARD 14)
-include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)

 # Qt section
-find_package(Qt5 5.7 COMPONENTS Widgets)
-if (WIN32)
-    find_package(Qt5WinExtras REQUIRED)
-    set(RPCS3_QT_LIBS Qt5::Widgets Qt5::WinExtras)
-    include_directories(${Qt5Widgets_INCLUDE_DIRS} ${Qt5WinExtras_INCLUDE_DIRS})
+find_package(Qt5 5.7 COMPONENTS Widgets Network)
+if(WIN32)
+	find_package(Qt5 5.7 COMPONENTS WinExtras REQUIRED)
+	set(RPCS3_QT_LIBS Qt5::Widgets Qt5::WinExtras Qt5::Network)
 else()
-    set(RPCS3_QT_LIBS Qt5::Widgets)
-    include_directories(${Qt5Widgets_INCLUDE_DIRS})
+	find_package(Qt5 5.7 COMPONENTS DBus Gui)
+	if(Qt5DBus_FOUND)
+		set(RPCS3_QT_LIBS Qt5::Widgets Qt5::DBus Qt5::Network)
+		add_definitions(-DHAVE_QTDBUS)
+	else()
+		set(RPCS3_QT_LIBS Qt5::Widgets Qt5::Network)
+	endif()
+	include_directories(${Qt5Gui_PRIVATE_INCLUDE_DIRS})
 endif()

 # Let's make sure we have Qt before we continue
-if (NOT Qt5Widgets_FOUND)
-	if (Qt5Widgets_VERSION VERSION_LESS 5.7.0)
+if(NOT Qt5Widgets_FOUND)
+	if(Qt5Widgets_VERSION VERSION_LESS 5.7.0)
 		message("Minimum supported Qt5 version is 5.7! You have version ${Qt5Widgets_VERSION} installed, please upgrade!")
-		if ("${CMAKE_SYSTEM}" MATCHES "Linux")
+		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 an up-to-date qt5 version.
-        https://launchpad.net/~beineri/+archive/ubuntu/opt-qt59-xenial
-        https://launchpad.net/~beineri/+archive/ubuntu/opt-qt59-trusty
+        https://launchpad.net/~beineri/+archive/ubuntu/opt-qt593-xenial
+        https://launchpad.net/~beineri/+archive/ubuntu/opt-qt593-trusty
 just make sure to run
    source /opt/qt59/bin/qt59-env.sh
 before re-running cmake")
-        elseif(WIN32)
+		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)
+	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.8\\msvc2017_64\\)")
 	elseif("${CMAKE_SYSTEM}" MATCHES "Linux")
 		message(FATAL_ERROR "Make sure to install your distro's qt5 package!")
@@ -51,14 +55,16 @@ set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTOUIC ON)

 # To make UI files on cmake 3.7 or less work
-set(CMAKE_INCLUDE_CURRENT_DIR ON)
+if(CMAKE_VERION VERSION_LESS 3.8)
+	set(CMAKE_INCLUDE_CURRENT_DIR ON)
+endif()

-if (Qt5_POSITION_INDEPENDENT_CODE)
-    SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
-    if(UNIX)
-        # Cotire needs this set for some reason
-        SET(CMAKE_CXX_COMPILE_OPTIONS_PIE -fPIC)
-    endif()
+if(Qt5_POSITION_INDEPENDENT_CODE)
+	set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+	if(UNIX)
+		# Cotire needs this set for some reason
+		set(CMAKE_CXX_COMPILE_OPTIONS_PIE -fPIC)
+	endif()
 endif()

 include(cotire)
@@ -87,68 +93,110 @@ endif()
 if(NOT MSVC)
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions")
 	# This hides our LLVM from mesa's LLVM, otherwise we get some unresolvable conflicts.
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--exclude-libs,ALL")
+	if(NOT APPLE)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--exclude-libs,ALL")
+	endif()
+
 	if(WIN32)
 		set(CMAKE_RC_COMPILER_INIT windres)
 		enable_language(RC)
 		set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> <FLAGS> -O coff <DEFINES> -i <SOURCE> -o <OBJECT>")
-		
+
 		# Workaround for mingw64 (MSYS2)
 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--allow-multiple-definition")
 	endif()
-	
-	add_compile_options(-msse -msse2 -mcx16 -mssse3 -mrtm)
-	
-	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+
+	add_compile_options(-msse -msse2 -mcx16 -mrtm)
+
+	if(NOT DEFINED ENV{TRAVIS})
+		add_compile_options(-march=native)
+	endif()
+
+	if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
 		# This fixes 'some' of the st11range issues. See issue #2516
-		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -image-base=0x10000")
+		if(APPLE)
+			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-image_base,0x10000 -Wl,-pagezero_size,0x10000")
+		else()
+			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -image-base=0x10000")
+		endif()
 	endif()
-	
+
 	# Some distros have the compilers set to use PIE by default, but RPCS3 doesn't work with PIE, so we need to disable it.
-	CHECK_C_COMPILER_FLAG("-no-pie" HAS_NO_PIE)
-	if(HAS_NO_PIE)
-		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -no-pie")
-	endif()
-	CHECK_C_COMPILER_FLAG("-nopie" HAS_NOPIE)
-	if(HAS_NOPIE)
-		if (NOT HAS_NO_PIE)
+	if(APPLE)
+		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-no_pie")
+	else()
+		CHECK_CXX_COMPILER_FLAG("-no-pie" HAS_NO_PIE)
+		CHECK_CXX_COMPILER_FLAG("-nopie" HAS_NOPIE)
+
+		if(HAS_NO_PIE)
+			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -no-pie")
+		elseif(HAS_NOPIE)
 			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -nopie")
 		endif()
 	endif()
-	
-	find_package(GLEW REQUIRED)
+
 	find_package(ZLIB REQUIRED)
 else()
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:throwingNew /D _CRT_SECURE_NO_DEPRECATE=1 /D _CRT_NON_CONFORMING_SWPRINTFS=1 /D _SCL_SECURE_NO_WARNINGS=1")
-	
+
 	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcmt.lib /NODEFAULTLIB:libcd.lib /NODEFAULTLIB:libcmtd.lib /NODEFAULTLIB:msvcrtd.lib")
 	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS /DYNAMICBASE:NO /BASE:0x10000 /FIXED")
 endif()

+set(ADDITIONAL_LIBS "")
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 	#on some Linux distros shm_unlink and similar functions are in librt only
-	set(ADDITIONAL_LIBS "rt" "X11" "asound")
+	set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} "rt")
 elseif(NOT MSVC AND NOT CMAKE_CXX_FLAGS MATCHES "LIBICONV_PLUG")
 	#it seems like glibc includes the iconv functions we use but other libc
 	#implementations like the one on OSX don't seem implement them
-	set(ADDITIONAL_LIBS "iconv")
-else()
-	set(ADDITIONAL_LIBS "")
+	set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} "iconv")
+endif()
+if(UNIX AND NOT APPLE)
+	set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} "X11")
+	find_package(Wayland)
+	if (WAYLAND_FOUND)
+		include_directories(${WAYLAND_INCLUDE_DIR})
+		add_definitions(-DVK_USE_PLATFORM_WAYLAND_KHR)
+	endif()
 endif()

 if(NOT RPCS3_SRC_DIR)
-  SET(RPCS3_SRC_DIR ${CMAKE_CURRENT_LIST_DIR})
-  Message("-- Initializing RPCS3_SRC_DIR=${RPCS3_SRC_DIR}")
+	set(RPCS3_SRC_DIR ${CMAKE_CURRENT_LIST_DIR})
+	message("-- Initializing RPCS3_SRC_DIR=${RPCS3_SRC_DIR}")
 else()
-  Message("-- Using Custom RPCS3_SRC_DIR=${RPCS3_SRC_DIR}")
+	message("-- Using Custom RPCS3_SRC_DIR=${RPCS3_SRC_DIR}")
 endif()

 set(CMAKE_MODULE_PATH "${RPCS3_SRC_DIR}/cmake_modules")

 find_package(OpenGL REQUIRED)
 find_package(OpenAL REQUIRED)
-if (NOT WITHOUT_LLVM)
+if(NOT WITHOUT_LLVM)
 	find_package(LLVM 4.0 CONFIG)
+	if(NOT LLVM_FOUND)
+		message("System LLVM was not found, 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)
+
+		# LLVM needs to be built out-of-tree
+		add_subdirectory(../llvm ../llvm_build)
+		set(LLVM_DIR "${CMAKE_CURRENT_BINARY_DIR}/../llvm_build/lib/cmake/llvm/")
+
+		# now tries to find LLVM again
+		find_package(LLVM 4.0 CONFIG)
+		if(NOT LLVM_FOUND)
+			message(WARNING "Couldn't build LLVM from the submodule. You might need to run `git submodule update --init`")
+		endif()
+	endif()
 endif()


@@ -158,9 +206,29 @@ elseif(WIN32)
 	set(PLATFORM_ARCH "Windows/x86_64")
 else()
 	set(PLATFORM_ARCH "linux/x86_64")
+	option(USE_ALSA "ALSA audio backend" ON)
+	option(USE_PULSE "PulseAudio audio backend" ON)
 	option(USE_LIBEVDEV "libevdev-based joystick support" ON)
+	option(USE_VULKAN "Vulkan render backend" ON)
 endif()

+if(USE_ALSA)
+	find_package(ALSA)
+	if(ALSA_FOUND)
+		add_definitions(-DHAVE_ALSA)
+		include_directories(SYSTEM ${ALSA_INCLUDE_DIRS})
+		list(APPEND ADDITIONAL_LIBS ${ALSA_LIBRARIES})
+	endif()
+endif()
+if(USE_PULSE)
+	find_package(PkgConfig)
+	pkg_check_modules(PULSE libpulse-simple)
+	if(PULSE_FOUND)
+		add_definitions(-DHAVE_PULSE)
+		include_directories(SYSTEM ${PULSE_INCLUDE_DIRS})
+		list(APPEND ADDITIONAL_LIBS ${PULSE_LDFLAGS})
+	endif()
+endif()
 if(USE_LIBEVDEV)
 	find_package(PkgConfig)
 	pkg_check_modules(LIBEVDEV libevdev)
@@ -170,6 +238,18 @@ if(USE_LIBEVDEV)
 		list(APPEND ADDITIONAL_LIBS ${LIBEVDEV_LDFLAGS})
 	endif()
 endif()
+if(NOT WIN32 AND USE_VULKAN)
+	find_package(Vulkan)
+	if(VULKAN_FOUND)
+		add_definitions(-DHAVE_VULKAN)
+		list(APPEND ADDITIONAL_LIBS ${VULKAN_LIBRARY})
+		if(VULKAN_PREBUILT)
+			list(APPEND ADDITIONAL_LIBS glslang HLSL OGLCompiler SPIRV OSDependent)
+		endif()
+	else()
+		message("WARNING! USE_VULKAN was enabled, but libvulkan was not found. RPCS3 will be compiled without Vulkan support.")
+	endif()
+endif()

 # Select the version of libpng to use, default is builtin
 if(USE_SYSTEM_LIBPNG)
@@ -192,8 +272,6 @@ else()
 endif()

 include_directories(
-${GLEW_INCLUDE_DIR}
-${ZLIB_INCLUDE_DIR}
 ${OPENAL_INCLUDE_DIR}
 ${LLVM_INCLUDE_DIRS}
 "${RPCS3_SRC_DIR}/../3rdparty/pugixml/src"
@@ -212,6 +290,7 @@ ${LLVM_INCLUDE_DIRS}
 "${RPCS3_SRC_DIR}/../3rdparty/GL"
 "${RPCS3_SRC_DIR}/../3rdparty/stblib"
 "${RPCS3_SRC_DIR}/../3rdparty/cereal/include"
+"${RPCS3_SRC_DIR}/../3rdparty/Optional"
 )

 if(WIN32)
@@ -221,17 +300,17 @@ if(WIN32)
 endif()

 if(NOT LLVM_FOUND)
-	Message("LLVM 4.0 not found. RPCS3 will be compiled without LLVM support.")
+	message("LLVM 4.0 not found. RPCS3 will be compiled without LLVM support.")
 else()
 	add_definitions(${LLVM_DEFINITIONS})
 	add_definitions(-DLLVM_AVAILABLE)
-	if (CMAKE_BUILD_TYPE STREQUAL "Release")
-		llvm_map_components_to_libnames(LLVM_LIBS mcjit vectorize ipo x86codegen x86disassembler)
+	if(CMAKE_BUILD_TYPE STREQUAL "Release")
+		llvm_map_components_to_libnames(LLVM_LIBS core support executionengine object runtimedyld x86desc x86info scalaropts mcjit vectorize ipo x86codegen x86disassembler)
 	else()
-		llvm_map_components_to_libnames(LLVM_LIBS mcjit vectorize ipo x86codegen x86disassembler mcdisassembler)
+		llvm_map_components_to_libnames(LLVM_LIBS core support executionengine object runtimedyld x86desc x86info scalaropts mcjit vectorize ipo x86codegen x86disassembler mcdisassembler)
 	endif()

-	if (NOT MSVC)
+	if(NOT MSVC)
 		set_source_files_properties(${RPCS3_SRC_DIR}/../Utilities/JIT.cpp PROPERTIES COMPILE_FLAGS -fno-rtti)
 		set_source_files_properties(${RPCS3_SRC_DIR}/Emu/Cell/PPUTranslator.cpp PROPERTIES COMPILE_FLAGS -fno-rtti)
 	endif()
@@ -250,7 +329,7 @@ if(NOT USE_SYSTEM_FFMPEG)
 endif()

 get_property(dirs DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
-foreach(dir ${dirs})
+foreach (dir ${dirs})
 	message(STATUS "dir='${dir}'")
 endforeach()

@@ -262,7 +341,7 @@ RPCS3_SRC
 "${RPCS3_SRC_DIR}/../asmjit/src/asmjit/*.cpp"
 )

-if (NOT WIN32 AND "${CMAKE_SYSTEM}" MATCHES "Linux")
+if(NOT WIN32 AND VULKAN_FOUND)
 # Compile glslang and SPIRV modules needed for glsl compilation
 	file(
 	GLOB_RECURSE
@@ -271,30 +350,28 @@ if (NOT WIN32 AND "${CMAKE_SYSTEM}" MATCHES "Linux")
 	"${RPCS3_SRC_DIR}/../Vulkan/glslang/glslang/MachineIndependent/*.cpp"
 	"${RPCS3_SRC_DIR}/../Vulkan/glslang/glslang/OSDependent/Unix/*.cpp"
 	"${RPCS3_SRC_DIR}/../Vulkan/glslang/OGLCompilersDLL/*.cpp"
-	"${RPCS3_SRC_DIR}/../Vulkan/glslang/hlsl/*.cpp"
 	"${RPCS3_SRC_DIR}/../Vulkan/glslang/SPIRV/*.cpp"
 	)
-	
-	set (RPCS3_SRC ${RPCS3_SRC} ${UNIX_GLSLANG})
+
+	set(RPCS3_SRC ${RPCS3_SRC} ${UNIX_GLSLANG})
 endif()

 #File exclusion section

-#Ignore vulkan if not on windows or linux
-if(NOT WIN32 AND NOT "${CMAKE_SYSTEM}" MATCHES "Linux")
-	set (EXCLUDE_FILES "/RSX/VK/")
+if(NOT WIN32 AND NOT VULKAN_FOUND)
+	set(EXCLUDE_FILES "/RSX/VK/")
 endif()

 # Ignore autogenerated moc_* files if present
-set (EXCLUDE_FILES ${EXCLUDE_FILES} "moc_")
-set (EXCLUDE_FILES ${EXCLUDE_FILES} "rpcs3_automoc")
-set (EXCLUDE_FILES ${EXCLUDE_FILES} "qrc_resources.cpp")
+set(EXCLUDE_FILES ${EXCLUDE_FILES} "moc_")
+set(EXCLUDE_FILES ${EXCLUDE_FILES} "rpcs3_automoc")
+set(EXCLUDE_FILES ${EXCLUDE_FILES} "qrc_resources.cpp")

 foreach (TMP_PATH ${RPCS3_SRC})
 	foreach (EXCLUDE_PATH ${EXCLUDE_FILES})
-		string (FIND ${TMP_PATH} ${EXCLUDE_PATH} EXCLUDE_FILE_FOUND)
-		if (NOT ${EXCLUDE_FILE_FOUND} EQUAL -1)
-			list (REMOVE_ITEM RPCS3_SRC ${TMP_PATH})
+		string(FIND ${TMP_PATH} ${EXCLUDE_PATH} EXCLUDE_FILE_FOUND)
+		if(NOT ${EXCLUDE_FILE_FOUND} EQUAL -1)
+			list(REMOVE_ITEM RPCS3_SRC ${TMP_PATH})
 		endif ()
 	endforeach(EXCLUDE_PATH)
 endforeach(TMP_PATH)
@@ -303,58 +380,90 @@ endforeach(TMP_PATH)
 file(GLOB_RECURSE TMP_MOC "${RPCS3_SRC_DIR}/moc_*.cpp" "${RPCS3_SRC_DIR}/rpcs3_automoc.cpp" "${RPCS3_SRC_DIR}/qrc_resources.cpp")
 set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${TMP_MOC}")

-if (WIN32)
-    add_executable(rpcs3 WIN32 ${RPCS3_SRC} ${RES_FILES} resources.qrc)
+if(WIN32)
+	add_executable(rpcs3 WIN32 ${RPCS3_SRC} ${RES_FILES} resources.qrc)
 else()
-    add_executable(rpcs3 ${RPCS3_SRC} ${RES_FILES} resources.qrc)
+	add_executable(rpcs3 ${RPCS3_SRC} ${RES_FILES} resources.qrc)
 endif()

 add_dependencies(rpcs3 GitVersion)

+if(NOT MSVC)
+	find_package(GLEW 1.13.0 REQUIRED)
+	target_link_libraries(rpcs3 GLEW::GLEW)
+endif()
+
 if(WIN32)
 	target_link_libraries(rpcs3 ws2_32.lib Winmm.lib Psapi.lib VKstatic.1 glslang OSDependent OGLCompiler SPIRV HLSL setupapi.lib hidapi-hid Shlwapi.lib)
 	if(NOT MSVC)
-		target_link_libraries(rpcs3  ${OPENGL_LIBRARIES} ${GLEW_LIBRARY} opengl32.lib glu32.lib libpthread)
+		target_link_libraries(rpcs3 ${OPENGL_LIBRARIES} opengl32.lib glu32.lib libpthread)
 	else()
-		target_link_libraries(rpcs3  dxgi.lib d2d1.lib dwrite.lib)
+		target_link_libraries(rpcs3 dxgi.lib d2d1.lib dwrite.lib)
 	endif()
-	target_link_libraries(rpcs3  avformat.lib avcodec.lib avutil.lib swresample.lib swscale.lib png16_static ${OPENAL_LIBRARY} ${ADDITIONAL_LIBS})
+	target_link_libraries(rpcs3 avformat.lib avcodec.lib avutil.lib swscale.lib png16_static ${OPENAL_LIBRARY} ${ADDITIONAL_LIBS})
 else()
-	target_link_libraries(rpcs3 ${OPENAL_LIBRARY} ${GLEW_LIBRARY} ${OPENGL_LIBRARIES})
-	if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-		target_link_libraries(rpcs3 hidapi-hidraw udev vulkan)
+	target_link_libraries(rpcs3 ${OPENAL_LIBRARY} ${OPENGL_LIBRARIES})
+	if(APPLE)
+		target_link_libraries(rpcs3 hidapi-mac "-framework CoreFoundation" "-framework IOKit")
+	elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+		target_link_libraries(rpcs3 hidapi-hidraw udev)
 	else()
 		target_link_libraries(rpcs3 hidapi-libusb usb)
 	endif()
-	target_link_libraries(rpcs3 ${CMAKE_DL_LIBS} -lpthread ${ZLIB_LIBRARIES} ${ADDITIONAL_LIBS})
-	if (USE_SYSTEM_FFMPEG)
-		link_libraries(${FFMPEG_LIBRARY_DIR})
-		target_link_libraries(rpcs3  libavformat.so libavcodec.so libavutil.so libswresample.so libswscale.so)
-	else()
-		target_link_libraries(rpcs3  libavformat.a libavcodec.a libavutil.a libswresample.a libswscale.a)
+	if(VULKAN_FOUND)
+		target_link_libraries(rpcs3 ${VULKAN_LIBRARIES})
 	endif()
-	if (USE_SYSTEM_LIBPNG)
-		target_link_libraries(rpcs3  ${PNG_LIBRARIES})
+	target_link_libraries(rpcs3 ${CMAKE_DL_LIBS} -lpthread ZLIB::ZLIB ${ADDITIONAL_LIBS})
+	if(USE_SYSTEM_FFMPEG)
+		link_libraries(${FFMPEG_LIBRARY_DIR})
+		target_link_libraries(rpcs3 libavformat.so libavcodec.so libavutil.so libswscale.so)
 	else()
-		target_link_libraries(rpcs3  png16_static)
+		target_link_libraries(rpcs3 libavformat.a libavcodec.a libavutil.a libswscale.a)
+	endif()
+	if(USE_SYSTEM_LIBPNG)
+		target_link_libraries(rpcs3 ${PNG_LIBRARIES})
+	else()
+		target_link_libraries(rpcs3 png16_static)
 	endif()
 endif()

 # For some reason GCC 7 requires manually linking with -latomic
-if (CMAKE_COMPILER_IS_GNUCC AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 7))
+if(CMAKE_COMPILER_IS_GNUCXX AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 7))
 	target_link_libraries(rpcs3 -latomic)
 endif()

 if(LLVM_FOUND)
-	target_link_libraries(rpcs3  ${LLVM_LIBS})
+	target_link_libraries(rpcs3 ${LLVM_LIBS})
 endif()

 target_link_libraries(rpcs3 ${RPCS3_QT_LIBS})

 set_target_properties(rpcs3 PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${RPCS3_SRC_DIR}/stdafx.h")

+if(MSVC)
+	# Under Windows, some QT DLLs need to be in the same directory of the compiled
+	# RPCS3 binary, so call the windeployqt tool that will take care of copying
+	# them from the local QT installation at the end of the build.
+	if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+		add_custom_command(TARGET rpcs3 POST_BUILD
+			COMMAND $ENV{QTDIR}/bin/windeployqt --no-angle --no-opengl-sw --no-svg --no-translations --debug ${CMAKE_BINARY_DIR}/bin
+		)
+	else()
+		add_custom_command(TARGET rpcs3 POST_BUILD
+			COMMAND $ENV{QTDIR}/bin/windeployqt --no-angle --no-opengl-sw --no-svg --no-translations ${CMAKE_BINARY_DIR}/bin
+		)
+	endif()
+endif()
+
 cotire(rpcs3)

+if (UNIX)
+# Copy icons to executable directory
+add_custom_command(TARGET rpcs3 POST_BUILD
+                   COMMAND ${CMAKE_COMMAND} -E copy_directory
+                       ${CMAKE_SOURCE_DIR}/bin/Icons $<TARGET_FILE_DIR:rpcs3>/Icons)
+endif()
+                       
 # Unix installation
 if(UNIX AND NOT APPLE)
 	# Install the binary
@@ -366,4 +475,9 @@ if(UNIX AND NOT APPLE)
 		DESTINATION ${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/48x48/apps)
 	install(FILES rpcs3.desktop
 		DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications)
+    # Install other files
+    install(DIRECTORY ../bin/Icons
+		DESTINATION ${CMAKE_INSTALL_PREFIX}/share/rpcs3)
+    install(DIRECTORY ../bin/GuiConfigs
+		DESTINATION ${CMAKE_INSTALL_PREFIX}/share/rpcs3)
 endif()
@@ -150,8 +150,8 @@ s64 decrypt_block(const fs::file* in, u8* out, EDAT_HEADER *edat, NPD_HEADER *np
 	const int metadata_section_size = ((edat->flags & EDAT_COMPRESSED_FLAG) != 0 || (edat->flags & EDAT_FLAG_0x20) != 0) ? 0x20 : 0x10;
 	const int metadata_offset = 0x100;

-	std::unique_ptr<u8> enc_data;
-	std::unique_ptr<u8> dec_data;
+	std::unique_ptr<u8[]> enc_data;
+	std::unique_ptr<u8[]> dec_data;
 	u8 hash[0x10] = { 0 };
 	u8 key_result[0x10] = { 0 };
 	u8 hash_result[0x14] = { 0 };
@@ -315,7 +315,7 @@ int decrypt_data(const fs::file* in, const fs::file* out, EDAT_HEADER *edat, NPD
 {
 	const int total_blocks = (int)((edat->file_size + edat->block_size - 1) / edat->block_size);
 	u64 size_left = (int)edat->file_size;
-	std::unique_ptr<u8> data(new u8[edat->block_size]);
+	std::unique_ptr<u8[]> data(new u8[edat->block_size]);

 	for (int i = 0; i < total_blocks; i++)
 	{
@@ -427,8 +427,8 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs:

 	long bytes_read = 0;
 	long bytes_to_read = metadata_size;
-	std::unique_ptr<u8> metadata(new u8[metadata_size]);
-	std::unique_ptr<u8> empty_metadata(new u8[metadata_size]);
+	std::unique_ptr<u8[]> metadata(new u8[metadata_size]);
+	std::unique_ptr<u8[]> empty_metadata(new u8[metadata_size]);

 	while (bytes_to_read > 0)
 	{
@@ -487,7 +487,7 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs:
 			if ((edat->flags & EDAT_FLAG_0x20) != 0) //Sony failed again, they used buffer from 0x100 with half size of real metadata.
 			{
 				int metadata_buf_size = block_num * 0x10;
-				std::unique_ptr<u8> metadata_buf(new u8[metadata_buf_size]);
+				std::unique_ptr<u8[]> metadata_buf(new u8[metadata_buf_size]);
 				f->seek(file_offset + metadata_offset);
 				f->read(metadata_buf.get(), metadata_buf_size);
 				sha1(metadata_buf.get(), metadata_buf_size, signature_hash);
@@ -516,7 +516,7 @@ int check_data(unsigned char *key, EDAT_HEADER *edat, NPD_HEADER *npd, const fs:
 		{
 			// Setup header signature hash.
 			memset(signature_hash, 0, 20);
-			std::unique_ptr<u8> header_buf(new u8[0xD8]);
+			std::unique_ptr<u8[]> header_buf(new u8[0xD8]);
 			f->seek(file_offset);
 			f->read(header_buf.get(), 0xD8);
 			sha1(header_buf.get(), 0xD8, signature_hash );
@@ -577,7 +577,7 @@ int validate_npd_hashes(const char* file_name, const u8* klicensee, NPD_HEADER *
 	int dev_hash_result = 0;

 	const int file_name_length = (int) strlen(file_name);
-	std::unique_ptr<u8> buf(new u8[0x30 + file_name_length]);
+	std::unique_ptr<u8[]> buf(new u8[0x30 + file_name_length]);
 	
 	// Build the title buffer (content_id + file_name).
 	memcpy(buf.get(), npd->content_id, 0x30);
@@ -3,19 +3,72 @@
 #include "aes.h"
 #include "sha1.h"
 #include "key_vault.h"
+#include "Utilities/StrFmt.h"
+#include "Emu/System.h"
+#include "Emu/VFS.h"
 #include "unpkg.h"

-bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>& sync)
+bool pkg_install(const std::string& path, atomic_t<double>& sync)
 {
 	const std::size_t BUF_SIZE = 8192 * 1024; // 8 MB

-	// Save current file offset (probably zero)
-	const u64 start_offset = pkg_f.pos();
+	std::vector<fs::file> filelist;
+	filelist.emplace_back(fs::file{path});
+	u32 cur_file = 0;
+	u64 cur_offset = 0;
+	u64 cur_file_offset = 0;
+
+	auto archive_seek = [&](const s64 new_offset, const fs::seek_mode damode = fs::seek_set)
+	{
+		if(damode == fs::seek_set) cur_offset = new_offset;
+		else if (damode == fs::seek_cur) cur_offset += new_offset;
+
+		u64 _offset = 0;
+		for (u32 i = 0; i < filelist.size(); i++)
+		{
+			if (cur_offset < (_offset + filelist[i].size()))
+			{
+				cur_file = i;
+				cur_file_offset = cur_offset - _offset;
+				filelist[i].seek(cur_file_offset);
+				break;
+			}
+			_offset += filelist[i].size();
+		}
+	};
+
+	auto archive_read = [&](const void *data_ptr, const u64 num_bytes)
+	{
+		u64 num_bytes_left = filelist[cur_file].size() - cur_file_offset;
+		//check if it continues in another file
+		if (num_bytes > num_bytes_left)
+		{
+			filelist[cur_file].read((u8 *)data_ptr, num_bytes_left);
+			if ((cur_file + 1) < filelist.size()) cur_file++;
+			else
+			{
+				cur_offset += num_bytes_left;
+				cur_file_offset = filelist[cur_file].size();
+				return num_bytes_left;
+			}
+			u64 num_read = filelist[cur_file].read((u8 *)data_ptr + num_bytes_left, num_bytes - num_bytes_left);
+			cur_offset += (num_read + num_bytes_left);
+			cur_file_offset = num_read;
+			return (num_read+num_bytes_left);
+		}
+
+		u64 num_read = filelist[cur_file].read((u8 *)data_ptr, num_bytes);
+
+		cur_offset += num_read;
+		cur_file_offset += num_read;
+
+		return num_read;
+	};

 	// Get basic PKG information
 	PKGHeader header;

-	if (!pkg_f.read(header))
+	if (archive_read(&header, sizeof(header)) != sizeof(header))
 	{
 		LOG_ERROR(LOADER, "PKG file is too short!");
 		return false;
@@ -49,10 +102,31 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 	}
 	}

-	if (header.pkg_size > pkg_f.size())
+	if (header.pkg_size > filelist[0].size())
 	{
-		LOG_ERROR(LOADER, "PKG file size mismatch (pkg_size=0x%llx)", header.pkg_size);
-		return false;
+		// Check if multi-files pkg
+		if (path.size() < 7 || path.compare(path.size() - 7, 7, "_00.pkg", 7) != 0)
+		{
+			LOG_ERROR(LOADER, "PKG file size mismatch (pkg_size=0x%llx)", header.pkg_size);
+			return false;
+		}
+
+		std::string name_wo_number = path.substr(0, path.size() - 7);
+		u64 cursize = filelist[0].size();
+		while (cursize < header.pkg_size)
+		{
+			std::string archive_filename = fmt::format("%s_%02d.pkg", name_wo_number, filelist.size());
+
+			fs::file archive_file(archive_filename);
+			if (!archive_file)
+			{
+				LOG_ERROR(LOADER, "Missing part of the multi-files pkg: %s", archive_filename);
+				return false;
+			}
+
+			cursize += archive_file.size();
+			filelist.emplace_back(std::move(archive_file));
+		}
 	}

 	if (header.data_size + header.data_offset > header.pkg_size)
@@ -63,8 +137,14 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>

 	be_t<u32> drm_type{0};
 	be_t<u32> content_type{0};
+	std::string install_id;

-	pkg_f.seek(header.pkg_info_off);
+	// Read title ID and use it as an installation directory
+	install_id.resize(9);
+	archive_seek(55);
+	archive_read(&install_id.front(), install_id.size());
+
+	archive_seek(header.pkg_info_off);

 	for (u32 i = 0; i < header.pkg_info_num; i++)
 	{
@@ -74,7 +154,7 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 			be_t<u32> size;
 		} packet;
 		
-		pkg_f.read(packet);
+		archive_read(&packet, sizeof(packet));

 		// TODO
 		switch (+packet.id)
@@ -83,7 +163,7 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		{
 			if (packet.size == sizeof(drm_type))
 			{
-				pkg_f.read(drm_type);
+				archive_read(&drm_type, sizeof(drm_type));
 				continue;
 			}

@@ -93,7 +173,20 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		{
 			if (packet.size == sizeof(content_type))
 			{
-				pkg_f.read(content_type);
+				archive_read(&content_type, sizeof(content_type));
+				continue;
+			}
+
+			break;
+		}
+		case 0xA:
+		{
+			if (packet.size > 8)
+			{
+				// Read an actual installation directory (DLC)
+				install_id.resize(packet.size);
+				archive_read(&install_id.front(), packet.size);
+				install_id = install_id.c_str() + 8;
 				continue;
 			}

@@ -101,7 +194,26 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		}
 		}

-		pkg_f.seek(packet.size, fs::seek_cur);
+		archive_seek(packet.size, fs::seek_cur);
+	}
+
+	// If false, an existing directory is being overwritten: cannot cancel the operation
+	bool was_null = true;
+
+	// Get full path and create the directory
+	const std::string dir = Emu.GetHddDir() + "game/" + install_id + '/';
+
+	if (!fs::create_dir(dir))
+	{
+		if (fs::g_tls_error == fs::error::exist)
+		{
+			was_null = false;
+		}
+		else
+		{
+			LOG_ERROR(LOADER, "PKG: Could not create the installation directory %s", dir);
+			return false;
+		}
 	}

 	// Allocate buffer with BUF_SIZE size or more if required
@@ -110,10 +222,10 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 	// Define decryption subfunction (`psp` arg selects the key for specific block)
 	auto decrypt = [&](u64 offset, u64 size, const uchar* key) -> u64
 	{
-		pkg_f.seek(start_offset + header.data_offset + offset);
+		archive_seek(header.data_offset + offset);

 		// Read the data and set available size
-		const u64 read = pkg_f.read(buf.get(), size);
+		const u64 read = archive_read(buf.get(), size);

 		// Get block count
 		const u64 blocks = (read + 15) / 16;
@@ -206,7 +318,7 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>

 		decrypt(entry.name_offset, entry.name_size, is_psp ? PKG_AES_KEY2 : dec_key.data());

-		const std::string name(reinterpret_cast<char*>(buf.get()), entry.name_size);
+		std::string name{reinterpret_cast<char*>(buf.get()), entry.name_size};

 		LOG_NOTICE(LOADER, "Entry 0x%08x: %s", entry.type, name);

@@ -224,17 +336,17 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		case 0x15:
 		case 0x16:
 		{
-			const std::string path = dir + name;
+			const std::string path = dir + vfs::escape(name);

 			const bool did_overwrite = fs::is_file(path);

-			if (did_overwrite && (entry.type&PKG_FILE_ENTRY_OVERWRITE) == 0)
+			if (did_overwrite && (entry.type & PKG_FILE_ENTRY_OVERWRITE) == 0)
 			{
 				LOG_NOTICE(LOADER, "Didn't overwrite %s", name);
 				break;
 			}

-			if (fs::file out{ path, fs::rewrite })
+			if (fs::file out{path, fs::rewrite})
 			{
 				for (u64 pos = 0; pos < entry.file_size; pos += BUF_SIZE)
 				{
@@ -254,8 +366,16 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>

 					if (sync.fetch_add((block_size + 0.0) / header.data_size) < 0.)
 					{
-						LOG_ERROR(LOADER, "Package installation cancelled: %s", dir);
-						return false;
+						if (was_null)
+						{
+							LOG_ERROR(LOADER, "Package installation cancelled: %s", dir);
+							out.close();
+							fs::remove_all(dir, true);
+							return false;
+						}
+
+						// Cannot cancel the installation
+						sync += 1.;
 					}
 				}

@@ -279,7 +399,7 @@ bool pkg_install(const fs::file& pkg_f, const std::string& dir, atomic_t<double>
 		case PKG_FILE_ENTRY_FOLDER:
 		case 0x12:
 		{
-			const std::string path = dir + name;
+			const std::string path = dir + vfs::escape(name);

 			if (fs::create_dir(path))
 			{
@@ -57,4 +57,4 @@ struct PKGEntry
 	be_t<u32> pad;          // Padding (zeros)
 };

-bool pkg_install(const class fs::file& pkg_f, const std::string& dir, atomic_t<double>&);
+bool pkg_install(const std::string& path, atomic_t<double>&);
@@ -148,20 +148,40 @@ void WriteEhdr(const fs::file& f, Elf32_Ehdr& ehdr)
 	Write8(f, ehdr.e_data);
 	Write8(f, ehdr.e_curver);
 	Write8(f, ehdr.e_os_abi);
-	Write64(f, ehdr.e_abi_ver);
-	Write16(f, ehdr.e_type);
-	Write16(f, ehdr.e_machine);
-	Write32(f, ehdr.e_version);
-	Write32(f, ehdr.e_entry);
-	Write32(f, ehdr.e_phoff);
-	Write32(f, ehdr.e_shoff);
-	Write32(f, ehdr.e_flags);
-	Write16(f, ehdr.e_ehsize);
-	Write16(f, ehdr.e_phentsize);
-	Write16(f, ehdr.e_phnum);
-	Write16(f, ehdr.e_shentsize);
-	Write16(f, ehdr.e_shnum);
-	Write16(f, ehdr.e_shstrndx);
+	if (ehdr.e_data == 1)
+	{
+		Write64LE(f, ehdr.e_abi_ver);
+		Write16LE(f, ehdr.e_type);
+		Write16LE(f, ehdr.e_machine);
+		Write32LE(f, ehdr.e_version);
+		Write32LE(f, ehdr.e_entry);
+		Write32LE(f, ehdr.e_phoff);
+		Write32LE(f, ehdr.e_shoff);
+		Write32LE(f, ehdr.e_flags);
+		Write16LE(f, ehdr.e_ehsize);
+		Write16LE(f, ehdr.e_phentsize);
+		Write16LE(f, ehdr.e_phnum);
+		Write16LE(f, ehdr.e_shentsize);
+		Write16LE(f, ehdr.e_shnum);
+		Write16LE(f, ehdr.e_shstrndx);
+	}
+	else
+	{
+		Write64(f, ehdr.e_abi_ver);
+		Write16(f, ehdr.e_type);
+		Write16(f, ehdr.e_machine);
+		Write32(f, ehdr.e_version);
+		Write32(f, ehdr.e_entry);
+		Write32(f, ehdr.e_phoff);
+		Write32(f, ehdr.e_shoff);
+		Write32(f, ehdr.e_flags);
+		Write16(f, ehdr.e_ehsize);
+		Write16(f, ehdr.e_phentsize);
+		Write16(f, ehdr.e_phnum);
+		Write16(f, ehdr.e_shentsize);
+		Write16(f, ehdr.e_shnum);
+		Write16(f, ehdr.e_shstrndx);
+	}
 }

 void WritePhdr(const fs::file& f, Elf32_Phdr& phdr)
@@ -190,6 +210,32 @@ void WriteShdr(const fs::file& f, Elf32_Shdr& shdr)
 	Write32(f, shdr.sh_entsize);
 }

+void WritePhdrLE(const fs::file& f, Elf32_Phdr& phdr)
+{
+	Write32LE(f, phdr.p_type);
+	Write32LE(f, phdr.p_offset);
+	Write32LE(f, phdr.p_vaddr);
+	Write32LE(f, phdr.p_paddr);
+	Write32LE(f, phdr.p_filesz);
+	Write32LE(f, phdr.p_memsz);
+	Write32LE(f, phdr.p_flags);
+	Write32LE(f, phdr.p_align);
+}
+
+void WriteShdrLE(const fs::file& f, Elf32_Shdr& shdr)
+{
+	Write32LE(f, shdr.sh_name);
+	Write32LE(f, shdr.sh_type);
+	Write32LE(f, shdr.sh_flags);
+	Write32LE(f, shdr.sh_addr);
+	Write32LE(f, shdr.sh_offset);
+	Write32LE(f, shdr.sh_size);
+	Write32LE(f, shdr.sh_link);
+	Write32LE(f, shdr.sh_info);
+	Write32LE(f, shdr.sh_addralign);
+	Write32LE(f, shdr.sh_entsize);
+}
+

 void AppInfo::Load(const fs::file& f)
 {
@@ -200,6 +246,15 @@ void AppInfo::Load(const fs::file& f)
 	padding   = Read64(f);
 }

+void AppInfo::LoadLE(const fs::file& f)
+{
+	authid = Read64LE(f);
+	vendor_id = Read32LE(f);
+	self_type = Read32LE(f);
+	version = Read64(f);
+	padding = Read64(f);
+}
+
 void AppInfo::Show()
 {
 	LOG_NOTICE(LOADER, "AuthID: 0x%llx", authid);
@@ -218,6 +273,16 @@ void SectionInfo::Load(const fs::file& f)
 	encrypted  = Read32(f);
 }

+void SectionInfo::LoadLE(const fs::file& f)
+{
+	offset = Read64LE(f);
+	size = Read64LE(f);
+	compressed = Read32LE(f);
+	unknown1 = Read32LE(f);
+	unknown2 = Read32LE(f);
+	encrypted = Read32LE(f);
+}
+
 void SectionInfo::Show()
 {
 	LOG_NOTICE(LOADER, "Offset: 0x%llx", offset);
@@ -236,6 +301,14 @@ void SCEVersionInfo::Load(const fs::file& f)
 	unknown        = Read32(f);
 }

+void SCEVersionInfo::LoadLE(const fs::file& f)
+{
+	subheader_type = Read32LE(f);
+	present = Read32LE(f);
+	size = Read32LE(f);
+	unknown = Read32LE(f);
+}
+
 void SCEVersionInfo::Show()
 {
 	LOG_NOTICE(LOADER, "Sub-header type: 0x%08x", subheader_type);
@@ -290,6 +363,65 @@ void ControlInfo::Load(const fs::file& f)
 	}
 }

+void ControlInfo::LoadLE(const fs::file& f)
+{
+	type = Read32LE(f);
+	size = Read32LE(f);
+	next = Read64LE(f);
+
+	if (type == 1)
+	{
+		control_flags.ctrl_flag1 = Read32LE(f);
+		control_flags.unknown1 = Read32LE(f);
+		control_flags.unknown2 = Read32LE(f);
+		control_flags.unknown3 = Read32LE(f);
+		control_flags.unknown4 = Read32LE(f);
+		control_flags.unknown5 = Read32LE(f);
+		control_flags.unknown6 = Read32LE(f);
+		control_flags.unknown7 = Read32LE(f);
+	}
+	else if (type == 2)
+	{
+		if (size == 0x30)
+		{
+			f.read(file_digest_30.digest, 20);
+			file_digest_30.unknown = Read64LE(f);
+		}
+		else if (size == 0x40)
+		{
+			f.read(file_digest_40.digest1, 20);
+			f.read(file_digest_40.digest2, 20);
+			file_digest_40.unknown = Read64LE(f);
+		}
+	}
+	else if (type == 3)
+	{
+		npdrm.magic = Read32LE(f);
+		npdrm.unknown1 = Read32LE(f);
+		npdrm.license = Read32LE(f);
+		npdrm.type = Read32LE(f);
+		f.read(npdrm.content_id, 48);
+		f.read(npdrm.digest, 16);
+		f.read(npdrm.invdigest, 16);
+		f.read(npdrm.xordigest, 16);
+		npdrm.unknown2 = Read64LE(f);
+		npdrm.unknown3 = Read64LE(f);
+	}
+	else if (type == 5)
+	{
+		f.read(type5.unk, 0x100);
+	}
+	else if (type == 6)
+	{
+		type6.unknown1 = Read32LE(f);
+		f.read(type6.unk, 0xFC);
+	}
+	else if (type == 7)
+	{
+		f.read(type7.unk, 0x40);
+	}
+}
+
 void ControlInfo::Show()
 {
 	LOG_NOTICE(LOADER, "Type: 0x%08x", type);
@@ -634,6 +766,19 @@ void SceHeader::Load(const fs::file& f)
 	se_esize = Read64(f);
 }

+void SceHeader::LoadLE(const fs::file& f)
+{
+	se_magic = Read32(f);
+	se_hver = Read32LE(f);
+	se_flags = Read16LE(f);
+	se_type = Read16LE(f);
+	se_meta = Read32LE(f);
+	se_hsize = Read64LE(f);
+	se_esize = Read64LE(f);
+	Read64LE(f);
+	Read64LE(f);
+}
+
 void SelfHeader::Load(const fs::file& f)
 {
 	se_htype = Read64(f);
@@ -648,6 +793,11 @@ void SelfHeader::Load(const fs::file& f)
 	pad = Read64(f);
 }

+void SelfHeader::LoadLE(const fs::file& f)
+{
+	f.read(this, sizeof(*this));
+}
+
 SCEDecrypter::SCEDecrypter(const fs::file& s)
 	: sce_f(s)
 	, data_buf_length(0)
@@ -885,11 +1035,22 @@ SELFDecrypter::SELFDecrypter(const fs::file& s)
 {
 }

+static bool isVita(const SceHeader hdr)
+{
+	return (hdr.se_hver == 3);
+}
+
 bool SELFDecrypter::LoadHeaders(bool isElf32)
 {
 	// Read SCE header.
 	self_f.seek(0);
-	sce_hdr.Load(self_f);
+	sce_hdr.LoadLE(self_f);
+
+	if (!isVita(sce_hdr)) 
+	{
+		self_f.seek(0);
+		sce_hdr.Load(self_f);
+	}

 	// Check SCE magic.
 	if (!sce_hdr.CheckMagic())
@@ -899,11 +1060,26 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 	}

 	// Read SELF header.
-	self_hdr.Load(self_f);
+	if (!isVita(sce_hdr))
+	{
+		self_hdr.Load(self_f);
+	}
+	else
+	{
+		self_hdr.LoadLE(self_f);
+	}

 	// Read the APP INFO.
 	self_f.seek(self_hdr.se_appinfooff);
-	app_info.Load(self_f);
+	
+	if (!isVita(sce_hdr))
+	{
+		app_info.Load(self_f);
+	}
+	else
+	{
+		app_info.LoadLE(self_f);
+	}

 	// Read ELF header.
 	self_f.seek(self_hdr.se_elfoff);
@@ -926,7 +1102,14 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 		for(u32 i = 0; i < elf32_hdr.e_phnum; ++i)
 		{
 			phdr32_arr.emplace_back();
-			phdr32_arr.back().Load(self_f);
+			if (!isVita(sce_hdr))
+			{
+				phdr32_arr.back().Load(self_f);
+			}
+			else
+			{
+				phdr32_arr.back().LoadLE(self_f);
+			}
 		}
 	}
 	else
@@ -956,12 +1139,26 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 	for(u32 i = 0; i < ((isElf32) ? elf32_hdr.e_phnum : elf64_hdr.e_phnum); ++i)
 	{
 		secinfo_arr.emplace_back();
-		secinfo_arr.back().Load(self_f);
+		if (!isVita(sce_hdr))
+		{
+			secinfo_arr.back().Load(self_f);
+		}
+		else
+		{
+			secinfo_arr.back().LoadLE(self_f);
+		}
 	}

 	// Read SCE version info.
 	self_f.seek(self_hdr.se_sceveroff);
-	scev_info.Load(self_f);
+	if (!isVita(sce_hdr))
+	{
+		scev_info.Load(self_f);
+	}
+	else
+	{
+		scev_info.LoadLE(self_f);
+	}

 	// Read control info.
 	ctrlinfo_arr.clear();
@@ -972,7 +1169,14 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 	{
 		ctrlinfo_arr.emplace_back();
 		ControlInfo &cinfo = ctrlinfo_arr.back();
-		cinfo.Load(self_f);
+		if (!isVita(sce_hdr))
+		{
+			cinfo.Load(self_f);
+		}
+		else
+		{
+			cinfo.LoadLE(self_f);
+		}
 		i += cinfo.size;
 	}

@@ -992,7 +1196,14 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
 		for(u32 i = 0; i < elf32_hdr.e_shnum; ++i)
 		{
 			shdr32_arr.emplace_back();
-			shdr32_arr.back().Load(self_f);
+			if (!isVita(sce_hdr))
+			{
+				shdr32_arr.back().Load(self_f);
+			}
+			else
+			{
+				shdr32_arr.back().LoadLE(self_f);
+			}
 		}
 	}
 	else
@@ -1157,6 +1368,8 @@ bool SELFDecrypter::LoadMetadata(u8* klic_key)
 	memcpy(metadata_iv, keyset.riv, 0x10);

 	// Check DEBUG flag.
+	if (sce_hdr.se_flags == 0x00c0)
+		return true;
 	if ((sce_hdr.se_flags & 0x8000) != 0x8000)
 	{
 		// Decrypt the NPDRM layer.
@@ -1219,6 +1432,14 @@ bool SELFDecrypter::DecryptData()
 		}
 	}

+	if (meta_hdr.section_count == 0) 
+	{
+		for (unsigned int i = 0; i < secinfo_arr.size(); i++)
+		{
+			data_buf_length += secinfo_arr[i].size;
+		}
+	}
+
 	// Allocate a buffer to store decrypted data.
 	data_buf = std::make_unique<u8[]>(data_buf_length);

@@ -1266,6 +1487,16 @@ bool SELFDecrypter::DecryptData()
 		}
 	}

+	if (meta_hdr.section_count == 0) 
+	{
+		for (unsigned int i = 0; i < secinfo_arr.size(); i++)
+		{
+			self_f.seek(secinfo_arr[i].offset);
+			self_f.read(data_buf.get() + data_buf_offset, secinfo_arr[i].size);
+			data_buf_offset += secinfo_arr[i].size;
+		}
+	}
+
 	return true;
 }

@@ -1285,20 +1516,75 @@ fs::file SELFDecrypter::MakeElf(bool isElf32)
 		// Write program headers.
 		for (u32 i = 0; i < elf32_hdr.e_phnum; ++i)
 		{
-			WritePhdr(e, phdr32_arr[i]);
+			if (elf32_hdr.e_data == 1)
+			{
+				WritePhdrLE(e, phdr32_arr[i]);
+			}
+			else
+			{
+				WritePhdr(e, phdr32_arr[i]);
+			}
 		}

-		for (unsigned int i = 0; i < meta_hdr.section_count; i++)
+		if (meta_hdr.section_count != 0)
 		{
-			// PHDR type.
-			if (meta_shdr[i].type == 2)
+			for (unsigned int i = 0; i < meta_hdr.section_count; i++)
 			{
-				// Seek to the program header data offset and write the data.
-				e.seek(phdr32_arr[meta_shdr[i].program_idx].p_offset);
-				e.write(data_buf.get() + data_buf_offset, meta_shdr[i].data_size);
+				// PHDR type.
+				if (meta_shdr[i].type == 2)
+				{
+					// Seek to the program header data offset and write the data.
+					e.seek(phdr32_arr[meta_shdr[i].program_idx].p_offset);
+					e.write(data_buf.get() + data_buf_offset, meta_shdr[i].data_size);
+
+					// Advance the data buffer offset by data size.
+					data_buf_offset += meta_shdr[i].data_size;
+				}
+			}
+		}
+		else 
+		{
+			for (unsigned int i = 0; i < phdr32_arr.size(); i++)
+			{
+				// Decompress if necessary. 
+				if (secinfo_arr[i].compressed == 2)
+				{
+					// Store the length in writeable memory space.
+					std::unique_ptr<uLongf> decomp_buf_length(new uLongf);
+					memcpy(decomp_buf_length.get(), &phdr32_arr[i].p_filesz, sizeof(uLongf));
+					/// Create a pointer to a buffer for decompression.
+					std::unique_ptr<u8[]> decomp_buf(new u8[phdr32_arr[i].p_filesz]);
+
+					// Create a buffer separate from data_buf to uncompress.
+					std::unique_ptr<u8[]> zlib_buf(new u8[data_buf_length]);
+					memcpy(zlib_buf.get(), data_buf.get(), data_buf_length);
+
+					// Use zlib uncompress on the new buffer.
+					// decomp_buf_length changes inside the call to uncompress, so it must be a pointer to correct type (in writeable mem space).
+					int rv = uncompress(decomp_buf.get(), decomp_buf_length.get(), zlib_buf.get() + data_buf_offset, data_buf_length);
+
+					// Check for errors (TODO: Probably safe to remove this once these changes have passed testing.)
+					switch (rv)
+					{
+					case Z_MEM_ERROR:	LOG_ERROR(LOADER, "MakeELF encountered a Z_MEM_ERROR!"); break;
+					case Z_BUF_ERROR:	LOG_ERROR(LOADER, "MakeELF encountered a Z_BUF_ERROR!"); break;
+					case Z_DATA_ERROR:	LOG_ERROR(LOADER, "MakeELF encountered a Z_DATA_ERROR!"); break;
+					default: break;
+					}
+
+					// Seek to the program header data offset and write the data.
+					e.seek(phdr32_arr[i].p_offset);
+					e.write(decomp_buf.get(), phdr32_arr[i].p_filesz);
+				}
+				else
+				{
+					// Seek to the program header data offset and write the data.
+					e.seek(phdr32_arr[i].p_offset);
+					e.write(data_buf.get() + data_buf_offset, secinfo_arr[i].size);
+				}

 				// Advance the data buffer offset by data size.
-				data_buf_offset += meta_shdr[i].data_size;
+				data_buf_offset += secinfo_arr[i].size;
 			}
 		}

@@ -1309,7 +1595,14 @@ fs::file SELFDecrypter::MakeElf(bool isElf32)

 			for (u32 i = 0; i < elf32_hdr.e_shnum; ++i)
 			{
-				WriteShdr(e, shdr32_arr[i]);
+				if (elf32_hdr.e_data == 1)
+				{
+					WriteShdrLE(e, shdr32_arr[i]);
+				}
+				else
+				{
+					WriteShdr(e, shdr32_arr[i]);
+				}
 			}
 		}
 	}
@@ -1424,8 +1717,20 @@ static bool IsSelfElf32(const fs::file& f)

 	SceHeader hdr;
 	SelfHeader sh;
-	hdr.Load(f);
-	sh.Load(f);
+
+	hdr.LoadLE(f);
+
+	if (!isVita(hdr)) 
+	{
+		f.seek(0);
+		hdr.Load(f);
+		sh.Load(f);
+	}
+	else
+	{
+		sh.LoadLE(f);
+	}
+
 	
 	// Locate the class byte and check it.
 	u8 elf_class[0x8];
@@ -1451,13 +1756,23 @@ static bool CheckDebugSelf(fs::file& s)
 	// Check for DEBUG version.
 	if (key_version == 0x80 || key_version == 0xc0)
 	{
-		LOG_WARNING(LOADER, "Debug SELF detected! Removing fake header...");
+		
+		s.seek(0x04);
+		const u16 version = s.read<le_t<u16>>();

+		if (version == 3)
+		{
+			return false;
+		}
+
+		LOG_WARNING(LOADER, "Debug SELF detected! Removing fake header...");
+		
 		// Get the real elf offset.
 		s.seek(0x10);

+		const u64 realoffset = key_version == 0x80 ? +s.read<be_t<u64>>() : +s.read<le_t<u64>>();
 		// Start at the real elf offset.
-		s.seek(key_version == 0x80 ? +s.read<be_t<u64>>() : +s.read<le_t<u64>>());
+		s.seek(realoffset);

 		// Write the real ELF file back.
 		fs::file e = fs::make_stream<std::vector<u8>>();
@@ -1560,4 +1875,4 @@ std::array<u8, 0x10> get_default_self_klic()
 	std::array<u8, 0x10> key;
 	std::copy(std::begin(NP_KLIC_FREE), std::end(NP_KLIC_FREE), std::begin(key));
 	return key;
-}
+}
@@ -11,6 +11,7 @@ struct AppInfo
 	u64 padding;

 	void Load(const fs::file& f);
+	void LoadLE(const fs::file& f);
 	void Show();
 };

@@ -24,6 +25,7 @@ struct SectionInfo
 	u32 encrypted;

 	void Load(const fs::file& f);
+	void LoadLE(const fs::file& f);
 	void Show();
 };

@@ -35,6 +37,7 @@ struct SCEVersionInfo
 	u32 unknown;

 	void Load(const fs::file& f);
+	void LoadLE(const fs::file& f);
 	void Show();
 };

@@ -92,9 +95,33 @@ struct ControlInfo
 			u64 unknown3;

 		} npdrm;
+
+		// type 5 0x110 bytes
+		struct
+		{
+			u32 pad;
+			u8 unk[0x100];
+		} type5;
+
+		// type 6 0x110 bytes
+		struct
+		{
+			u32 pad;
+			u32 unknown1;
+			u8 unk[0xFC];
+		} type6;
+
+		// type 7 0x50 bytes
+		struct
+		{
+			u32 pad;
+			u8 unk[0x40];
+		} type7;
+
 	};

 	void Load(const fs::file& f);
+	void LoadLE(const fs::file& f);
 	void Show();
 };

@@ -317,6 +344,7 @@ struct SceHeader
 	u64 se_esize;

 	void Load(const fs::file& f);
+	void LoadLE(const fs::file& f);
 	void Show(){}
 	bool CheckMagic() const { return se_magic == 0x53434500; }
 };
@@ -335,6 +363,7 @@ struct SelfHeader
 	u64 pad;
 	
 	void Load(const fs::file& f);
+	void LoadLE(const fs::file& f);
 	void Show(){}
 };

@@ -118,7 +118,7 @@ void aesecb128_encrypt(unsigned char *key, unsigned char *in, unsigned char *out

 bool hmac_hash_compare(unsigned char *key, int key_len, unsigned char *in, int in_len, unsigned char *hash, int hash_len)
 {
-	std::unique_ptr<u8> out(new u8[key_len]);
+	std::unique_ptr<u8[]> out(new u8[key_len]);

 	sha1_hmac(key, key_len, in, in_len, out.get());

@@ -132,7 +132,7 @@ void hmac_hash_forge(unsigned char *key, int key_len, unsigned char *in, int in_

 bool cmac_hash_compare(unsigned char *key, int key_len, unsigned char *in, int in_len, unsigned char *hash, int hash_len)
 {
-	std::unique_ptr<u8> out(new u8[key_len]);
+	std::unique_ptr<u8[]> out(new u8[key_len]);

 	aes_context ctx;
 	aes_setkey_enc(&ctx, key, 128);
@@ -50,6 +50,8 @@ OpenALThread::OpenALThread()
 	{
 		m_format = g_cfg.audio.convert_to_u16 ? AL_FORMAT_71CHN16 : AL_FORMAT_71CHN32;
 	}
+
+	m_buffers = std::make_unique<ALuint[]>(g_cfg.audio.frames);
 }

 OpenALThread::~OpenALThread()
@@ -83,7 +85,7 @@ void OpenALThread::Close()
 	if (alIsSource(m_source))
 		alDeleteSources(1, &m_source);

-	alDeleteBuffers(g_al_buffers_count, m_buffers);
+	alDeleteBuffers(g_cfg.audio.frames, m_buffers.get());
 	checkForAlError("alDeleteBuffers");
 }

@@ -98,7 +100,7 @@ void OpenALThread::Open(const void* src, int size)
 	alGenSources(1, &m_source);
 	checkForAlError("alGenSources");

-	alGenBuffers(g_al_buffers_count, m_buffers);
+	alGenBuffers(g_cfg.audio.frames, m_buffers.get());
 	checkForAlError("alGenBuffers");

 	alSourcei(m_source, AL_LOOPING, AL_FALSE);
@@ -106,13 +108,13 @@ void OpenALThread::Open(const void* src, int size)

 	m_buffer_size = size;

-	for (uint i = 0; i<g_al_buffers_count; ++i)
+	for (int i = 0; i < g_cfg.audio.frames; ++i)
 	{
 		alBufferData(m_buffers[i], m_format, src, m_buffer_size, 48000);
 		checkForAlError("alBufferData");
 	}

-	alSourceQueueBuffers(m_source, g_al_buffers_count, m_buffers);
+	alSourceQueueBuffers(m_source, g_cfg.audio.frames, m_buffers.get());
 	checkForAlError("alSourceQueueBuffers");
 	Play();
 }
@@ -2,15 +2,14 @@

 #include "Emu/Audio/AudioThread.h"
 #include "3rdparty/OpenAL/include/alext.h"
+#include <memory>

 class OpenALThread : public AudioThread
 {
 private:
-	static const uint g_al_buffers_count = 24;
-
 	ALint m_format;
 	ALuint m_source;
-	ALuint m_buffers[g_al_buffers_count];
+	std::unique_ptr<ALuint[]> m_buffers;
 	ALsizei m_buffer_size;

 public:
@@ -1,18 +1,19 @@
 #include "stdafx.h"
-#include "Utilities/GSL.h"
 #include "Emu/System.h"

 #include "ALSAThread.h"

-#ifdef __linux__
+#ifdef HAVE_ALSA

 #include <alsa/asoundlib.h>

 static thread_local snd_pcm_t* s_tls_handle{nullptr};
+static thread_local snd_pcm_hw_params_t* s_tls_hw_params{nullptr};
+static thread_local snd_pcm_sw_params_t* s_tls_sw_params{nullptr};

 static void error(int err, const char* reason)
 {
-	fprintf(stderr, "ALSA: %s failed: %s\n", reason, snd_strerror(err));
+	LOG_ERROR(GENERAL, "ALSA: %s failed: %s\n", reason, snd_strerror(err));
 }

 static bool check(int err, const char* reason)
@@ -28,55 +29,88 @@ static bool check(int err, const char* reason)

 ALSAThread::ALSAThread()
 {
-	snd_pcm_hw_params_t* hw_params{nullptr};
-
-	auto at_ret = gsl::finally([&]()
-	{
-		if (hw_params)
-		{
-			snd_pcm_hw_params_free(hw_params);
-		}
-	});
-
 	if (!check(snd_pcm_open(&s_tls_handle, "default", SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK), "snd_pcm_open"))
 		return;

-	if (!check(snd_pcm_hw_params_malloc(&hw_params), "snd_pcm_hw_params_malloc"))
+	if (!check(snd_pcm_hw_params_malloc(&s_tls_hw_params), "snd_pcm_hw_params_malloc"))
 		return;

-	if (!check(snd_pcm_hw_params_any(s_tls_handle, hw_params), "snd_pcm_hw_params_any"))
+	if (!check(snd_pcm_hw_params_any(s_tls_handle, s_tls_hw_params), "snd_pcm_hw_params_any"))
 		return;

-	if (!check(snd_pcm_hw_params_set_access(s_tls_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED), "snd_pcm_hw_params_set_access"))
+	if (!check(snd_pcm_hw_params_set_access(s_tls_handle, s_tls_hw_params, SND_PCM_ACCESS_RW_INTERLEAVED), "snd_pcm_hw_params_set_access"))
 		return;

-	if (!check(snd_pcm_hw_params_set_format(s_tls_handle, hw_params, g_cfg.audio.convert_to_u16 ? SND_PCM_FORMAT_S16_LE : SND_PCM_FORMAT_FLOAT_LE), "snd_pcm_hw_params_set_format"))
+	if (!check(snd_pcm_hw_params_set_format(s_tls_handle, s_tls_hw_params, g_cfg.audio.convert_to_u16 ? SND_PCM_FORMAT_S16_LE : SND_PCM_FORMAT_FLOAT_LE), "snd_pcm_hw_params_set_format"))
 		return;

-	if (!check(snd_pcm_hw_params_set_rate(s_tls_handle, hw_params, 48000, 0), "snd_pcm_hw_params_set_rate_near"))
+	uint rate = 48000;
+	if (!check(snd_pcm_hw_params_set_rate_near(s_tls_handle, s_tls_hw_params, &rate, nullptr), "snd_pcm_hw_params_set_rate_near"))
 		return;

-	if (!check(snd_pcm_hw_params_set_channels(s_tls_handle, hw_params, g_cfg.audio.downmix_to_2ch ? 2 : 8), "snd_pcm_hw_params_set_channels"))
+	if (!check(snd_pcm_hw_params_set_channels(s_tls_handle, s_tls_hw_params, g_cfg.audio.downmix_to_2ch ? 2 : 8), "snd_pcm_hw_params_set_channels"))
 		return;

-	if (!check(snd_pcm_hw_params_set_buffer_size(s_tls_handle, hw_params, 8 * 256), "snd_pcm_hw_params_set_buffer_size"))
+	//uint period = 5333;
+	//if (!check(snd_pcm_hw_params_set_period_time_near(s_tls_handle, s_tls_hw_params, &period, nullptr), "snd_pcm_hw_params_set_period_time_near"))
+	//	return;
+
+	//if (!check(snd_pcm_hw_params_set_periods(s_tls_handle, s_tls_hw_params, 4, 0), "snd_pcm_hw_params_set_periods"))
+	//	return;
+
+	snd_pcm_uframes_t bufsize_frames = g_cfg.audio.frames * 256;
+	snd_pcm_uframes_t period_frames = 256;
+
+	if (!check(snd_pcm_hw_params_set_buffer_size_near(s_tls_handle, s_tls_hw_params, &bufsize_frames), "snd_pcm_hw_params_set_buffer_size_near"))
 		return;

-	if (!check(snd_pcm_hw_params_set_period_size(s_tls_handle, hw_params, 256, 0), "snd_pcm_hw_params_set_period_size"))
+	if (!check(snd_pcm_hw_params_set_period_size_near(s_tls_handle, s_tls_hw_params, &period_frames, 0), "snd_pcm_hw_params_set_period_size"))
 		return;

-	//if (!check(snd_pcm_hw_params_set_periods(s_tls_handle, hw_params, 2, 0), "snd_pcm_hw_params_set_periods"))
-	//  return;
+	if (!check(snd_pcm_hw_params(s_tls_handle, s_tls_hw_params), "snd_pcm_hw_params"))
+		return;

-	if (!check(snd_pcm_hw_params(s_tls_handle, hw_params), "snd_pcm_hw_params"))
+	if (!check(snd_pcm_hw_params_get_buffer_size(s_tls_hw_params, &bufsize_frames), "snd_pcm_hw_params_get_buffer_size"))
+		return;
+
+	if (!check(snd_pcm_hw_params_get_period_size(s_tls_hw_params, &period_frames, nullptr), "snd_pcm_hw_params_get_period_size"))
+		return;
+
+	if (!check(snd_pcm_sw_params_malloc(&s_tls_sw_params), "snd_pcm_sw_params_malloc"))
+		return;
+
+	if (!check(snd_pcm_sw_params_current(s_tls_handle, s_tls_sw_params), "snd_pcm_sw_params_current"))
+		return;
+
+	period_frames *= g_cfg.audio.startt;
+
+	if (!check(snd_pcm_sw_params_set_start_threshold(s_tls_handle, s_tls_sw_params, period_frames), "snd_pcm_sw_params_set_start_threshold"))
+		return;
+
+	if (!check(snd_pcm_sw_params_set_stop_threshold(s_tls_handle, s_tls_sw_params, bufsize_frames), "snd_pcm_sw_params_set_stop_threshold"))
+		return;
+
+	if (!check(snd_pcm_sw_params(s_tls_handle, s_tls_sw_params), "snd_pcm_sw_params"))
 		return;

 	if (!check(snd_pcm_prepare(s_tls_handle), "snd_pcm_prepare"))
 		return;
+
+	LOG_NOTICE(GENERAL, "ALSA: bufsize_frames=%u, period_frames=%u", bufsize_frames, period_frames);
 }

 ALSAThread::~ALSAThread()
 {
+	if (s_tls_sw_params)
+	{
+		snd_pcm_sw_params_free(s_tls_sw_params);
+	}
+
+	if (s_tls_hw_params)
+	{
+		snd_pcm_hw_params_free(s_tls_hw_params);
+	}
+
 	if (s_tls_handle)
 	{
 		snd_pcm_close(s_tls_handle);
@@ -105,29 +139,30 @@ void ALSAThread::AddData(const void* src, int size)
 	size /= g_cfg.audio.convert_to_u16 ? 2 : 4;
 	size /= g_cfg.audio.downmix_to_2ch ? 2 : 8;

-	int res;
+	int res = snd_pcm_writei(s_tls_handle, src, size);

-	while (true)
+	if (res == -EAGAIN)
 	{
-		res = snd_pcm_writei(s_tls_handle, src, size);
+		LOG_WARNING(GENERAL, "ALSA: EAGAIN");
+		return;
+	}

-		if (res == -EAGAIN)
+	if (res < 0)
+	{
+		res = snd_pcm_recover(s_tls_handle, res, 0);
+
+		if (res < 0)
 		{
-			continue;
-		}
-		else if (res == -EPIPE)
-		{
-			snd_pcm_prepare(s_tls_handle);
-		}
-		else
-		{
-			break;
+			LOG_WARNING(GENERAL, "ALSA: failed to recover (%d)", res);
+			return;
 		}
+
+		res = snd_pcm_writei(s_tls_handle, src, size);
 	}

 	if (res != size)
 	{
-		error(res, "snd_pcm_writei");
+		LOG_WARNING(GENERAL, "ALSA: error (%d)", res);
 	}
 }

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

-#ifdef __linux__
+#ifdef HAVE_ALSA

 #include "Emu/Audio/AudioThread.h"

@@ -0,0 +1,60 @@
+#include "Emu/System.h"
+#include "PulseThread.h"
+
+#ifdef HAVE_PULSE
+
+#include <pulse/simple.h>
+#include <pulse/error.h>
+
+PulseThread::PulseThread()
+{
+}
+
+PulseThread::~PulseThread()
+{
+	this->Close();
+}
+
+void PulseThread::Play()
+{
+}
+
+void PulseThread::Close()
+{
+	if(this->connection) {
+		pa_simple_free(this->connection);
+		this->connection = nullptr;
+	}
+}
+
+void PulseThread::Stop()
+{
+}
+
+void PulseThread::Open(const void* src, int size)
+{
+	pa_sample_spec ss;
+	ss.format = g_cfg.audio.convert_to_u16 ? PA_SAMPLE_S16LE : PA_SAMPLE_FLOAT32LE;
+	ss.channels = g_cfg.audio.downmix_to_2ch ? 2 : 8;
+	ss.rate = 48000;
+
+	int err;
+	this->connection = pa_simple_new(NULL, "RPCS3", PA_STREAM_PLAYBACK, NULL, "Game", &ss, NULL, NULL, &err);
+	if(!this->connection) {
+		fprintf(stderr, "PulseAudio: Failed to initialize audio: %s\n", pa_strerror(err));
+	}
+
+	this->AddData(src, size);
+}
+
+void PulseThread::AddData(const void* src, int size)
+{
+	if(this->connection) {
+		int err;
+		if(pa_simple_write(this->connection, src, size, &err) < 0) {
+			fprintf(stderr, "PulseAudio: Failed to write audio stream: %s\n", pa_strerror(err));
+		}
+	}
+}
+
+#endif
@@ -0,0 +1,23 @@
+#pragma once
+
+#ifdef HAVE_PULSE
+#include <pulse/simple.h>
+#include "Emu/Audio/AudioThread.h"
+
+class PulseThread : public AudioThread
+{
+public:
+	PulseThread();
+	virtual ~PulseThread() override;
+
+	virtual void Play() override;
+	virtual void Open(const void* src, int size) override;
+	virtual void Close() override;
+	virtual void Stop() override;
+	virtual void AddData(const void* src, int size) override;
+
+private:
+	pa_simple *connection = nullptr;
+};
+
+#endif
@@ -121,7 +121,7 @@ void XAudio2Thread::xa27_open()
 		return;
 	}

-	s_tls_source_voice->SetVolume(g_cfg.audio.downmix_to_2ch ? 1.0 : 4.0);
+	s_tls_source_voice->SetVolume(g_cfg.audio.downmix_to_2ch ? 1.0f : 4.0f);
 }

 void XAudio2Thread::xa27_add(const void* src, int size)
@@ -4,6 +4,7 @@
 #include "CPUThread.h"
 #include "Emu/IdManager.h"
 #include "Utilities/GDBDebugServer.h"
+#include <typeinfo>

 #ifdef _WIN32
 #include <Windows.h>
@@ -1 +1,13 @@
+#ifdef LLVM_AVAILABLE
+
 #include "CPUTranslator.h"
+
+cpu_translator::cpu_translator(llvm::LLVMContext& context, llvm::Module* module, bool is_be)
+    : m_context(context)
+	, m_module(module)
+	, m_is_be(is_be)
+{
+
+}
+
+#endif
@@ -1 +1,750 @@
 #pragma once
+
+#ifdef LLVM_AVAILABLE
+
+#include "restore_new.h"
+#ifdef _MSC_VER
+#pragma warning(push, 0)
+#endif
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Module.h"
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#include "define_new_memleakdetect.h"
+
+#include "../Utilities/types.h"
+#include "../Utilities/StrFmt.h"
+#include "../Utilities/BEType.h"
+#include "../Utilities/BitField.h"
+
+#include <unordered_map>
+#include <map>
+#include <unordered_set>
+#include <set>
+#include <array>
+#include <vector>
+
+template <typename T = void>
+struct llvm_value_t
+{
+	static_assert(std::is_same<T, void>::value, "llvm_value_t<> error: unknown type");
+
+	using type = void;
+	static constexpr uint esize      = 0;
+	static constexpr bool is_int     = false;
+	static constexpr bool is_sint    = false;
+	static constexpr bool is_uint    = false;
+	static constexpr bool is_float   = false;
+	static constexpr uint is_vector  = false;
+	static constexpr uint is_pointer = false;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getVoidTy(context);
+	}
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		return value;
+	}
+
+	llvm::Value* value;
+
+	// llvm_value_t() = default;
+
+	// llvm_value_t(llvm::Value* value)
+	// 	: value(value)
+	// {
+	// }
+};
+
+template <>
+struct llvm_value_t<bool> : llvm_value_t<void>
+{
+	using type = bool;
+	using base = llvm_value_t<void>;
+	using base::base;
+
+	static constexpr uint esize  = 1;
+	static constexpr uint is_int = true;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getInt1Ty(context);
+	}
+};
+
+template <>
+struct llvm_value_t<char> : llvm_value_t<void>
+{
+	using type = char;
+	using base = llvm_value_t<void>;
+	using base::base;
+
+	static constexpr uint esize  = 8;
+	static constexpr bool is_int = true;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getInt8Ty(context);
+	}
+};
+
+template <>
+struct llvm_value_t<s8> : llvm_value_t<char>
+{
+	using type = s8;
+	using base = llvm_value_t<char>;
+	using base::base;
+
+	static constexpr bool is_sint = true;
+};
+
+template <>
+struct llvm_value_t<u8> : llvm_value_t<char>
+{
+	using type = u8;
+	using base = llvm_value_t<char>;
+	using base::base;
+
+	static constexpr bool is_uint = true;
+};
+
+template <>
+struct llvm_value_t<s16> : llvm_value_t<s8>
+{
+	using type = s16;
+	using base = llvm_value_t<s8>;
+	using base::base;
+
+	static constexpr uint esize = 16;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getInt16Ty(context);
+	}
+};
+
+template <>
+struct llvm_value_t<u16> : llvm_value_t<s16>
+{
+	using type = u16;
+	using base = llvm_value_t<s16>;
+	using base::base;
+
+	static constexpr bool is_sint = false;
+	static constexpr bool is_uint = true;
+};
+
+template <>
+struct llvm_value_t<s32> : llvm_value_t<s8>
+{
+	using type = s32;
+	using base = llvm_value_t<s8>;
+	using base::base;
+
+	static constexpr uint esize = 32;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getInt32Ty(context);
+	}
+};
+
+template <>
+struct llvm_value_t<u32> : llvm_value_t<s32>
+{
+	using type = u32;
+	using base = llvm_value_t<s32>;
+	using base::base;
+
+	static constexpr bool is_sint = false;
+	static constexpr bool is_uint = true;
+};
+
+template <>
+struct llvm_value_t<s64> : llvm_value_t<s8>
+{
+	using type = s64;
+	using base = llvm_value_t<s8>;
+	using base::base;
+
+	static constexpr uint esize = 64;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getInt64Ty(context);
+	}
+};
+
+template <>
+struct llvm_value_t<u64> : llvm_value_t<s64>
+{
+	using type = u64;
+	using base = llvm_value_t<s64>;
+	using base::base;
+
+	static constexpr bool is_sint = false;
+	static constexpr bool is_uint = true;
+};
+
+template <>
+struct llvm_value_t<s128> : llvm_value_t<s8>
+{
+	using type = s128;
+	using base = llvm_value_t<s8>;
+	using base::base;
+
+	static constexpr uint esize = 128;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getIntNTy(context, 128);
+	}
+};
+
+template <>
+struct llvm_value_t<u128> : llvm_value_t<s128>
+{
+	using type = u128;
+	using base = llvm_value_t<s128>;
+	using base::base;
+
+	static constexpr bool is_sint = false;
+	static constexpr bool is_uint = true;
+};
+
+template <>
+struct llvm_value_t<f32> : llvm_value_t<void>
+{
+	using type = f32;
+	using base = llvm_value_t<void>;
+	using base::base;
+
+	static constexpr uint esize    = 32;
+	static constexpr bool is_float = true;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getFloatTy(context);
+	}
+};
+
+template <>
+struct llvm_value_t<f64> : llvm_value_t<void>
+{
+	using type = f64;
+	using base = llvm_value_t<void>;
+	using base::base;
+
+	static constexpr uint esize    = 64;
+	static constexpr bool is_float = true;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::Type::getDoubleTy(context);
+	}
+};
+
+template <typename T>
+struct llvm_value_t<T*> : llvm_value_t<T>
+{
+	static_assert(!std::is_void<T>::value, "llvm_value_t<> error: invalid pointer to void type");
+
+	using type = T*;
+	using base = llvm_value_t<T>;
+	using base::base;
+
+	static constexpr uint is_pointer = llvm_value_t<T>::is_pointer + 1;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm_value_t<T>::get_type(context)->getPointerTo();
+	}
+};
+
+template <typename T, uint N>
+struct llvm_value_t<T[N]> : llvm_value_t<T>
+{
+	static_assert(!llvm_value_t<T>::is_vector, "llvm_value_t<> error: invalid multidimensional vector");
+	static_assert(!llvm_value_t<T>::is_pointer, "llvm_value_t<>: vector of pointers is not allowed");
+
+	using type = T[N];
+	using base = llvm_value_t<T>;
+	using base::base;
+
+	static constexpr uint is_vector  = N;
+	static constexpr uint is_pointer = 0;
+
+	static llvm::Type* get_type(llvm::LLVMContext& context)
+	{
+		return llvm::VectorType::get(llvm_value_t<T>::get_type(context), N);
+	}
+};
+
+template <typename T, typename A1, typename A2>
+struct llvm_add_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_sint || llvm_value_t<T>::is_uint || llvm_value_t<T>::is_float, "llvm_add_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_int)
+		{
+			return ir->CreateAdd(v1, v2);
+		}
+
+		if (llvm_value_t<T>::is_float)
+		{
+			return ir->CreateFAdd(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_add_t<typename T1::type, T1, T2> operator +(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T, typename A1, typename A2>
+struct llvm_sub_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_sint || llvm_value_t<T>::is_uint || llvm_value_t<T>::is_float, "llvm_sub_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_int)
+		{
+			return ir->CreateSub(v1, v2);
+		}
+
+		if (llvm_value_t<T>::is_float)
+		{
+			return ir->CreateFSub(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_sub_t<typename T1::type, T1, T2> operator -(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T, typename A1, typename A2>
+struct llvm_mul_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_sint || llvm_value_t<T>::is_uint || llvm_value_t<T>::is_float, "llvm_mul_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_int)
+		{
+			return ir->CreateMul(v1, v2);
+		}
+
+		if (llvm_value_t<T>::is_float)
+		{
+			return ir->CreateFMul(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_mul_t<typename T1::type, T1, T2> operator *(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T, typename A1, typename A2>
+struct llvm_div_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_sint || llvm_value_t<T>::is_uint || llvm_value_t<T>::is_float, "llvm_div_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_sint)
+		{
+			return ir->CreateSDiv(v1, v2);
+		}
+
+		if (llvm_value_t<T>::is_uint)
+		{
+			return ir->CreateUDiv(v1, v2);
+		}
+
+		if (llvm_value_t<T>::is_float)
+		{
+			return ir->CreateFDiv(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_div_t<typename T1::type, T1, T2> operator /(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T, typename A1>
+struct llvm_neg_t
+{
+	using type = T;
+
+	A1 a1;
+
+	static_assert(llvm_value_t<T>::is_sint || llvm_value_t<T>::is_uint || llvm_value_t<T>::is_float, "llvm_neg_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+
+		if (llvm_value_t<T>::is_int)
+		{
+			return ir->CreateNeg(v1);
+		}
+
+		if (llvm_value_t<T>::is_float)
+		{
+			return ir->CreateFNeg(v1);
+		}
+	}
+};
+
+template <typename T1, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<llvm_value_t<typename T1::type>::esize>>
+inline llvm_neg_t<typename T1::type, T1> operator -(T1 a1)
+{
+	return {a1};
+}
+
+// Constant int helper
+struct llvm_int_t
+{
+	u64 value;
+
+	u64 eval(llvm::IRBuilder<>*) const
+	{
+		return value;
+	}
+};
+
+template <typename T, typename A1, typename A2>
+struct llvm_shl_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_sint || llvm_value_t<T>::is_uint, "llvm_shl_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_sint)
+		{
+			return ir->CreateShl(v1, v2);
+		}
+
+		if (llvm_value_t<T>::is_uint)
+		{
+			return ir->CreateShl(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_shl_t<typename T1::type, T1, T2> operator <<(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T1, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<llvm_value_t<typename T1::type>::is_int>>
+inline llvm_shl_t<typename T1::type, T1, llvm_int_t> operator <<(T1 a1, u64 a2)
+{
+	return {a1, llvm_int_t{a2}};
+}
+
+template <typename T, typename A1, typename A2>
+struct llvm_shr_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_sint || llvm_value_t<T>::is_uint, "llvm_shr_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_sint)
+		{
+			return ir->CreateAShr(v1, v2);
+		}
+
+		if (llvm_value_t<T>::is_uint)
+		{
+			return ir->CreateLShr(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_shr_t<typename T1::type, T1, T2> operator >>(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T1, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<llvm_value_t<typename T1::type>::is_int>>
+inline llvm_shr_t<typename T1::type, T1, llvm_int_t> operator >>(T1 a1, u64 a2)
+{
+	return {a1, llvm_int_t{a2}};
+}
+
+template <typename T, typename A1, typename A2>
+struct llvm_and_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_int, "llvm_and_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_int)
+		{
+			return ir->CreateAnd(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_and_t<typename T1::type, T1, T2> operator &(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T1, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<llvm_value_t<typename T1::type>::is_int>>
+inline llvm_and_t<typename T1::type, T1, llvm_int_t> operator &(T1 a1, u64 a2)
+{
+	return {a1, llvm_int_t{a2}};
+}
+
+template <typename T, typename A1, typename A2>
+struct llvm_or_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_int, "llvm_or_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_int)
+		{
+			return ir->CreateOr(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_or_t<typename T1::type, T1, T2> operator |(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T1, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<llvm_value_t<typename T1::type>::is_int>>
+inline llvm_or_t<typename T1::type, T1, llvm_int_t> operator |(T1 a1, u64 a2)
+{
+	return {a1, llvm_int_t{a2}};
+}
+
+template <typename T, typename A1, typename A2>
+struct llvm_xor_t
+{
+	using type = T;
+
+	A1 a1;
+	A2 a2;
+
+	static_assert(llvm_value_t<T>::is_int, "llvm_xor_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+		const auto v2 = a2.eval(ir);
+
+		if (llvm_value_t<T>::is_int)
+		{
+			return ir->CreateXor(v1, v2);
+		}
+	}
+};
+
+template <typename T1, typename T2, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<std::is_same<typename T1::type, typename T2::type>::value>>
+inline llvm_xor_t<typename T1::type, T1, T2> operator ^(T1 a1, T2 a2)
+{
+	return {a1, a2};
+}
+
+template <typename T1, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<llvm_value_t<typename T1::type>::is_int>>
+inline llvm_xor_t<typename T1::type, T1, llvm_int_t> operator ^(T1 a1, u64 a2)
+{
+	return {a1, llvm_int_t{a2}};
+}
+
+template <typename T, typename A1>
+struct llvm_not_t
+{
+	using type = T;
+
+	A1 a1;
+
+	static_assert(llvm_value_t<T>::is_int, "llvm_not_t<>: invalid type");
+
+	llvm::Value* eval(llvm::IRBuilder<>* ir) const
+	{
+		const auto v1 = a1.eval(ir);
+
+		if (llvm_value_t<T>::is_int)
+		{
+			return ir->CreateNot(v1);
+		}
+	}
+};
+
+template <typename T1, typename = decltype(std::declval<T1>().eval(0)), typename = std::enable_if_t<llvm_value_t<typename T1::type>::is_int>>
+inline llvm_not_t<typename T1::type, T1> operator ~(T1 a1)
+{
+	return {a1};
+}
+
+class cpu_translator
+{
+protected:
+	cpu_translator(llvm::LLVMContext& context, llvm::Module* module, bool is_be);
+
+	// LLVM context
+	llvm::LLVMContext& m_context;
+
+	// Module to which all generated code is output to
+	llvm::Module* const m_module;
+
+	// Endianness, affects vector element numbering (TODO)
+	const bool m_is_be;
+
+	// IR builder
+	llvm::IRBuilder<>* m_ir;
+
+public:
+	// Convert a C++ type to an LLVM type (TODO: remove)
+	template <typename T>
+	llvm::Type* GetType()
+	{
+		return llvm_value_t<T>::get_type(m_context);
+	}
+
+	template <typename T>
+	llvm::Type* get_type()
+	{
+		return llvm_value_t<T>::get_type(m_context);
+	}
+
+	template <typename T>
+	using value_t = llvm_value_t<T>;
+
+	template <typename T>
+	auto eval(T expr)
+	{
+		value_t<typename T::type> result;
+		result.value = expr.eval(m_ir);
+		return result;
+	}
+
+	// Get unsigned addition carry into the sign bit (s = a + b)
+	template <typename T>
+	static inline auto ucarry(T a, T b, T s)
+	{
+		return ((a ^ b) & ~s) | (a & b);
+	}
+
+	// Get signed addition overflow into the sign bit (s = a + b)
+	template <typename T>
+	static inline auto scarry(T a, T b, T s)
+	{
+		return (b ^ s) & ~(a ^ b);
+	}
+
+	// Get signed subtraction overflow into the sign bit (d = a - b)
+	template <typename T>
+	static inline auto sborrow(T a, T b, T d)
+	{
+		return (a ^ b) & (a ^ d);
+	}
+
+	// Bitwise select (c ? a : b)
+	template <typename T>
+	static inline auto merge(T c, T a, T b)
+	{
+		return (a & c) | (b & ~c);
+	}
+
+	// Average: (a + b + 1) >> 1
+	template <typename T>
+	static inline auto avg(T a, T b)
+	{
+		return (a >> 1) + (b >> 1) + ((a | b) & 1);
+	}
+};
+
+#endif
--- a/Show More
+++ b/Show More