Update xci.h

Add support of xci files

CMakeLists.txt

@@ -278,7 +278,7 @@ endif()
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
         if (MSVC14 AND ARCHITECTURE_x86_64)
-            set(QT_VER qt-5.10.0-msvc2015_64)
+            set(QT_VER qt-5.7-msvc2015_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
         endif()

externals/CMakeLists.txt

@@ -17,7 +17,6 @@ endif()
 
 # libfmt
 add_subdirectory(fmt)
-add_library(fmt::fmt ALIAS fmt)
 
 # getopt
 if (MSVC)

src/common/CMakeLists.txt

@@ -32,8 +32,6 @@ add_library(common STATIC
     break_points.cpp
     break_points.h
     chunk_file.h
-    cityhash.cpp
-    cityhash.h
     code_block.h
     color.h
     common_funcs.h
@@ -41,6 +39,7 @@ add_library(common STATIC
     common_types.h
     file_util.cpp
     file_util.h
+    hash.cpp
     hash.h
     linear_disk_cache.h
     logging/backend.cpp
@@ -90,7 +89,7 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
+target_link_libraries(common PUBLIC Boost::boost microprofile)
 if (ARCHITECTURE_x86_64)
     target_link_libraries(common PRIVATE xbyak)
 endif()

src/common/bit_field.h

@@ -115,7 +115,7 @@ private:
     // assignment would copy the full storage value, rather than just the bits
     // relevant to this particular bit field.
     // We don't delete it because we want BitField to be trivially copyable.
-    constexpr BitField& operator=(const BitField&) = default;
+    BitField& operator=(const BitField&) = default;
 
     // StorageType is T for non-enum types and the underlying type of T if
     // T is an enumeration. Note that T is wrapped within an enable_if in the
@@ -166,20 +166,20 @@ public:
     // so that we can use this within unions
     constexpr BitField() = default;
 
-    constexpr FORCE_INLINE operator T() const {
+    FORCE_INLINE operator T() const {
         return Value();
     }
 
-    constexpr FORCE_INLINE void Assign(const T& value) {
+    FORCE_INLINE void Assign(const T& value) {
         storage = (storage & ~mask) | FormatValue(value);
     }
 
-    constexpr T Value() const {
+    FORCE_INLINE T Value() const {
         return ExtractValue(storage);
     }
 
     // TODO: we may want to change this to explicit operator bool() if it's bug-free in VS2015
-    constexpr FORCE_INLINE bool ToBool() const {
+    FORCE_INLINE bool ToBool() const {
         return Value() != 0;
     }
 

src/common/cityhash.cpp

@@ -1,340 +0,0 @@
-// Copyright (c) 2011 Google, Inc.
-//
-// 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.
-//
-// CityHash, by Geoff Pike and Jyrki Alakuijala
-//
-// This file provides CityHash64() and related functions.
-//
-// It's probably possible to create even faster hash functions by
-// writing a program that systematically explores some of the space of
-// possible hash functions, by using SIMD instructions, or by
-// compromising on hash quality.
-
-#include <algorithm>
-#include <string.h> // for memcpy and memset
-#include "cityhash.h"
-#include "common/swap.h"
-
-// #include "config.h"
-#ifdef __GNUC__
-#define HAVE_BUILTIN_EXPECT 1
-#endif
-#ifdef COMMON_BIG_ENDIAN
-#define WORDS_BIGENDIAN 1
-#endif
-
-using namespace std;
-
-typedef uint8_t uint8;
-typedef uint32_t uint32;
-typedef uint64_t uint64;
-
-namespace Common {
-
-static uint64 UNALIGNED_LOAD64(const char* p) {
-    uint64 result;
-    memcpy(&result, p, sizeof(result));
-    return result;
-}
-
-static uint32 UNALIGNED_LOAD32(const char* p) {
-    uint32 result;
-    memcpy(&result, p, sizeof(result));
-    return result;
-}
-
-#ifdef WORDS_BIGENDIAN
-#define uint32_in_expected_order(x) (swap32(x))
-#define uint64_in_expected_order(x) (swap64(x))
-#else
-#define uint32_in_expected_order(x) (x)
-#define uint64_in_expected_order(x) (x)
-#endif
-
-#if !defined(LIKELY)
-#if HAVE_BUILTIN_EXPECT
-#define LIKELY(x) (__builtin_expect(!!(x), 1))
-#else
-#define LIKELY(x) (x)
-#endif
-#endif
-
-static uint64 Fetch64(const char* p) {
-    return uint64_in_expected_order(UNALIGNED_LOAD64(p));
-}
-
-static uint32 Fetch32(const char* p) {
-    return uint32_in_expected_order(UNALIGNED_LOAD32(p));
-}
-
-// Some primes between 2^63 and 2^64 for various uses.
-static const uint64 k0 = 0xc3a5c85c97cb3127ULL;
-static const uint64 k1 = 0xb492b66fbe98f273ULL;
-static const uint64 k2 = 0x9ae16a3b2f90404fULL;
-
-// Bitwise right rotate.  Normally this will compile to a single
-// instruction, especially if the shift is a manifest constant.
-static uint64 Rotate(uint64 val, int shift) {
-    // Avoid shifting by 64: doing so yields an undefined result.
-    return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
-}
-
-static uint64 ShiftMix(uint64 val) {
-    return val ^ (val >> 47);
-}
-
-static uint64 HashLen16(uint64 u, uint64 v) {
-    return Hash128to64(uint128(u, v));
-}
-
-static uint64 HashLen16(uint64 u, uint64 v, uint64 mul) {
-    // Murmur-inspired hashing.
-    uint64 a = (u ^ v) * mul;
-    a ^= (a >> 47);
-    uint64 b = (v ^ a) * mul;
-    b ^= (b >> 47);
-    b *= mul;
-    return b;
-}
-
-static uint64 HashLen0to16(const char* s, size_t len) {
-    if (len >= 8) {
-        uint64 mul = k2 + len * 2;
-        uint64 a = Fetch64(s) + k2;
-        uint64 b = Fetch64(s + len - 8);
-        uint64 c = Rotate(b, 37) * mul + a;
-        uint64 d = (Rotate(a, 25) + b) * mul;
-        return HashLen16(c, d, mul);
-    }
-    if (len >= 4) {
-        uint64 mul = k2 + len * 2;
-        uint64 a = Fetch32(s);
-        return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
-    }
-    if (len > 0) {
-        uint8 a = s[0];
-        uint8 b = s[len >> 1];
-        uint8 c = s[len - 1];
-        uint32 y = static_cast<uint32>(a) + (static_cast<uint32>(b) << 8);
-        uint32 z = static_cast<uint32>(len) + (static_cast<uint32>(c) << 2);
-        return ShiftMix(y * k2 ^ z * k0) * k2;
-    }
-    return k2;
-}
-
-// This probably works well for 16-byte strings as well, but it may be overkill
-// in that case.
-static uint64 HashLen17to32(const char* s, size_t len) {
-    uint64 mul = k2 + len * 2;
-    uint64 a = Fetch64(s) * k1;
-    uint64 b = Fetch64(s + 8);
-    uint64 c = Fetch64(s + len - 8) * mul;
-    uint64 d = Fetch64(s + len - 16) * k2;
-    return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, a + Rotate(b + k2, 18) + c, mul);
-}
-
-// Return a 16-byte hash for 48 bytes.  Quick and dirty.
-// Callers do best to use "random-looking" values for a and b.
-static pair<uint64, uint64> WeakHashLen32WithSeeds(uint64 w, uint64 x, uint64 y, uint64 z, uint64 a,
-                                                   uint64 b) {
-    a += w;
-    b = Rotate(b + a + z, 21);
-    uint64 c = a;
-    a += x;
-    a += y;
-    b += Rotate(a, 44);
-    return make_pair(a + z, b + c);
-}
-
-// Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-static pair<uint64, uint64> WeakHashLen32WithSeeds(const char* s, uint64 a, uint64 b) {
-    return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16), Fetch64(s + 24), a,
-                                  b);
-}
-
-// Return an 8-byte hash for 33 to 64 bytes.
-static uint64 HashLen33to64(const char* s, size_t len) {
-    uint64 mul = k2 + len * 2;
-    uint64 a = Fetch64(s) * k2;
-    uint64 b = Fetch64(s + 8);
-    uint64 c = Fetch64(s + len - 24);
-    uint64 d = Fetch64(s + len - 32);
-    uint64 e = Fetch64(s + 16) * k2;
-    uint64 f = Fetch64(s + 24) * 9;
-    uint64 g = Fetch64(s + len - 8);
-    uint64 h = Fetch64(s + len - 16) * mul;
-    uint64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
-    uint64 v = ((a + g) ^ d) + f + 1;
-    uint64 w = swap64((u + v) * mul) + h;
-    uint64 x = Rotate(e + f, 42) + c;
-    uint64 y = (swap64((v + w) * mul) + g) * mul;
-    uint64 z = e + f + c;
-    a = swap64((x + z) * mul + y) + b;
-    b = ShiftMix((z + a) * mul + d + h) * mul;
-    return b + x;
-}
-
-uint64 CityHash64(const char* s, size_t len) {
-    if (len <= 32) {
-        if (len <= 16) {
-            return HashLen0to16(s, len);
-        } else {
-            return HashLen17to32(s, len);
-        }
-    } else if (len <= 64) {
-        return HashLen33to64(s, len);
-    }
-
-    // For strings over 64 bytes we hash the end first, and then as we
-    // loop we keep 56 bytes of state: v, w, x, y, and z.
-    uint64 x = Fetch64(s + len - 40);
-    uint64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
-    uint64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-    pair<uint64, uint64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
-    pair<uint64, uint64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
-    x = x * k1 + Fetch64(s);
-
-    // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-    len = (len - 1) & ~static_cast<size_t>(63);
-    do {
-        x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-        y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-        x ^= w.second;
-        y += v.first + Fetch64(s + 40);
-        z = Rotate(z + w.first, 33) * k1;
-        v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-        w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-        std::swap(z, x);
-        s += 64;
-        len -= 64;
-    } while (len != 0);
-    return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
-                     HashLen16(v.second, w.second) + x);
-}
-
-uint64 CityHash64WithSeed(const char* s, size_t len, uint64 seed) {
-    return CityHash64WithSeeds(s, len, k2, seed);
-}
-
-uint64 CityHash64WithSeeds(const char* s, size_t len, uint64 seed0, uint64 seed1) {
-    return HashLen16(CityHash64(s, len) - seed0, seed1);
-}
-
-// A subroutine for CityHash128().  Returns a decent 128-bit hash for strings
-// of any length representable in signed long.  Based on City and Murmur.
-static uint128 CityMurmur(const char* s, size_t len, uint128 seed) {
-    uint64 a = Uint128Low64(seed);
-    uint64 b = Uint128High64(seed);
-    uint64 c = 0;
-    uint64 d = 0;
-    signed long l = static_cast<long>(len) - 16;
-    if (l <= 0) { // len <= 16
-        a = ShiftMix(a * k1) * k1;
-        c = b * k1 + HashLen0to16(s, len);
-        d = ShiftMix(a + (len >= 8 ? Fetch64(s) : c));
-    } else { // len > 16
-        c = HashLen16(Fetch64(s + len - 8) + k1, a);
-        d = HashLen16(b + len, c + Fetch64(s + len - 16));
-        a += d;
-        do {
-            a ^= ShiftMix(Fetch64(s) * k1) * k1;
-            a *= k1;
-            b ^= a;
-            c ^= ShiftMix(Fetch64(s + 8) * k1) * k1;
-            c *= k1;
-            d ^= c;
-            s += 16;
-            l -= 16;
-        } while (l > 0);
-    }
-    a = HashLen16(a, c);
-    b = HashLen16(d, b);
-    return uint128(a ^ b, HashLen16(b, a));
-}
-
-uint128 CityHash128WithSeed(const char* s, size_t len, uint128 seed) {
-    if (len < 128) {
-        return CityMurmur(s, len, seed);
-    }
-
-    // We expect len >= 128 to be the common case.  Keep 56 bytes of state:
-    // v, w, x, y, and z.
-    pair<uint64, uint64> v, w;
-    uint64 x = Uint128Low64(seed);
-    uint64 y = Uint128High64(seed);
-    uint64 z = len * k1;
-    v.first = Rotate(y ^ k1, 49) * k1 + Fetch64(s);
-    v.second = Rotate(v.first, 42) * k1 + Fetch64(s + 8);
-    w.first = Rotate(y + z, 35) * k1 + x;
-    w.second = Rotate(x + Fetch64(s + 88), 53) * k1;
-
-    // This is the same inner loop as CityHash64(), manually unrolled.
-    do {
-        x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-        y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-        x ^= w.second;
-        y += v.first + Fetch64(s + 40);
-        z = Rotate(z + w.first, 33) * k1;
-        v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-        w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-        std::swap(z, x);
-        s += 64;
-        x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-        y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-        x ^= w.second;
-        y += v.first + Fetch64(s + 40);
-        z = Rotate(z + w.first, 33) * k1;
-        v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-        w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-        std::swap(z, x);
-        s += 64;
-        len -= 128;
-    } while (LIKELY(len >= 128));
-    x += Rotate(v.first + z, 49) * k0;
-    y = y * k0 + Rotate(w.second, 37);
-    z = z * k0 + Rotate(w.first, 27);
-    w.first *= 9;
-    v.first *= k0;
-    // If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
-    for (size_t tail_done = 0; tail_done < len;) {
-        tail_done += 32;
-        y = Rotate(x + y, 42) * k0 + v.second;
-        w.first += Fetch64(s + len - tail_done + 16);
-        x = x * k0 + w.first;
-        z += w.second + Fetch64(s + len - tail_done);
-        w.second += v.first;
-        v = WeakHashLen32WithSeeds(s + len - tail_done, v.first + z, v.second);
-        v.first *= k0;
-    }
-    // At this point our 56 bytes of state should contain more than
-    // enough information for a strong 128-bit hash.  We use two
-    // different 56-byte-to-8-byte hashes to get a 16-byte final result.
-    x = HashLen16(x, v.first);
-    y = HashLen16(y + z, w.first);
-    return uint128(HashLen16(x + v.second, w.second) + y, HashLen16(x + w.second, y + v.second));
-}
-
-uint128 CityHash128(const char* s, size_t len) {
-    return len >= 16
-               ? CityHash128WithSeed(s + 16, len - 16, uint128(Fetch64(s), Fetch64(s + 8) + k0))
-               : CityHash128WithSeed(s, len, uint128(k0, k1));
-}
-
-} // namespace Common

src/common/cityhash.h

@@ -1,110 +0,0 @@
-// Copyright (c) 2011 Google, Inc.
-//
-// 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.
-//
-// CityHash, by Geoff Pike and Jyrki Alakuijala
-//
-// http://code.google.com/p/cityhash/
-//
-// This file provides a few functions for hashing strings.  All of them are
-// high-quality functions in the sense that they pass standard tests such
-// as Austin Appleby's SMHasher.  They are also fast.
-//
-// For 64-bit x86 code, on short strings, we don't know of anything faster than
-// CityHash64 that is of comparable quality.  We believe our nearest competitor
-// is Murmur3.  For 64-bit x86 code, CityHash64 is an excellent choice for hash
-// tables and most other hashing (excluding cryptography).
-//
-// For 64-bit x86 code, on long strings, the picture is more complicated.
-// On many recent Intel CPUs, such as Nehalem, Westmere, Sandy Bridge, etc.,
-// CityHashCrc128 appears to be faster than all competitors of comparable
-// quality.  CityHash128 is also good but not quite as fast.  We believe our
-// nearest competitor is Bob Jenkins' Spooky.  We don't have great data for
-// other 64-bit CPUs, but for long strings we know that Spooky is slightly
-// faster than CityHash on some relatively recent AMD x86-64 CPUs, for example.
-// Note that CityHashCrc128 is declared in citycrc.h.
-//
-// For 32-bit x86 code, we don't know of anything faster than CityHash32 that
-// is of comparable quality.  We believe our nearest competitor is Murmur3A.
-// (On 64-bit CPUs, it is typically faster to use the other CityHash variants.)
-//
-// Functions in the CityHash family are not suitable for cryptography.
-//
-// Please see CityHash's README file for more details on our performance
-// measurements and so on.
-//
-// WARNING: This code has been only lightly tested on big-endian platforms!
-// It is known to work well on little-endian platforms that have a small penalty
-// for unaligned reads, such as current Intel and AMD moderate-to-high-end CPUs.
-// It should work on all 32-bit and 64-bit platforms that allow unaligned reads;
-// bug reports are welcome.
-//
-// By the way, for some hash functions, given strings a and b, the hash
-// of a+b is easily derived from the hashes of a and b.  This property
-// doesn't hold for any hash functions in this file.
-
-#pragma once
-
-#include <utility>
-#include <stdint.h>
-#include <stdlib.h> // for size_t.
-
-namespace Common {
-
-typedef std::pair<uint64_t, uint64_t> uint128;
-
-inline uint64_t Uint128Low64(const uint128& x) {
-    return x.first;
-}
-inline uint64_t Uint128High64(const uint128& x) {
-    return x.second;
-}
-
-// Hash function for a byte array.
-uint64_t CityHash64(const char* buf, size_t len);
-
-// Hash function for a byte array.  For convenience, a 64-bit seed is also
-// hashed into the result.
-uint64_t CityHash64WithSeed(const char* buf, size_t len, uint64_t seed);
-
-// Hash function for a byte array.  For convenience, two seeds are also
-// hashed into the result.
-uint64_t CityHash64WithSeeds(const char* buf, size_t len, uint64_t seed0, uint64_t seed1);
-
-// Hash function for a byte array.
-uint128 CityHash128(const char* s, size_t len);
-
-// Hash function for a byte array.  For convenience, a 128-bit seed is also
-// hashed into the result.
-uint128 CityHash128WithSeed(const char* s, size_t len, uint128 seed);
-
-// Hash 128 input bits down to 64 bits of output.
-// This is intended to be a reasonably good hash function.
-inline uint64_t Hash128to64(const uint128& x) {
-    // Murmur-inspired hashing.
-    const uint64_t kMul = 0x9ddfea08eb382d69ULL;
-    uint64_t a = (Uint128Low64(x) ^ Uint128High64(x)) * kMul;
-    a ^= (a >> 47);
-    uint64_t b = (Uint128High64(x) ^ a) * kMul;
-    b ^= (b >> 47);
-    b *= kMul;
-    return b;
-}
-
-} // namespace Common

src/common/hash.cpp

@@ -0,0 +1,141 @@
+// Copyright 2015 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#if defined(_MSC_VER)
+#include <stdlib.h>
+#endif
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/hash.h"
+
+namespace Common {
+
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+// Block read - if your platform needs to do endian-swapping or can only handle aligned reads, do
+// the conversion here
+static FORCE_INLINE u64 getblock64(const u64* p, size_t i) {
+    return p[i];
+}
+
+// Finalization mix - force all bits of a hash block to avalanche
+static FORCE_INLINE u64 fmix64(u64 k) {
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccdllu;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53llu;
+    k ^= k >> 33;
+
+    return k;
+}
+
+// This is the 128-bit variant of the MurmurHash3 hash function that is targeted for 64-bit
+// platforms (MurmurHash3_x64_128). It was taken from:
+// https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
+void MurmurHash3_128(const void* key, size_t len, u32 seed, void* out) {
+    const u8* data = (const u8*)key;
+    const size_t nblocks = len / 16;
+
+    u64 h1 = seed;
+    u64 h2 = seed;
+
+    const u64 c1 = 0x87c37b91114253d5llu;
+    const u64 c2 = 0x4cf5ad432745937fllu;
+
+    // Body
+
+    const u64* blocks = (const u64*)(data);
+
+    for (size_t i = 0; i < nblocks; i++) {
+        u64 k1 = getblock64(blocks, i * 2 + 0);
+        u64 k2 = getblock64(blocks, i * 2 + 1);
+
+        k1 *= c1;
+        k1 = _rotl64(k1, 31);
+        k1 *= c2;
+        h1 ^= k1;
+
+        h1 = _rotl64(h1, 27);
+        h1 += h2;
+        h1 = h1 * 5 + 0x52dce729;
+
+        k2 *= c2;
+        k2 = _rotl64(k2, 33);
+        k2 *= c1;
+        h2 ^= k2;
+
+        h2 = _rotl64(h2, 31);
+        h2 += h1;
+        h2 = h2 * 5 + 0x38495ab5;
+    }
+
+    // Tail
+
+    const u8* tail = (const u8*)(data + nblocks * 16);
+
+    u64 k1 = 0;
+    u64 k2 = 0;
+
+    switch (len & 15) {
+    case 15:
+        k2 ^= ((u64)tail[14]) << 48;
+    case 14:
+        k2 ^= ((u64)tail[13]) << 40;
+    case 13:
+        k2 ^= ((u64)tail[12]) << 32;
+    case 12:
+        k2 ^= ((u64)tail[11]) << 24;
+    case 11:
+        k2 ^= ((u64)tail[10]) << 16;
+    case 10:
+        k2 ^= ((u64)tail[9]) << 8;
+    case 9:
+        k2 ^= ((u64)tail[8]) << 0;
+        k2 *= c2;
+        k2 = _rotl64(k2, 33);
+        k2 *= c1;
+        h2 ^= k2;
+
+    case 8:
+        k1 ^= ((u64)tail[7]) << 56;
+    case 7:
+        k1 ^= ((u64)tail[6]) << 48;
+    case 6:
+        k1 ^= ((u64)tail[5]) << 40;
+    case 5:
+        k1 ^= ((u64)tail[4]) << 32;
+    case 4:
+        k1 ^= ((u64)tail[3]) << 24;
+    case 3:
+        k1 ^= ((u64)tail[2]) << 16;
+    case 2:
+        k1 ^= ((u64)tail[1]) << 8;
+    case 1:
+        k1 ^= ((u64)tail[0]) << 0;
+        k1 *= c1;
+        k1 = _rotl64(k1, 31);
+        k1 *= c2;
+        h1 ^= k1;
+    };
+
+    // Finalization
+
+    h1 ^= len;
+    h2 ^= len;
+
+    h1 += h2;
+    h2 += h1;
+
+    h1 = fmix64(h1);
+    h2 = fmix64(h2);
+
+    h1 += h2;
+    h2 += h1;
+
+    ((u64*)out)[0] = h1;
+    ((u64*)out)[1] = h2;
+}
+
+} // namespace Common

src/common/hash.h

@@ -5,12 +5,12 @@
 #pragma once
 
 #include <cstddef>
-#include <cstring>
-#include "common/cityhash.h"
 #include "common/common_types.h"
 
 namespace Common {
 
+void MurmurHash3_128(const void* key, size_t len, u32 seed, void* out);
+
 /**
  * Computes a 64-bit hash over the specified block of data
  * @param data Block of data to compute hash over
@@ -18,54 +18,9 @@ namespace Common {
  * @returns 64-bit hash value that was computed over the data block
  */
 static inline u64 ComputeHash64(const void* data, size_t len) {
-    return CityHash64(static_cast<const char*>(data), len);
+    u64 res[2];
+    MurmurHash3_128(data, len, 0, res);
+    return res[0];
 }
 
-/**
- * Computes a 64-bit hash of a struct. In addition to being trivially copyable, it is also critical
- * that either the struct includes no padding, or that any padding is initialized to a known value
- * by memsetting the struct to 0 before filling it in.
- */
-template <typename T>
-static inline u64 ComputeStructHash64(const T& data) {
-    static_assert(std::is_trivially_copyable<T>(),
-                  "Type passed to ComputeStructHash64 must be trivially copyable");
-    return ComputeHash64(&data, sizeof(data));
-}
-
-/// A helper template that ensures the padding in a struct is initialized by memsetting to 0.
-template <typename T>
-struct HashableStruct {
-    // In addition to being trivially copyable, T must also have a trivial default constructor,
-    // because any member initialization would be overridden by memset
-    static_assert(std::is_trivial<T>(), "Type passed to HashableStruct must be trivial");
-    /*
-     * We use a union because "implicitly-defined copy/move constructor for a union X copies the
-     * object representation of X." and "implicitly-defined copy assignment operator for a union X
-     * copies the object representation (3.9) of X." = Bytewise copy instead of memberwise copy.
-     * This is important because the padding bytes are included in the hash and comparison between
-     * objects.
-     */
-    union {
-        T state;
-    };
-
-    HashableStruct() {
-        // Memset structure to zero padding bits, so that they will be deterministic when hashing
-        std::memset(&state, 0, sizeof(T));
-    }
-
-    bool operator==(const HashableStruct<T>& o) const {
-        return std::memcmp(&state, &o.state, sizeof(T)) == 0;
-    };
-
-    bool operator!=(const HashableStruct<T>& o) const {
-        return !(*this == o);
-    };
-
-    size_t Hash() const {
-        return Common::ComputeStructHash64(state);
-    }
-};
-
 } // namespace Common

src/common/logging/backend.cpp

@@ -11,7 +11,6 @@
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
-#include "common/string_util.h"
 
 namespace Log {
 
@@ -107,20 +106,25 @@ const char* GetLevelName(Level log_level) {
 }
 
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                  const char* function, std::string message) {
+                  const char* function, const char* format, va_list args) {
     using std::chrono::duration_cast;
     using std::chrono::steady_clock;
 
     static steady_clock::time_point time_origin = steady_clock::now();
 
+    std::array<char, 4 * 1024> formatting_buffer;
+
     Entry entry;
     entry.timestamp = duration_cast<std::chrono::microseconds>(steady_clock::now() - time_origin);
     entry.log_class = log_class;
     entry.log_level = log_level;
-    entry.filename = Common::TrimSourcePath(filename);
-    entry.line_num = line_nr;
-    entry.function = function;
-    entry.message = std::move(message);
+
+    snprintf(formatting_buffer.data(), formatting_buffer.size(), "%s:%s:%u", filename, function,
+             line_nr);
+    entry.location = std::string(formatting_buffer.data());
+
+    vsnprintf(formatting_buffer.data(), formatting_buffer.size(), format, args);
+    entry.message = std::string(formatting_buffer.data());
 
     return entry;
 }
@@ -131,28 +135,15 @@ void SetFilter(Filter* new_filter) {
     filter = new_filter;
 }
 
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                 const char* function, const char* format, ...) {
-    if (filter && !filter->CheckMessage(log_class, log_level))
+    if (filter != nullptr && !filter->CheckMessage(log_class, log_level))
         return;
-    std::array<char, 4 * 1024> formatting_buffer;
+
     va_list args;
     va_start(args, format);
-    vsnprintf(formatting_buffer.data(), formatting_buffer.size(), format, args);
+    Entry entry = CreateEntry(log_class, log_level, filename, line_nr, function, format, args);
     va_end(args);
-    Entry entry = CreateEntry(log_class, log_level, filename, line_num, function,
-                              std::string(formatting_buffer.data()));
-
-    PrintColoredMessage(entry);
-}
-
-void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, const char* format,
-                       const fmt::format_args& args) {
-    if (filter && !filter->CheckMessage(log_class, log_level))
-        return;
-    Entry entry =
-        CreateEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
 
     PrintColoredMessage(entry);
 }

src/common/logging/backend.h

@@ -22,16 +22,13 @@ struct Entry {
     std::chrono::microseconds timestamp;
     Class log_class;
     Level log_level;
-    std::string filename;
-    unsigned int line_num;
-    std::string function;
+    std::string location;
     std::string message;
 
     Entry() = default;
     Entry(Entry&& o) = default;
 
     Entry& operator=(Entry&& o) = default;
-    Entry& operator=(const Entry& o) = default;
 };
 
 /**
@@ -47,7 +44,7 @@ const char* GetLevelName(Level log_level);
 
 /// Creates a log entry by formatting the given source location, and message.
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                  const char* function, std::string message);
+                  const char* function, const char* format, va_list args);
 
 void SetFilter(Filter* filter);
 } // namespace Log

src/common/logging/filter.cpp

@@ -65,14 +65,14 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
                              const std::string::const_iterator end) {
     auto level_separator = std::find(begin, end, ':');
     if (level_separator == end) {
-        NGLOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s",
-                    std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s",
+                  std::string(begin, end).c_str());
         return false;
     }
 
     const Level level = GetLevelByName(level_separator + 1, end);
     if (level == Level::Count) {
-        NGLOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
         return false;
     }
 
@@ -83,7 +83,7 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
 
     const Class log_class = GetClassByName(begin, level_separator);
     if (log_class == Class::Count) {
-        NGLOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
         return false;
     }
 

src/common/logging/filter.h

@@ -19,7 +19,7 @@ namespace Log {
 class Filter {
 public:
     /// Initializes the filter with all classes having `default_level` as the minimum level.
-    Filter(Level default_level = Level::Info);
+    Filter(Level default_level);
 
     /// Resets the filter so that all classes have `level` as the minimum displayed level.
     void ResetAll(Level level);

src/common/logging/log.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <fmt/format.h>
 #include "common/common_types.h"
 
 namespace Log {
@@ -92,7 +91,7 @@ enum class Class : ClassType {
 };
 
 /// Logs a message to the global logger.
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                 const char* function,
 #ifdef _MSC_VER
                 _Printf_format_string_
@@ -104,18 +103,6 @@ void LogMessage(Class log_class, Level log_level, const char* filename, unsigned
 #endif
     ;
 
-/// Logs a message to the global logger, using fmt
-void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, const char* format,
-                       const fmt::format_args& args);
-
-template <typename... Args>
-void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, const char* format, const Args&... args) {
-    FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
-                      fmt::make_args(args...));
-}
-
 } // namespace Log
 
 #define LOG_GENERIC(log_class, log_level, ...)                                                     \
@@ -138,28 +125,3 @@ void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsig
     LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Error, __VA_ARGS__)
 #define LOG_CRITICAL(log_class, ...)                                                               \
     LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Critical, __VA_ARGS__)
-
-// Define the fmt lib macros
-#ifdef _DEBUG
-#define NGLOG_TRACE(log_class, ...)                                                                \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Trace, __FILE__, __LINE__,         \
-                         __func__, __VA_ARGS__)
-#else
-#define NGLOG_TRACE(log_class, fmt, ...) (void(0))
-#endif
-
-#define NGLOG_DEBUG(log_class, ...)                                                                \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Debug, __FILE__, __LINE__,         \
-                         __func__, __VA_ARGS__)
-#define NGLOG_INFO(log_class, ...)                                                                 \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Info, __FILE__, __LINE__,          \
-                         __func__, __VA_ARGS__)
-#define NGLOG_WARNING(log_class, ...)                                                              \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Warning, __FILE__, __LINE__,       \
-                         __func__, __VA_ARGS__)
-#define NGLOG_ERROR(log_class, ...)                                                                \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Error, __FILE__, __LINE__,         \
-                         __func__, __VA_ARGS__)
-#define NGLOG_CRITICAL(log_class, ...)                                                             \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Critical, __FILE__, __LINE__,      \
-                         __func__, __VA_ARGS__)

src/common/logging/text_formatter.cpp

@@ -18,29 +18,50 @@
 
 namespace Log {
 
-std::string FormatLogMessage(const Entry& entry) {
+// TODO(bunnei): This should be moved to a generic path manipulation library
+const char* TrimSourcePath(const char* path, const char* root) {
+    const char* p = path;
+
+    while (*p != '\0') {
+        const char* next_slash = p;
+        while (*next_slash != '\0' && *next_slash != '/' && *next_slash != '\\') {
+            ++next_slash;
+        }
+
+        bool is_src = Common::ComparePartialString(p, next_slash, root);
+        p = next_slash;
+
+        if (*p != '\0') {
+            ++p;
+        }
+        if (is_src) {
+            path = p;
+        }
+    }
+    return path;
+}
+
+void FormatLogMessage(const Entry& entry, char* out_text, size_t text_len) {
     unsigned int time_seconds = static_cast<unsigned int>(entry.timestamp.count() / 1000000);
     unsigned int time_fractional = static_cast<unsigned int>(entry.timestamp.count() % 1000000);
 
     const char* class_name = GetLogClassName(entry.log_class);
     const char* level_name = GetLevelName(entry.log_level);
 
-    return fmt::format("[{:4d}.{:06d}] {} <{}> {}:{}:{}: {}", time_seconds, time_fractional,
-                       class_name, level_name, entry.filename, entry.function, entry.line_num,
-                       entry.message);
+    snprintf(out_text, text_len, "[%4u.%06u] %s <%s> %s: %s", time_seconds, time_fractional,
+             class_name, level_name, TrimSourcePath(entry.location.c_str()), entry.message.c_str());
 }
 
 void PrintMessage(const Entry& entry) {
-    auto str = FormatLogMessage(entry) + '\n';
-    fputs(str.c_str(), stderr);
+    std::array<char, 4 * 1024> format_buffer;
+    FormatLogMessage(entry, format_buffer.data(), format_buffer.size());
+    fputs(format_buffer.data(), stderr);
+    fputc('\n', stderr);
 }
 
 void PrintColoredMessage(const Entry& entry) {
 #ifdef _WIN32
-    HANDLE console_handle = GetStdHandle(STD_ERROR_HANDLE);
-    if (console_handle == INVALID_HANDLE_VALUE) {
-        return;
-    }
+    static HANDLE console_handle = GetStdHandle(STD_ERROR_HANDLE);
 
     CONSOLE_SCREEN_BUFFER_INFO original_info = {0};
     GetConsoleScreenBufferInfo(console_handle, &original_info);

src/common/logging/text_formatter.h

@@ -10,8 +10,20 @@ namespace Log {
 
 struct Entry;
 
+/**
+ * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
+ * intended to be used to strip a system-specific build directory from the `__FILE__` macro,
+ * leaving only the path relative to the sources root.
+ *
+ * @param path The input file path as a null-terminated string
+ * @param root The name of the root source directory as a null-terminated string. Path up to and
+ *             including the last occurrence of this name will be stripped
+ * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
+ */
+const char* TrimSourcePath(const char* path, const char* root = "src");
+
 /// Formats a log entry into the provided text buffer.
-std::string FormatLogMessage(const Entry& entry);
+void FormatLogMessage(const Entry& entry, char* out_text, size_t text_len);
 /// Formats and prints a log entry to stderr.
 void PrintMessage(const Entry& entry);
 /// Prints the same message as `PrintMessage`, but colored acoording to the severity level.

src/common/string_util.cpp

@@ -462,27 +462,4 @@ std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_l
 
     return std::string(buffer, len);
 }
-
-const char* TrimSourcePath(const char* path, const char* root) {
-    const char* p = path;
-
-    while (*p != '\0') {
-        const char* next_slash = p;
-        while (*next_slash != '\0' && *next_slash != '/' && *next_slash != '\\') {
-            ++next_slash;
-        }
-
-        bool is_src = Common::ComparePartialString(p, next_slash, root);
-        p = next_slash;
-
-        if (*p != '\0') {
-            ++p;
-        }
-        if (is_src) {
-            path = p;
-        }
-    }
-    return path;
-}
-
 } // namespace Common

src/common/string_util.h

@@ -134,17 +134,4 @@ bool ComparePartialString(InIt begin, InIt end, const char* other) {
  * NUL-terminated then the string ends at max_len characters.
  */
 std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_len);
-
-/**
- * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
- * intended to be used to strip a system-specific build directory from the `__FILE__` macro,
- * leaving only the path relative to the sources root.
- *
- * @param path The input file path as a null-terminated string
- * @param root The name of the root source directory as a null-terminated string. Path up to and
- *             including the last occurrence of this name will be stripped
- * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
- */
-const char* TrimSourcePath(const char* path, const char* root = "src");
-
 } // namespace Common

src/common/swap.h

@@ -103,19 +103,7 @@ inline __attribute__((always_inline)) u64 swap64(u64 _data) {
     return __builtin_bswap64(_data);
 }
 #elif defined(__Bitrig__) || defined(__OpenBSD__)
-// redefine swap16, swap32, swap64 as inline functions
-#undef swap16
-#undef swap32
-#undef swap64
-inline u16 swap16(u16 _data) {
-    return __swap16(_data);
-}
-inline u32 swap32(u32 _data) {
-    return __swap32(_data);
-}
-inline u64 swap64(u64 _data) {
-    return __swap64(_data);
-}
+// swap16, swap32, swap64 are left as is
 #elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
 inline u16 swap16(u16 _data) {
     return bswap16(_data);

src/common/telemetry.h

@@ -15,7 +15,7 @@ namespace Telemetry {
 /// Field type, used for grouping fields together in the final submitted telemetry log
 enum class FieldType : u8 {
     None = 0,     ///< No specified field group
-    App,          ///< yuzu application fields (e.g. version, branch, etc.)
+    App,          ///< Citra application fields (e.g. version, branch, etc.)
     Session,      ///< Emulated session fields (e.g. title ID, log, etc.)
     Performance,  ///< Emulated performance (e.g. fps, emulated CPU speed, etc.)
     UserFeedback, ///< User submitted feedback (e.g. star rating, user notes, etc.)

src/core/CMakeLists.txt

@@ -88,14 +88,8 @@ add_library(core STATIC
     hle/romfs.h
     hle/service/acc/acc.cpp
     hle/service/acc/acc.h
-    hle/service/acc/acc_aa.cpp
-    hle/service/acc/acc_aa.h
-    hle/service/acc/acc_su.cpp
-    hle/service/acc/acc_su.h
     hle/service/acc/acc_u0.cpp
     hle/service/acc/acc_u0.h
-    hle/service/acc/acc_u1.cpp
-    hle/service/acc/acc_u1.h
     hle/service/am/am.cpp
     hle/service/am/am.h
     hle/service/am/applet_ae.cpp
@@ -136,8 +130,6 @@ add_library(core STATIC
     hle/service/friend/friend.h
     hle/service/friend/friend_a.cpp
     hle/service/friend/friend_a.h
-    hle/service/friend/friend_u.cpp
-    hle/service/friend/friend_u.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
     hle/service/lm/lm.cpp

src/core/core.cpp

@@ -92,8 +92,6 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
             return ResultStatus::ErrorLoader_ErrorEncrypted;
         case Loader::ResultStatus::ErrorInvalidFormat:
             return ResultStatus::ErrorLoader_ErrorInvalidFormat;
-        case Loader::ResultStatus::ErrorUnsupportedArch:
-            return ResultStatus::ErrorUnsupportedArch;
         default:
             return ResultStatus::ErrorSystemMode;
         }
@@ -117,8 +115,6 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
             return ResultStatus::ErrorLoader_ErrorEncrypted;
         case Loader::ResultStatus::ErrorInvalidFormat:
             return ResultStatus::ErrorLoader_ErrorInvalidFormat;
-        case Loader::ResultStatus::ErrorUnsupportedArch:
-            return ResultStatus::ErrorUnsupportedArch;
         default:
             return ResultStatus::ErrorLoader;
         }

src/core/core.h

@@ -44,7 +44,6 @@ public:
         ErrorSystemFiles,               ///< Error in finding system files
         ErrorSharedFont,                ///< Error in finding shared font
         ErrorVideoCore,                 ///< Error in the video core
-        ErrorUnsupportedArch,           ///< Unsupported Architecture (32-Bit ROMs)
         ErrorUnknown                    ///< Any other error
     };
 

src/core/file_sys/disk_filesystem.cpp

@@ -174,9 +174,8 @@ u64 Disk_Storage::GetSize() const {
 }
 
 bool Disk_Storage::SetSize(const u64 size) const {
-    file->Resize(size);
-    file->Flush();
-    return true;
+    LOG_WARNING(Service_FS, "(STUBBED) called");
+    return false;
 }
 
 Disk_Directory::Disk_Directory(const std::string& path) : directory() {

src/core/hle/kernel/hle_ipc.cpp

@@ -268,11 +268,8 @@ std::vector<u8> HLERequestContext::ReadBuffer() const {
 
 size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size) const {
     const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
-    const size_t buffer_size{GetWriteBufferSize()};
-    if (size > buffer_size) {
-        LOG_CRITICAL(Core, "size (%016zx) is greater than buffer_size (%016zx)", size, buffer_size);
-        size = buffer_size; // TODO(bunnei): This needs to be HW tested
-    }
+
+    ASSERT_MSG(size <= GetWriteBufferSize(), "Size %lx is too big", size);
 
     if (is_buffer_b) {
         Memory::WriteBlock(BufferDescriptorB()[0].Address(), buffer, size);

src/core/hle/kernel/process.cpp

@@ -121,9 +121,8 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
     // TODO(bunnei): This is heap area that should be allocated by the kernel and not mapped as part
     // of the user address space.
     vm_manager
-        .MapMemoryBlock(Memory::STACK_AREA_VADDR_END - stack_size,
-                        std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size,
-                        MemoryState::Mapped)
+        .MapMemoryBlock(Memory::STACK_VADDR, std::make_shared<std::vector<u8>>(stack_size, 0), 0,
+                        stack_size, MemoryState::Mapped)
         .Unwrap();
     misc_memory_used += stack_size;
     memory_region->used += stack_size;

src/core/hle/kernel/shared_memory.cpp

@@ -120,6 +120,18 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
         return ERR_WRONG_PERMISSION;
     }
 
+    // TODO(Subv): The same process that created a SharedMemory object
+    // can not map it in its own address space unless it was created with addr=0, result 0xD900182C.
+
+    if (address != 0) {
+        // TODO(shinyquagsire23): Check for virtual/mappable memory here too?
+        if (address >= Memory::HEAP_VADDR && address < Memory::HEAP_VADDR_END) {
+            LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, invalid address",
+                      GetObjectId(), address, name.c_str());
+            return ERR_INVALID_ADDRESS;
+        }
+    }
+
     VAddr target_address = address;
 
     if (base_address == 0 && target_address == 0) {

src/core/hle/kernel/svc.cpp

@@ -371,18 +371,6 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     return RESULT_SUCCESS;
 }
 
-/// Sets the thread activity
-static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x%08X, unknown=0x%08X", handle, unknown);
-    return RESULT_SUCCESS;
-}
-
-/// Gets the thread context
-static ResultCode GetThreadContext(Handle handle, VAddr addr) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x%08X, addr=0x%" PRIx64, handle, addr);
-    return RESULT_SUCCESS;
-}
-
 /// Gets the priority for the specified thread
 static ResultCode GetThreadPriority(u32* priority, Handle handle) {
     const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(handle);
@@ -865,8 +853,8 @@ static const FunctionDef SVC_Table[] = {
     {0x2F, nullptr, "GetLastThreadInfo"},
     {0x30, nullptr, "GetResourceLimitLimitValue"},
     {0x31, nullptr, "GetResourceLimitCurrentValue"},
-    {0x32, SvcWrap<SetThreadActivity>, "SetThreadActivity"},
-    {0x33, SvcWrap<GetThreadContext>, "GetThreadContext"},
+    {0x32, nullptr, "SetThreadActivity"},
+    {0x33, nullptr, "GetThreadContext"},
     {0x34, nullptr, "Unknown"},
     {0x35, nullptr, "Unknown"},
     {0x36, nullptr, "Unknown"},

src/core/hle/kernel/svc_wrap.h

@@ -70,11 +70,6 @@ void SvcWrap() {
     FuncReturn(retval);
 }
 
-template <ResultCode func(u32, u64)>
-void SvcWrap() {
-    FuncReturn(func((u32)(PARAM(0) & 0xFFFFFFFF), PARAM(1)).raw);
-}
-
 template <ResultCode func(u32, u32, u64)>
 void SvcWrap() {
     FuncReturn(func((u32)(PARAM(0) & 0xFFFFFFFF), (u32)(PARAM(1) & 0xFFFFFFFF), PARAM(2)).raw);

src/core/hle/kernel/thread.cpp

@@ -342,7 +342,7 @@ SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
 
     // Initialize new "main" thread
     auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
-                                     Memory::STACK_AREA_VADDR_END, owner_process);
+                                     Memory::STACK_VADDR_END, owner_process);
 
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 

src/core/hle/kernel/vm_manager.cpp

@@ -380,7 +380,7 @@ void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
 
 u64 VMManager::GetTotalMemoryUsage() {
     LOG_WARNING(Kernel, "(STUBBED) called");
-    return 0xF8000000;
+    return 0xBE000000;
 }
 
 u64 VMManager::GetTotalHeapUsage() {

src/core/hle/service/acc/acc.cpp

@@ -2,142 +2,14 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/acc/acc.h"
-#include "core/hle/service/acc/acc_aa.h"
-#include "core/hle/service/acc/acc_su.h"
 #include "core/hle/service/acc/acc_u0.h"
-#include "core/hle/service/acc/acc_u1.h"
 
 namespace Service {
 namespace Account {
 
-// TODO: RE this structure
-struct UserData {
-    INSERT_PADDING_WORDS(1);
-    u32 icon_id;
-    u8 bg_color_id;
-    INSERT_PADDING_BYTES(0x7);
-    INSERT_PADDING_BYTES(0x10);
-    INSERT_PADDING_BYTES(0x60);
-};
-static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
-
-struct ProfileBase {
-    u8 user_id[0x10];
-    u64 timestamp;
-    u8 username[0x20];
-};
-static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase structure has incorrect size");
-
-using Uid = std::array<u64, 2>;
-static constexpr Uid DEFAULT_USER_ID{0x10ull, 0x20ull};
-
-class IProfile final : public ServiceFramework<IProfile> {
-public:
-    IProfile() : ServiceFramework("IProfile") {
-        static const FunctionInfo functions[] = {
-            {1, &IProfile::GetBase, "GetBase"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetBase(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        ProfileBase profile_base{};
-        IPC::ResponseBuilder rb{ctx, 16};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw(profile_base);
-    }
-};
-
-class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
-public:
-    IManagerForApplication() : ServiceFramework("IManagerForApplication") {
-        static const FunctionInfo functions[] = {
-            {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
-            {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    void CheckAvailability(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(true); // TODO: Check when this is supposed to return true and when not
-    }
-
-    void GetAccountId(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(0x12345678ABCDEF);
-    }
-};
-
-void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(true); // TODO: Check when this is supposed to return true and when not
-}
-
-void Module::Interface::ListAllUsers(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids.data(), user_ids.size());
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Module::Interface::ListOpenUsers(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids.data(), user_ids.size());
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IProfile>();
-    LOG_DEBUG(Service_ACC, "called");
-}
-
-void Module::Interface::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IManagerForApplication>();
-    LOG_DEBUG(Service_ACC, "called");
-}
-
-void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushRaw(DEFAULT_USER_ID);
-}
-
-Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
-
 void InstallInterfaces(SM::ServiceManager& service_manager) {
-    auto module = std::make_shared<Module>();
-    std::make_shared<ACC_AA>(module)->InstallAsService(service_manager);
-    std::make_shared<ACC_SU>(module)->InstallAsService(service_manager);
-    std::make_shared<ACC_U0>(module)->InstallAsService(service_manager);
-    std::make_shared<ACC_U1>(module)->InstallAsService(service_manager);
+    std::make_shared<ACC_U0>()->InstallAsService(service_manager);
 }
 
 } // namespace Account

src/core/hle/service/acc/acc.h

@@ -9,25 +9,6 @@
 namespace Service {
 namespace Account {
 
-class Module final {
-public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        Interface(std::shared_ptr<Module> module, const char* name);
-
-        void GetUserExistence(Kernel::HLERequestContext& ctx);
-        void ListAllUsers(Kernel::HLERequestContext& ctx);
-        void ListOpenUsers(Kernel::HLERequestContext& ctx);
-        void GetLastOpenedUser(Kernel::HLERequestContext& ctx);
-        void GetProfile(Kernel::HLERequestContext& ctx);
-        void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);
-        void GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx);
-
-    protected:
-        std::shared_ptr<Module> module;
-    };
-};
-
 /// Registers all ACC services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 

src/core/hle/service/acc/acc_aa.cpp

@@ -1,22 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/acc/acc_aa.h"
-
-namespace Service {
-namespace Account {
-
-ACC_AA::ACC_AA(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:aa") {
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "EnsureCacheAsync"},
-        {1, nullptr, "LoadCache"},
-        {2, nullptr, "GetDeviceAccountId"},
-        {50, nullptr, "RegisterNotificationTokenAsync"},
-        {51, nullptr, "UnregisterNotificationTokenAsync"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Account
-} // namespace Service

src/core/hle/service/acc/acc_aa.h

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/acc/acc.h"
-
-namespace Service {
-namespace Account {
-
-class ACC_AA final : public Module::Interface {
-public:
-    explicit ACC_AA(std::shared_ptr<Module> module);
-};
-
-} // namespace Account
-} // namespace Service

src/core/hle/service/acc/acc_su.cpp

@@ -1,55 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/acc/acc_su.h"
-
-namespace Service {
-namespace Account {
-
-ACC_SU::ACC_SU(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:su") {
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetUserCount"},
-        {1, &ACC_SU::GetUserExistence, "GetUserExistence"},
-        {2, &ACC_SU::ListAllUsers, "ListAllUsers"},
-        {3, &ACC_SU::ListOpenUsers, "ListOpenUsers"},
-        {4, &ACC_SU::GetLastOpenedUser, "GetLastOpenedUser"},
-        {5, &ACC_SU::GetProfile, "GetProfile"},
-        {6, nullptr, "GetProfileDigest"},
-        {50, nullptr, "IsUserRegistrationRequestPermitted"},
-        {51, nullptr, "TrySelectUserWithoutInteraction"},
-        {60, nullptr, "ListOpenContextStoredUsers"},
-        {100, nullptr, "GetUserRegistrationNotifier"},
-        {101, nullptr, "GetUserStateChangeNotifier"},
-        {102, nullptr, "GetBaasAccountManagerForSystemService"},
-        {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
-        {104, nullptr, "GetProfileUpdateNotifier"},
-        {105, nullptr, "CheckNetworkServiceAvailabilityAsync"},
-        {110, nullptr, "StoreSaveDataThumbnail"},
-        {111, nullptr, "ClearSaveDataThumbnail"},
-        {112, nullptr, "LoadSaveDataThumbnail"},
-        {113, nullptr, "GetSaveDataThumbnailExistence"},
-        {190, nullptr, "GetUserLastOpenedApplication"},
-        {191, nullptr, "ActivateOpenContextHolder"},
-        {200, nullptr, "BeginUserRegistration"},
-        {201, nullptr, "CompleteUserRegistration"},
-        {202, nullptr, "CancelUserRegistration"},
-        {203, nullptr, "DeleteUser"},
-        {204, nullptr, "SetUserPosition"},
-        {205, nullptr, "GetProfileEditor"},
-        {206, nullptr, "CompleteUserRegistrationForcibly"},
-        {210, nullptr, "CreateFloatingRegistrationRequest"},
-        {230, nullptr, "AuthenticateServiceAsync"},
-        {250, nullptr, "GetBaasAccountAdministrator"},
-        {290, nullptr, "ProxyProcedureForGuestLoginWithNintendoAccount"},
-        {291, nullptr, "ProxyProcedureForFloatingRegistrationWithNintendoAccount"},
-        {299, nullptr, "SuspendBackgroundDaemon"},
-        {997, nullptr, "DebugInvalidateTokenCacheForUser"},
-        {998, nullptr, "DebugSetUserStateClose"},
-        {999, nullptr, "DebugSetUserStateOpen"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Account
-} // namespace Service

src/core/hle/service/acc/acc_su.h

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/acc/acc.h"
-
-namespace Service {
-namespace Account {
-
-class ACC_SU final : public Module::Interface {
-public:
-    explicit ACC_SU(std::shared_ptr<Module> module);
-};
-
-} // namespace Account
-} // namespace Service

src/core/hle/service/acc/acc_u0.cpp

@@ -2,31 +2,120 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/acc/acc_u0.h"
 
 namespace Service {
 namespace Account {
 
-ACC_U0::ACC_U0(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:u0") {
+using Uid = std::array<u64, 2>;
+static constexpr Uid DEFAULT_USER_ID{0x10ull, 0x20ull};
+
+class IProfile final : public ServiceFramework<IProfile> {
+public:
+    IProfile() : ServiceFramework("IProfile") {
+        static const FunctionInfo functions[] = {
+            {1, &IProfile::GetBase, "GetBase"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetBase(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        ProfileBase profile_base{};
+        IPC::ResponseBuilder rb{ctx, 16};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw(profile_base);
+    }
+};
+
+class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
+public:
+    IManagerForApplication() : ServiceFramework("IManagerForApplication") {
+        static const FunctionInfo functions[] = {
+            {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
+            {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    void CheckAvailability(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(true); // TODO: Check when this is supposed to return true and when not
+    }
+
+    void GetAccountId(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u64>(0x12345678ABCDEF);
+    }
+};
+
+void ACC_U0::GetUserExistence(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(true); // TODO: Check when this is supposed to return true and when not
+}
+
+void ACC_U0::ListAllUsers(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
+    ctx.WriteBuffer(user_ids.data(), user_ids.size());
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void ACC_U0::ListOpenUsers(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
+    ctx.WriteBuffer(user_ids.data(), user_ids.size());
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void ACC_U0::GetProfile(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IProfile>();
+    LOG_DEBUG(Service_ACC, "called");
+}
+
+void ACC_U0::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void ACC_U0::GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IManagerForApplication>();
+    LOG_DEBUG(Service_ACC, "called");
+}
+
+void ACC_U0::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw(DEFAULT_USER_ID);
+}
+
+ACC_U0::ACC_U0() : ServiceFramework("acc:u0") {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetUserCount"},
         {1, &ACC_U0::GetUserExistence, "GetUserExistence"},
         {2, &ACC_U0::ListAllUsers, "ListAllUsers"},
         {3, &ACC_U0::ListOpenUsers, "ListOpenUsers"},
         {4, &ACC_U0::GetLastOpenedUser, "GetLastOpenedUser"},
         {5, &ACC_U0::GetProfile, "GetProfile"},
-        {6, nullptr, "GetProfileDigest"},
-        {50, nullptr, "IsUserRegistrationRequestPermitted"},
-        {51, nullptr, "TrySelectUserWithoutInteraction"},
-        {60, nullptr, "ListOpenContextStoredUsers"},
         {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
         {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},
-        {102, nullptr, "AuthenticateApplicationAsync"},
-        {103, nullptr, "CheckNetworkServiceAvailabilityAsync"},
-        {110, nullptr, "StoreSaveDataThumbnail"},
-        {111, nullptr, "ClearSaveDataThumbnail"},
-        {120, nullptr, "CreateGuestLoginRequest"},
-        {130, nullptr, "LoadOpenContext"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/acc/acc_u0.h

@@ -4,14 +4,36 @@
 
 #pragma once
 
-#include "core/hle/service/acc/acc.h"
+#include "core/hle/service/service.h"
 
 namespace Service {
 namespace Account {
 
-class ACC_U0 final : public Module::Interface {
+// TODO: RE this structure
+struct UserData {
+    INSERT_PADDING_BYTES(0x80);
+};
+static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
+
+// TODO: RE this structure
+struct ProfileBase {
+    INSERT_PADDING_BYTES(0x38);
+};
+static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase structure has incorrect size");
+
+class ACC_U0 final : public ServiceFramework<ACC_U0> {
 public:
-    explicit ACC_U0(std::shared_ptr<Module> module);
+    ACC_U0();
+    ~ACC_U0() = default;
+
+private:
+    void GetUserExistence(Kernel::HLERequestContext& ctx);
+    void ListAllUsers(Kernel::HLERequestContext& ctx);
+    void ListOpenUsers(Kernel::HLERequestContext& ctx);
+    void GetLastOpenedUser(Kernel::HLERequestContext& ctx);
+    void GetProfile(Kernel::HLERequestContext& ctx);
+    void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);
+    void GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Account

src/core/hle/service/acc/acc_u1.cpp

@@ -1,42 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/acc/acc_u1.h"
-
-namespace Service {
-namespace Account {
-
-ACC_U1::ACC_U1(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:u1") {
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetUserCount"},
-        {1, &ACC_U1::GetUserExistence, "GetUserExistence"},
-        {2, &ACC_U1::ListAllUsers, "ListAllUsers"},
-        {3, &ACC_U1::ListOpenUsers, "ListOpenUsers"},
-        {4, &ACC_U1::GetLastOpenedUser, "GetLastOpenedUser"},
-        {5, &ACC_U1::GetProfile, "GetProfile"},
-        {6, nullptr, "GetProfileDigest"},
-        {50, nullptr, "IsUserRegistrationRequestPermitted"},
-        {51, nullptr, "TrySelectUserWithoutInteraction"},
-        {60, nullptr, "ListOpenContextStoredUsers"},
-        {100, nullptr, "GetUserRegistrationNotifier"},
-        {101, nullptr, "GetUserStateChangeNotifier"},
-        {102, nullptr, "GetBaasAccountManagerForSystemService"},
-        {103, nullptr, "GetProfileUpdateNotifier"},
-        {104, nullptr, "CheckNetworkServiceAvailabilityAsync"},
-        {105, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
-        {110, nullptr, "StoreSaveDataThumbnail"},
-        {111, nullptr, "ClearSaveDataThumbnail"},
-        {112, nullptr, "LoadSaveDataThumbnail"},
-        {113, nullptr, "GetSaveDataThumbnailExistence"},
-        {190, nullptr, "GetUserLastOpenedApplication"},
-        {191, nullptr, "ActivateOpenContextHolder"},
-        {997, nullptr, "DebugInvalidateTokenCacheForUser"},
-        {998, nullptr, "DebugSetUserStateClose"},
-        {999, nullptr, "DebugSetUserStateOpen"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Account
-} // namespace Service

src/core/hle/service/acc/acc_u1.h

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/acc/acc.h"
-
-namespace Service {
-namespace Account {
-
-class ACC_U1 final : public Module::Interface {
-public:
-    explicit ACC_U1(std::shared_ptr<Module> module);
-};
-
-} // namespace Account
-} // namespace Service

src/core/hle/service/am/am.cpp

@@ -19,11 +19,8 @@ namespace AM {
 
 IWindowController::IWindowController() : ServiceFramework("IWindowController") {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "CreateWindow"},
         {1, &IWindowController::GetAppletResourceUserId, "GetAppletResourceUserId"},
         {10, &IWindowController::AcquireForegroundRights, "AcquireForegroundRights"},
-        {11, nullptr, "ReleaseForegroundRights"},
-        {12, nullptr, "RejectToChangeIntoBackground"},
     };
     RegisterHandlers(functions);
 }
@@ -81,11 +78,8 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework("IDebugFunctions") {}
 ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger)) {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "Exit"},
         {1, &ISelfController::LockExit, "LockExit"},
         {2, &ISelfController::UnlockExit, "UnlockExit"},
-        {3, nullptr, "EnterFatalSection"},
-        {4, nullptr, "LeaveFatalSection"},
         {9, &ISelfController::GetLibraryAppletLaunchableEvent, "GetLibraryAppletLaunchableEvent"},
         {10, &ISelfController::SetScreenShotPermission, "SetScreenShotPermission"},
         {11, &ISelfController::SetOperationModeChangedNotification,
@@ -94,29 +88,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
          "SetPerformanceModeChangedNotification"},
         {13, &ISelfController::SetFocusHandlingMode, "SetFocusHandlingMode"},
         {14, &ISelfController::SetRestartMessageEnabled, "SetRestartMessageEnabled"},
-        {15, nullptr, "SetScreenShotAppletIdentityInfo"},
         {16, &ISelfController::SetOutOfFocusSuspendingEnabled, "SetOutOfFocusSuspendingEnabled"},
-        {17, nullptr, "SetControllerFirmwareUpdateSection"},
-        {18, nullptr, "SetRequiresCaptureButtonShortPressedMessage"},
-        {19, nullptr, "SetScreenShotImageOrientation"},
-        {20, nullptr, "SetDesirableKeyboardLayout"},
         {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
-        {41, nullptr, "IsSystemBufferSharingEnabled"},
-        {42, nullptr, "GetSystemSharedLayerHandle"},
-        {50, nullptr, "SetHandlesRequestToDisplay"},
-        {51, nullptr, "ApproveToDisplay"},
-        {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
-        {61, nullptr, "SetMediaPlaybackState"},
-        {62, nullptr, "SetIdleTimeDetectionExtension"},
-        {63, nullptr, "GetIdleTimeDetectionExtension"},
-        {64, nullptr, "SetInputDetectionSourceSet"},
-        {65, nullptr, "ReportUserIsActive"},
-        {66, nullptr, "GetCurrentIlluminance"},
-        {67, nullptr, "IsIlluminanceAvailable"},
-        {68, nullptr, "SetAutoSleepDisabled"},
-        {69, nullptr, "IsAutoSleepDisabled"},
-        {70, nullptr, "ReportMultimediaError"},
-        {80, nullptr, "SetWirelessPriorityMode"},
     };
     RegisterHandlers(functions);
 
@@ -233,30 +206,9 @@ ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter"
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
         {1, &ICommonStateGetter::ReceiveMessage, "ReceiveMessage"},
-        {2, nullptr, "GetThisAppletKind"},
-        {3, nullptr, "AllowToEnterSleep"},
-        {4, nullptr, "DisallowToEnterSleep"},
         {5, &ICommonStateGetter::GetOperationMode, "GetOperationMode"},
         {6, &ICommonStateGetter::GetPerformanceMode, "GetPerformanceMode"},
-        {7, nullptr, "GetCradleStatus"},
-        {8, nullptr, "GetBootMode"},
         {9, &ICommonStateGetter::GetCurrentFocusState, "GetCurrentFocusState"},
-        {10, nullptr, "RequestToAcquireSleepLock"},
-        {11, nullptr, "ReleaseSleepLock"},
-        {12, nullptr, "ReleaseSleepLockTransiently"},
-        {13, nullptr, "GetAcquiredSleepLockEvent"},
-        {20, nullptr, "PushToGeneralChannel"},
-        {30, nullptr, "GetHomeButtonReaderLockAccessor"},
-        {31, nullptr, "GetReaderLockAccessorEx"},
-        {40, nullptr, "GetCradleFwVersion"},
-        {50, nullptr, "IsVrModeEnabled"},
-        {51, nullptr, "SetVrModeEnabled"},
-        {52, nullptr, "SwitchLcdBacklight"},
-        {55, nullptr, "IsInControllerFirmwareUpdateSection"},
-        {60, nullptr, "GetDefaultDisplayResolution"},
-        {61, nullptr, "GetDefaultDisplayResolutionChangeEvent"},
-        {62, nullptr, "GetHdcpAuthenticationState"},
-        {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
     };
     RegisterHandlers(functions);
 
@@ -326,7 +278,7 @@ public:
             {104, nullptr, "PopInteractiveOutData"},
             {105, nullptr, "GetPopOutDataEvent"},
             {106, nullptr, "GetPopInteractiveOutDataEvent"},
-            {110, nullptr, "NeedsToExitProcess"},
+            {120, nullptr, "NeedsToExitProcess"},
             {120, nullptr, "GetLibraryAppletInfo"},
             {150, nullptr, "RequestForAppletToGetForeground"},
             {160, nullptr, "GetIndirectLayerConsumerHandle"},
@@ -378,7 +330,6 @@ public:
         : ServiceFramework("IStorageAccessor"), buffer(std::move(buffer)) {
         static const FunctionInfo functions[] = {
             {0, &IStorageAccessor::GetSize, "GetSize"},
-            {10, nullptr, "Write"},
             {11, &IStorageAccessor::Read, "Read"},
         };
         RegisterHandlers(functions);
@@ -421,7 +372,6 @@ public:
         : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
         static const FunctionInfo functions[] = {
             {0, &IStorage::Open, "Open"},
-            {1, nullptr, "OpenTransferStorage"},
         };
         RegisterHandlers(functions);
     }
@@ -442,42 +392,12 @@ private:
 IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
     static const FunctionInfo functions[] = {
         {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
-        {10, nullptr, "CreateApplicationAndPushAndRequestToStart"},
-        {11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
-        {12, nullptr, "CreateApplicationAndRequestToStart"},
-        {13, nullptr, "CreateApplicationAndRequestToStartForQuest"},
         {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
         {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
         {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
-        {23, nullptr, "GetDisplayVersion"},
-        {24, nullptr, "GetLaunchStorageInfoForDebug"},
-        {25, nullptr, "ExtendSaveData"},
-        {26, nullptr, "GetSaveDataSize"},
-        {30, nullptr, "BeginBlockingHomeButtonShortAndLongPressed"},
-        {31, nullptr, "EndBlockingHomeButtonShortAndLongPressed"},
-        {32, nullptr, "BeginBlockingHomeButton"},
-        {33, nullptr, "EndBlockingHomeButton"},
-        {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
-        {50, nullptr, "GetPseudoDeviceId"},
-        {60, nullptr, "SetMediaPlaybackStateForApplication"},
-        {65, nullptr, "IsGamePlayRecordingSupported"},
         {66, &IApplicationFunctions::InitializeGamePlayRecording, "InitializeGamePlayRecording"},
         {67, &IApplicationFunctions::SetGamePlayRecordingState, "SetGamePlayRecordingState"},
-        {68, nullptr, "RequestFlushGamePlayingMovieForDebug"},
-        {70, nullptr, "RequestToShutdown"},
-        {71, nullptr, "RequestToReboot"},
-        {80, nullptr, "ExitAndRequestToShowThanksMessage"},
-        {90, nullptr, "EnableApplicationCrashReport"},
-        {100, nullptr, "InitializeApplicationCopyrightFrameBuffer"},
-        {101, nullptr, "SetApplicationCopyrightImage"},
-        {102, nullptr, "SetApplicationCopyrightVisibility"},
-        {110, nullptr, "QueryApplicationPlayStatistics"},
-        {120, nullptr, "ExecuteProgram"},
-        {121, nullptr, "ClearUserChannel"},
-        {122, nullptr, "UnpopToUserChannel"},
-        {500, nullptr, "StartContinuousRecordingFlushForDebug"},
-        {1000, nullptr, "CreateMovieMaker"},
-        {1001, nullptr, "PrepareForJit"},
+        {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/am/applet_ae.cpp

@@ -21,7 +21,6 @@ public:
             {2, &ILibraryAppletProxy::GetWindowController, "GetWindowController"},
             {3, &ILibraryAppletProxy::GetAudioController, "GetAudioController"},
             {4, &ILibraryAppletProxy::GetDisplayController, "GetDisplayController"},
-            {10, nullptr, "GetProcessWindingController"},
             {11, &ILibraryAppletProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
             {20, &ILibraryAppletProxy::GetApplicationFunctions, "GetApplicationFunctions"},
             {1000, &ILibraryAppletProxy::GetDebugFunctions, "GetDebugFunctions"},

src/core/hle/service/am/applet_oe.cpp

@@ -21,7 +21,6 @@ public:
             {2, &IApplicationProxy::GetWindowController, "GetWindowController"},
             {3, &IApplicationProxy::GetAudioController, "GetAudioController"},
             {4, &IApplicationProxy::GetDisplayController, "GetDisplayController"},
-            {10, nullptr, "GetProcessWindingController"},
             {11, &IApplicationProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
             {20, &IApplicationProxy::GetApplicationFunctions, "GetApplicationFunctions"},
             {1000, &IApplicationProxy::GetDebugFunctions, "GetDebugFunctions"},

src/core/hle/service/aoc/aoc_u.cpp

@@ -19,7 +19,6 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u") {
         {5, nullptr, "GetAddOnContentBaseId"},
         {6, nullptr, "PrepareAddOnContentByApplicationId"},
         {7, nullptr, "PrepareAddOnContent"},
-        {8, nullptr, "GetAddOnContentListChangedEvent"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/audio/audin_u.cpp

@@ -14,20 +14,15 @@ class IAudioIn final : public ServiceFramework<IAudioIn> {
 public:
     IAudioIn() : ServiceFramework("IAudioIn") {
         static const FunctionInfo functions[] = {
-            {0, nullptr, "GetAudioInState"},
-            {1, nullptr, "StartAudioIn"},
-            {2, nullptr, "StopAudioIn"},
-            {3, nullptr, "AppendAudioInBuffer"},
-            {4, nullptr, "RegisterBufferEvent"},
-            {5, nullptr, "GetReleasedAudioInBuffer"},
-            {6, nullptr, "ContainsAudioInBuffer"},
-            {7, nullptr, "AppendAudioInBufferWithUserEvent"},
-            {8, nullptr, "AppendAudioInBufferAuto"},
-            {9, nullptr, "GetReleasedAudioInBufferAuto"},
-            {10, nullptr, "AppendAudioInBufferWithUserEventAuto"},
-            {11, nullptr, "GetAudioInBufferCount"},
-            {12, nullptr, "SetAudioInDeviceGain"},
-            {13, nullptr, "GetAudioInDeviceGain"},
+            {0x0, nullptr, "GetAudioInState"},
+            {0x1, nullptr, "StartAudioIn"},
+            {0x2, nullptr, "StopAudioIn"},
+            {0x3, nullptr, "AppendAudioInBuffer_1"},
+            {0x4, nullptr, "RegisterBufferEvent"},
+            {0x5, nullptr, "GetReleasedAudioInBuffer_1"},
+            {0x6, nullptr, "ContainsAudioInBuffer"},
+            {0x7, nullptr, "AppendAudioInBuffer_2"},
+            {0x8, nullptr, "GetReleasedAudioInBuffer_2"},
         };
         RegisterHandlers(functions);
     }
@@ -36,10 +31,8 @@ public:
 
 AudInU::AudInU() : ServiceFramework("audin:u") {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "ListAudioIns"},
-        {1, nullptr, "OpenAudioIn"},
-        {3, nullptr, "OpenAudioInAuto"},
-        {4, nullptr, "ListAudioInsAuto"},
+        {0x00000000, nullptr, "ListAudioIns"},
+        {0x00000001, nullptr, "OpenAudioIn"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/audio/audout_u.cpp

@@ -25,18 +25,15 @@ class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
     IAudioOut() : ServiceFramework("IAudioOut"), audio_out_state(AudioState::Stopped) {
         static const FunctionInfo functions[] = {
-            {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
-            {1, &IAudioOut::StartAudioOut, "StartAudioOut"},
-            {2, &IAudioOut::StopAudioOut, "StopAudioOut"},
-            {3, &IAudioOut::AppendAudioOutBuffer, "AppendAudioOutBuffer"},
-            {4, &IAudioOut::RegisterBufferEvent, "RegisterBufferEvent"},
-            {5, &IAudioOut::GetReleasedAudioOutBuffer, "GetReleasedAudioOutBuffer"},
-            {6, nullptr, "ContainsAudioOutBuffer"},
-            {7, nullptr, "AppendAudioOutBufferAuto"},
-            {8, nullptr, "GetReleasedAudioOutBufferAuto"},
-            {9, nullptr, "GetAudioOutBufferCount"},
-            {10, nullptr, "GetAudioOutPlayedSampleCount"},
-            {11, nullptr, "FlushAudioOutBuffers"},
+            {0x0, nullptr, "GetAudioOutState"},
+            {0x1, &IAudioOut::StartAudioOut, "StartAudioOut"},
+            {0x2, &IAudioOut::StopAudioOut, "StopAudioOut"},
+            {0x3, &IAudioOut::AppendAudioOutBuffer_1, "AppendAudioOutBuffer_1"},
+            {0x4, &IAudioOut::RegisterBufferEvent, "RegisterBufferEvent"},
+            {0x5, &IAudioOut::GetReleasedAudioOutBuffer_1, "GetReleasedAudioOutBuffer_1"},
+            {0x6, nullptr, "ContainsAudioOutBuffer"},
+            {0x7, nullptr, "AppendAudioOutBuffer_2"},
+            {0x8, nullptr, "GetReleasedAudioOutBuffer_2"},
         };
         RegisterHandlers(functions);
 
@@ -60,13 +57,6 @@ public:
     }
 
 private:
-    void GetAudioOutState(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Audio, "called");
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(static_cast<u32>(audio_out_state));
-    }
-
     void StartAudioOut(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
@@ -97,7 +87,7 @@ private:
         rb.PushCopyObjects(buffer_event);
     }
 
-    void AppendAudioOutBuffer(Kernel::HLERequestContext& ctx) {
+    void AppendAudioOutBuffer_1(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
 
@@ -108,7 +98,7 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    void GetReleasedAudioOutBuffer(Kernel::HLERequestContext& ctx) {
+    void GetReleasedAudioOutBuffer_1(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
         // TODO(st4rk): This is how libtransistor currently implements the
@@ -199,8 +189,8 @@ void AudOutU::OpenAudioOut(Kernel::HLERequestContext& ctx) {
 AudOutU::AudOutU() : ServiceFramework("audout:u") {
     static const FunctionInfo functions[] = {{0x00000000, &AudOutU::ListAudioOuts, "ListAudioOuts"},
                                              {0x00000001, &AudOutU::OpenAudioOut, "OpenAudioOut"},
-                                             {0x00000002, nullptr, "ListAudioOutsAuto"},
-                                             {0x00000003, nullptr, "OpenAudioOutAuto"}};
+                                             {0x00000002, nullptr, "Unknown2"},
+                                             {0x00000003, nullptr, "Unknown3"}};
     RegisterHandlers(functions);
 }
 

src/core/hle/service/audio/audrec_u.cpp

@@ -14,15 +14,13 @@ class IFinalOutputRecorder final : public ServiceFramework<IFinalOutputRecorder>
 public:
     IFinalOutputRecorder() : ServiceFramework("IFinalOutputRecorder") {
         static const FunctionInfo functions[] = {
-            {0, nullptr, "GetFinalOutputRecorderState"},
-            {1, nullptr, "StartFinalOutputRecorder"},
-            {2, nullptr, "StopFinalOutputRecorder"},
-            {3, nullptr, "AppendFinalOutputRecorderBuffer"},
-            {4, nullptr, "RegisterBufferEvent"},
-            {5, nullptr, "GetReleasedFinalOutputRecorderBuffer"},
-            {6, nullptr, "ContainsFinalOutputRecorderBuffer"},
-            {8, nullptr, "AppendFinalOutputRecorderBufferAuto"},
-            {9, nullptr, "GetReleasedFinalOutputRecorderBufferAuto"},
+            {0x0, nullptr, "GetFinalOutputRecorderState"},
+            {0x1, nullptr, "StartFinalOutputRecorder"},
+            {0x2, nullptr, "StopFinalOutputRecorder"},
+            {0x3, nullptr, "AppendFinalOutputRecorderBuffer"},
+            {0x4, nullptr, "RegisterBufferEvent"},
+            {0x5, nullptr, "GetReleasedFinalOutputRecorderBuffer"},
+            {0x6, nullptr, "ContainsFinalOutputRecorderBuffer"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/audio/audren_u.cpp

@@ -19,18 +19,16 @@ class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
     IAudioRenderer() : ServiceFramework("IAudioRenderer") {
         static const FunctionInfo functions[] = {
-            {0, nullptr, "GetAudioRendererSampleRate"},
-            {1, nullptr, "GetAudioRendererSampleCount"},
-            {2, nullptr, "GetAudioRendererMixBufferCount"},
-            {3, nullptr, "GetAudioRendererState"},
-            {4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
-            {5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
-            {6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
-            {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
-            {8, nullptr, "SetAudioRendererRenderingTimeLimit"},
-            {9, nullptr, "GetAudioRendererRenderingTimeLimit"},
-            {10, nullptr, "RequestUpdateAudioRendererAuto"},
-            {11, nullptr, "ExecuteAudioRendererRendering"},
+            {0x0, nullptr, "GetAudioRendererSampleRate"},
+            {0x1, nullptr, "GetAudioRendererSampleCount"},
+            {0x2, nullptr, "GetAudioRendererMixBufferCount"},
+            {0x3, nullptr, "GetAudioRendererState"},
+            {0x4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
+            {0x5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
+            {0x6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
+            {0x7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
+            {0x8, nullptr, "SetAudioRendererRenderingTimeLimit"},
+            {0x9, nullptr, "GetAudioRendererRenderingTimeLimit"},
         };
         RegisterHandlers(functions);
 
@@ -160,7 +158,7 @@ public:
             {0x0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
             {0x1, &IAudioDevice::SetAudioDeviceOutputVolume, "SetAudioDeviceOutputVolume"},
             {0x2, nullptr, "GetAudioDeviceOutputVolume"},
-            {0x3, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceName"},
+            {0x3, nullptr, "GetActiveAudioDeviceName"},
             {0x4, &IAudioDevice::QueryAudioDeviceSystemEvent, "QueryAudioDeviceSystemEvent"},
             {0x5, &IAudioDevice::GetActiveChannelCount, "GetActiveChannelCount"},
             {0x6, nullptr, "ListAudioDeviceNameAuto"},
@@ -201,18 +199,6 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    void GetActiveAudioDeviceName(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_Audio, "(STUBBED) called");
-        IPC::RequestParser rp{ctx};
-
-        const std::string audio_interface = "AudioDevice";
-        ctx.WriteBuffer(audio_interface.c_str(), audio_interface.size());
-
-        IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(1);
-    }
-
     void QueryAudioDeviceSystemEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
@@ -239,8 +225,6 @@ AudRenU::AudRenU() : ServiceFramework("audren:u") {
         {0, &AudRenU::OpenAudioRenderer, "OpenAudioRenderer"},
         {1, &AudRenU::GetAudioRendererWorkBufferSize, "GetAudioRendererWorkBufferSize"},
         {2, &AudRenU::GetAudioDevice, "GetAudioDevice"},
-        {3, nullptr, "OpenAudioRendererAuto"},
-        {4, nullptr, "GetAudioDeviceServiceWithRevisionInfo"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/audio/codecctl.cpp

@@ -22,9 +22,9 @@ CodecCtl::CodecCtl() : ServiceFramework("codecctl") {
         {0x00000007, nullptr, "SetCodecActiveTarget"},
         {0x00000008, nullptr, "Unknown"},
         {0x00000009, nullptr, "BindCodecHeadphoneMicJackInterrupt"},
-        {0x00000010, nullptr, "IsCodecHeadphoneMicJackInserted"},
-        {0x00000011, nullptr, "ClearCodecHeadphoneMicJackInterrupt"},
-        {0x00000012, nullptr, "IsCodecDeviceRequested"},
+        {0x0000000A, nullptr, "IsCodecHeadphoneMicJackInserted"},
+        {0x0000000B, nullptr, "ClearCodecHeadphoneMicJackInterrupt"},
+        {0x0000000C, nullptr, "IsCodecDeviceRequested"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -23,7 +23,7 @@ public:
         : ServiceFramework("IStorage"), backend(std::move(backend)) {
         static const FunctionInfo functions[] = {
             {0, &IStorage::Read, "Read"}, {1, nullptr, "Write"},   {2, nullptr, "Flush"},
-            {3, nullptr, "SetSize"},      {4, nullptr, "GetSize"}, {5, nullptr, "OperateRange"},
+            {3, nullptr, "SetSize"},      {4, nullptr, "GetSize"},
         };
         RegisterHandlers(functions);
     }
@@ -72,9 +72,8 @@ public:
     explicit IFile(std::unique_ptr<FileSys::StorageBackend>&& backend)
         : ServiceFramework("IFile"), backend(std::move(backend)) {
         static const FunctionInfo functions[] = {
-            {0, &IFile::Read, "Read"},       {1, &IFile::Write, "Write"},
-            {2, &IFile::Flush, "Flush"},     {3, &IFile::SetSize, "SetSize"},
-            {4, &IFile::GetSize, "GetSize"}, {5, nullptr, "OperateRange"},
+            {0, &IFile::Read, "Read"}, {1, &IFile::Write, "Write"}, {2, nullptr, "Flush"},
+            {3, nullptr, "SetSize"},   {4, nullptr, "GetSize"},
         };
         RegisterHandlers(functions);
     }
@@ -151,33 +150,6 @@ private:
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
-
-    void Flush(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_FS, "called");
-        backend->Flush();
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void SetSize(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 size = rp.Pop<u64>();
-        backend->SetSize(size);
-        LOG_DEBUG(Service_FS, "called, size=%" PRIu64, size);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void GetSize(Kernel::HLERequestContext& ctx) {
-        const u64 size = backend->GetSize();
-        LOG_DEBUG(Service_FS, "called, size=%" PRIu64, size);
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(size);
-    }
 };
 
 class IDirectory final : public ServiceFramework<IDirectory> {
@@ -236,21 +208,11 @@ public:
         : ServiceFramework("IFileSystem"), backend(std::move(backend)) {
         static const FunctionInfo functions[] = {
             {0, &IFileSystem::CreateFile, "CreateFile"},
-            {1, nullptr, "DeleteFile"},
             {2, &IFileSystem::CreateDirectory, "CreateDirectory"},
-            {3, nullptr, "DeleteDirectory"},
-            {4, nullptr, "DeleteDirectoryRecursively"},
-            {5, nullptr, "RenameFile"},
-            {6, nullptr, "RenameDirectory"},
             {7, &IFileSystem::GetEntryType, "GetEntryType"},
             {8, &IFileSystem::OpenFile, "OpenFile"},
             {9, &IFileSystem::OpenDirectory, "OpenDirectory"},
             {10, &IFileSystem::Commit, "Commit"},
-            {11, nullptr, "GetFreeSpaceSize"},
-            {12, nullptr, "GetTotalSpaceSize"},
-            {13, nullptr, "CleanDirectoryRecursively"},
-            {14, nullptr, "GetFileTimeStampRaw"},
-            {15, nullptr, "QueryEntry"},
         };
         RegisterHandlers(functions);
     }
@@ -375,94 +337,14 @@ private:
 
 FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "MountContent"},
-        {1, &FSP_SRV::Initialize, "Initialize"},
-        {2, nullptr, "OpenDataFileSystemByCurrentProcess"},
-        {7, nullptr, "OpenFileSystemWithPatch"},
-        {8, nullptr, "OpenFileSystemWithId"},
-        {9, nullptr, "OpenDataFileSystemByApplicationId"},
-        {11, nullptr, "OpenBisFileSystem"},
-        {12, nullptr, "OpenBisStorage"},
-        {13, nullptr, "InvalidateBisCache"},
-        {17, nullptr, "OpenHostFileSystem"},
+        {1, &FSP_SRV::Initalize, "Initalize"},
         {18, &FSP_SRV::MountSdCard, "MountSdCard"},
-        {19, nullptr, "FormatSdCardFileSystem"},
-        {21, nullptr, "DeleteSaveDataFileSystem"},
         {22, &FSP_SRV::CreateSaveData, "CreateSaveData"},
-        {23, nullptr, "CreateSaveDataFileSystemBySystemSaveDataId"},
-        {24, nullptr, "RegisterSaveDataFileSystemAtomicDeletion"},
-        {25, nullptr, "DeleteSaveDataFileSystemBySaveDataSpaceId"},
-        {26, nullptr, "FormatSdCardDryRun"},
-        {27, nullptr, "IsExFatSupported"},
-        {28, nullptr, "DeleteSaveDataFileSystemBySaveDataAttribute"},
-        {30, nullptr, "OpenGameCardStorage"},
-        {31, nullptr, "OpenGameCardFileSystem"},
-        {32, nullptr, "ExtendSaveDataFileSystem"},
-        {33, nullptr, "DeleteCacheStorage"},
-        {34, nullptr, "GetCacheStorageSize"},
         {51, &FSP_SRV::MountSaveData, "MountSaveData"},
-        {52, nullptr, "OpenSaveDataFileSystemBySystemSaveDataId"},
-        {53, nullptr, "OpenReadOnlySaveDataFileSystem"},
-        {57, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
-        {58, nullptr, "ReadSaveDataFileSystemExtraData"},
-        {59, nullptr, "WriteSaveDataFileSystemExtraData"},
-        {60, nullptr, "OpenSaveDataInfoReader"},
-        {61, nullptr, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
-        {62, nullptr, "OpenCacheStorageList"},
-        {64, nullptr, "OpenSaveDataInternalStorageFileSystem"},
-        {65, nullptr, "UpdateSaveDataMacForDebug"},
-        {66, nullptr, "WriteSaveDataFileSystemExtraData2"},
-        {80, nullptr, "OpenSaveDataMetaFile"},
-        {81, nullptr, "OpenSaveDataTransferManager"},
-        {82, nullptr, "OpenSaveDataTransferManagerVersion2"},
-        {100, nullptr, "OpenImageDirectoryFileSystem"},
-        {110, nullptr, "OpenContentStorageFileSystem"},
         {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
-        {201, nullptr, "OpenDataStorageByProgramId"},
         {202, nullptr, "OpenDataStorageByDataId"},
         {203, &FSP_SRV::OpenRomStorage, "OpenRomStorage"},
-        {400, nullptr, "OpenDeviceOperator"},
-        {500, nullptr, "OpenSdCardDetectionEventNotifier"},
-        {501, nullptr, "OpenGameCardDetectionEventNotifier"},
-        {510, nullptr, "OpenSystemDataUpdateEventNotifier"},
-        {511, nullptr, "NotifySystemDataUpdateEvent"},
-        {600, nullptr, "SetCurrentPosixTime"},
-        {601, nullptr, "QuerySaveDataTotalSize"},
-        {602, nullptr, "VerifySaveDataFileSystem"},
-        {603, nullptr, "CorruptSaveDataFileSystem"},
-        {604, nullptr, "CreatePaddingFile"},
-        {605, nullptr, "DeleteAllPaddingFiles"},
-        {606, nullptr, "GetRightsId"},
-        {607, nullptr, "RegisterExternalKey"},
-        {608, nullptr, "UnregisterAllExternalKey"},
-        {609, nullptr, "GetRightsIdByPath"},
-        {610, nullptr, "GetRightsIdAndKeyGenerationByPath"},
-        {611, nullptr, "SetCurrentPosixTimeWithTimeDifference"},
-        {612, nullptr, "GetFreeSpaceSizeForSaveData"},
-        {613, nullptr, "VerifySaveDataFileSystemBySaveDataSpaceId"},
-        {614, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId"},
-        {615, nullptr, "QuerySaveDataInternalStorageTotalSize"},
-        {620, nullptr, "SetSdCardEncryptionSeed"},
-        {630, nullptr, "SetSdCardAccessibility"},
-        {631, nullptr, "IsSdCardAccessible"},
-        {640, nullptr, "IsSignedSystemPartitionOnSdCardValid"},
-        {700, nullptr, "OpenAccessFailureResolver"},
-        {701, nullptr, "GetAccessFailureDetectionEvent"},
-        {702, nullptr, "IsAccessFailureDetected"},
-        {710, nullptr, "ResolveAccessFailure"},
-        {720, nullptr, "AbandonAccessFailure"},
-        {800, nullptr, "GetAndClearFileSystemProxyErrorInfo"},
-        {1000, nullptr, "SetBisRootForHost"},
-        {1001, nullptr, "SetSaveDataSize"},
-        {1002, nullptr, "SetSaveDataRootPath"},
-        {1003, nullptr, "DisableAutoSaveDataCreation"},
-        {1004, nullptr, "SetGlobalAccessLogMode"},
         {1005, &FSP_SRV::GetGlobalAccessLogMode, "GetGlobalAccessLogMode"},
-        {1006, nullptr, "OutputAccessLogToSdCard"},
-        {1007, nullptr, "RegisterUpdatePartition"},
-        {1008, nullptr, "OpenRegisteredUpdatePartition"},
-        {1009, nullptr, "GetAndClearMemoryReportInfo"},
-        {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
     };
     RegisterHandlers(functions);
 }
@@ -478,7 +360,7 @@ void FSP_SRV::TryLoadRomFS() {
     }
 }
 
-void FSP_SRV::Initialize(Kernel::HLERequestContext& ctx) {
+void FSP_SRV::Initalize(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2};

src/core/hle/service/filesystem/fsp_srv.h

@@ -22,7 +22,7 @@ public:
 private:
     void TryLoadRomFS();
 
-    void Initialize(Kernel::HLERequestContext& ctx);
+    void Initalize(Kernel::HLERequestContext& ctx);
     void MountSdCard(Kernel::HLERequestContext& ctx);
     void CreateSaveData(Kernel::HLERequestContext& ctx);
     void MountSaveData(Kernel::HLERequestContext& ctx);

src/core/hle/service/friend/friend.cpp

@@ -6,12 +6,11 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/friend/friend.h"
 #include "core/hle/service/friend/friend_a.h"
-#include "core/hle/service/friend/friend_u.h"
 
 namespace Service {
 namespace Friend {
 
-void Module::Interface::CreateFriendService(Kernel::HLERequestContext& ctx) {
+void Module::Interface::Unknown(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
     LOG_WARNING(Service_Friend, "(STUBBED) called");
@@ -23,7 +22,6 @@ Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module = std::make_shared<Module>();
     std::make_shared<Friend_A>(module)->InstallAsService(service_manager);
-    std::make_shared<Friend_U>(module)->InstallAsService(service_manager);
 }
 
 } // namespace Friend

src/core/hle/service/friend/friend.h

@@ -15,7 +15,7 @@ public:
     public:
         Interface(std::shared_ptr<Module> module, const char* name);
 
-        void CreateFriendService(Kernel::HLERequestContext& ctx);
+        void Unknown(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> module;

src/core/hle/service/friend/friend_a.cpp

@@ -10,8 +10,7 @@ namespace Friend {
 Friend_A::Friend_A(std::shared_ptr<Module> module)
     : Module::Interface(std::move(module), "friend:a") {
     static const FunctionInfo functions[] = {
-        {0, &Friend_A::CreateFriendService, "CreateFriendService"},
-        {1, nullptr, "CreateNotificationService"},
+        {0, &Friend_A::Unknown, "Unknown"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/friend/friend_u.cpp

@@ -1,20 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/friend/friend_u.h"
-
-namespace Service {
-namespace Friend {
-
-Friend_U::Friend_U(std::shared_ptr<Module> module)
-    : Module::Interface(std::move(module), "friend:u") {
-    static const FunctionInfo functions[] = {
-        {0, &Friend_U::CreateFriendService, "CreateFriendService"},
-        {1, nullptr, "CreateNotificationService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Friend
-} // namespace Service

src/core/hle/service/friend/friend_u.h

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/friend/friend.h"
-
-namespace Service {
-namespace Friend {
-
-class Friend_U final : public Module::Interface {
-public:
-    explicit Friend_U(std::shared_ptr<Module> module);
-};
-
-} // namespace Friend
-} // namespace Service

src/core/hle/service/hid/hid.cpp

@@ -65,14 +65,13 @@ private:
     }
 
     void UpdatePadCallback(u64 userdata, int cycles_late) {
-        SharedMemory mem{};
-        std::memcpy(&mem, shared_mem->GetPointer(), sizeof(SharedMemory));
+        SharedMemory* mem = reinterpret_cast<SharedMemory*>(shared_mem->GetPointer());
 
         if (is_device_reload_pending.exchange(false))
             LoadInputDevices();
 
         // Set up controllers as neon red+blue Joy-Con attached to console
-        ControllerHeader& controller_header = mem.controllers[Controller_Handheld].header;
+        ControllerHeader& controller_header = mem->controllers[Controller_Handheld].header;
         controller_header.type = ControllerType_Handheld | ControllerType_JoyconPair;
         controller_header.single_colors_descriptor = ColorDesc_ColorsNonexistent;
         controller_header.right_color_body = JOYCON_BODY_NEON_RED;
@@ -80,8 +79,8 @@ private:
         controller_header.left_color_body = JOYCON_BODY_NEON_BLUE;
         controller_header.left_color_buttons = JOYCON_BUTTONS_NEON_BLUE;
 
-        for (int index = 0; index < HID_NUM_LAYOUTS; index++) {
-            ControllerLayout& layout = mem.controllers[Controller_Handheld].layouts[index];
+        for (int layoutIdx = 0; layoutIdx < HID_NUM_LAYOUTS; layoutIdx++) {
+            ControllerLayout& layout = mem->controllers[Controller_Handheld].layouts[layoutIdx];
             layout.header.num_entries = HID_NUM_ENTRIES;
             layout.header.max_entry_index = HID_NUM_ENTRIES - 1;
 
@@ -137,25 +136,10 @@ private:
             // layouts)
         }
 
-        // TODO(bunnei): Properly implement the touch screen, the below will just write empty data
-
-        TouchScreen& touchscreen = mem.touchscreen;
-        const u64 last_entry = touchscreen.header.latest_entry;
-        const u64 curr_entry = (last_entry + 1) % touchscreen.entries.size();
-        const u64 timestamp = CoreTiming::GetTicks();
-        const u64 sample_counter = touchscreen.entries[last_entry].header.timestamp + 1;
-        touchscreen.header.timestamp_ticks = timestamp;
-        touchscreen.header.num_entries = touchscreen.entries.size();
-        touchscreen.header.latest_entry = curr_entry;
-        touchscreen.header.max_entry_index = touchscreen.entries.size();
-        touchscreen.header.timestamp = timestamp;
-        touchscreen.entries[curr_entry].header.timestamp = sample_counter;
-        touchscreen.entries[curr_entry].header.num_touches = 0;
+        // TODO(shinyquagsire23): Update touch info
 
         // TODO(shinyquagsire23): Signal events
 
-        std::memcpy(shared_mem->GetPointer(), &mem, sizeof(SharedMemory));
-
         // Reschedule recurrent event
         CoreTiming::ScheduleEvent(pad_update_ticks - cycles_late, pad_update_event);
     }
@@ -198,75 +182,24 @@ public:
             {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
             {21, &Hid::ActivateMouse, "ActivateMouse"},
             {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
-            {40, nullptr, "AcquireXpadIdEventHandle"},
-            {41, nullptr, "ReleaseXpadIdEventHandle"},
-            {51, nullptr, "ActivateXpad"},
-            {55, nullptr, "GetXpadIds"},
-            {56, nullptr, "ActivateJoyXpad"},
-            {58, nullptr, "GetJoyXpadLifoHandle"},
-            {59, nullptr, "GetJoyXpadIds"},
-            {60, nullptr, "ActivateSixAxisSensor"},
-            {61, nullptr, "DeactivateSixAxisSensor"},
-            {62, nullptr, "GetSixAxisSensorLifoHandle"},
-            {63, nullptr, "ActivateJoySixAxisSensor"},
-            {64, nullptr, "DeactivateJoySixAxisSensor"},
-            {65, nullptr, "GetJoySixAxisSensorLifoHandle"},
             {66, &Hid::StartSixAxisSensor, "StartSixAxisSensor"},
-            {67, nullptr, "StopSixAxisSensor"},
-            {68, nullptr, "IsSixAxisSensorFusionEnabled"},
-            {69, nullptr, "EnableSixAxisSensorFusion"},
-            {70, nullptr, "SetSixAxisSensorFusionParameters"},
-            {71, nullptr, "GetSixAxisSensorFusionParameters"},
-            {72, nullptr, "ResetSixAxisSensorFusionParameters"},
-            {73, nullptr, "SetAccelerometerParameters"},
-            {74, nullptr, "GetAccelerometerParameters"},
-            {75, nullptr, "ResetAccelerometerParameters"},
-            {76, nullptr, "SetAccelerometerPlayMode"},
-            {77, nullptr, "GetAccelerometerPlayMode"},
-            {78, nullptr, "ResetAccelerometerPlayMode"},
             {79, &Hid::SetGyroscopeZeroDriftMode, "SetGyroscopeZeroDriftMode"},
-            {80, nullptr, "GetGyroscopeZeroDriftMode"},
-            {81, nullptr, "ResetGyroscopeZeroDriftMode"},
-            {82, nullptr, "IsSixAxisSensorAtRest"},
-            {91, nullptr, "ActivateGesture"},
             {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
-            {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
             {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
             {103, &Hid::ActivateNpad, "ActivateNpad"},
-            {104, nullptr, "DeactivateNpad"},
             {106, &Hid::AcquireNpadStyleSetUpdateEventHandle,
              "AcquireNpadStyleSetUpdateEventHandle"},
-            {107, nullptr, "DisconnectNpad"},
-            {108, &Hid::GetPlayerLedPattern, "GetPlayerLedPattern"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
             {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,
              "SetNpadJoyAssignmentModeSingleByDefault"},
-            {123, nullptr, "SetNpadJoyAssignmentModeSingleByDefault"},
             {124, &Hid::SetNpadJoyAssignmentModeDual, "SetNpadJoyAssignmentModeDual"},
-            {125, nullptr, "MergeSingleJoyAsDualJoy"},
-            {126, nullptr, "StartLrAssignmentMode"},
-            {127, nullptr, "StopLrAssignmentMode"},
             {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
-            {129, nullptr, "GetNpadHandheldActivationMode"},
-            {130, nullptr, "SwapNpadAssignment"},
-            {131, nullptr, "IsUnintendedHomeButtonInputProtectionEnabled"},
-            {132, nullptr, "EnableUnintendedHomeButtonInputProtection"},
             {200, &Hid::GetVibrationDeviceInfo, "GetVibrationDeviceInfo"},
             {201, &Hid::SendVibrationValue, "SendVibrationValue"},
             {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
             {203, &Hid::CreateActiveVibrationDeviceList, "CreateActiveVibrationDeviceList"},
-            {204, nullptr, "PermitVibration"},
-            {205, nullptr, "IsVibrationPermitted"},
             {206, &Hid::SendVibrationValues, "SendVibrationValues"},
-            {300, nullptr, "ActivateConsoleSixAxisSensor"},
-            {301, nullptr, "StartConsoleSixAxisSensor"},
-            {302, nullptr, "StopConsoleSixAxisSensor"},
-            {400, nullptr, "IsUsbFullKeyControllerEnabled"},
-            {401, nullptr, "EnableUsbFullKeyController"},
-            {402, nullptr, "IsUsbFullKeyControllerConnected"},
-            {1000, nullptr, "SetNpadCommunicationMode"},
-            {1001, nullptr, "GetNpadCommunicationMode"},
         };
         RegisterHandlers(functions);
 
@@ -332,13 +265,6 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
-    void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(0);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -358,12 +284,6 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
-    void GetPlayerLedPattern(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
     void SetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);

src/core/hle/service/nifm/nifm.cpp

@@ -70,8 +70,9 @@ private:
     }
     void GetResult(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_NIFM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(0);
     }
     void GetSystemEventReadableHandles(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_NIFM, "(STUBBED) called");

src/core/hle/service/ns/pl_u.cpp

@@ -37,9 +37,7 @@ PL_U::PL_U() : ServiceFramework("pl:u") {
         {1, &PL_U::GetLoadState, "GetLoadState"},
         {2, &PL_U::GetSize, "GetSize"},
         {3, &PL_U::GetSharedMemoryAddressOffset, "GetSharedMemoryAddressOffset"},
-        {4, &PL_U::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"},
-        {5, nullptr, "GetSharedFontInOrderOfPriority"},
-    };
+        {4, &PL_U::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"}};
     RegisterHandlers(functions);
 
     // Attempt to load shared font data from disk
@@ -47,10 +45,10 @@ PL_U::PL_U() : ServiceFramework("pl:u") {
     FileUtil::CreateFullPath(filepath); // Create path if not already created
     FileUtil::IOFile file(filepath, "rb");
 
-    shared_font = std::make_shared<std::vector<u8>>(SHARED_FONT_MEM_SIZE);
     if (file.IsOpen()) {
         // Read shared font data
         ASSERT(file.GetSize() == SHARED_FONT_MEM_SIZE);
+        shared_font = std::make_shared<std::vector<u8>>(static_cast<size_t>(file.GetSize()));
         file.ReadBytes(shared_font->data(), shared_font->size());
     } else {
         LOG_WARNING(Service_NS, "Unable to load shared font: %s", filepath.c_str());
@@ -97,19 +95,22 @@ void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
 }
 
 void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
-    // TODO(bunnei): This is a less-than-ideal solution to load a RAM dump of the Switch shared
-    // font data. This (likely) relies on exact address, size, and offsets from the original
-    // dump. In the future, we need to replace this with a more robust solution.
+    if (shared_font != nullptr) {
+        // TODO(bunnei): This is a less-than-ideal solution to load a RAM dump of the Switch shared
+        // font data. This (likely) relies on exact address, size, and offsets from the original
+        // dump. In the future, we need to replace this with a more robust solution.
 
-    // Map backing memory for the font data
-    Core::CurrentProcess()->vm_manager.MapMemoryBlock(
-        SHARED_FONT_MEM_VADDR, shared_font, 0, SHARED_FONT_MEM_SIZE, Kernel::MemoryState::Shared);
+        // Map backing memory for the font data
+        Core::CurrentProcess()->vm_manager.MapMemoryBlock(SHARED_FONT_MEM_VADDR, shared_font, 0,
+                                                          SHARED_FONT_MEM_SIZE,
+                                                          Kernel::MemoryState::Shared);
 
-    // Create shared font memory object
-    shared_font_mem = Kernel::SharedMemory::Create(
-        Core::CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
-        Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
-        "PL_U:shared_font_mem");
+        // Create shared font memory object
+        shared_font_mem = Kernel::SharedMemory::Create(
+            Core::CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
+            Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
+            "PL_U:shared_font_mem");
+    }
 
     LOG_DEBUG(Service_NS, "called");
     IPC::ResponseBuilder rb{ctx, 2, 1};

src/core/hle/service/nvdrv/interface.cpp

@@ -96,14 +96,7 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
         {2, &NVDRV::Close, "Close"},
         {3, &NVDRV::Initialize, "Initialize"},
         {4, &NVDRV::QueryEvent, "QueryEvent"},
-        {5, nullptr, "MapSharedMem"},
-        {6, nullptr, "GetStatus"},
-        {7, nullptr, "ForceSetClientPID"},
         {8, &NVDRV::SetClientPID, "SetClientPID"},
-        {9, nullptr, "DumpGraphicsMemoryInfo"},
-        {10, nullptr, "InitializeDevtools"},
-        {11, nullptr, "Ioctl2"},
-        {12, nullptr, "Ioctl3"},
         {13, &NVDRV::FinishInitialize, "FinishInitialize"},
     };
     RegisterHandlers(functions);

src/core/hle/service/nvdrv/nvmemp.cpp

@@ -13,17 +13,17 @@ namespace Nvidia {
 
 NVMEMP::NVMEMP() : ServiceFramework("nvmemp") {
     static const FunctionInfo functions[] = {
-        {0, &NVMEMP::Cmd0, "Cmd0"},
-        {1, &NVMEMP::Cmd1, "Cmd1"},
+        {0, &NVMEMP::Unknown0, "Unknown0"},
+        {1, &NVMEMP::Unknown1, "Unknown1"},
     };
     RegisterHandlers(functions);
 }
 
-void NVMEMP::Cmd0(Kernel::HLERequestContext& ctx) {
+void NVMEMP::Unknown0(Kernel::HLERequestContext& ctx) {
     UNIMPLEMENTED();
 }
 
-void NVMEMP::Cmd1(Kernel::HLERequestContext& ctx) {
+void NVMEMP::Unknown1(Kernel::HLERequestContext& ctx) {
     UNIMPLEMENTED();
 }
 

src/core/hle/service/nvdrv/nvmemp.h

@@ -15,8 +15,8 @@ public:
     ~NVMEMP() = default;
 
 private:
-    void Cmd0(Kernel::HLERequestContext& ctx);
-    void Cmd1(Kernel::HLERequestContext& ctx);
+    void Unknown0(Kernel::HLERequestContext& ctx);
+    void Unknown1(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Nvidia

src/core/hle/service/pctl/pctl_a.cpp

@@ -11,106 +11,10 @@ namespace PCTL {
 
 class IParentalControlService final : public ServiceFramework<IParentalControlService> {
 public:
-    IParentalControlService() : ServiceFramework("IParentalControlService") {
-        static const FunctionInfo functions[] = {
-            {1, nullptr, "Initialize"},
-            {1001, nullptr, "CheckFreeCommunicationPermission"},
-            {1002, nullptr, "ConfirmLaunchApplicationPermission"},
-            {1003, nullptr, "ConfirmResumeApplicationPermission"},
-            {1004, nullptr, "ConfirmSnsPostPermission"},
-            {1005, nullptr, "ConfirmSystemSettingsPermission"},
-            {1006, nullptr, "IsRestrictionTemporaryUnlocked"},
-            {1007, nullptr, "RevertRestrictionTemporaryUnlocked"},
-            {1008, nullptr, "EnterRestrictedSystemSettings"},
-            {1009, nullptr, "LeaveRestrictedSystemSettings"},
-            {1010, nullptr, "IsRestrictedSystemSettingsEntered"},
-            {1011, nullptr, "RevertRestrictedSystemSettingsEntered"},
-            {1012, nullptr, "GetRestrictedFeatures"},
-            {1013, nullptr, "ConfirmStereoVisionPermission"},
-            {1014, nullptr, "ConfirmPlayableApplicationVideoOld"},
-            {1015, nullptr, "ConfirmPlayableApplicationVideo"},
-            {1031, nullptr, "IsRestrictionEnabled"},
-            {1032, nullptr, "GetSafetyLevel"},
-            {1033, nullptr, "SetSafetyLevel"},
-            {1034, nullptr, "GetSafetyLevelSettings"},
-            {1035, nullptr, "GetCurrentSettings"},
-            {1036, nullptr, "SetCustomSafetyLevelSettings"},
-            {1037, nullptr, "GetDefaultRatingOrganization"},
-            {1038, nullptr, "SetDefaultRatingOrganization"},
-            {1039, nullptr, "GetFreeCommunicationApplicationListCount"},
-            {1042, nullptr, "AddToFreeCommunicationApplicationList"},
-            {1043, nullptr, "DeleteSettings"},
-            {1044, nullptr, "GetFreeCommunicationApplicationList"},
-            {1045, nullptr, "UpdateFreeCommunicationApplicationList"},
-            {1046, nullptr, "DisableFeaturesForReset"},
-            {1047, nullptr, "NotifyApplicationDownloadStarted"},
-            {1061, nullptr, "ConfirmStereoVisionRestrictionConfigurable"},
-            {1062, nullptr, "GetStereoVisionRestriction"},
-            {1063, nullptr, "SetStereoVisionRestriction"},
-            {1064, nullptr, "ResetConfirmedStereoVisionPermission"},
-            {1065, nullptr, "IsStereoVisionPermitted"},
-            {1201, nullptr, "UnlockRestrictionTemporarily"},
-            {1202, nullptr, "UnlockSystemSettingsRestriction"},
-            {1203, nullptr, "SetPinCode"},
-            {1204, nullptr, "GenerateInquiryCode"},
-            {1205, nullptr, "CheckMasterKey"},
-            {1206, nullptr, "GetPinCodeLength"},
-            {1207, nullptr, "GetPinCodeChangedEvent"},
-            {1208, nullptr, "GetPinCode"},
-            {1403, nullptr, "IsPairingActive"},
-            {1406, nullptr, "GetSettingsLastUpdated"},
-            {1411, nullptr, "GetPairingAccountInfo"},
-            {1421, nullptr, "GetAccountNickname"},
-            {1424, nullptr, "GetAccountState"},
-            {1432, nullptr, "GetSynchronizationEvent"},
-            {1451, nullptr, "StartPlayTimer"},
-            {1452, nullptr, "StopPlayTimer"},
-            {1453, nullptr, "IsPlayTimerEnabled"},
-            {1454, nullptr, "GetPlayTimerRemainingTime"},
-            {1455, nullptr, "IsRestrictedByPlayTimer"},
-            {1456, nullptr, "GetPlayTimerSettings"},
-            {1457, nullptr, "GetPlayTimerEventToRequestSuspension"},
-            {1458, nullptr, "IsPlayTimerAlarmDisabled"},
-            {1471, nullptr, "NotifyWrongPinCodeInputManyTimes"},
-            {1472, nullptr, "CancelNetworkRequest"},
-            {1473, nullptr, "GetUnlinkedEvent"},
-            {1474, nullptr, "ClearUnlinkedEvent"},
-            {1601, nullptr, "DisableAllFeatures"},
-            {1602, nullptr, "PostEnableAllFeatures"},
-            {1603, nullptr, "IsAllFeaturesDisabled"},
-            {1901, nullptr, "DeleteFromFreeCommunicationApplicationListForDebug"},
-            {1902, nullptr, "ClearFreeCommunicationApplicationListForDebug"},
-            {1903, nullptr, "GetExemptApplicationListCountForDebug"},
-            {1904, nullptr, "GetExemptApplicationListForDebug"},
-            {1905, nullptr, "UpdateExemptApplicationListForDebug"},
-            {1906, nullptr, "AddToExemptApplicationListForDebug"},
-            {1907, nullptr, "DeleteFromExemptApplicationListForDebug"},
-            {1908, nullptr, "ClearExemptApplicationListForDebug"},
-            {1941, nullptr, "DeletePairing"},
-            {1951, nullptr, "SetPlayTimerSettingsForDebug"},
-            {1952, nullptr, "GetPlayTimerSpentTimeForTest"},
-            {1953, nullptr, "SetPlayTimerAlarmDisabledForDebug"},
-            {2001, nullptr, "RequestPairingAsync"},
-            {2002, nullptr, "FinishRequestPairing"},
-            {2003, nullptr, "AuthorizePairingAsync"},
-            {2004, nullptr, "FinishAuthorizePairing"},
-            {2005, nullptr, "RetrievePairingInfoAsync"},
-            {2006, nullptr, "FinishRetrievePairingInfo"},
-            {2007, nullptr, "UnlinkPairingAsync"},
-            {2008, nullptr, "FinishUnlinkPairing"},
-            {2009, nullptr, "GetAccountMiiImageAsync"},
-            {2010, nullptr, "FinishGetAccountMiiImage"},
-            {2011, nullptr, "GetAccountMiiImageContentTypeAsync"},
-            {2012, nullptr, "FinishGetAccountMiiImageContentType"},
-            {2013, nullptr, "SynchronizeParentalControlSettingsAsync"},
-            {2014, nullptr, "FinishSynchronizeParentalControlSettings"},
-            {2015, nullptr, "FinishSynchronizeParentalControlSettingsWithLastUpdated"},
-            {2016, nullptr, "RequestUpdateExemptionListAsync"},
-        };
-        RegisterHandlers(functions);
-    }
+    IParentalControlService() : ServiceFramework("IParentalControlService") {}
 };
-void PCTL_A::CreateService(Kernel::HLERequestContext& ctx) {
+
+void PCTL_A::GetService(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IParentalControlService>();
@@ -119,8 +23,7 @@ void PCTL_A::CreateService(Kernel::HLERequestContext& ctx) {
 
 PCTL_A::PCTL_A() : ServiceFramework("pctl:a") {
     static const FunctionInfo functions[] = {
-        {0, &PCTL_A::CreateService, "CreateService"},
-        {1, nullptr, "CreateServiceWithoutInitialize"},
+        {0, &PCTL_A::GetService, "GetService"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/pctl/pctl_a.h

@@ -15,7 +15,7 @@ public:
     ~PCTL_A() = default;
 
 private:
-    void CreateService(Kernel::HLERequestContext& ctx);
+    void GetService(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace PCTL

src/core/hle/service/service.cpp

@@ -112,15 +112,15 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(Kernel::HLERequestContext
     auto cmd_buf = ctx.CommandBuffer();
     std::string function_name = info == nullptr ? fmt::format("{}", ctx.GetCommand()) : info->name;
 
-    fmt::memory_buffer buf;
-    fmt::format_to(buf, "function '{}': port='{}' cmd_buf={{[0]={:#x}", function_name, service_name,
-                   cmd_buf[0]);
+    fmt::MemoryWriter w;
+    w.write("function '{}': port='{}' cmd_buf={{[0]={:#x}", function_name, service_name,
+            cmd_buf[0]);
     for (int i = 1; i <= 8; ++i) {
-        fmt::format_to(buf, ", [{}]={:#x}", i, cmd_buf[i]);
+        w.write(", [{}]={:#x}", i, cmd_buf[i]);
     }
-    buf.push_back('}');
+    w << '}';
 
-    LOG_ERROR(Service, "unknown / unimplemented %s", fmt::to_string(buf).c_str());
+    LOG_ERROR(Service, "unknown / unimplemented %s", w.c_str());
     UNIMPLEMENTED();
 }
 

src/core/hle/service/ssl/ssl.cpp

@@ -2,106 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/ssl/ssl.h"
 
 namespace Service {
 namespace SSL {
 
-class ISslConnection final : public ServiceFramework<ISslConnection> {
-public:
-    ISslConnection() : ServiceFramework("ISslConnection") {
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "SetSocketDescriptor"},
-            {1, nullptr, "SetHostName"},
-            {2, nullptr, "SetVerifyOption"},
-            {3, nullptr, "SetIoMode"},
-            {4, nullptr, "GetSocketDescriptor"},
-            {5, nullptr, "GetHostName"},
-            {6, nullptr, "GetVerifyOption"},
-            {7, nullptr, "GetIoMode"},
-            {8, nullptr, "DoHandshake"},
-            {9, nullptr, "DoHandshakeGetServerCert"},
-            {10, nullptr, "Read"},
-            {11, nullptr, "Write"},
-            {12, nullptr, "Pending"},
-            {13, nullptr, "Peek"},
-            {14, nullptr, "Poll"},
-            {15, nullptr, "GetVerifyCertError"},
-            {16, nullptr, "GetNeededServerCertBufferSize"},
-            {17, nullptr, "SetSessionCacheMode"},
-            {18, nullptr, "GetSessionCacheMode"},
-            {19, nullptr, "FlushSessionCache"},
-            {20, nullptr, "SetRenegotiationMode"},
-            {21, nullptr, "GetRenegotiationMode"},
-            {22, nullptr, "SetOption"},
-            {23, nullptr, "GetOption"},
-            {24, nullptr, "GetVerifyCertErrors"},
-            {25, nullptr, "GetCipherInfo"},
-        };
-        RegisterHandlers(functions);
-    }
-};
-
-class ISslContext final : public ServiceFramework<ISslContext> {
-public:
-    ISslContext() : ServiceFramework("ISslContext") {
-        static const FunctionInfo functions[] = {
-            {0, &ISslContext::SetOption, "SetOption"},
-            {1, nullptr, "GetOption"},
-            {2, &ISslContext::CreateConnection, "CreateConnection"},
-            {3, nullptr, "GetConnectionCount"},
-            {4, nullptr, "ImportServerPki"},
-            {5, nullptr, "ImportClientPki"},
-            {6, nullptr, "RemoveServerPki"},
-            {7, nullptr, "RemoveClientPki"},
-            {8, nullptr, "RegisterInternalPki"},
-            {9, nullptr, "AddPolicyOid"},
-            {10, nullptr, "ImportCrl"},
-            {11, nullptr, "RemoveCrl"},
-        };
-        RegisterHandlers(functions);
-    }
-    ~ISslContext() = default;
-
-private:
-    void SetOption(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_SSL, "(STUBBED) called");
-        IPC::RequestParser rp{ctx};
-
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void CreateConnection(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_SSL, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ISslConnection>();
-    }
-};
-
-void SSL::CreateContext(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_SSL, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISslContext>();
-}
-
-SSL::SSL() : ServiceFramework("ssl") {
-    static const FunctionInfo functions[] = {
-        {0, &SSL::CreateContext, "CreateContext"},
-        {1, nullptr, "GetContextCount"},
-        {2, nullptr, "GetCertificates"},
-        {3, nullptr, "GetCertificateBufSize"},
-        {4, nullptr, "DebugIoctl"},
-        {5, nullptr, "SetInterfaceVersion"},
-        {6, nullptr, "FlushSessionCache"},
-    };
-    RegisterHandlers(functions);
-}
+SSL::SSL() : ServiceFramework("ssl") {}
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<SSL>()->InstallAsService(service_manager);

src/core/hle/service/ssl/ssl.h

@@ -13,9 +13,6 @@ class SSL final : public ServiceFramework<SSL> {
 public:
     explicit SSL();
     ~SSL() = default;
-
-private:
-    void CreateContext(Kernel::HLERequestContext& ctx);
 };
 
 /// Registers all SSL services with the specified service manager.

src/core/hle/service/vi/vi.cpp

@@ -17,7 +17,6 @@
 #include "core/hle/service/vi/vi_m.h"
 #include "core/hle/service/vi/vi_s.h"
 #include "core/hle/service/vi/vi_u.h"
-#include "core/settings.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
@@ -712,23 +711,6 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    void GetDisplayResolution(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-        IPC::RequestParser rp{ctx};
-        u64 display_id = rp.Pop<u64>();
-
-        IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
-        rb.Push(RESULT_SUCCESS);
-
-        if (Settings::values.use_docked_mode) {
-            rb.Push(static_cast<u32>(DisplayResolution::DockedWidth));
-            rb.Push(static_cast<u32>(DisplayResolution::DockedHeight));
-        } else {
-            rb.Push(static_cast<u32>(DisplayResolution::UndockedWidth));
-            rb.Push(static_cast<u32>(DisplayResolution::UndockedHeight));
-        }
-    }
-
     void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_VI, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
@@ -826,7 +808,6 @@ IApplicationDisplayService::IApplicationDisplayService(
         {1000, &IApplicationDisplayService::ListDisplays, "ListDisplays"},
         {1010, &IApplicationDisplayService::OpenDisplay, "OpenDisplay"},
         {1020, &IApplicationDisplayService::CloseDisplay, "CloseDisplay"},
-        {1102, &IApplicationDisplayService::GetDisplayResolution, "GetDisplayResolution"},
         {2101, &IApplicationDisplayService::SetLayerScalingMode, "SetLayerScalingMode"},
         {2020, &IApplicationDisplayService::OpenLayer, "OpenLayer"},
         {2030, &IApplicationDisplayService::CreateStrayLayer, "CreateStrayLayer"},

src/core/hle/service/vi/vi.h

@@ -14,13 +14,6 @@ struct EventType;
 namespace Service {
 namespace VI {
 
-enum class DisplayResolution : u32 {
-    DockedWidth = 1920,
-    DockedHeight = 1080,
-    UndockedWidth = 1280,
-    UndockedHeight = 720,
-};
-
 class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {

src/core/loader/deconstructed_rom_directory.cpp

@@ -76,7 +76,7 @@ FileType AppLoader_DeconstructedRomDirectory::IdentifyType(FileUtil::IOFile& fil
         } else if (Common::ToLower(virtual_name) == "sdk") {
             is_sdk_found = true;
         } else {
-            // Continue searching
+            // Contrinue searching
             return true;
         }
 
@@ -119,11 +119,6 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
     }
     metadata.Print();
 
-    const FileSys::ProgramAddressSpaceType arch_bits{metadata.GetAddressSpaceType()};
-    if (arch_bits == FileSys::ProgramAddressSpaceType::Is32Bit) {
-        return ResultStatus::ErrorUnsupportedArch;
-    }
-
     // Load NSO modules
     VAddr next_load_addr{Memory::PROCESS_IMAGE_VADDR};
     for (const auto& module : {"rtld", "main", "subsdk0", "subsdk1", "subsdk2", "subsdk3",

src/core/loader/elf.cpp

@@ -414,7 +414,7 @@ ResultStatus AppLoader_ELF::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
 
-    process->Run(codeset->entrypoint, 48, Memory::DEFAULT_STACK_SIZE);
+    process->Run(codeset->entrypoint, 48, Memory::STACK_SIZE);
 
     is_loaded = true;
     return ResultStatus::Success;

src/core/loader/loader.h

@@ -72,7 +72,6 @@ enum class ResultStatus {
     ErrorAlreadyLoaded,
     ErrorMemoryAllocationFailed,
     ErrorEncrypted,
-    ErrorUnsupportedArch,
 };
 
 /// Interface for loading an application

src/core/loader/nro.cpp

@@ -137,7 +137,7 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process->address_mappings = default_address_mappings;
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
-    process->Run(base_addr, 48, Memory::DEFAULT_STACK_SIZE);
+    process->Run(base_addr, 48, Memory::STACK_SIZE);
 
     is_loaded = true;
     return ResultStatus::Success;

src/core/loader/nso.cpp

@@ -165,7 +165,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process->address_mappings = default_address_mappings;
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
-    process->Run(Memory::PROCESS_IMAGE_VADDR, 48, Memory::DEFAULT_STACK_SIZE);
+    process->Run(Memory::PROCESS_IMAGE_VADDR, 48, Memory::STACK_SIZE);
 
     is_loaded = true;
     return ResultStatus::Success;

src/core/loader/xci.h

@@ -0,0 +1,40 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include "common/common_types.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/loader/linker.h"
+#include "core/loader/loader.h"
+
+namespace Loader {
+
+/// Loads an XCI file
+class AppLoader_XCI final : public AppLoader, Linker {
+public:
+    AppLoader_XCI(FileUtil::IOFile&& file, std::string filepath);
+
+    /**
+     * Returns the type of the file
+     * @param file FileUtil::IOFile open file
+     * @param filepath Path of the file that we are opening.
+     * @return FileType found, or FileType::Error if this loader doesn't know it
+     */
+    static FileType IdentifyType(FileUtil::IOFile& file, const std::string& filepath);
+
+    FileType GetFileType() override {
+        return IdentifyType(file, filepath);
+    }
+
+    ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
+
+private:
+    bool LoadXci(const std::string& path, VAddr load_base);
+
+    std::string filepath;
+};
+
+} // namespace Loader

src/core/memory.h

@@ -162,13 +162,12 @@ enum : VAddr {
     TLS_AREA_VADDR = NEW_LINEAR_HEAP_VADDR_END,
     TLS_ENTRY_SIZE = 0x200,
     TLS_AREA_SIZE = 0x10000000,
-    TLS_AREA_VADDR_END = TLS_AREA_VADDR + TLS_AREA_SIZE,
+    TLS_ADREA_VADDR_END = TLS_AREA_VADDR + TLS_AREA_SIZE,
 
     /// Application stack
-    STACK_AREA_VADDR = TLS_AREA_VADDR_END,
-    STACK_AREA_SIZE = 0x10000000,
-    STACK_AREA_VADDR_END = STACK_AREA_VADDR + STACK_AREA_SIZE,
-    DEFAULT_STACK_SIZE = 0x100000,
+    STACK_VADDR = TLS_ADREA_VADDR_END,
+    STACK_SIZE = 0x10000,
+    STACK_VADDR_END = STACK_VADDR + STACK_SIZE,
 
     /// Application heap
     /// Size is confirmed to be a static value on fw 3.0.0

src/core/telemetry_session.cpp

@@ -87,8 +87,8 @@ TelemetrySession::TelemetrySession() {
 #ifdef ENABLE_WEB_SERVICE
     if (Settings::values.enable_telemetry) {
         backend = std::make_unique<WebService::TelemetryJson>(
-            Settings::values.telemetry_endpoint_url, Settings::values.yuzu_username,
-            Settings::values.yuzu_token);
+            Settings::values.telemetry_endpoint_url, Settings::values.citra_username,
+            Settings::values.citra_token);
     } else {
         backend = std::make_unique<Telemetry::NullVisitor>();
     }

src/core/telemetry_session.h

@@ -50,8 +50,8 @@ u64 RegenerateTelemetryId();
 
 /**
  * Verifies the username and token.
- * @param username yuzu username to use for authentication.
- * @param token yuzu token to use for authentication.
+ * @param username Citra username to use for authentication.
+ * @param token Citra token to use for authentication.
  * @param func A function that gets exectued when the verification is finished
  * @returns Future with bool indicating whether the verification succeeded
  */

src/video_core/CMakeLists.txt

@@ -9,11 +9,8 @@ add_library(video_core STATIC
     engines/maxwell_3d.h
     engines/maxwell_compute.cpp
     engines/maxwell_compute.h
-    engines/shader_bytecode.h
     gpu.cpp
     gpu.h
-    macro_interpreter.cpp
-    macro_interpreter.h
     memory_manager.cpp
     memory_manager.h
     rasterizer_interface.h
@@ -28,8 +25,6 @@ add_library(video_core STATIC
     renderer_opengl/gl_shader_decompiler.h
     renderer_opengl/gl_shader_gen.cpp
     renderer_opengl/gl_shader_gen.h
-    renderer_opengl/gl_shader_manager.cpp
-    renderer_opengl/gl_shader_manager.h
     renderer_opengl/gl_shader_util.cpp
     renderer_opengl/gl_shader_util.h
     renderer_opengl/gl_state.cpp

src/video_core/engines/maxwell_3d.cpp

@@ -19,21 +19,35 @@ namespace Engines {
 /// First register id that is actually a Macro call.
 constexpr u32 MacroRegistersStart = 0xE00;
 
-Maxwell3D::Maxwell3D(MemoryManager& memory_manager)
-    : memory_manager(memory_manager), macro_interpreter(*this) {}
+const std::unordered_map<u32, Maxwell3D::MethodInfo> Maxwell3D::method_handlers = {
+    {0xE1A, {"BindTextureInfoBuffer", 1, &Maxwell3D::BindTextureInfoBuffer}},
+    {0xE24, {"SetShader", 5, &Maxwell3D::SetShader}},
+    {0xE2A, {"BindStorageBuffer", 1, &Maxwell3D::BindStorageBuffer}},
+};
+
+Maxwell3D::Maxwell3D(MemoryManager& memory_manager) : memory_manager(memory_manager) {}
 
 void Maxwell3D::SubmitMacroCode(u32 entry, std::vector<u32> code) {
     uploaded_macros[entry * 2 + MacroRegistersStart] = std::move(code);
 }
 
-void Maxwell3D::CallMacroMethod(u32 method, std::vector<u32> parameters) {
-    auto macro_code = uploaded_macros.find(method);
-    // The requested macro must have been uploaded already.
-    ASSERT_MSG(macro_code != uploaded_macros.end(), "Macro %08X was not uploaded", method);
+void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters) {
+    // TODO(Subv): Write an interpreter for the macros uploaded via registers 0x45 and 0x47
 
-    // Reset the current macro and execute it.
+    // The requested macro must have been uploaded already.
+    ASSERT_MSG(uploaded_macros.find(method) != uploaded_macros.end(), "Macro %08X was not uploaded",
+               method);
+
+    auto itr = method_handlers.find(method);
+    ASSERT_MSG(itr != method_handlers.end(), "Unhandled method call %08X", method);
+
+    ASSERT(itr->second.arguments == parameters.size());
+
+    (this->*itr->second.handler)(parameters);
+
+    // Reset the current macro and its parameters.
     executing_macro = 0;
-    macro_interpreter.Execute(macro_code->second, std::move(parameters));
+    macro_params.clear();
 }
 
 void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
@@ -63,7 +77,7 @@ void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
 
         // Call the macro when there are no more parameters in the command buffer
         if (remaining_params == 0) {
-            CallMacroMethod(executing_macro, std::move(macro_params));
+            CallMacroMethod(executing_macro, macro_params);
         }
         return;
     }
@@ -179,6 +193,84 @@ void Maxwell3D::DrawArrays() {
     VideoCore::g_renderer->Rasterizer()->AccelerateDrawBatch(false /*is_indexed*/);
 }
 
+void Maxwell3D::BindTextureInfoBuffer(const std::vector<u32>& parameters) {
+    /**
+     * Parameters description:
+     * [0] = Shader stage, usually 4 for FragmentShader
+     */
+
+    u32 stage = parameters[0];
+
+    // Perform the same operations as the real macro code.
+    GPUVAddr address = static_cast<GPUVAddr>(regs.tex_info_buffers.address[stage]) << 8;
+    u32 size = regs.tex_info_buffers.size[stage];
+
+    regs.const_buffer.cb_size = size;
+    regs.const_buffer.cb_address_high = address >> 32;
+    regs.const_buffer.cb_address_low = address & 0xFFFFFFFF;
+}
+
+void Maxwell3D::SetShader(const std::vector<u32>& parameters) {
+    /**
+     * Parameters description:
+     * [0] = Shader Program.
+     * [1] = Unknown, presumably the shader id.
+     * [2] = Offset to the start of the shader, after the 0x30 bytes header.
+     * [3] = Shader Stage.
+     * [4] = Const Buffer Address >> 8.
+     */
+    auto shader_program = static_cast<Regs::ShaderProgram>(parameters[0]);
+    // TODO(Subv): This address is probably an offset from the CODE_ADDRESS register.
+    GPUVAddr address = parameters[2];
+    auto shader_stage = static_cast<Regs::ShaderStage>(parameters[3]);
+    GPUVAddr cb_address = parameters[4] << 8;
+
+    auto& shader = state.shader_programs[static_cast<size_t>(shader_program)];
+    shader.program = shader_program;
+    shader.stage = shader_stage;
+    shader.address = address;
+
+    // Perform the same operations as the real macro code.
+    // TODO(Subv): Early exit if register 0xD1C + shader_program contains the same as params[1].
+    auto& shader_regs = regs.shader_config[static_cast<size_t>(shader_program)];
+    shader_regs.start_id = address;
+    // TODO(Subv): Write params[1] to register 0xD1C + shader_program.
+    // TODO(Subv): Write params[2] to register 0xD22 + shader_program.
+
+    // Note: This value is hardcoded in the macro's code.
+    static constexpr u32 DefaultCBSize = 0x10000;
+    regs.const_buffer.cb_size = DefaultCBSize;
+    regs.const_buffer.cb_address_high = cb_address >> 32;
+    regs.const_buffer.cb_address_low = cb_address & 0xFFFFFFFF;
+
+    // Write a hardcoded 0x11 to CB_BIND, this binds the current const buffer to buffer c1[] in the
+    // shader. It's likely that these are the constants for the shader.
+    regs.cb_bind[static_cast<size_t>(shader_stage)].valid.Assign(1);
+    regs.cb_bind[static_cast<size_t>(shader_stage)].index.Assign(1);
+
+    ProcessCBBind(shader_stage);
+}
+
+void Maxwell3D::BindStorageBuffer(const std::vector<u32>& parameters) {
+    /**
+     * Parameters description:
+     * [0] = Buffer offset >> 2
+     */
+
+    u32 buffer_offset = parameters[0] << 2;
+
+    // Perform the same operations as the real macro code.
+    // Note: This value is hardcoded in the macro's code.
+    static constexpr u32 DefaultCBSize = 0x5F00;
+    regs.const_buffer.cb_size = DefaultCBSize;
+
+    GPUVAddr address = regs.ssbo_info.BufferAddress();
+    regs.const_buffer.cb_address_high = address >> 32;
+    regs.const_buffer.cb_address_low = address & 0xFFFFFFFF;
+
+    regs.const_buffer.cb_pos = buffer_offset;
+}
+
 void Maxwell3D::ProcessCBBind(Regs::ShaderStage stage) {
     // Bind the buffer currently in CB_ADDRESS to the specified index in the desired shader stage.
     auto& shader = state.shader_stages[static_cast<size_t>(stage)];
@@ -231,8 +323,6 @@ Texture::TICEntry Maxwell3D::GetTICEntry(u32 tic_index) const {
 
     // TODO(Subv): Different data types for separate components are not supported
     ASSERT(r_type == g_type && r_type == b_type && r_type == a_type);
-    // TODO(Subv): Only UNORM formats are supported for now.
-    ASSERT(r_type == Texture::ComponentType::UNORM);
 
     return tic_entry;
 }
@@ -296,31 +386,5 @@ std::vector<Texture::FullTextureInfo> Maxwell3D::GetStageTextures(Regs::ShaderSt
     return textures;
 }
 
-u32 Maxwell3D::GetRegisterValue(u32 method) const {
-    ASSERT_MSG(method < Regs::NUM_REGS, "Invalid Maxwell3D register");
-    return regs.reg_array[method];
-}
-
-bool Maxwell3D::IsShaderStageEnabled(Regs::ShaderStage stage) const {
-    // The Vertex stage is always enabled.
-    if (stage == Regs::ShaderStage::Vertex)
-        return true;
-
-    switch (stage) {
-    case Regs::ShaderStage::TesselationControl:
-        return regs.shader_config[static_cast<size_t>(Regs::ShaderProgram::TesselationControl)]
-                   .enable != 0;
-    case Regs::ShaderStage::TesselationEval:
-        return regs.shader_config[static_cast<size_t>(Regs::ShaderProgram::TesselationEval)]
-                   .enable != 0;
-    case Regs::ShaderStage::Geometry:
-        return regs.shader_config[static_cast<size_t>(Regs::ShaderProgram::Geometry)].enable != 0;
-    case Regs::ShaderStage::Fragment:
-        return regs.shader_config[static_cast<size_t>(Regs::ShaderProgram::Fragment)].enable != 0;
-    }
-
-    UNREACHABLE();
-}
-
 } // namespace Engines
 } // namespace Tegra

src/video_core/engines/maxwell_3d.h

@@ -13,7 +13,6 @@
 #include "common/common_types.h"
 #include "common/math_util.h"
 #include "video_core/gpu.h"
-#include "video_core/macro_interpreter.h"
 #include "video_core/memory_manager.h"
 #include "video_core/textures/texture.h"
 
@@ -427,11 +426,14 @@ public:
                         BitField<0, 1, u32> enable;
                         BitField<4, 4, ShaderProgram> program;
                     };
-                    u32 offset;
-                    INSERT_PADDING_WORDS(14);
+                    u32 start_id;
+                    INSERT_PADDING_WORDS(1);
+                    u32 gpr_alloc;
+                    ShaderStage type;
+                    INSERT_PADDING_WORDS(9);
                 } shader_config[MaxShaderProgram];
 
-                INSERT_PADDING_WORDS(0x80);
+                INSERT_PADDING_WORDS(0x8C);
 
                 struct {
                     u32 cb_size;
@@ -496,18 +498,21 @@ public:
             bool enabled;
         };
 
+        struct ShaderProgramInfo {
+            Regs::ShaderStage stage;
+            Regs::ShaderProgram program;
+            GPUVAddr address;
+        };
+
         struct ShaderStageInfo {
             std::array<ConstBufferInfo, Regs::MaxConstBuffers> const_buffers;
         };
 
         std::array<ShaderStageInfo, Regs::MaxShaderStage> shader_stages;
+        std::array<ShaderProgramInfo, Regs::MaxShaderProgram> shader_programs;
     };
 
     State state{};
-    MemoryManager& memory_manager;
-
-    /// Reads a register value located at the input method address
-    u32 GetRegisterValue(u32 method) const;
 
     /// Write the value to the register identified by method.
     void WriteReg(u32 method, u32 value, u32 remaining_params);
@@ -518,10 +523,9 @@ public:
     /// Returns a list of enabled textures for the specified shader stage.
     std::vector<Texture::FullTextureInfo> GetStageTextures(Regs::ShaderStage stage) const;
 
-    /// Returns whether the specified shader stage is enabled or not.
-    bool IsShaderStageEnabled(Regs::ShaderStage stage) const;
-
 private:
+    MemoryManager& memory_manager;
+
     std::unordered_map<u32, std::vector<u32>> uploaded_macros;
 
     /// Macro method that is currently being executed / being fed parameters.
@@ -529,9 +533,6 @@ private:
     /// Parameters that have been submitted to the macro call so far.
     std::vector<u32> macro_params;
 
-    /// Interpreter for the macro codes uploaded to the GPU.
-    MacroInterpreter macro_interpreter;
-
     /// Retrieves information about a specific TIC entry from the TIC buffer.
     Texture::TICEntry GetTICEntry(u32 tic_index) const;
 
@@ -543,7 +544,7 @@ private:
      * @param method Method to call
      * @param parameters Arguments to the method call
      */
-    void CallMacroMethod(u32 method, std::vector<u32> parameters);
+    void CallMacroMethod(u32 method, const std::vector<u32>& parameters);
 
     /// Handles a write to the QUERY_GET register.
     void ProcessQueryGet();
@@ -556,6 +557,19 @@ private:
 
     /// Handles a write to the VERTEX_END_GL register, triggering a draw.
     void DrawArrays();
+
+    /// Method call handlers
+    void BindTextureInfoBuffer(const std::vector<u32>& parameters);
+    void SetShader(const std::vector<u32>& parameters);
+    void BindStorageBuffer(const std::vector<u32>& parameters);
+
+    struct MethodInfo {
+        const char* name;
+        u32 arguments;
+        void (Maxwell3D::*handler)(const std::vector<u32>& parameters);
+    };
+
+    static const std::unordered_map<u32, MethodInfo> method_handlers;
 };
 
 #define ASSERT_REG_POSITION(field_name, position)                                                  \

src/video_core/engines/shader_bytecode.h

@@ -1,327 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <map>
-#include <string>
-#include "common/bit_field.h"
-
-namespace Tegra {
-namespace Shader {
-
-struct Register {
-    Register() = default;
-
-    constexpr Register(u64 value) : value(value) {}
-
-    constexpr u64 GetIndex() const {
-        return value;
-    }
-
-    constexpr operator u64() const {
-        return value;
-    }
-
-    template <typename T>
-    constexpr u64 operator-(const T& oth) const {
-        return value - oth;
-    }
-
-    template <typename T>
-    constexpr u64 operator&(const T& oth) const {
-        return value & oth;
-    }
-
-    constexpr u64 operator&(const Register& oth) const {
-        return value & oth.value;
-    }
-
-    constexpr u64 operator~() const {
-        return ~value;
-    }
-
-private:
-    u64 value;
-};
-
-union Attribute {
-    Attribute() = default;
-
-    constexpr Attribute(u64 value) : value(value) {}
-
-    enum class Index : u64 {
-        Position = 7,
-        Attribute_0 = 8,
-    };
-
-    union {
-        BitField<22, 2, u64> element;
-        BitField<24, 6, Index> index;
-        BitField<47, 3, u64> size;
-    } fmt20;
-
-    union {
-        BitField<30, 2, u64> element;
-        BitField<32, 6, Index> index;
-    } fmt28;
-
-    BitField<39, 8, u64> reg;
-    u64 value;
-};
-
-union Uniform {
-    BitField<20, 14, u64> offset;
-    BitField<34, 5, u64> index;
-};
-
-union OpCode {
-    enum class Id : u64 {
-        TEXS = 0x6C,
-        IPA = 0xE0,
-        FFMA_IMM = 0x65,
-        FFMA_CR = 0x93,
-        FFMA_RC = 0xA3,
-        FFMA_RR = 0xB3,
-
-        FADD_C = 0x98B,
-        FMUL_C = 0x98D,
-        MUFU = 0xA10,
-        FADD_R = 0xB8B,
-        FMUL_R = 0xB8D,
-        LD_A = 0x1DFB,
-        ST_A = 0x1DFE,
-
-        FSETP_R = 0x5BB,
-        FSETP_C = 0x4BB,
-        EXIT = 0xE30,
-        KIL = 0xE33,
-
-        FMUL_IMM = 0x70D,
-        FMUL_IMM_x = 0x72D,
-        FADD_IMM = 0x70B,
-        FADD_IMM_x = 0x72B,
-    };
-
-    enum class Type {
-        Trivial,
-        Arithmetic,
-        Ffma,
-        Flow,
-        Memory,
-        Unknown,
-    };
-
-    struct Info {
-        Type type;
-        std::string name;
-    };
-
-    OpCode() = default;
-
-    constexpr OpCode(Id value) : value(static_cast<u64>(value)) {}
-
-    constexpr OpCode(u64 value) : value{value} {}
-
-    constexpr Id EffectiveOpCode() const {
-        switch (op1) {
-        case Id::TEXS:
-            return op1;
-        }
-
-        switch (op2) {
-        case Id::IPA:
-            return op2;
-        }
-
-        switch (op3) {
-        case Id::FFMA_IMM:
-        case Id::FFMA_CR:
-        case Id::FFMA_RC:
-        case Id::FFMA_RR:
-            return op3;
-        }
-
-        switch (op4) {
-        case Id::EXIT:
-        case Id::FSETP_R:
-        case Id::FSETP_C:
-        case Id::KIL:
-            return op4;
-        }
-
-        switch (op5) {
-        case Id::MUFU:
-        case Id::LD_A:
-        case Id::ST_A:
-        case Id::FADD_R:
-        case Id::FADD_C:
-        case Id::FMUL_R:
-        case Id::FMUL_C:
-            return op5;
-
-        case Id::FMUL_IMM:
-        case Id::FMUL_IMM_x:
-            return Id::FMUL_IMM;
-
-        case Id::FADD_IMM:
-        case Id::FADD_IMM_x:
-            return Id::FADD_IMM;
-        }
-
-        return static_cast<Id>(value);
-    }
-
-    static const Info& GetInfo(const OpCode& opcode) {
-        static const std::map<Id, Info> info_table{BuildInfoTable()};
-        const auto& search{info_table.find(opcode.EffectiveOpCode())};
-        if (search != info_table.end()) {
-            return search->second;
-        }
-
-        static const Info unknown{Type::Unknown, "UNK"};
-        return unknown;
-    }
-
-    constexpr operator Id() const {
-        return static_cast<Id>(value);
-    }
-
-    constexpr OpCode operator<<(size_t bits) const {
-        return value << bits;
-    }
-
-    constexpr OpCode operator>>(size_t bits) const {
-        return value >> bits;
-    }
-
-    template <typename T>
-    constexpr u64 operator-(const T& oth) const {
-        return value - oth;
-    }
-
-    constexpr u64 operator&(const OpCode& oth) const {
-        return value & oth.value;
-    }
-
-    constexpr u64 operator~() const {
-        return ~value;
-    }
-
-    static std::map<Id, Info> BuildInfoTable() {
-        std::map<Id, Info> info_table;
-        info_table[Id::TEXS] = {Type::Memory, "texs"};
-        info_table[Id::LD_A] = {Type::Memory, "ld_a"};
-        info_table[Id::ST_A] = {Type::Memory, "st_a"};
-        info_table[Id::MUFU] = {Type::Arithmetic, "mufu"};
-        info_table[Id::FFMA_IMM] = {Type::Ffma, "ffma_imm"};
-        info_table[Id::FFMA_CR] = {Type::Ffma, "ffma_cr"};
-        info_table[Id::FFMA_RC] = {Type::Ffma, "ffma_rc"};
-        info_table[Id::FFMA_RR] = {Type::Ffma, "ffma_rr"};
-        info_table[Id::FADD_R] = {Type::Arithmetic, "fadd_r"};
-        info_table[Id::FADD_C] = {Type::Arithmetic, "fadd_c"};
-        info_table[Id::FADD_IMM] = {Type::Arithmetic, "fadd_imm"};
-        info_table[Id::FMUL_R] = {Type::Arithmetic, "fmul_r"};
-        info_table[Id::FMUL_C] = {Type::Arithmetic, "fmul_c"};
-        info_table[Id::FMUL_IMM] = {Type::Arithmetic, "fmul_imm"};
-        info_table[Id::FSETP_C] = {Type::Arithmetic, "fsetp_c"};
-        info_table[Id::FSETP_R] = {Type::Arithmetic, "fsetp_r"};
-        info_table[Id::EXIT] = {Type::Trivial, "exit"};
-        info_table[Id::IPA] = {Type::Trivial, "ipa"};
-        info_table[Id::KIL] = {Type::Flow, "kil"};
-        return info_table;
-    }
-
-    BitField<57, 7, Id> op1;
-    BitField<56, 8, Id> op2;
-    BitField<55, 9, Id> op3;
-    BitField<52, 12, Id> op4;
-    BitField<51, 13, Id> op5;
-    u64 value;
-};
-static_assert(sizeof(OpCode) == 0x8, "Incorrect structure size");
-
-} // namespace Shader
-} // namespace Tegra
-
-namespace std {
-
-// TODO(bunne): The below is forbidden by the C++ standard, but works fine. See #330.
-template <>
-struct make_unsigned<Tegra::Shader::Attribute> {
-    using type = Tegra::Shader::Attribute;
-};
-
-template <>
-struct make_unsigned<Tegra::Shader::Register> {
-    using type = Tegra::Shader::Register;
-};
-
-template <>
-struct make_unsigned<Tegra::Shader::OpCode> {
-    using type = Tegra::Shader::OpCode;
-};
-
-} // namespace std
-
-namespace Tegra {
-namespace Shader {
-
-enum class Pred : u64 {
-    UnusedIndex = 0x7,
-    NeverExecute = 0xf,
-};
-
-enum class SubOp : u64 {
-    Cos = 0x0,
-    Sin = 0x1,
-    Ex2 = 0x2,
-    Lg2 = 0x3,
-    Rcp = 0x4,
-    Rsq = 0x5,
-};
-
-union Instruction {
-    Instruction& operator=(const Instruction& instr) {
-        hex = instr.hex;
-        return *this;
-    }
-
-    OpCode opcode;
-    BitField<0, 8, Register> gpr0;
-    BitField<8, 8, Register> gpr8;
-    BitField<16, 4, Pred> pred;
-    BitField<20, 8, Register> gpr20;
-    BitField<20, 7, SubOp> sub_op;
-    BitField<28, 8, Register> gpr28;
-    BitField<36, 13, u64> imm36;
-    BitField<39, 8, Register> gpr39;
-
-    union {
-        BitField<45, 1, u64> negate_b;
-        BitField<46, 1, u64> abs_a;
-        BitField<48, 1, u64> negate_a;
-        BitField<49, 1, u64> abs_b;
-        BitField<50, 1, u64> abs_d;
-    } alu;
-
-    union {
-        BitField<48, 1, u64> negate_b;
-        BitField<49, 1, u64> negate_c;
-    } ffma;
-
-    BitField<60, 1, u64> is_b_gpr;
-    BitField<59, 1, u64> is_c_gpr;
-
-    Attribute attribute;
-    Uniform uniform;
-
-    u64 hex;
-};
-static_assert(sizeof(Instruction) == 0x8, "Incorrect structure size");
-static_assert(std::is_standard_layout<Instruction>::value,
-              "Structure does not have standard layout");
-
-} // namespace Shader
-} // namespace Tegra

src/video_core/macro_interpreter.cpp

@@ -1,257 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/macro_interpreter.h"
-
-namespace Tegra {
-
-MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
-
-void MacroInterpreter::Execute(const std::vector<u32>& code, std::vector<u32> parameters) {
-    Reset();
-    registers[1] = parameters[0];
-    this->parameters = std::move(parameters);
-
-    // Execute the code until we hit an exit condition.
-    bool keep_executing = true;
-    while (keep_executing) {
-        keep_executing = Step(code, false);
-    }
-
-    // Assert the the macro used all the input parameters
-    ASSERT(next_parameter_index == this->parameters.size());
-}
-
-void MacroInterpreter::Reset() {
-    registers = {};
-    pc = 0;
-    delayed_pc = boost::none;
-    method_address.raw = 0;
-    parameters.clear();
-    // The next parameter index starts at 1, because $r1 already has the value of the first
-    // parameter.
-    next_parameter_index = 1;
-}
-
-bool MacroInterpreter::Step(const std::vector<u32>& code, bool is_delay_slot) {
-    u32 base_address = pc;
-
-    Opcode opcode = GetOpcode(code);
-    pc += 4;
-
-    // Update the program counter if we were delayed
-    if (delayed_pc != boost::none) {
-        ASSERT(is_delay_slot);
-        pc = *delayed_pc;
-        delayed_pc = boost::none;
-    }
-
-    switch (opcode.operation) {
-    case Operation::ALU: {
-        u32 result = GetALUResult(opcode.alu_operation, GetRegister(opcode.src_a),
-                                  GetRegister(opcode.src_b));
-        ProcessResult(opcode.result_operation, opcode.dst, result);
-        break;
-    }
-    case Operation::AddImmediate: {
-        ProcessResult(opcode.result_operation, opcode.dst,
-                      GetRegister(opcode.src_a) + opcode.immediate);
-        break;
-    }
-    case Operation::ExtractInsert: {
-        u32 dst = GetRegister(opcode.src_a);
-        u32 src = GetRegister(opcode.src_b);
-
-        src = (src >> opcode.bf_src_bit) & opcode.GetBitfieldMask();
-        dst &= ~(opcode.GetBitfieldMask() << opcode.bf_dst_bit);
-        dst |= src << opcode.bf_dst_bit;
-        ProcessResult(opcode.result_operation, opcode.dst, dst);
-        break;
-    }
-    case Operation::ExtractShiftLeftImmediate: {
-        u32 dst = GetRegister(opcode.src_a);
-        u32 src = GetRegister(opcode.src_b);
-
-        u32 result = ((src >> dst) & opcode.GetBitfieldMask()) << opcode.bf_dst_bit;
-
-        ProcessResult(opcode.result_operation, opcode.dst, result);
-        break;
-    }
-    case Operation::ExtractShiftLeftRegister: {
-        u32 dst = GetRegister(opcode.src_a);
-        u32 src = GetRegister(opcode.src_b);
-
-        u32 result = ((src >> opcode.bf_src_bit) & opcode.GetBitfieldMask()) << dst;
-
-        ProcessResult(opcode.result_operation, opcode.dst, result);
-        break;
-    }
-    case Operation::Read: {
-        u32 result = Read(GetRegister(opcode.src_a) + opcode.immediate);
-        ProcessResult(opcode.result_operation, opcode.dst, result);
-        break;
-    }
-    case Operation::Branch: {
-        ASSERT_MSG(!is_delay_slot, "Executing a branch in a delay slot is not valid");
-        u32 value = GetRegister(opcode.src_a);
-        bool taken = EvaluateBranchCondition(opcode.branch_condition, value);
-        if (taken) {
-            // Ignore the delay slot if the branch has the annul bit.
-            if (opcode.branch_annul) {
-                pc = base_address + (opcode.immediate << 2);
-                return true;
-            }
-
-            delayed_pc = base_address + (opcode.immediate << 2);
-            // Execute one more instruction due to the delay slot.
-            return Step(code, true);
-        }
-        break;
-    }
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented macro operation %u",
-                          static_cast<u32>(opcode.operation.Value()));
-    }
-
-    if (opcode.is_exit) {
-        // Exit has a delay slot, execute the next instruction
-        // Note: Executing an exit during a branch delay slot will cause the instruction at the
-        // branch target to be executed before exiting.
-        Step(code, true);
-        return false;
-    }
-
-    return true;
-}
-
-MacroInterpreter::Opcode MacroInterpreter::GetOpcode(const std::vector<u32>& code) const {
-    ASSERT((pc % sizeof(u32)) == 0);
-    ASSERT(pc < code.size() * sizeof(u32));
-    return {code[pc / sizeof(u32)]};
-}
-
-u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const {
-    switch (operation) {
-    case ALUOperation::Add:
-        return src_a + src_b;
-    // TODO(Subv): Implement AddWithCarry
-    case ALUOperation::Subtract:
-        return src_a - src_b;
-    // TODO(Subv): Implement SubtractWithBorrow
-    case ALUOperation::Xor:
-        return src_a ^ src_b;
-    case ALUOperation::Or:
-        return src_a | src_b;
-    case ALUOperation::And:
-        return src_a & src_b;
-    case ALUOperation::AndNot:
-        return src_a & ~src_b;
-    case ALUOperation::Nand:
-        return ~(src_a & src_b);
-
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented ALU operation %u", static_cast<u32>(operation));
-    }
-}
-
-void MacroInterpreter::ProcessResult(ResultOperation operation, u32 reg, u32 result) {
-    switch (operation) {
-    case ResultOperation::IgnoreAndFetch:
-        // Fetch parameter and ignore result.
-        SetRegister(reg, FetchParameter());
-        break;
-    case ResultOperation::Move:
-        // Move result.
-        SetRegister(reg, result);
-        break;
-    case ResultOperation::MoveAndSetMethod:
-        // Move result and use as Method Address.
-        SetRegister(reg, result);
-        SetMethodAddress(result);
-        break;
-    case ResultOperation::FetchAndSend:
-        // Fetch parameter and send result.
-        SetRegister(reg, FetchParameter());
-        Send(result);
-        break;
-    case ResultOperation::MoveAndSend:
-        // Move and send result.
-        SetRegister(reg, result);
-        Send(result);
-        break;
-    case ResultOperation::FetchAndSetMethod:
-        // Fetch parameter and use result as Method Address.
-        SetRegister(reg, FetchParameter());
-        SetMethodAddress(result);
-        break;
-    case ResultOperation::MoveAndSetMethodFetchAndSend:
-        // Move result and use as Method Address, then fetch and send parameter.
-        SetRegister(reg, result);
-        SetMethodAddress(result);
-        Send(FetchParameter());
-        break;
-    case ResultOperation::MoveAndSetMethodSend:
-        // Move result and use as Method Address, then send bits 12:17 of result.
-        SetRegister(reg, result);
-        SetMethodAddress(result);
-        Send((result >> 12) & 0b111111);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented result operation %u", static_cast<u32>(operation));
-    }
-}
-
-u32 MacroInterpreter::FetchParameter() {
-    ASSERT(next_parameter_index < parameters.size());
-    return parameters[next_parameter_index++];
-}
-
-u32 MacroInterpreter::GetRegister(u32 register_id) const {
-    // Register 0 is supposed to always return 0.
-    if (register_id == 0)
-        return 0;
-
-    ASSERT(register_id < registers.size());
-    return registers[register_id];
-}
-
-void MacroInterpreter::SetRegister(u32 register_id, u32 value) {
-    // Register 0 is supposed to always return 0. NOP is implemented as a store to the zero
-    // register.
-    if (register_id == 0)
-        return;
-
-    ASSERT(register_id < registers.size());
-    registers[register_id] = value;
-}
-
-void MacroInterpreter::SetMethodAddress(u32 address) {
-    method_address.raw = address;
-}
-
-void MacroInterpreter::Send(u32 value) {
-    maxwell3d.WriteReg(method_address.address, value, 0);
-    // Increment the method address by the method increment.
-    method_address.address.Assign(method_address.address.Value() +
-                                  method_address.increment.Value());
-}
-
-u32 MacroInterpreter::Read(u32 method) const {
-    return maxwell3d.GetRegisterValue(method);
-}
-
-bool MacroInterpreter::EvaluateBranchCondition(BranchCondition cond, u32 value) const {
-    switch (cond) {
-    case BranchCondition::Zero:
-        return value == 0;
-    case BranchCondition::NotZero:
-        return value != 0;
-    }
-    UNREACHABLE();
-}
-
-} // namespace Tegra

src/video_core/macro_interpreter.h

@@ -1,164 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <vector>
-#include <boost/optional.hpp>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-
-namespace Tegra {
-namespace Engines {
-class Maxwell3D;
-}
-
-class MacroInterpreter final {
-public:
-    explicit MacroInterpreter(Engines::Maxwell3D& maxwell3d);
-
-    /**
-     * Executes the macro code with the specified input parameters.
-     * @param code The macro byte code to execute
-     * @param parameters The parameters of the macro
-     */
-    void Execute(const std::vector<u32>& code, std::vector<u32> parameters);
-
-private:
-    enum class Operation : u32 {
-        ALU = 0,
-        AddImmediate = 1,
-        ExtractInsert = 2,
-        ExtractShiftLeftImmediate = 3,
-        ExtractShiftLeftRegister = 4,
-        Read = 5,
-        Unused = 6, // This operation doesn't seem to be a valid encoding.
-        Branch = 7,
-    };
-
-    enum class ALUOperation : u32 {
-        Add = 0,
-        AddWithCarry = 1,
-        Subtract = 2,
-        SubtractWithBorrow = 3,
-        // Operations 4-7 don't seem to be valid encodings.
-        Xor = 8,
-        Or = 9,
-        And = 10,
-        AndNot = 11,
-        Nand = 12
-    };
-
-    enum class ResultOperation : u32 {
-        IgnoreAndFetch = 0,
-        Move = 1,
-        MoveAndSetMethod = 2,
-        FetchAndSend = 3,
-        MoveAndSend = 4,
-        FetchAndSetMethod = 5,
-        MoveAndSetMethodFetchAndSend = 6,
-        MoveAndSetMethodSend = 7
-    };
-
-    enum class BranchCondition : u32 {
-        Zero = 0,
-        NotZero = 1,
-    };
-
-    union Opcode {
-        u32 raw;
-        BitField<0, 3, Operation> operation;
-        BitField<4, 3, ResultOperation> result_operation;
-        BitField<4, 1, BranchCondition> branch_condition;
-        BitField<5, 1, u32>
-            branch_annul; // If set on a branch, then the branch doesn't have a delay slot.
-        BitField<7, 1, u32> is_exit;
-        BitField<8, 3, u32> dst;
-        BitField<11, 3, u32> src_a;
-        BitField<14, 3, u32> src_b;
-        // The signed immediate overlaps the second source operand and the alu operation.
-        BitField<14, 18, s32> immediate;
-
-        BitField<17, 5, ALUOperation> alu_operation;
-
-        // Bitfield instructions data
-        BitField<17, 5, u32> bf_src_bit;
-        BitField<22, 5, u32> bf_size;
-        BitField<27, 5, u32> bf_dst_bit;
-
-        u32 GetBitfieldMask() const {
-            return (1 << bf_size) - 1;
-        }
-    };
-
-    union MethodAddress {
-        u32 raw;
-        BitField<0, 12, u32> address;
-        BitField<12, 6, u32> increment;
-    };
-
-    /// Resets the execution engine state, zeroing registers, etc.
-    void Reset();
-
-    /**
-     * Executes a single macro instruction located at the current program counter. Returns whether
-     * the interpreter should keep running.
-     * @param code The macro code to execute.
-     * @param is_delay_slot Whether the current step is being executed due to a delay slot in a
-     * previous instruction.
-     */
-    bool Step(const std::vector<u32>& code, bool is_delay_slot);
-
-    /// Calculates the result of an ALU operation. src_a OP src_b;
-    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const;
-
-    /// Performs the result operation on the input result and stores it in the specified register
-    /// (if necessary).
-    void ProcessResult(ResultOperation operation, u32 reg, u32 result);
-
-    /// Evaluates the branch condition and returns whether the branch should be taken or not.
-    bool EvaluateBranchCondition(BranchCondition cond, u32 value) const;
-
-    /// Reads an opcode at the current program counter location.
-    Opcode GetOpcode(const std::vector<u32>& code) const;
-
-    /// Returns the specified register's value. Register 0 is hardcoded to always return 0.
-    u32 GetRegister(u32 register_id) const;
-
-    /// Sets the register to the input value.
-    void SetRegister(u32 register_id, u32 value);
-
-    /// Sets the method address to use for the next Send instruction.
-    void SetMethodAddress(u32 address);
-
-    /// Calls a GPU Engine method with the input parameter.
-    void Send(u32 value);
-
-    /// Reads a GPU register located at the method address.
-    u32 Read(u32 method) const;
-
-    /// Returns the next parameter in the parameter queue.
-    u32 FetchParameter();
-
-    Engines::Maxwell3D& maxwell3d;
-
-    u32 pc; ///< Current program counter
-    boost::optional<u32>
-        delayed_pc; ///< Program counter to execute at after the delay slot is executed.
-
-    static constexpr size_t NumMacroRegisters = 8;
-
-    /// General purpose macro registers.
-    std::array<u32, NumMacroRegisters> registers = {};
-
-    /// Method address to use for the next Send instruction.
-    MethodAddress method_address = {};
-
-    /// Input parameters of the current macro.
-    std::vector<u32> parameters;
-    /// Index of the next parameter that will be fetched by the 'parm' instruction.
-    u32 next_parameter_index = 0;
-};
-} // namespace Tegra

src/video_core/rasterizer_interface.h

@@ -21,16 +21,16 @@ public:
     /// Notify rasterizer that the specified Maxwell register has been changed
     virtual void NotifyMaxwellRegisterChanged(u32 id) = 0;
 
-    /// Notify rasterizer that all caches should be flushed to Switch memory
+    /// Notify rasterizer that all caches should be flushed to 3DS memory
     virtual void FlushAll() = 0;
 
-    /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
+    /// Notify rasterizer that any caches of the specified region should be flushed to 3DS memory
     virtual void FlushRegion(VAddr addr, u64 size) = 0;
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
     virtual void InvalidateRegion(VAddr addr, u64 size) = 0;
 
-    /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
+    /// Notify rasterizer that any caches of the specified region should be flushed to 3DS memory
     /// and invalidated
     virtual void FlushAndInvalidateRegion(VAddr addr, u64 size) = 0;
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -34,26 +34,38 @@ MICROPROFILE_DEFINE(OpenGL_Drawing, "OpenGL", "Drawing", MP_RGB(128, 128, 192));
 MICROPROFILE_DEFINE(OpenGL_Blits, "OpenGL", "Blits", MP_RGB(100, 100, 255));
 MICROPROFILE_DEFINE(OpenGL_CacheManagement, "OpenGL", "Cache Mgmt", MP_RGB(100, 255, 100));
 
+enum class UniformBindings : GLuint { Common, VS, FS };
+
+static void SetShaderUniformBlockBinding(GLuint shader, const char* name, UniformBindings binding,
+                                         size_t expected_size) {
+    GLuint ub_index = glGetUniformBlockIndex(shader, name);
+    if (ub_index != GL_INVALID_INDEX) {
+        GLint ub_size = 0;
+        glGetActiveUniformBlockiv(shader, ub_index, GL_UNIFORM_BLOCK_DATA_SIZE, &ub_size);
+        ASSERT_MSG(ub_size == expected_size,
+                   "Uniform block size did not match! Got %d, expected %zu",
+                   static_cast<int>(ub_size), expected_size);
+        glUniformBlockBinding(shader, ub_index, static_cast<GLuint>(binding));
+    }
+}
+
+static void SetShaderUniformBlockBindings(GLuint shader) {
+    SetShaderUniformBlockBinding(shader, "shader_data", UniformBindings::Common,
+                                 sizeof(RasterizerOpenGL::UniformData));
+    SetShaderUniformBlockBinding(shader, "vs_config", UniformBindings::VS,
+                                 sizeof(RasterizerOpenGL::VSUniformData));
+    SetShaderUniformBlockBinding(shader, "fs_config", UniformBindings::FS,
+                                 sizeof(RasterizerOpenGL::FSUniformData));
+}
+
 RasterizerOpenGL::RasterizerOpenGL() {
+    shader_dirty = true;
+
     has_ARB_buffer_storage = false;
     has_ARB_direct_state_access = false;
     has_ARB_separate_shader_objects = false;
     has_ARB_vertex_attrib_binding = false;
 
-    // Create sampler objects
-    for (size_t i = 0; i < texture_samplers.size(); ++i) {
-        texture_samplers[i].Create();
-        state.texture_units[i].sampler = texture_samplers[i].sampler.handle;
-    }
-
-    // Create SSBOs
-    for (size_t stage = 0; stage < ssbos.size(); ++stage) {
-        for (size_t buffer = 0; buffer < ssbos[stage].size(); ++buffer) {
-            ssbos[stage][buffer].Create();
-            state.draw.const_buffers[stage][buffer].ssbo = ssbos[stage][buffer].handle;
-        }
-    }
-
     GLint ext_num;
     glGetIntegerv(GL_NUM_EXTENSIONS, &ext_num);
     for (GLint i = 0; i < ext_num; i++) {
@@ -70,8 +82,6 @@ RasterizerOpenGL::RasterizerOpenGL() {
         }
     }
 
-    ASSERT_MSG(has_ARB_separate_shader_objects, "has_ARB_separate_shader_objects is unsupported");
-
     // Clipping plane 0 is always enabled for PICA fixed clip plane z <= 0
     state.clip_distance[0] = true;
 
@@ -86,31 +96,36 @@ RasterizerOpenGL::RasterizerOpenGL() {
     state.draw.uniform_buffer = uniform_buffer.handle;
     state.Apply();
 
+    glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformData), nullptr, GL_STATIC_DRAW);
+    glBindBufferBase(GL_UNIFORM_BUFFER, 0, uniform_buffer.handle);
+
+    uniform_block_data.dirty = true;
+
     // Create render framebuffer
     framebuffer.Create();
 
-    hw_vao.Create();
-    hw_vao_enabled_attributes.fill(false);
+    if (has_ARB_separate_shader_objects) {
+        hw_vao.Create();
+        hw_vao_enabled_attributes.fill(false);
 
-    stream_buffer = OGLStreamBuffer::MakeBuffer(has_ARB_buffer_storage, GL_ARRAY_BUFFER);
-    stream_buffer->Create(STREAM_BUFFER_SIZE, STREAM_BUFFER_SIZE / 2);
-    state.draw.vertex_buffer = stream_buffer->GetHandle();
+        stream_buffer = OGLStreamBuffer::MakeBuffer(has_ARB_buffer_storage, GL_ARRAY_BUFFER);
+        stream_buffer->Create(STREAM_BUFFER_SIZE, STREAM_BUFFER_SIZE / 2);
+        state.draw.vertex_buffer = stream_buffer->GetHandle();
 
-    shader_program_manager = std::make_unique<GLShader::ProgramManager>();
+        pipeline.Create();
+        state.draw.program_pipeline = pipeline.handle;
+        state.draw.shader_program = 0;
+        state.draw.vertex_array = hw_vao.handle;
+        state.Apply();
 
-    state.draw.shader_program = 0;
-    state.draw.vertex_array = hw_vao.handle;
-    state.Apply();
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, stream_buffer->GetHandle());
 
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, stream_buffer->GetHandle());
-
-    for (unsigned index = 0; index < uniform_buffers.size(); ++index) {
-        auto& buffer = uniform_buffers[index];
-        buffer.Create();
-        glBindBuffer(GL_UNIFORM_BUFFER, buffer.handle);
-        glBufferData(GL_UNIFORM_BUFFER, sizeof(GLShader::MaxwellUniformData), nullptr,
-                     GL_STREAM_COPY);
-        glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer.handle);
+        vs_uniform_buffer.Create();
+        glBindBuffer(GL_UNIFORM_BUFFER, vs_uniform_buffer.handle);
+        glBufferData(GL_UNIFORM_BUFFER, sizeof(VSUniformData), nullptr, GL_STREAM_COPY);
+        glBindBufferBase(GL_UNIFORM_BUFFER, 1, vs_uniform_buffer.handle);
+    } else {
+        UNREACHABLE();
     }
 
     accelerate_draw = AccelDraw::Disabled;
@@ -179,74 +194,26 @@ void RasterizerOpenGL::SetupVertexArray(u8* array_ptr, GLintptr buffer_offset) {
     buffer_offset += data_size;
 }
 
-void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset, size_t ptr_pos) {
-    // Helper function for uploading uniform data
-    const auto copy_buffer = [&](GLuint handle, GLintptr offset, GLsizeiptr size) {
-        if (has_ARB_direct_state_access) {
-            glCopyNamedBufferSubData(stream_buffer->GetHandle(), handle, offset, 0, size);
-        } else {
-            glBindBuffer(GL_COPY_WRITE_BUFFER, handle);
-            glCopyBufferSubData(GL_ARRAY_BUFFER, GL_COPY_WRITE_BUFFER, offset, 0, size);
-        }
-    };
+void RasterizerOpenGL::SetupVertexShader(VSUniformData* ub_ptr, GLintptr buffer_offset) {
+    MICROPROFILE_SCOPE(OpenGL_VS);
+    LOG_CRITICAL(Render_OpenGL, "Emulated shaders are not supported! Using a passthrough shader.");
+    glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, current_shader->shader.handle);
+}
 
-    auto& gpu = Core::System().GetInstance().GPU().Maxwell3D();
-    ASSERT_MSG(!gpu.regs.shader_config[0].enable, "VertexA is unsupported!");
-
-    for (unsigned index = 1; index < Maxwell::MaxShaderProgram; ++index) {
-        ptr_pos += sizeof(GLShader::MaxwellUniformData);
-
-        auto& shader_config = gpu.regs.shader_config[index];
-        const Maxwell::ShaderProgram program{static_cast<Maxwell::ShaderProgram>(index)};
-
-        const auto& stage = index - 1; // Stage indices are 0 - 5
-
-        const bool is_enabled = gpu.IsShaderStageEnabled(static_cast<Maxwell::ShaderStage>(stage));
-
-        // Skip stages that are not enabled
-        if (!is_enabled) {
-            continue;
-        }
-
-        // Upload uniform data as one UBO per stage
-        const GLintptr ubo_offset = buffer_offset + static_cast<GLintptr>(ptr_pos);
-        copy_buffer(uniform_buffers[stage].handle, ubo_offset,
-                    sizeof(GLShader::MaxwellUniformData));
-        GLShader::MaxwellUniformData* ub_ptr =
-            reinterpret_cast<GLShader::MaxwellUniformData*>(&buffer_ptr[ptr_pos]);
-        ub_ptr->SetFromRegs(gpu.state.shader_stages[stage]);
-
-        // Fetch program code from memory
-        GLShader::ProgramCode program_code;
-        const u64 gpu_address{gpu.regs.code_address.CodeAddress() + shader_config.offset};
-        const VAddr cpu_address{gpu.memory_manager.PhysicalToVirtualAddress(gpu_address)};
-        Memory::ReadBlock(cpu_address, program_code.data(), program_code.size() * sizeof(u64));
-        GLShader::ShaderSetup setup{std::move(program_code)};
-
-        switch (program) {
-        case Maxwell::ShaderProgram::VertexB: {
-            GLShader::MaxwellVSConfig vs_config{setup};
-            shader_program_manager->UseProgrammableVertexShader(vs_config, setup);
-            break;
-        }
-        case Maxwell::ShaderProgram::Fragment: {
-            GLShader::MaxwellFSConfig fs_config{setup};
-            shader_program_manager->UseProgrammableFragmentShader(fs_config, setup);
-            break;
-        }
-        default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented shader index=%d, enable=%d, offset=0x%08X", index,
-                         shader_config.enable.Value(), shader_config.offset);
-            UNREACHABLE();
-        }
-    }
-
-    shader_program_manager->UseTrivialGeometryShader();
+void RasterizerOpenGL::SetupFragmentShader(FSUniformData* ub_ptr, GLintptr buffer_offset) {
+    MICROPROFILE_SCOPE(OpenGL_FS);
+    UNREACHABLE();
 }
 
 bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
+    if (!has_ARB_separate_shader_objects) {
+        UNREACHABLE();
+        return false;
+    }
+
     accelerate_draw = is_indexed ? AccelDraw::Indexed : AccelDraw::Arrays;
     DrawArrays();
+
     return true;
 }
 
@@ -303,11 +270,19 @@ void RasterizerOpenGL::DrawArrays() {
 
     // TODO(bunnei): Sync framebuffer_scale uniform here
     // TODO(bunnei): Sync scissorbox uniform(s) here
+    // TODO(bunnei): Sync and bind the texture surfaces
 
-    // Sync and bind the texture surfaces
-    BindTextures();
-    // Configure the constant buffer objects
-    SetupConstBuffers();
+    // Sync and bind the shader
+    if (shader_dirty) {
+        SetShader();
+        shader_dirty = false;
+    }
+
+    // Sync the uniform data
+    if (uniform_block_data.dirty) {
+        glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(UniformData), &uniform_block_data.data);
+        uniform_block_data.dirty = false;
+    }
 
     // Viewport can have negative offsets or larger dimensions than our framebuffer sub-rect. Enable
     // scissor test to prevent drawing outside of the framebuffer region
@@ -328,9 +303,7 @@ void RasterizerOpenGL::DrawArrays() {
     if (is_indexed) {
         UNREACHABLE();
     }
-
-    // Uniform space for the 5 shader stages
-    buffer_size += sizeof(GLShader::MaxwellUniformData) * Maxwell::MaxShaderStage;
+    buffer_size += sizeof(VSUniformData);
 
     size_t ptr_pos = 0;
     u8* buffer_ptr;
@@ -346,12 +319,25 @@ void RasterizerOpenGL::DrawArrays() {
         UNREACHABLE();
     }
 
-    SetupShaders(buffer_ptr, buffer_offset, ptr_pos);
+    SetupVertexShader(reinterpret_cast<VSUniformData*>(&buffer_ptr[ptr_pos]),
+                      buffer_offset + static_cast<GLintptr>(ptr_pos));
+    const GLintptr vs_ubo_offset = buffer_offset + static_cast<GLintptr>(ptr_pos);
+    ptr_pos += sizeof(VSUniformData);
 
     stream_buffer->Unmap();
 
-    shader_program_manager->ApplyTo(state);
-    state.Apply();
+    const auto copy_buffer = [&](GLuint handle, GLintptr offset, GLsizeiptr size) {
+        if (has_ARB_direct_state_access) {
+            glCopyNamedBufferSubData(stream_buffer->GetHandle(), handle, offset, 0, size);
+        } else {
+            glBindBuffer(GL_COPY_WRITE_BUFFER, handle);
+            glCopyBufferSubData(GL_ARRAY_BUFFER, GL_COPY_WRITE_BUFFER, offset, 0, size);
+        }
+    };
+
+    copy_buffer(vs_uniform_buffer.handle, vs_ubo_offset, sizeof(VSUniformData));
+
+    glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, current_shader->shader.handle);
 
     if (is_indexed) {
         UNREACHABLE();
@@ -388,39 +374,6 @@ void RasterizerOpenGL::DrawArrays() {
     }
 }
 
-void RasterizerOpenGL::BindTextures() {
-    using Regs = Tegra::Engines::Maxwell3D::Regs;
-    auto& maxwell3d = Core::System::GetInstance().GPU().Get3DEngine();
-
-    // Each Maxwell shader stage can have an arbitrary number of textures, but we're limited to a
-    // certain number in OpenGL. We try to only use the minimum amount of host textures by not
-    // keeping a 1:1 relation between guest texture ids and host texture ids, ie, guest texture id 8
-    // can be host texture id 0 if it's the only texture used in the guest shader program.
-    u32 host_texture_index = 0;
-    for (u32 stage = 0; stage < Regs::MaxShaderStage; ++stage) {
-        ASSERT(host_texture_index < texture_samplers.size());
-        const auto textures = maxwell3d.GetStageTextures(static_cast<Regs::ShaderStage>(stage));
-        for (unsigned texture_index = 0; texture_index < textures.size(); ++texture_index) {
-            const auto& texture = textures[texture_index];
-
-            if (texture.enabled) {
-                texture_samplers[host_texture_index].SyncWithConfig(texture.tsc);
-                Surface surface = res_cache.GetTextureSurface(texture);
-                if (surface != nullptr) {
-                    state.texture_units[host_texture_index].texture_2d = surface->texture.handle;
-                } else {
-                    // Can occur when texture addr is null or its memory is unmapped/invalid
-                    state.texture_units[texture_index].texture_2d = 0;
-                }
-
-                ++host_texture_index;
-            } else {
-                state.texture_units[texture_index].texture_2d = 0;
-            }
-        }
-    }
-}
-
 void RasterizerOpenGL::NotifyMaxwellRegisterChanged(u32 id) {}
 
 void RasterizerOpenGL::FlushAll() {
@@ -499,77 +452,61 @@ bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& framebu
     return true;
 }
 
-void RasterizerOpenGL::SamplerInfo::Create() {
-    sampler.Create();
-    mag_filter = min_filter = Tegra::Texture::TextureFilter::Linear;
-    wrap_u = wrap_v = Tegra::Texture::WrapMode::Wrap;
-    border_color_r = border_color_g = border_color_b = border_color_a = 0;
+void RasterizerOpenGL::SetShader() {
+    // TODO(bunnei): The below sets up a static test shader for passing untransformed vertices to
+    // OpenGL for rendering. This should be removed/replaced when we start emulating Maxwell
+    // shaders.
 
-    // default is GL_LINEAR_MIPMAP_LINEAR
-    glSamplerParameteri(sampler.handle, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    // Other attributes have correct defaults
+    static constexpr char vertex_shader[] = R"(
+#version 150 core
+
+in vec2 vert_position;
+in vec2 vert_tex_coord;
+out vec2 frag_tex_coord;
+
+void main() {
+    // Multiply input position by the rotscale part of the matrix and then manually translate by
+    // the last column. This is equivalent to using a full 3x3 matrix and expanding the vector
+    // to `vec3(vert_position.xy, 1.0)`
+    gl_Position = vec4(mat2(mat3x2(0.0015625f, 0.0, 0.0, -0.0027778, -1.0, 1.0)) * vert_position + mat3x2(0.0015625f, 0.0, 0.0, -0.0027778, -1.0, 1.0)[2], 0.0, 1.0);
+    frag_tex_coord = vert_tex_coord;
 }
+)";
 
-void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntry& config) {
-    GLuint s = sampler.handle;
+    static constexpr char fragment_shader[] = R"(
+#version 150 core
 
-    if (mag_filter != config.mag_filter) {
-        mag_filter = config.mag_filter;
-        glSamplerParameteri(s, GL_TEXTURE_MAG_FILTER, MaxwellToGL::TextureFilterMode(mag_filter));
-    }
-    if (min_filter != config.min_filter) {
-        min_filter = config.min_filter;
-        glSamplerParameteri(s, GL_TEXTURE_MIN_FILTER, MaxwellToGL::TextureFilterMode(min_filter));
-    }
+in vec2 frag_tex_coord;
+out vec4 color;
 
-    if (wrap_u != config.wrap_u) {
-        wrap_u = config.wrap_u;
-        glSamplerParameteri(s, GL_TEXTURE_WRAP_S, MaxwellToGL::WrapMode(wrap_u));
-    }
-    if (wrap_v != config.wrap_v) {
-        wrap_v = config.wrap_v;
-        glSamplerParameteri(s, GL_TEXTURE_WRAP_T, MaxwellToGL::WrapMode(wrap_v));
-    }
+uniform sampler2D color_texture;
 
-    if (wrap_u == Tegra::Texture::WrapMode::Border || wrap_v == Tegra::Texture::WrapMode::Border) {
-        // TODO(Subv): Implement border color
-        ASSERT(false);
-    }
+void main() {
+    color = vec4(1.0, 0.0, 1.0, 0.0);
 }
+)";
 
-void RasterizerOpenGL::SetupConstBuffers() {
-    using Regs = Tegra::Engines::Maxwell3D::Regs;
-    auto& gpu = Core::System::GetInstance().GPU();
-    auto& maxwell3d = gpu.Get3DEngine();
-
-    // Upload only the enabled buffers from the 16 constbuffers of each shader stage
-    u32 current_bindpoint = 0;
-    for (u32 stage = 0; stage < Regs::MaxShaderStage; ++stage) {
-        auto& shader_stage = maxwell3d.state.shader_stages[stage];
-        bool stage_enabled = maxwell3d.IsShaderStageEnabled(static_cast<Regs::ShaderStage>(stage));
-
-        for (u32 buffer_id = 0; buffer_id < Regs::MaxConstBuffers; ++buffer_id) {
-            const auto& buffer = shader_stage.const_buffers[buffer_id];
-
-            state.draw.const_buffers[stage][buffer_id].enabled = buffer.enabled && stage_enabled;
-
-            if (buffer.enabled && stage_enabled) {
-                state.draw.const_buffers[stage][buffer_id].bindpoint = current_bindpoint;
-                current_bindpoint++;
-
-                VAddr addr = gpu.memory_manager->PhysicalToVirtualAddress(buffer.address);
-                const u8* data = Memory::GetPointer(addr);
-                glBindBuffer(GL_SHADER_STORAGE_BUFFER,
-                             state.draw.const_buffers[stage][buffer_id].ssbo);
-                glBufferData(GL_SHADER_STORAGE_BUFFER, buffer.size, data, GL_DYNAMIC_DRAW);
-                glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
-            } else {
-                state.draw.const_buffers[stage][buffer_id].bindpoint = -1;
-            }
-        }
+    if (current_shader) {
+        return;
     }
 
+    LOG_CRITICAL(Render_OpenGL, "Emulated shaders are not supported! Using a passthrough shader.");
+
+    current_shader = &test_shader;
+    if (has_ARB_separate_shader_objects) {
+        test_shader.shader.Create(vertex_shader, nullptr, fragment_shader, {}, true);
+        glActiveShaderProgram(pipeline.handle, test_shader.shader.handle);
+    } else {
+        UNREACHABLE();
+    }
+
+    state.draw.shader_program = test_shader.shader.handle;
     state.Apply();
+
+    if (has_ARB_separate_shader_objects) {
+        state.draw.shader_program = 0;
+        state.Apply();
+    }
 }
 
 void RasterizerOpenGL::BindFramebufferSurfaces(const Surface& color_surface,

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -15,12 +15,10 @@
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "common/vector_math.h"
-#include "video_core/engines/maxwell_3d.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
-#include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_state.h"
 #include "video_core/renderer_opengl/gl_stream_buffer.h"
 
@@ -47,7 +45,7 @@ public:
     /// OpenGL shader generated for a given Maxwell register state
     struct MaxwellShader {
         /// OpenGL shader resource
-        OGLProgram shader;
+        OGLShader shader;
     };
 
     struct VertexShader {
@@ -58,38 +56,41 @@ public:
         OGLShader shader;
     };
 
+    /// Uniform structure for the Uniform Buffer Object, all vectors must be 16-byte aligned
+    // NOTE: Always keep a vec4 at the end. The GL spec is not clear wether the alignment at
+    //       the end of a uniform block is included in UNIFORM_BLOCK_DATA_SIZE or not.
+    //       Not following that rule will cause problems on some AMD drivers.
+    struct UniformData {};
+
+    // static_assert(
+    //    sizeof(UniformData) == 0x460,
+    //    "The size of the UniformData structure has changed, update the structure in the shader");
+    static_assert(sizeof(UniformData) < 16384,
+                  "UniformData structure must be less than 16kb as per the OpenGL spec");
+
+    struct VSUniformData {};
+    // static_assert(
+    //    sizeof(VSUniformData) == 1856,
+    //    "The size of the VSUniformData structure has changed, update the structure in the
+    //    shader");
+    static_assert(sizeof(VSUniformData) < 16384,
+                  "VSUniformData structure must be less than 16kb as per the OpenGL spec");
+
+    struct FSUniformData {};
+    // static_assert(
+    //    sizeof(FSUniformData) == 1856,
+    //    "The size of the FSUniformData structure has changed, update the structure in the
+    //    shader");
+    static_assert(sizeof(FSUniformData) < 16384,
+                  "FSUniformData structure must be less than 16kb as per the OpenGL spec");
+
 private:
-    class SamplerInfo {
-    public:
-        OGLSampler sampler;
-
-        /// Creates the sampler object, initializing its state so that it's in sync with the
-        /// SamplerInfo struct.
-        void Create();
-        /// Syncs the sampler object with the config, updating any necessary state.
-        void SyncWithConfig(const Tegra::Texture::TSCEntry& config);
-
-    private:
-        Tegra::Texture::TextureFilter mag_filter;
-        Tegra::Texture::TextureFilter min_filter;
-        Tegra::Texture::WrapMode wrap_u;
-        Tegra::Texture::WrapMode wrap_v;
-        u32 border_color_r;
-        u32 border_color_g;
-        u32 border_color_b;
-        u32 border_color_a;
-    };
+    struct SamplerInfo {};
 
     /// Binds the framebuffer color and depth surface
     void BindFramebufferSurfaces(const Surface& color_surface, const Surface& depth_surface,
                                  bool has_stencil);
 
-    /// Binds the required textures to OpenGL before drawing a batch.
-    void BindTextures();
-
-    /// Configures the current constbuffers to use for the draw command.
-    void SetupConstBuffers();
-
     /// Syncs the viewport to match the guest state
     void SyncViewport(const MathUtil::Rectangle<u32>& surfaces_rect, u16 res_scale);
 
@@ -99,6 +100,9 @@ private:
     /// Syncs the clip coefficients to match the guest state
     void SyncClipCoef();
 
+    /// Sets the OpenGL shader in accordance with the current guest state
+    void SetShader();
+
     /// Syncs the cull mode to match the guest state
     void SyncCullMode();
 
@@ -126,16 +130,23 @@ private:
 
     RasterizerCacheOpenGL res_cache;
 
-    std::unique_ptr<GLShader::ProgramManager> shader_program_manager;
+    /// Shader used for test renderering - to be removed once we have emulated shaders
+    MaxwellShader test_shader{};
+
+    const MaxwellShader* current_shader{};
+    bool shader_dirty{};
+
+    struct {
+        UniformData data;
+        bool dirty;
+    } uniform_block_data = {};
+
+    OGLPipeline pipeline;
     OGLVertexArray sw_vao;
     OGLVertexArray hw_vao;
     std::array<bool, 16> hw_vao_enabled_attributes;
 
-    std::array<SamplerInfo, GLShader::NumTextureSamplers> texture_samplers;
-    std::array<std::array<OGLBuffer, Tegra::Engines::Maxwell3D::Regs::MaxConstBuffers>,
-               Tegra::Engines::Maxwell3D::Regs::MaxShaderStage>
-        ssbos;
-
+    std::array<SamplerInfo, 32> texture_samplers;
     static constexpr size_t VERTEX_BUFFER_SIZE = 128 * 1024 * 1024;
     std::unique_ptr<OGLStreamBuffer> vertex_buffer;
     OGLBuffer uniform_buffer;
@@ -149,9 +160,19 @@ private:
     void AnalyzeVertexArray(bool is_indexed);
     void SetupVertexArray(u8* array_ptr, GLintptr buffer_offset);
 
-    std::array<OGLBuffer, Tegra::Engines::Maxwell3D::Regs::MaxShaderStage> uniform_buffers;
+    OGLBuffer vs_uniform_buffer;
+    std::unordered_map<GLShader::MaxwellVSConfig, VertexShader*> vs_shader_map;
+    std::unordered_map<std::string, VertexShader> vs_shader_cache;
+    OGLShader vs_default_shader;
 
-    void SetupShaders(u8* buffer_ptr, GLintptr buffer_offset, size_t ptr_pos);
+    void SetupVertexShader(VSUniformData* ub_ptr, GLintptr buffer_offset);
+
+    OGLBuffer fs_uniform_buffer;
+    std::unordered_map<GLShader::MaxwellFSConfig, FragmentShader*> fs_shader_map;
+    std::unordered_map<std::string, FragmentShader> fs_shader_cache;
+    OGLShader fs_default_shader;
+
+    void SetupFragmentShader(FSUniformData* ub_ptr, GLintptr buffer_offset);
 
     enum class AccelDraw { Disabled, Arrays, Indexed };
     AccelDraw accelerate_draw;

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -30,7 +30,6 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_state.h"
-#include "video_core/textures/decoders.h"
 #include "video_core/utils.h"
 #include "video_core/video_core.h"
 
@@ -41,36 +40,36 @@ struct FormatTuple {
     GLint internal_format;
     GLenum format;
     GLenum type;
-    bool compressed;
-    // How many pixels in the original texture are equivalent to one pixel in the compressed
-    // texture.
-    u32 compression_factor;
 };
 
-static constexpr std::array<FormatTuple, 1> fb_format_tuples = {{
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, false, 1}, // RGBA8
+static constexpr std::array<FormatTuple, 5> fb_format_tuples = {{
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8},     // RGBA8
+    {GL_RGB8, GL_BGR, GL_UNSIGNED_BYTE},              // RGB8
+    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1}, // RGB5A1
+    {GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5},     // RGB565
+    {GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4},   // RGBA4
 }};
 
-static constexpr std::array<FormatTuple, 2> tex_format_tuples = {{
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, false, 1},                       // RGBA8
-    {GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, true, 16}, // DXT1
+static constexpr std::array<FormatTuple, 4> depth_format_tuples = {{
+    {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}, // D16
+    {},
+    {GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT},   // D24
+    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8}, // D24S8
 }};
 
+static constexpr FormatTuple tex_tuple = {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE};
+
 static const FormatTuple& GetFormatTuple(PixelFormat pixel_format) {
     const SurfaceType type = SurfaceParams::GetFormatType(pixel_format);
     if (type == SurfaceType::Color) {
         ASSERT(static_cast<size_t>(pixel_format) < fb_format_tuples.size());
         return fb_format_tuples[static_cast<unsigned int>(pixel_format)];
     } else if (type == SurfaceType::Depth || type == SurfaceType::DepthStencil) {
-        // TODO(Subv): Implement depth formats
-        ASSERT_MSG(false, "Unimplemented");
-    } else if (type == SurfaceType::Texture) {
-        ASSERT(static_cast<size_t>(pixel_format) < tex_format_tuples.size());
-        return tex_format_tuples[static_cast<unsigned int>(pixel_format)];
+        size_t tuple_idx = static_cast<size_t>(pixel_format) - 14;
+        ASSERT(tuple_idx < depth_format_tuples.size());
+        return depth_format_tuples[tuple_idx];
     }
-
-    UNREACHABLE();
-    return {};
+    return tex_tuple;
 }
 
 template <typename Map, typename Interval>
@@ -93,16 +92,26 @@ static void MortonCopyTile(u32 stride, u8* tile_buffer, u8* gl_buffer) {
             u8* tile_ptr = tile_buffer + VideoCore::MortonInterleave(x, y) * bytes_per_pixel;
             u8* gl_ptr = gl_buffer + ((7 - y) * stride + x) * gl_bytes_per_pixel;
             if (morton_to_gl) {
-                std::memcpy(gl_ptr, tile_ptr, bytes_per_pixel);
+                if (format == PixelFormat::D24S8) {
+                    gl_ptr[0] = tile_ptr[3];
+                    std::memcpy(gl_ptr + 1, tile_ptr, 3);
+                } else {
+                    std::memcpy(gl_ptr, tile_ptr, bytes_per_pixel);
+                }
             } else {
-                std::memcpy(tile_ptr, gl_ptr, bytes_per_pixel);
+                if (format == PixelFormat::D24S8) {
+                    std::memcpy(tile_ptr, gl_ptr + 1, 3);
+                    tile_ptr[3] = gl_ptr[0];
+                } else {
+                    std::memcpy(tile_ptr, gl_ptr, bytes_per_pixel);
+                }
             }
         }
     }
 }
 
 template <bool morton_to_gl, PixelFormat format>
-void MortonCopy(u32 stride, u32 height, u8* gl_buffer, VAddr base, VAddr start, VAddr end) {
+static void MortonCopy(u32 stride, u32 height, u8* gl_buffer, VAddr base, VAddr start, VAddr end) {
     constexpr u32 bytes_per_pixel = SurfaceParams::GetFormatBpp(format) / 8;
     constexpr u32 gl_bytes_per_pixel = CachedSurface::GetGLBytesPerPixel(format);
 
@@ -113,28 +122,46 @@ void MortonCopy(u32 stride, u32 height, u8* gl_buffer, VAddr base, VAddr start,
                                    Memory::GetPointer(base), gl_buffer, morton_to_gl);
 }
 
-template <>
-void MortonCopy<true, PixelFormat::DXT1>(u32 stride, u32 height, u8* gl_buffer, VAddr base,
-                                         VAddr start, VAddr end) {
-    constexpr u32 bytes_per_pixel = SurfaceParams::GetFormatBpp(PixelFormat::DXT1) / 8;
-    constexpr u32 gl_bytes_per_pixel = CachedSurface::GetGLBytesPerPixel(PixelFormat::DXT1);
-
-    // TODO(bunnei): Assumes the default rendering GOB size of 16 (128 lines). We should check the
-    // configuration for this and perform more generic un/swizzle
-    LOG_WARNING(Render_OpenGL, "need to use correct swizzle/GOB parameters!");
-    auto data =
-        Tegra::Texture::UnswizzleTexture(base, Tegra::Texture::TextureFormat::DXT1, stride, height);
-    std::memcpy(gl_buffer, data.data(), data.size());
-}
-
-static constexpr std::array<void (*)(u32, u32, u8*, VAddr, VAddr, VAddr), 2> morton_to_gl_fns = {
+static constexpr std::array<void (*)(u32, u32, u8*, VAddr, VAddr, VAddr), 18> morton_to_gl_fns = {
     MortonCopy<true, PixelFormat::RGBA8>,
-    MortonCopy<true, PixelFormat::DXT1>,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
 };
 
-static constexpr std::array<void (*)(u32, u32, u8*, VAddr, VAddr, VAddr), 2> gl_to_morton_fns = {
+static constexpr std::array<void (*)(u32, u32, u8*, VAddr, VAddr, VAddr), 18> gl_to_morton_fns = {
     MortonCopy<false, PixelFormat::RGBA8>,
-    MortonCopy<false, PixelFormat::DXT1>,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
 };
 
 // Allocate an uninitialized texture of appropriate size and format for the surface
@@ -148,11 +175,8 @@ static void AllocateSurfaceTexture(GLuint texture, const FormatTuple& format_tup
     cur_state.Apply();
     glActiveTexture(GL_TEXTURE0);
 
-    if (!format_tuple.compressed) {
-        // Only pre-create the texture for non-compressed textures.
-        glTexImage2D(GL_TEXTURE_2D, 0, format_tuple.internal_format, width, height, 0,
-                     format_tuple.format, format_tuple.type, nullptr);
-    }
+    glTexImage2D(GL_TEXTURE_2D, 0, format_tuple.internal_format, width, height, 0,
+                 format_tuple.format, format_tuple.type, nullptr);
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -582,18 +606,9 @@ void CachedSurface::UploadGLTexture(const MathUtil::Rectangle<u32>& rect, GLuint
     glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(stride));
 
     glActiveTexture(GL_TEXTURE0);
-    if (tuple.compressed) {
-        glCompressedTexImage2D(GL_TEXTURE_2D, 0, tuple.internal_format,
-                               static_cast<GLsizei>(rect.GetWidth()),
-                               static_cast<GLsizei>(rect.GetHeight()), 0,
-                               rect.GetWidth() * rect.GetHeight() *
-                                   GetGLBytesPerPixel(pixel_format) / tuple.compression_factor,
-                               &gl_buffer[buffer_offset]);
-    } else {
-        glTexSubImage2D(GL_TEXTURE_2D, 0, x0, y0, static_cast<GLsizei>(rect.GetWidth()),
-                        static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
-                        &gl_buffer[buffer_offset]);
-    }
+    glTexSubImage2D(GL_TEXTURE_2D, 0, x0, y0, static_cast<GLsizei>(rect.GetWidth()),
+                    static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
+                    &gl_buffer[buffer_offset]);
 
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 
@@ -818,7 +833,7 @@ void main() {
     color = texelFetch(tbo, tbo_offset).rabg;
 }
 )";
-    d24s8_abgr_shader.CreateFromSource(vs_source, nullptr, fs_source);
+    d24s8_abgr_shader.Create(vs_source, nullptr, fs_source);
 
     OpenGLState state = OpenGLState::GetCurState();
     GLuint old_program = state.draw.shader_program;
@@ -939,6 +954,15 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, ScaleMatc
             if (expandable != nullptr && expandable->res_scale > target_res_scale) {
                 target_res_scale = expandable->res_scale;
             }
+            // Keep res_scale when reinterpreting d24s8 -> rgba8
+            if (params.pixel_format == PixelFormat::RGBA8) {
+                find_params.pixel_format = PixelFormat::D24S8;
+                expandable = FindMatch<MatchFlags::Expand | MatchFlags::Invalid>(
+                    surface_cache, find_params, match_res_scale);
+                if (expandable != nullptr && expandable->res_scale > target_res_scale) {
+                    target_res_scale = expandable->res_scale;
+                }
+            }
         }
         SurfaceParams new_params = params;
         new_params.res_scale = target_res_scale;
@@ -1032,34 +1056,9 @@ SurfaceRect_Tuple RasterizerCacheOpenGL::GetSurfaceSubRect(const SurfaceParams&
     return std::make_tuple(surface, surface->GetScaledSubRect(params));
 }
 
-Surface RasterizerCacheOpenGL::GetTextureSurface(const Tegra::Texture::FullTextureInfo& config) {
-    auto& gpu = Core::System::GetInstance().GPU();
-
-    SurfaceParams params;
-    params.addr = gpu.memory_manager->PhysicalToVirtualAddress(config.tic.Address());
-    params.width = config.tic.Width();
-    params.height = config.tic.Height();
-    params.is_tiled = config.tic.IsTiled();
-    params.pixel_format = SurfaceParams::PixelFormatFromTextureFormat(config.tic.format);
-    params.UpdateParams();
-
-    if (config.tic.Width() % 8 != 0 || config.tic.Height() % 8 != 0) {
-        Surface src_surface;
-        MathUtil::Rectangle<u32> rect;
-        std::tie(src_surface, rect) = GetSurfaceSubRect(params, ScaleMatch::Ignore, true);
-
-        params.res_scale = src_surface->res_scale;
-        Surface tmp_surface = CreateSurface(params);
-        BlitTextures(src_surface->texture.handle, rect, tmp_surface->texture.handle,
-                     tmp_surface->GetScaledRect(),
-                     SurfaceParams::GetFormatType(params.pixel_format), read_framebuffer.handle,
-                     draw_framebuffer.handle);
-
-        remove_surfaces.emplace(tmp_surface);
-        return tmp_surface;
-    }
-
-    return GetSurface(params, ScaleMatch::Ignore, true);
+Surface RasterizerCacheOpenGL::GetTextureSurface(const void* config) {
+    UNREACHABLE();
+    return {};
 }
 
 SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(
@@ -1241,7 +1240,28 @@ void RasterizerCacheOpenGL::ValidateSurface(const Surface& surface, VAddr addr,
             continue;
         }
 
-        // Load data from Switch memory
+        // D24S8 to RGBA8
+        if (surface->pixel_format == PixelFormat::RGBA8) {
+            params.pixel_format = PixelFormat::D24S8;
+            Surface reinterpret_surface =
+                FindMatch<MatchFlags::Copy>(surface_cache, params, ScaleMatch::Ignore, interval);
+            if (reinterpret_surface != nullptr) {
+                ASSERT(reinterpret_surface->pixel_format == PixelFormat::D24S8);
+
+                SurfaceInterval convert_interval = params.GetCopyableInterval(reinterpret_surface);
+                SurfaceParams convert_params = surface->FromInterval(convert_interval);
+                auto src_rect = reinterpret_surface->GetScaledSubRect(convert_params);
+                auto dest_rect = surface->GetScaledSubRect(convert_params);
+
+                ConvertD24S8toABGR(reinterpret_surface->texture.handle, src_rect,
+                                   surface->texture.handle, dest_rect);
+
+                surface->invalid_regions.erase(convert_interval);
+                continue;
+            }
+        }
+
+        // Load data from 3DS memory
         FlushRegion(params.addr, params.size);
         surface->LoadGLBuffer(params.addr, params.end);
         surface->UploadGLTexture(surface->GetSubRect(params), read_framebuffer.handle,

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -24,7 +24,6 @@
 #include "common/math_util.h"
 #include "video_core/gpu.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
-#include "video_core/textures/texture.h"
 
 struct CachedSurface;
 using Surface = std::shared_ptr<CachedSurface>;
@@ -52,8 +51,30 @@ enum class ScaleMatch {
 
 struct SurfaceParams {
     enum class PixelFormat {
+        // First 5 formats are shared between textures and color buffers
         RGBA8 = 0,
-        DXT1 = 1,
+        RGB8 = 1,
+        RGB5A1 = 2,
+        RGB565 = 3,
+        RGBA4 = 4,
+
+        // Texture-only formats
+        IA8 = 5,
+        RG8 = 6,
+        I8 = 7,
+        A8 = 8,
+        IA4 = 9,
+        I4 = 10,
+        A4 = 11,
+        ETC1 = 12,
+        ETC1A4 = 13,
+
+        // Depth buffer-only formats
+        D16 = 14,
+        // gap
+        D24 = 16,
+        D24S8 = 17,
+
         Invalid = 255,
     };
 
@@ -67,15 +88,28 @@ struct SurfaceParams {
     };
 
     static constexpr unsigned int GetFormatBpp(PixelFormat format) {
-        if (format == PixelFormat::Invalid)
-            return 0;
-
-        constexpr std::array<unsigned int, 2> bpp_table = {
+        constexpr std::array<unsigned int, 18> bpp_table = {
             32, // RGBA8
-            64, // DXT1
+            24, // RGB8
+            16, // RGB5A1
+            16, // RGB565
+            16, // RGBA4
+            16, // IA8
+            16, // RG8
+            8,  // I8
+            8,  // A8
+            8,  // IA4
+            4,  // I4
+            4,  // A4
+            4,  // ETC1
+            8,  // ETC1A4
+            16, // D16
+            0,
+            24, // D24
+            32, // D24S8
         };
 
-        ASSERT(static_cast<size_t>(format) < bpp_table.size());
+        assert(static_cast<size_t>(format) < bpp_table.size());
         return bpp_table[static_cast<size_t>(format)];
     }
     unsigned int GetFormatBpp() const {
@@ -100,18 +134,6 @@ struct SurfaceParams {
         }
     }
 
-    static PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format) {
-        // TODO(Subv): Properly implement this
-        switch (format) {
-        case Tegra::Texture::TextureFormat::A8R8G8B8:
-            return PixelFormat::RGBA8;
-        case Tegra::Texture::TextureFormat::DXT1:
-            return PixelFormat::DXT1;
-        default:
-            UNREACHABLE();
-        }
-    }
-
     static bool CheckFormatsBlittable(PixelFormat pixel_format_a, PixelFormat pixel_format_b) {
         SurfaceType a_type = GetFormatType(pixel_format_a);
         SurfaceType b_type = GetFormatType(pixel_format_b);
@@ -132,17 +154,22 @@ struct SurfaceParams {
         return false;
     }
 
-    static SurfaceType GetFormatType(PixelFormat pixel_format) {
-        if ((unsigned int)pixel_format <= static_cast<unsigned int>(PixelFormat::RGBA8)) {
+    static constexpr SurfaceType GetFormatType(PixelFormat pixel_format) {
+        if ((unsigned int)pixel_format < 5) {
             return SurfaceType::Color;
         }
 
-        if ((unsigned int)pixel_format <= static_cast<unsigned int>(PixelFormat::DXT1)) {
+        if ((unsigned int)pixel_format < 14) {
             return SurfaceType::Texture;
         }
 
-        // TODO(Subv): Implement the other formats
-        ASSERT(false);
+        if (pixel_format == PixelFormat::D16 || pixel_format == PixelFormat::D24) {
+            return SurfaceType::Depth;
+        }
+
+        if (pixel_format == PixelFormat::D24S8) {
+            return SurfaceType::DepthStencil;
+        }
 
         return SurfaceType::Invalid;
     }
@@ -238,10 +265,12 @@ struct CachedSurface : SurfaceParams {
     OGLTexture texture;
 
     static constexpr unsigned int GetGLBytesPerPixel(PixelFormat format) {
-        if (format == PixelFormat::Invalid)
-            return 0;
-
-        return SurfaceParams::GetFormatBpp(format) / 8;
+        // OpenGL needs 4 bpp alignment for D24 since using GL_UNSIGNED_INT as type
+        return format == PixelFormat::Invalid
+                   ? 0
+                   : (format == PixelFormat::D24 || GetFormatType(format) == SurfaceType::Texture)
+                         ? 4
+                         : SurfaceParams::GetFormatBpp(format) / 8;
     }
 
     std::unique_ptr<u8[]> gl_buffer;
@@ -274,17 +303,17 @@ public:
     void CopySurface(const Surface& src_surface, const Surface& dst_surface,
                      SurfaceInterval copy_interval);
 
-    /// Load a texture from Switch memory to OpenGL and cache it (if not already cached)
+    /// Load a texture from 3DS memory to OpenGL and cache it (if not already cached)
     Surface GetSurface(const SurfaceParams& params, ScaleMatch match_res_scale,
                        bool load_if_create);
 
     /// Attempt to find a subrect (resolution scaled) of a surface, otherwise loads a texture from
-    /// Switch memory to OpenGL and caches it (if not already cached)
+    /// 3DS memory to OpenGL and caches it (if not already cached)
     SurfaceRect_Tuple GetSurfaceSubRect(const SurfaceParams& params, ScaleMatch match_res_scale,
                                         bool load_if_create);
 
     /// Get a surface based on the texture configuration
-    Surface GetTextureSurface(const Tegra::Texture::FullTextureInfo& config);
+    Surface GetTextureSurface(const void* config);
 
     /// Get the color and depth surfaces based on the framebuffer configuration
     SurfaceSurfaceRect_Tuple GetFramebufferSurfaces(bool using_color_fb, bool using_depth_fb,
@@ -299,7 +328,7 @@ public:
     /// Write any cached resources overlapping the region back to memory (if dirty)
     void FlushRegion(VAddr addr, u64 size, Surface flush_surface = nullptr);
 
-    /// Mark region as being invalidated by region_owner (nullptr if Switch memory)
+    /// Mark region as being invalidated by region_owner (nullptr if 3DS memory)
     void InvalidateRegion(VAddr addr, u64 size, const Surface& region_owner);
 
     /// Flush all cached resources tracked by this cache manager
@@ -334,7 +363,7 @@ private:
     OGLVertexArray attributeless_vao;
     OGLBuffer d24s8_abgr_buffer;
     GLsizeiptr d24s8_abgr_buffer_size;
-    OGLProgram d24s8_abgr_shader;
+    OGLShader d24s8_abgr_shader;
     GLint d24s8_abgr_tbo_size_u_id;
     GLint d24s8_abgr_viewport_u_id;
 };

src/video_core/renderer_opengl/gl_resource_manager.h

@@ -13,16 +13,14 @@
 class OGLTexture : private NonCopyable {
 public:
     OGLTexture() = default;
-
-    OGLTexture(OGLTexture&& o) : handle(std::exchange(o.handle, 0)) {}
-
+    OGLTexture(OGLTexture&& o) {
+        std::swap(handle, o.handle);
+    }
     ~OGLTexture() {
         Release();
     }
-
     OGLTexture& operator=(OGLTexture&& o) {
-        Release();
-        handle = std::exchange(o.handle, 0);
+        std::swap(handle, o.handle);
         return *this;
     }
 
@@ -48,16 +46,14 @@ public:
 class OGLSampler : private NonCopyable {
 public:
     OGLSampler() = default;
-
-    OGLSampler(OGLSampler&& o) : handle(std::exchange(o.handle, 0)) {}
-
+    OGLSampler(OGLSampler&& o) {
+        std::swap(handle, o.handle);
+    }
     ~OGLSampler() {
         Release();
     }
-
     OGLSampler& operator=(OGLSampler&& o) {
-        Release();
-        handle = std::exchange(o.handle, 0);
+        std::swap(handle, o.handle);
         return *this;
     }
 
@@ -83,71 +79,25 @@ public:
 class OGLShader : private NonCopyable {
 public:
     OGLShader() = default;
-
-    OGLShader(OGLShader&& o) : handle(std::exchange(o.handle, 0)) {}
-
+    OGLShader(OGLShader&& o) {
+        std::swap(handle, o.handle);
+    }
     ~OGLShader() {
         Release();
     }
-
     OGLShader& operator=(OGLShader&& o) {
-        Release();
-        handle = std::exchange(o.handle, 0);
+        std::swap(handle, o.handle);
         return *this;
     }
 
-    void Create(const char* source, GLenum type) {
-        if (handle != 0)
-            return;
-        if (source == nullptr)
-            return;
-        handle = GLShader::LoadShader(source, type);
-    }
-
-    void Release() {
-        if (handle == 0)
-            return;
-        glDeleteShader(handle);
-        handle = 0;
-    }
-
-    GLuint handle = 0;
-};
-
-class OGLProgram : private NonCopyable {
-public:
-    OGLProgram() = default;
-
-    OGLProgram(OGLProgram&& o) : handle(std::exchange(o.handle, 0)) {}
-
-    ~OGLProgram() {
-        Release();
-    }
-
-    OGLProgram& operator=(OGLProgram&& o) {
-        Release();
-        handle = std::exchange(o.handle, 0);
-        return *this;
-    }
-
-    template <typename... T>
-    void Create(bool separable_program, T... shaders) {
-        if (handle != 0)
-            return;
-        handle = GLShader::LoadProgram(separable_program, shaders...);
-    }
-
     /// Creates a new internal OpenGL resource and stores the handle
-    void CreateFromSource(const char* vert_shader, const char* geo_shader, const char* frag_shader,
-                          bool separable_program = false) {
-        OGLShader vert, geo, frag;
-        if (vert_shader)
-            vert.Create(vert_shader, GL_VERTEX_SHADER);
-        if (geo_shader)
-            geo.Create(geo_shader, GL_GEOMETRY_SHADER);
-        if (frag_shader)
-            frag.Create(frag_shader, GL_FRAGMENT_SHADER);
-        Create(separable_program, vert.handle, geo.handle, frag.handle);
+    void Create(const char* vert_shader, const char* geo_shader, const char* frag_shader,
+                const std::vector<const char*>& feedback_vars = {},
+                bool separable_program = false) {
+        if (handle != 0)
+            return;
+        handle = GLShader::LoadProgram(vert_shader, geo_shader, frag_shader, feedback_vars,
+                                       separable_program);
     }
 
     /// Deletes the internal OpenGL resource
@@ -198,16 +148,14 @@ public:
 class OGLBuffer : private NonCopyable {
 public:
     OGLBuffer() = default;
-
-    OGLBuffer(OGLBuffer&& o) : handle(std::exchange(o.handle, 0)) {}
-
+    OGLBuffer(OGLBuffer&& o) {
+        std::swap(handle, o.handle);
+    }
     ~OGLBuffer() {
         Release();
     }
-
     OGLBuffer& operator=(OGLBuffer&& o) {
-        Release();
-        handle = std::exchange(o.handle, 0);
+        std::swap(handle, o.handle);
         return *this;
     }
 
@@ -266,16 +214,14 @@ public:
 class OGLVertexArray : private NonCopyable {
 public:
     OGLVertexArray() = default;
-
-    OGLVertexArray(OGLVertexArray&& o) : handle(std::exchange(o.handle, 0)) {}
-
+    OGLVertexArray(OGLVertexArray&& o) {
+        std::swap(handle, o.handle);
+    }
     ~OGLVertexArray() {
         Release();
     }
-
     OGLVertexArray& operator=(OGLVertexArray&& o) {
-        Release();
-        handle = std::exchange(o.handle, 0);
+        std::swap(handle, o.handle);
         return *this;
     }
 
@@ -301,16 +247,14 @@ public:
 class OGLFramebuffer : private NonCopyable {
 public:
     OGLFramebuffer() = default;
-
-    OGLFramebuffer(OGLFramebuffer&& o) : handle(std::exchange(o.handle, 0)) {}
-
+    OGLFramebuffer(OGLFramebuffer&& o) {
+        std::swap(handle, o.handle);
+    }
     ~OGLFramebuffer() {
         Release();
     }
-
     OGLFramebuffer& operator=(OGLFramebuffer&& o) {
-        Release();
-        handle = std::exchange(o.handle, 0);
+        std::swap(handle, o.handle);
         return *this;
     }
 

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -2,523 +2,57 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <map>
-#include <set>
 #include <string>
+#include <queue>
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "video_core/engines/shader_bytecode.h"
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 
-namespace GLShader {
+namespace Maxwell3D {
+namespace Shader {
 namespace Decompiler {
 
-using Tegra::Shader::Attribute;
-using Tegra::Shader::Instruction;
-using Tegra::Shader::OpCode;
-using Tegra::Shader::Register;
-using Tegra::Shader::SubOp;
-using Tegra::Shader::Uniform;
-
 constexpr u32 PROGRAM_END = MAX_PROGRAM_CODE_LENGTH;
 
-class DecompileFail : public std::runtime_error {
+class Impl {
 public:
-    using std::runtime_error::runtime_error;
-};
+    Impl(const std::array<u32, MAX_PROGRAM_CODE_LENGTH>& program_code,
+         const std::array<u32, MAX_SWIZZLE_DATA_LENGTH>& swizzle_data, u32 main_offset,
+         const std::function<std::string(u32)>& inputreg_getter,
+         const std::function<std::string(u32)>& outputreg_getter, bool sanitize_mul,
+         const std::string& emit_cb, const std::string& setemit_cb)
+        : program_code(program_code), swizzle_data(swizzle_data), main_offset(main_offset),
+          inputreg_getter(inputreg_getter), outputreg_getter(outputreg_getter),
+          sanitize_mul(sanitize_mul), emit_cb(emit_cb), setemit_cb(setemit_cb) {}
 
-/// Describes the behaviour of code path of a given entry point and a return point.
-enum class ExitMethod {
-    Undetermined, ///< Internal value. Only occur when analyzing JMP loop.
-    AlwaysReturn, ///< All code paths reach the return point.
-    Conditional,  ///< Code path reaches the return point or an END instruction conditionally.
-    AlwaysEnd,    ///< All code paths reach a END instruction.
-};
-
-/// A subroutine is a range of code refereced by a CALL, IF or LOOP instruction.
-struct Subroutine {
-    /// Generates a name suitable for GLSL source code.
-    std::string GetName() const {
-        return "sub_" + std::to_string(begin) + "_" + std::to_string(end);
-    }
-
-    u32 begin;              ///< Entry point of the subroutine.
-    u32 end;                ///< Return point of the subroutine.
-    ExitMethod exit_method; ///< Exit method of the subroutine.
-    std::set<u32> labels;   ///< Addresses refereced by JMP instructions.
-
-    bool operator<(const Subroutine& rhs) const {
-        return std::tie(begin, end) < std::tie(rhs.begin, rhs.end);
-    }
-};
-
-/// Analyzes shader code and produces a set of subroutines.
-class ControlFlowAnalyzer {
-public:
-    ControlFlowAnalyzer(const ProgramCode& program_code, u32 main_offset)
-        : program_code(program_code) {
-
-        // Recursively finds all subroutines.
-        const Subroutine& program_main = AddSubroutine(main_offset, PROGRAM_END);
-        if (program_main.exit_method != ExitMethod::AlwaysEnd)
-            throw DecompileFail("Program does not always end");
-    }
-
-    std::set<Subroutine> GetSubroutines() {
-        return std::move(subroutines);
-    }
-
-private:
-    const ProgramCode& program_code;
-    std::set<Subroutine> subroutines;
-    std::map<std::pair<u32, u32>, ExitMethod> exit_method_map;
-
-    /// Adds and analyzes a new subroutine if it is not added yet.
-    const Subroutine& AddSubroutine(u32 begin, u32 end) {
-        auto iter = subroutines.find(Subroutine{begin, end});
-        if (iter != subroutines.end())
-            return *iter;
-
-        Subroutine subroutine{begin, end};
-        subroutine.exit_method = Scan(begin, end, subroutine.labels);
-        if (subroutine.exit_method == ExitMethod::Undetermined)
-            throw DecompileFail("Recursive function detected");
-        return *subroutines.insert(std::move(subroutine)).first;
-    }
-
-    /// Scans a range of code for labels and determines the exit method.
-    ExitMethod Scan(u32 begin, u32 end, std::set<u32>& labels) {
-        auto [iter, inserted] =
-            exit_method_map.emplace(std::make_pair(begin, end), ExitMethod::Undetermined);
-        ExitMethod& exit_method = iter->second;
-        if (!inserted)
-            return exit_method;
-
-        for (u32 offset = begin; offset != end && offset != PROGRAM_END; ++offset) {
-            const Instruction instr = {program_code[offset]};
-            switch (instr.opcode.EffectiveOpCode()) {
-            case OpCode::Id::EXIT: {
-                return exit_method = ExitMethod::AlwaysEnd;
-            }
-            }
-        }
-        return exit_method = ExitMethod::AlwaysReturn;
-    }
-};
-
-class ShaderWriter {
-public:
-    void AddLine(const std::string& text) {
-        DEBUG_ASSERT(scope >= 0);
-        if (!text.empty()) {
-            shader_source += std::string(static_cast<size_t>(scope) * 4, ' ');
-        }
-        shader_source += text + '\n';
-    }
-
-    std::string GetResult() {
-        return std::move(shader_source);
-    }
-
-    int scope = 0;
-
-private:
-    std::string shader_source;
-};
-
-class GLSLGenerator {
-public:
-    GLSLGenerator(const std::set<Subroutine>& subroutines, const ProgramCode& program_code,
-                  u32 main_offset, Maxwell3D::Regs::ShaderStage stage)
-        : subroutines(subroutines), program_code(program_code), main_offset(main_offset),
-          stage(stage) {
-
-        Generate();
-    }
-
-    std::string GetShaderCode() {
-        return declarations.GetResult() + shader.GetResult();
-    }
-
-    /// Returns entries in the shader that are useful for external functions
-    ShaderEntries GetEntries() const {
-        return {GetConstBuffersDeclarations()};
-    }
-
-private:
-    /// Gets the Subroutine object corresponding to the specified address.
-    const Subroutine& GetSubroutine(u32 begin, u32 end) const {
-        auto iter = subroutines.find(Subroutine{begin, end});
-        ASSERT(iter != subroutines.end());
-        return *iter;
-    }
-
-    /// Generates code representing an input attribute register.
-    std::string GetInputAttribute(Attribute::Index attribute) {
-        declr_input_attribute.insert(attribute);
-
-        const u32 index{static_cast<u32>(attribute) -
-                        static_cast<u32>(Attribute::Index::Attribute_0)};
-        if (attribute >= Attribute::Index::Attribute_0) {
-            return "input_attribute_" + std::to_string(index);
-        }
-
-        LOG_CRITICAL(HW_GPU, "Unhandled input attribute: 0x%02x", index);
+    std::string Decompile() {
         UNREACHABLE();
-    }
-
-    /// Generates code representing an output attribute register.
-    std::string GetOutputAttribute(Attribute::Index attribute) {
-        switch (attribute) {
-        case Attribute::Index::Position:
-            return "gl_Position";
-        default:
-            const u32 index{static_cast<u32>(attribute) -
-                            static_cast<u32>(Attribute::Index::Attribute_0)};
-            if (attribute >= Attribute::Index::Attribute_0) {
-                declr_output_attribute.insert(attribute);
-                return "output_attribute_" + std::to_string(index);
-            }
-
-            LOG_CRITICAL(HW_GPU, "Unhandled output attribute: 0x%02x", index);
-            UNREACHABLE();
-        }
-    }
-
-    /// Generates code representing a temporary (GPR) register.
-    std::string GetRegister(const Register& reg) {
-        return *declr_register.insert("register_" + std::to_string(reg)).first;
-    }
-
-    /// Generates code representing a uniform (C buffer) register.
-    std::string GetUniform(const Uniform& reg) {
-        declr_const_buffers[reg.index].MarkAsUsed(reg.index, reg.offset);
-        return 'c' + std::to_string(reg.index) + '[' + std::to_string(reg.offset) + ']';
-    }
-
-    /**
-     * Adds code that calls a subroutine.
-     * @param subroutine the subroutine to call.
-     */
-    void CallSubroutine(const Subroutine& subroutine) {
-        if (subroutine.exit_method == ExitMethod::AlwaysEnd) {
-            shader.AddLine(subroutine.GetName() + "();");
-            shader.AddLine("return true;");
-        } else if (subroutine.exit_method == ExitMethod::Conditional) {
-            shader.AddLine("if (" + subroutine.GetName() + "()) { return true; }");
-        } else {
-            shader.AddLine(subroutine.GetName() + "();");
-        }
-    }
-
-    /**
-     * Writes code that does an assignment operation.
-     * @param reg the destination register code.
-     * @param value the code representing the value to assign.
-     */
-    void SetDest(u64 elem, const std::string& reg, const std::string& value,
-                 u64 dest_num_components, u64 value_num_components) {
-        std::string swizzle = ".";
-        swizzle += "xyzw"[elem];
-
-        std::string dest = reg + (dest_num_components != 1 ? swizzle : "");
-        std::string src = "(" + value + ")" + (value_num_components != 1 ? swizzle : "");
-
-        shader.AddLine(dest + " = " + src + ";");
-    }
-
-    /**
-     * Compiles a single instruction from Tegra to GLSL.
-     * @param offset the offset of the Tegra shader instruction.
-     * @return the offset of the next instruction to execute. Usually it is the current offset
-     * + 1. If the current instruction always terminates the program, returns PROGRAM_END.
-     */
-    u32 CompileInstr(u32 offset) {
-        const Instruction instr = {program_code[offset]};
-
-        shader.AddLine("// " + std::to_string(offset) + ": " + OpCode::GetInfo(instr.opcode).name);
-
-        switch (OpCode::GetInfo(instr.opcode).type) {
-        case OpCode::Type::Arithmetic: {
-            ASSERT(!instr.alu.abs_d);
-
-            std::string dest = GetRegister(instr.gpr0);
-            std::string op_a = instr.alu.negate_a ? "-" : "";
-            op_a += GetRegister(instr.gpr8);
-            if (instr.alu.abs_a) {
-                op_a = "abs(" + op_a + ")";
-            }
-
-            std::string op_b = instr.alu.negate_b ? "-" : "";
-            if (instr.is_b_gpr) {
-                op_b += GetRegister(instr.gpr20);
-            } else {
-                op_b += GetUniform(instr.uniform);
-            }
-            if (instr.alu.abs_b) {
-                op_b = "abs(" + op_b + ")";
-            }
-
-            switch (instr.opcode.EffectiveOpCode()) {
-            case OpCode::Id::FMUL_C:
-            case OpCode::Id::FMUL_R: {
-                SetDest(0, dest, op_a + " * " + op_b, 1, 1);
-                break;
-            }
-            case OpCode::Id::FADD_C:
-            case OpCode::Id::FADD_R: {
-                SetDest(0, dest, op_a + " + " + op_b, 1, 1);
-                break;
-            }
-            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled arithmetic instruction: 0x%02x (%s): 0x%08x",
-                             static_cast<unsigned>(instr.opcode.EffectiveOpCode()),
-                             OpCode::GetInfo(instr.opcode).name.c_str(), instr.hex);
-                throw DecompileFail("Unhandled instruction");
-                break;
-            }
-            }
-            break;
-        }
-        case OpCode::Type::Ffma: {
-            ASSERT_MSG(!instr.ffma.negate_b, "untested");
-            ASSERT_MSG(!instr.ffma.negate_c, "untested");
-
-            std::string dest = GetRegister(instr.gpr0);
-            std::string op_a = GetRegister(instr.gpr8);
-
-            std::string op_b = instr.ffma.negate_b ? "-" : "";
-            op_b += GetUniform(instr.uniform);
-
-            std::string op_c = instr.ffma.negate_c ? "-" : "";
-            op_c += GetRegister(instr.gpr39);
-
-            switch (instr.opcode.EffectiveOpCode()) {
-            case OpCode::Id::FFMA_CR: {
-                SetDest(0, dest, op_a + " * " + op_b + " + " + op_c, 1, 1);
-                break;
-            }
-
-            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled arithmetic FFMA instruction: 0x%02x (%s): 0x%08x",
-                             static_cast<unsigned>(instr.opcode.EffectiveOpCode()),
-                             OpCode::GetInfo(instr.opcode).name.c_str(), instr.hex);
-                throw DecompileFail("Unhandled instruction");
-                break;
-            }
-            }
-            break;
-        }
-        case OpCode::Type::Memory: {
-            std::string gpr0 = GetRegister(instr.gpr0);
-            const Attribute::Index attribute = instr.attribute.fmt20.index;
-
-            switch (instr.opcode.EffectiveOpCode()) {
-            case OpCode::Id::LD_A: {
-                ASSERT(instr.attribute.fmt20.size == 0);
-                SetDest(instr.attribute.fmt20.element, gpr0, GetInputAttribute(attribute), 1, 4);
-                break;
-            }
-            case OpCode::Id::ST_A: {
-                ASSERT(instr.attribute.fmt20.size == 0);
-                SetDest(instr.attribute.fmt20.element, GetOutputAttribute(attribute), gpr0, 4, 1);
-                break;
-            }
-            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled memory instruction: 0x%02x (%s): 0x%08x",
-                             static_cast<unsigned>(instr.opcode.EffectiveOpCode()),
-                             OpCode::GetInfo(instr.opcode).name.c_str(), instr.hex);
-                throw DecompileFail("Unhandled instruction");
-                break;
-            }
-            }
-            break;
-        }
-
-        default: {
-            switch (instr.opcode.EffectiveOpCode()) {
-            case OpCode::Id::EXIT: {
-                shader.AddLine("return true;");
-                offset = PROGRAM_END - 1;
-                break;
-            }
-
-            default: {
-                LOG_CRITICAL(HW_GPU, "Unhandled instruction: 0x%02x (%s): 0x%08x",
-                             static_cast<unsigned>(instr.opcode.EffectiveOpCode()),
-                             OpCode::GetInfo(instr.opcode).name.c_str(), instr.hex);
-                throw DecompileFail("Unhandled instruction");
-                break;
-            }
-            }
-
-            break;
-        }
-        }
-
-        return offset + 1;
-    }
-
-    /**
-     * Compiles a range of instructions from Tegra to GLSL.
-     * @param begin the offset of the starting instruction.
-     * @param end the offset where the compilation should stop (exclusive).
-     * @return the offset of the next instruction to compile. PROGRAM_END if the program
-     * terminates.
-     */
-    u32 CompileRange(u32 begin, u32 end) {
-        u32 program_counter;
-        for (program_counter = begin; program_counter < (begin > end ? PROGRAM_END : end);) {
-            program_counter = CompileInstr(program_counter);
-        }
-        return program_counter;
-    }
-
-    void Generate() {
-        // Add declarations for all subroutines
-        for (const auto& subroutine : subroutines) {
-            shader.AddLine("bool " + subroutine.GetName() + "();");
-        }
-        shader.AddLine("");
-
-        // Add the main entry point
-        shader.AddLine("bool exec_shader() {");
-        ++shader.scope;
-        CallSubroutine(GetSubroutine(main_offset, PROGRAM_END));
-        --shader.scope;
-        shader.AddLine("}\n");
-
-        // Add definitions for all subroutines
-        for (const auto& subroutine : subroutines) {
-            std::set<u32> labels = subroutine.labels;
-
-            shader.AddLine("bool " + subroutine.GetName() + "() {");
-            ++shader.scope;
-
-            if (labels.empty()) {
-                if (CompileRange(subroutine.begin, subroutine.end) != PROGRAM_END) {
-                    shader.AddLine("return false;");
-                }
-            } else {
-                labels.insert(subroutine.begin);
-                shader.AddLine("uint jmp_to = " + std::to_string(subroutine.begin) + "u;");
-                shader.AddLine("while (true) {");
-                ++shader.scope;
-
-                shader.AddLine("switch (jmp_to) {");
-
-                for (auto label : labels) {
-                    shader.AddLine("case " + std::to_string(label) + "u: {");
-                    ++shader.scope;
-
-                    auto next_it = labels.lower_bound(label + 1);
-                    u32 next_label = next_it == labels.end() ? subroutine.end : *next_it;
-
-                    u32 compile_end = CompileRange(label, next_label);
-                    if (compile_end > next_label && compile_end != PROGRAM_END) {
-                        // This happens only when there is a label inside a IF/LOOP block
-                        shader.AddLine("{ jmp_to = " + std::to_string(compile_end) + "u; break; }");
-                        labels.emplace(compile_end);
-                    }
-
-                    --shader.scope;
-                    shader.AddLine("}");
-                }
-
-                shader.AddLine("default: return false;");
-                shader.AddLine("}");
-
-                --shader.scope;
-                shader.AddLine("}");
-
-                shader.AddLine("return false;");
-            }
-
-            --shader.scope;
-            shader.AddLine("}\n");
-
-            DEBUG_ASSERT(shader.scope == 0);
-        }
-
-        GenerateDeclarations();
-    }
-
-    /// Returns a list of constant buffer declarations
-    std::vector<ConstBufferEntry> GetConstBuffersDeclarations() const {
-        std::vector<ConstBufferEntry> result;
-        std::copy_if(declr_const_buffers.begin(), declr_const_buffers.end(),
-                     std::back_inserter(result), [](const auto& entry) { return entry.IsUsed(); });
-        return result;
-    }
-
-    /// Add declarations for registers
-    void GenerateDeclarations() {
-        for (const auto& reg : declr_register) {
-            declarations.AddLine("float " + reg + " = 0.0;");
-        }
-        declarations.AddLine("");
-
-        for (const auto& index : declr_input_attribute) {
-            // TODO(bunnei): Use proper number of elements for these
-            declarations.AddLine("layout(location = " +
-                                 std::to_string(static_cast<u32>(index) -
-                                                static_cast<u32>(Attribute::Index::Attribute_0)) +
-                                 ") in vec4 " + GetInputAttribute(index) + ";");
-        }
-        declarations.AddLine("");
-
-        for (const auto& index : declr_output_attribute) {
-            // TODO(bunnei): Use proper number of elements for these
-            declarations.AddLine("layout(location = " +
-                                 std::to_string(static_cast<u32>(index) -
-                                                static_cast<u32>(Attribute::Index::Attribute_0)) +
-                                 ") out vec4 " + GetOutputAttribute(index) + ";");
-        }
-        declarations.AddLine("");
-
-        unsigned const_buffer_layout = 0;
-        for (const auto& entry : GetConstBuffersDeclarations()) {
-            declarations.AddLine("layout(std430, binding = " + std::to_string(const_buffer_layout) +
-                                 ") buffer c" + std::to_string(entry.GetIndex()) + "_buffer");
-            declarations.AddLine("{");
-            declarations.AddLine("    float c" + std::to_string(entry.GetIndex()) + "[];");
-            declarations.AddLine("};");
-            declarations.AddLine("");
-            ++const_buffer_layout;
-        }
+        return {};
     }
 
 private:
-    const std::set<Subroutine>& subroutines;
-    const ProgramCode& program_code;
-    const u32 main_offset;
-    Maxwell3D::Regs::ShaderStage stage;
-
-    ShaderWriter shader;
-    ShaderWriter declarations;
-
-    // Declarations
-    std::set<std::string> declr_register;
-    std::set<Attribute::Index> declr_input_attribute;
-    std::set<Attribute::Index> declr_output_attribute;
-    std::array<ConstBufferEntry, Maxwell3D::Regs::MaxConstBuffers> declr_const_buffers;
+    const std::array<u32, MAX_PROGRAM_CODE_LENGTH>& program_code;
+    const std::array<u32, MAX_SWIZZLE_DATA_LENGTH>& swizzle_data;
+    u32 main_offset;
+    const std::function<std::string(u32)>& inputreg_getter;
+    const std::function<std::string(u32)>& outputreg_getter;
+    bool sanitize_mul;
+    const std::string& emit_cb;
+    const std::string& setemit_cb;
 };
 
-std::string GetCommonDeclarations() {
-    return "bool exec_shader();";
-}
-
-boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code, u32 main_offset,
-                                                Maxwell3D::Regs::ShaderStage stage) {
-    try {
-        auto subroutines = ControlFlowAnalyzer(program_code, main_offset).GetSubroutines();
-        GLSLGenerator generator(subroutines, program_code, main_offset, stage);
-        return ProgramResult{generator.GetShaderCode(), generator.GetEntries()};
-    } catch (const DecompileFail& exception) {
-        LOG_ERROR(HW_GPU, "Shader decompilation failed: %s", exception.what());
-    }
-    return boost::none;
+std::string DecompileProgram(const std::array<u32, MAX_PROGRAM_CODE_LENGTH>& program_code,
+                             const std::array<u32, MAX_SWIZZLE_DATA_LENGTH>& swizzle_data,
+                             u32 main_offset,
+                             const std::function<std::string(u32)>& inputreg_getter,
+                             const std::function<std::string(u32)>& outputreg_getter,
+                             bool sanitize_mul, const std::string& emit_cb,
+                             const std::string& setemit_cb) {
+    Impl impl(program_code, swizzle_data, main_offset, inputreg_getter, outputreg_getter,
+              sanitize_mul, emit_cb, setemit_cb);
+    return impl.Decompile();
 }
 
 } // namespace Decompiler
-} // namespace GLShader
+} // namespace Shader
+} // namespace Maxwell3D

src/video_core/renderer_opengl/gl_shader_decompiler.h

@@ -5,20 +5,23 @@
 #include <array>
 #include <functional>
 #include <string>
-#include <boost/optional.hpp>
 #include "common/common_types.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/renderer_opengl/gl_shader_gen.h"
 
-namespace GLShader {
+namespace Maxwell3D {
+namespace Shader {
 namespace Decompiler {
 
-using Tegra::Engines::Maxwell3D;
+constexpr size_t MAX_PROGRAM_CODE_LENGTH{0x100000};
+constexpr size_t MAX_SWIZZLE_DATA_LENGTH{0x100000};
 
-std::string GetCommonDeclarations();
-
-boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code, u32 main_offset,
-                                                Maxwell3D::Regs::ShaderStage stage);
+std::string DecompileProgram(const std::array<u32, MAX_PROGRAM_CODE_LENGTH>& program_code,
+                             const std::array<u32, MAX_SWIZZLE_DATA_LENGTH>& swizzle_data,
+                             u32 main_offset,
+                             const std::function<std::string(u32)>& inputreg_getter,
+                             const std::function<std::string(u32)>& outputreg_getter,
+                             bool sanitize_mul, const std::string& emit_cb = "",
+                             const std::string& setemit_cb = "");
 
 } // namespace Decompiler
-} // namespace GLShader
+} // namespace Shader
+} // namespace Maxwell3D

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -3,60 +3,18 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/renderer_opengl/gl_shader_decompiler.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
 
 namespace GLShader {
 
-using Tegra::Engines::Maxwell3D;
-
-static constexpr u32 PROGRAM_OFFSET{10};
-
-ProgramResult GenerateVertexShader(const ShaderSetup& setup, const MaxwellVSConfig& config) {
-    std::string out = "#version 430 core\n";
-    out += "#extension GL_ARB_separate_shader_objects : enable\n\n";
-    out += Decompiler::GetCommonDeclarations();
-
-    ProgramResult program = Decompiler::DecompileProgram(setup.program_code, PROGRAM_OFFSET,
-                                                         Maxwell3D::Regs::ShaderStage::Vertex)
-                                .get_value_or({});
-    out += R"(
-
-out gl_PerVertex {
-    vec4 gl_Position;
-};
-
-void main() {
-    exec_shader();
+std::string GenerateVertexShader(const MaxwellVSConfig& config) {
+    UNREACHABLE();
+    return {};
 }
 
-)";
-    out += program.first;
-    return {out, program.second};
-}
-
-ProgramResult GenerateFragmentShader(const ShaderSetup& setup, const MaxwellFSConfig& config) {
-    std::string out = "#version 430 core\n";
-    out += "#extension GL_ARB_separate_shader_objects : enable\n\n";
-    out += Decompiler::GetCommonDeclarations();
-
-    ProgramResult program = Decompiler::DecompileProgram(setup.program_code, PROGRAM_OFFSET,
-                                                         Maxwell3D::Regs::ShaderStage::Fragment)
-                                .get_value_or({});
-    out += R"(
-
-out vec4 color;
-
-uniform sampler2D tex[32];
-
-void main() {
-    exec_shader();
-}
-
-)";
-    out += program.first;
-    return {out, program.second};
+std::string GenerateFragmentShader(const MaxwellFSConfig& config) {
+    UNREACHABLE();
+    return {};
 }
 
 } // namespace GLShader

src/video_core/renderer_opengl/gl_shader_gen.h

@@ -4,101 +4,46 @@
 
 #pragma once
 
-#include <array>
+#include <cstring>
 #include <string>
 #include <type_traits>
-#include <utility>
-#include <vector>
-#include "common/common_types.h"
 #include "common/hash.h"
 
 namespace GLShader {
 
-constexpr size_t MAX_PROGRAM_CODE_LENGTH{0x1000};
-
-using ProgramCode = std::array<u64, MAX_PROGRAM_CODE_LENGTH>;
-
-class ConstBufferEntry {
-public:
-    void MarkAsUsed(unsigned index, unsigned offset) {
-        is_used = true;
-        this->index = index;
-        max_offset = std::max(max_offset, offset);
-    }
-
-    bool IsUsed() const {
-        return is_used;
-    }
-
-    unsigned GetIndex() const {
-        return index;
-    }
-
-    unsigned GetSize() const {
-        return max_offset + 1;
-    }
-
-private:
-    bool is_used{};
-    unsigned index{};
-    unsigned max_offset{};
-};
-
-struct ShaderEntries {
-    std::vector<ConstBufferEntry> const_buffer_entries;
-};
-
-using ProgramResult = std::pair<std::string, ShaderEntries>;
-
-struct ShaderSetup {
-    ShaderSetup(ProgramCode&& program_code) : program_code(std::move(program_code)) {}
-
-    ProgramCode program_code;
-    bool program_code_hash_dirty = true;
-
-    u64 GetProgramCodeHash() {
-        if (program_code_hash_dirty) {
-            program_code_hash = Common::ComputeHash64(&program_code, sizeof(program_code));
-            program_code_hash_dirty = false;
-        }
-        return program_code_hash;
-    }
-
-private:
-    u64 program_code_hash{};
+enum Attributes {
+    ATTRIBUTE_POSITION,
+    ATTRIBUTE_COLOR,
+    ATTRIBUTE_TEXCOORD0,
+    ATTRIBUTE_TEXCOORD1,
+    ATTRIBUTE_TEXCOORD2,
+    ATTRIBUTE_TEXCOORD0_W,
+    ATTRIBUTE_NORMQUAT,
+    ATTRIBUTE_VIEW,
 };
 
 struct MaxwellShaderConfigCommon {
-    void Init(ShaderSetup& setup) {
-        program_hash = setup.GetProgramCodeHash();
-    }
-
-    u64 program_hash;
+    explicit MaxwellShaderConfigCommon(){};
 };
 
-struct MaxwellVSConfig : Common::HashableStruct<MaxwellShaderConfigCommon> {
-    explicit MaxwellVSConfig(ShaderSetup& setup) {
-        state.Init(setup);
-    }
+struct MaxwellVSConfig : MaxwellShaderConfigCommon {
+    explicit MaxwellVSConfig() : MaxwellShaderConfigCommon() {}
+
+    bool operator==(const MaxwellVSConfig& o) const {
+        return std::memcmp(this, &o, sizeof(MaxwellVSConfig)) == 0;
+    };
 };
 
-struct MaxwellFSConfig : Common::HashableStruct<MaxwellShaderConfigCommon> {
-    explicit MaxwellFSConfig(ShaderSetup& setup) {
-        state.Init(setup);
-    }
+struct MaxwellFSConfig : MaxwellShaderConfigCommon {
+    explicit MaxwellFSConfig() : MaxwellShaderConfigCommon() {}
+
+    bool operator==(const MaxwellFSConfig& o) const {
+        return std::memcmp(this, &o, sizeof(MaxwellFSConfig)) == 0;
+    };
 };
 
-/**
- * Generates the GLSL vertex shader program source code for the given VS program
- * @returns String of the shader source code
- */
-ProgramResult GenerateVertexShader(const ShaderSetup& setup, const MaxwellVSConfig& config);
-
-/**
- * Generates the GLSL fragment shader program source code for the given FS program
- * @returns String of the shader source code
- */
-ProgramResult GenerateFragmentShader(const ShaderSetup& setup, const MaxwellFSConfig& config);
+std::string GenerateVertexShader(const MaxwellVSConfig& config);
+std::string GenerateFragmentShader(const MaxwellFSConfig& config);
 
 } // namespace GLShader
 
@@ -107,14 +52,14 @@ namespace std {
 template <>
 struct hash<GLShader::MaxwellVSConfig> {
     size_t operator()(const GLShader::MaxwellVSConfig& k) const {
-        return k.Hash();
+        return Common::ComputeHash64(&k, sizeof(GLShader::MaxwellVSConfig));
     }
 };
 
 template <>
 struct hash<GLShader::MaxwellFSConfig> {
     size_t operator()(const GLShader::MaxwellFSConfig& k) const {
-        return k.Hash();
+        return Common::ComputeHash64(&k, sizeof(GLShader::MaxwellFSConfig));
     }
 };
 

src/video_core/renderer_opengl/gl_shader_manager.cpp

@@ -1,58 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core.h"
-#include "core/hle/kernel/process.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/renderer_opengl/gl_shader_manager.h"
-
-namespace GLShader {
-
-namespace Impl {
-void SetShaderUniformBlockBinding(GLuint shader, const char* name,
-                                  Maxwell3D::Regs::ShaderStage binding, size_t expected_size) {
-    GLuint ub_index = glGetUniformBlockIndex(shader, name);
-    if (ub_index != GL_INVALID_INDEX) {
-        GLint ub_size = 0;
-        glGetActiveUniformBlockiv(shader, ub_index, GL_UNIFORM_BLOCK_DATA_SIZE, &ub_size);
-        ASSERT_MSG(ub_size == expected_size,
-                   "Uniform block size did not match! Got %d, expected %zu",
-                   static_cast<int>(ub_size), expected_size);
-        glUniformBlockBinding(shader, ub_index, static_cast<GLuint>(binding));
-    }
-}
-
-void SetShaderUniformBlockBindings(GLuint shader) {
-    SetShaderUniformBlockBinding(shader, "vs_config", Maxwell3D::Regs::ShaderStage::Vertex,
-                                 sizeof(MaxwellUniformData));
-    SetShaderUniformBlockBinding(shader, "gs_config", Maxwell3D::Regs::ShaderStage::Geometry,
-                                 sizeof(MaxwellUniformData));
-    SetShaderUniformBlockBinding(shader, "fs_config", Maxwell3D::Regs::ShaderStage::Fragment,
-                                 sizeof(MaxwellUniformData));
-}
-
-void SetShaderSamplerBindings(GLuint shader) {
-    OpenGLState cur_state = OpenGLState::GetCurState();
-    GLuint old_program = std::exchange(cur_state.draw.shader_program, shader);
-    cur_state.Apply();
-
-    // Set the texture samplers to correspond to different texture units
-    for (u32 texture = 0; texture < NumTextureSamplers; ++texture) {
-        // Set the texture samplers to correspond to different texture units
-        std::string uniform_name = "tex[" + std::to_string(texture) + "]";
-        GLint uniform_tex = glGetUniformLocation(shader, uniform_name.c_str());
-        if (uniform_tex != -1) {
-            glUniform1i(uniform_tex, TextureUnits::MaxwellTexture(texture).id);
-        }
-    }
-
-    cur_state.draw.shader_program = old_program;
-    cur_state.Apply();
-}
-
-} // namespace Impl
-
-void MaxwellUniformData::SetFromRegs(const Maxwell3D::State::ShaderStageInfo& shader_stage) {}
-
-} // namespace GLShader

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -1,165 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <tuple>
-#include <unordered_map>
-#include <boost/functional/hash.hpp>
-#include <glad/glad.h>
-#include "video_core/renderer_opengl/gl_resource_manager.h"
-#include "video_core/renderer_opengl/gl_shader_gen.h"
-#include "video_core/renderer_opengl/maxwell_to_gl.h"
-
-namespace GLShader {
-
-/// Number of OpenGL texture samplers that can be used in the fragment shader
-static constexpr size_t NumTextureSamplers = 32;
-
-using Tegra::Engines::Maxwell3D;
-
-namespace Impl {
-void SetShaderUniformBlockBindings(GLuint shader);
-void SetShaderSamplerBindings(GLuint shader);
-} // namespace Impl
-
-/// Uniform structure for the Uniform Buffer Object, all vectors must be 16-byte aligned
-// NOTE: Always keep a vec4 at the end. The GL spec is not clear wether the alignment at
-//       the end of a uniform block is included in UNIFORM_BLOCK_DATA_SIZE or not.
-//       Not following that rule will cause problems on some AMD drivers.
-struct MaxwellUniformData {
-    void SetFromRegs(const Maxwell3D::State::ShaderStageInfo& shader_stage);
-    // TODO(Subv): Use this for something.
-};
-// static_assert(sizeof(MaxwellUniformData) == 1024, "MaxwellUniformData structure size is
-// incorrect");
-static_assert(sizeof(MaxwellUniformData) < 16384,
-              "MaxwellUniformData structure must be less than 16kb as per the OpenGL spec");
-
-class OGLShaderStage {
-public:
-    OGLShaderStage() = default;
-
-    void Create(const ProgramResult& program_result, GLenum type) {
-        OGLShader shader;
-        shader.Create(program_result.first.c_str(), type);
-        program.Create(true, shader.handle);
-        Impl::SetShaderUniformBlockBindings(program.handle);
-        Impl::SetShaderSamplerBindings(program.handle);
-        entries = program_result.second;
-    }
-    GLuint GetHandle() const {
-        return program.handle;
-    }
-
-    ShaderEntries GetEntries() const {
-        return entries;
-    }
-
-private:
-    OGLProgram program;
-    ShaderEntries entries;
-};
-
-// TODO(wwylele): beautify this doc
-// This is a shader cache designed for translating PICA shader to GLSL shader.
-// The double cache is needed because diffent KeyConfigType, which includes a hash of the code
-// region (including its leftover unused code) can generate the same GLSL code.
-template <typename KeyConfigType,
-          ProgramResult (*CodeGenerator)(const ShaderSetup&, const KeyConfigType&),
-          GLenum ShaderType>
-class ShaderCache {
-public:
-    ShaderCache() = default;
-
-    using Result = std::pair<GLuint, ShaderEntries>;
-
-    Result Get(const KeyConfigType& key, const ShaderSetup& setup) {
-        auto map_it = shader_map.find(key);
-        if (map_it == shader_map.end()) {
-            ProgramResult program = CodeGenerator(setup, key);
-
-            auto [iter, new_shader] = shader_cache.emplace(program.first, OGLShaderStage{});
-            OGLShaderStage& cached_shader = iter->second;
-            if (new_shader) {
-                cached_shader.Create(program, ShaderType);
-            }
-            shader_map[key] = &cached_shader;
-            return {cached_shader.GetHandle(), program.second};
-        } else {
-            return {map_it->second->GetHandle(), map_it->second->GetEntries()};
-        }
-    }
-
-private:
-    std::unordered_map<KeyConfigType, OGLShaderStage*> shader_map;
-    std::unordered_map<std::string, OGLShaderStage> shader_cache;
-};
-
-using VertexShaders = ShaderCache<MaxwellVSConfig, &GenerateVertexShader, GL_VERTEX_SHADER>;
-
-using FragmentShaders = ShaderCache<MaxwellFSConfig, &GenerateFragmentShader, GL_FRAGMENT_SHADER>;
-
-class ProgramManager {
-public:
-    ProgramManager() {
-        pipeline.Create();
-    }
-
-    ShaderEntries UseProgrammableVertexShader(const MaxwellVSConfig& config,
-                                              const ShaderSetup setup) {
-        ShaderEntries result;
-        std::tie(current.vs, result) = vertex_shaders.Get(config, setup);
-        return result;
-    }
-
-    ShaderEntries UseProgrammableFragmentShader(const MaxwellFSConfig& config,
-                                                const ShaderSetup setup) {
-        ShaderEntries result;
-        std::tie(current.fs, result) = fragment_shaders.Get(config, setup);
-        return result;
-    }
-
-    void UseTrivialGeometryShader() {
-        current.gs = 0;
-    }
-
-    void ApplyTo(OpenGLState& state) {
-        // Workaround for AMD bug
-        glUseProgramStages(pipeline.handle,
-                           GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT | GL_FRAGMENT_SHADER_BIT,
-                           0);
-
-        glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, current.vs);
-        glUseProgramStages(pipeline.handle, GL_GEOMETRY_SHADER_BIT, current.gs);
-        glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, current.fs);
-        state.draw.shader_program = 0;
-        state.draw.program_pipeline = pipeline.handle;
-    }
-
-private:
-    struct ShaderTuple {
-        GLuint vs = 0, gs = 0, fs = 0;
-        bool operator==(const ShaderTuple& rhs) const {
-            return std::tie(vs, gs, fs) == std::tie(rhs.vs, rhs.gs, rhs.fs);
-        }
-        struct Hash {
-            std::size_t operator()(const ShaderTuple& tuple) const {
-                std::size_t hash = 0;
-                boost::hash_combine(hash, tuple.vs);
-                boost::hash_combine(hash, tuple.gs);
-                boost::hash_combine(hash, tuple.fs);
-                return hash;
-            }
-        };
-    };
-    ShaderTuple current;
-    VertexShaders vertex_shaders;
-    FragmentShaders fragment_shaders;
-
-    std::unordered_map<ShaderTuple, OGLProgram, ShaderTuple::Hash> program_cache;
-    OGLPipeline pipeline;
-};
-
-} // namespace GLShader

src/video_core/renderer_opengl/gl_shader_util.cpp

@@ -10,41 +10,156 @@
 
 namespace GLShader {
 
-GLuint LoadShader(const char* source, GLenum type) {
-    const char* debug_type;
-    switch (type) {
-    case GL_VERTEX_SHADER:
-        debug_type = "vertex";
-        break;
-    case GL_GEOMETRY_SHADER:
-        debug_type = "geometry";
-        break;
-    case GL_FRAGMENT_SHADER:
-        debug_type = "fragment";
-        break;
-    default:
-        UNREACHABLE();
-    }
-    GLuint shader_id = glCreateShader(type);
-    glShaderSource(shader_id, 1, &source, nullptr);
-    NGLOG_DEBUG(Render_OpenGL, "Compiling {} shader...", debug_type);
-    glCompileShader(shader_id);
+GLuint LoadProgram(const char* vertex_shader, const char* geometry_shader,
+                   const char* fragment_shader, const std::vector<const char*>& feedback_vars,
+                   bool separable_program) {
+    // Create the shaders
+    GLuint vertex_shader_id = vertex_shader ? glCreateShader(GL_VERTEX_SHADER) : 0;
+    GLuint geometry_shader_id = geometry_shader ? glCreateShader(GL_GEOMETRY_SHADER) : 0;
+    GLuint fragment_shader_id = fragment_shader ? glCreateShader(GL_FRAGMENT_SHADER) : 0;
 
     GLint result = GL_FALSE;
-    GLint info_log_length;
-    glGetShaderiv(shader_id, GL_COMPILE_STATUS, &result);
-    glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
+    int info_log_length;
 
-    if (info_log_length > 1) {
-        std::string shader_error(info_log_length, ' ');
-        glGetShaderInfoLog(shader_id, info_log_length, nullptr, &shader_error[0]);
-        if (result == GL_TRUE) {
-            NGLOG_DEBUG(Render_OpenGL, "{}", shader_error);
-        } else {
-            NGLOG_ERROR(Render_OpenGL, "Error compiling {} shader:\n{}", debug_type, shader_error);
+    if (vertex_shader) {
+        // Compile Vertex Shader
+        LOG_DEBUG(Render_OpenGL, "Compiling vertex shader...");
+
+        glShaderSource(vertex_shader_id, 1, &vertex_shader, nullptr);
+        glCompileShader(vertex_shader_id);
+
+        // Check Vertex Shader
+        glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS, &result);
+        glGetShaderiv(vertex_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
+
+        if (info_log_length > 1) {
+            std::vector<char> vertex_shader_error(info_log_length);
+            glGetShaderInfoLog(vertex_shader_id, info_log_length, nullptr, &vertex_shader_error[0]);
+            if (result == GL_TRUE) {
+                LOG_DEBUG(Render_OpenGL, "%s", &vertex_shader_error[0]);
+            } else {
+                LOG_CRITICAL(Render_OpenGL, "Error compiling vertex shader:\n%s",
+                             &vertex_shader_error[0]);
+            }
         }
     }
-    return shader_id;
+
+    if (geometry_shader) {
+        // Compile Geometry Shader
+        LOG_DEBUG(Render_OpenGL, "Compiling geometry shader...");
+
+        glShaderSource(geometry_shader_id, 1, &geometry_shader, nullptr);
+        glCompileShader(geometry_shader_id);
+
+        // Check Geometry Shader
+        glGetShaderiv(geometry_shader_id, GL_COMPILE_STATUS, &result);
+        glGetShaderiv(geometry_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
+
+        if (info_log_length > 1) {
+            std::vector<char> geometry_shader_error(info_log_length);
+            glGetShaderInfoLog(geometry_shader_id, info_log_length, nullptr,
+                               &geometry_shader_error[0]);
+            if (result == GL_TRUE) {
+                LOG_DEBUG(Render_OpenGL, "%s", &geometry_shader_error[0]);
+            } else {
+                LOG_CRITICAL(Render_OpenGL, "Error compiling geometry shader:\n%s",
+                             &geometry_shader_error[0]);
+            }
+        }
+    }
+
+    if (fragment_shader) {
+        // Compile Fragment Shader
+        LOG_DEBUG(Render_OpenGL, "Compiling fragment shader...");
+
+        glShaderSource(fragment_shader_id, 1, &fragment_shader, nullptr);
+        glCompileShader(fragment_shader_id);
+
+        // Check Fragment Shader
+        glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &result);
+        glGetShaderiv(fragment_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
+
+        if (info_log_length > 1) {
+            std::vector<char> fragment_shader_error(info_log_length);
+            glGetShaderInfoLog(fragment_shader_id, info_log_length, nullptr,
+                               &fragment_shader_error[0]);
+            if (result == GL_TRUE) {
+                LOG_DEBUG(Render_OpenGL, "%s", &fragment_shader_error[0]);
+            } else {
+                LOG_CRITICAL(Render_OpenGL, "Error compiling fragment shader:\n%s",
+                             &fragment_shader_error[0]);
+            }
+        }
+    }
+
+    // Link the program
+    LOG_DEBUG(Render_OpenGL, "Linking program...");
+
+    GLuint program_id = glCreateProgram();
+    if (vertex_shader) {
+        glAttachShader(program_id, vertex_shader_id);
+    }
+    if (geometry_shader) {
+        glAttachShader(program_id, geometry_shader_id);
+    }
+    if (fragment_shader) {
+        glAttachShader(program_id, fragment_shader_id);
+    }
+
+    if (!feedback_vars.empty()) {
+        auto varyings = feedback_vars;
+        glTransformFeedbackVaryings(program_id, static_cast<GLsizei>(feedback_vars.size()),
+                                    &varyings[0], GL_INTERLEAVED_ATTRIBS);
+    }
+
+    if (separable_program) {
+        glProgramParameteri(program_id, GL_PROGRAM_SEPARABLE, GL_TRUE);
+    }
+
+    glLinkProgram(program_id);
+
+    // Check the program
+    glGetProgramiv(program_id, GL_LINK_STATUS, &result);
+    glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &info_log_length);
+
+    if (info_log_length > 1) {
+        std::vector<char> program_error(info_log_length);
+        glGetProgramInfoLog(program_id, info_log_length, nullptr, &program_error[0]);
+        if (result == GL_TRUE) {
+            LOG_DEBUG(Render_OpenGL, "%s", &program_error[0]);
+        } else {
+            LOG_CRITICAL(Render_OpenGL, "Error linking shader:\n%s", &program_error[0]);
+        }
+    }
+
+    // If the program linking failed at least one of the shaders was probably bad
+    if (result == GL_FALSE) {
+        if (vertex_shader) {
+            LOG_CRITICAL(Render_OpenGL, "Vertex shader:\n%s", vertex_shader);
+        }
+        if (geometry_shader) {
+            LOG_CRITICAL(Render_OpenGL, "Geometry shader:\n%s", geometry_shader);
+        }
+        if (fragment_shader) {
+            LOG_CRITICAL(Render_OpenGL, "Fragment shader:\n%s", fragment_shader);
+        }
+    }
+    ASSERT_MSG(result == GL_TRUE, "Shader not linked");
+
+    if (vertex_shader) {
+        glDetachShader(program_id, vertex_shader_id);
+        glDeleteShader(vertex_shader_id);
+    }
+    if (geometry_shader) {
+        glDetachShader(program_id, geometry_shader_id);
+        glDeleteShader(geometry_shader_id);
+    }
+    if (fragment_shader) {
+        glDetachShader(program_id, fragment_shader_id);
+        glDeleteShader(fragment_shader_id);
+    }
+
+    return program_id;
 }
 
 } // namespace GLShader

src/video_core/renderer_opengl/gl_shader_util.h

@@ -6,60 +6,18 @@
 
 #include <vector>
 #include <glad/glad.h>
-#include "common/assert.h"
-#include "common/logging/log.h"
 
 namespace GLShader {
 
-/**
- * Utility function to create and compile an OpenGL GLSL shader
- * @param source String of the GLSL shader program
- * @param type Type of the shader (GL_VERTEX_SHADER, GL_GEOMETRY_SHADER or GL_FRAGMENT_SHADER)
- */
-GLuint LoadShader(const char* source, GLenum type);
-
 /**
  * Utility function to create and compile an OpenGL GLSL shader program (vertex + fragment shader)
- * @param separable_program whether to create a separable program
- * @param shaders ID of shaders to attach to the program
- * @returns Handle of the newly created OpenGL program object
+ * @param vertex_shader String of the GLSL vertex shader program
+ * @param geometry_shader String of the GLSL geometry shader program
+ * @param fragment_shader String of the GLSL fragment shader program
+ * @returns Handle of the newly created OpenGL shader object
  */
-template <typename... T>
-GLuint LoadProgram(bool separable_program, T... shaders) {
-    // Link the program
-    NGLOG_DEBUG(Render_OpenGL, "Linking program...");
-
-    GLuint program_id = glCreateProgram();
-
-    ((shaders == 0 ? (void)0 : glAttachShader(program_id, shaders)), ...);
-
-    if (separable_program) {
-        glProgramParameteri(program_id, GL_PROGRAM_SEPARABLE, GL_TRUE);
-    }
-
-    glLinkProgram(program_id);
-
-    // Check the program
-    GLint result = GL_FALSE;
-    GLint info_log_length;
-    glGetProgramiv(program_id, GL_LINK_STATUS, &result);
-    glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &info_log_length);
-
-    if (info_log_length > 1) {
-        std::string program_error(info_log_length, ' ');
-        glGetProgramInfoLog(program_id, info_log_length, nullptr, &program_error[0]);
-        if (result == GL_TRUE) {
-            NGLOG_DEBUG(Render_OpenGL, "{}", program_error);
-        } else {
-            NGLOG_ERROR(Render_OpenGL, "Error linking shader:\n{}", program_error);
-        }
-    }
-
-    ASSERT_MSG(result == GL_TRUE, "Shader not linked");
-
-    ((shaders == 0 ? (void)0 : glDetachShader(program_id, shaders)), ...);
-
-    return program_id;
-}
+GLuint LoadProgram(const char* vertex_shader, const char* geometry_shader,
+                   const char* fragment_shader, const std::vector<const char*>& feedback_vars = {},
+                   bool separable_program = false);
 
 } // namespace GLShader

src/video_core/renderer_opengl/gl_state.cpp

@@ -194,7 +194,7 @@ void OpenGLState::Apply() const {
     // Textures
     for (unsigned i = 0; i < ARRAY_SIZE(texture_units); ++i) {
         if (texture_units[i].texture_2d != cur_state.texture_units[i].texture_2d) {
-            glActiveTexture(TextureUnits::MaxwellTexture(i).Enum());
+            glActiveTexture(TextureUnits::PicaTexture(i).Enum());
             glBindTexture(GL_TEXTURE_2D, texture_units[i].texture_2d);
         }
         if (texture_units[i].sampler != cur_state.texture_units[i].sampler) {
@@ -202,20 +202,6 @@ void OpenGLState::Apply() const {
         }
     }
 
-    // Constbuffers
-    for (u32 stage = 0; stage < draw.const_buffers.size(); ++stage) {
-        for (u32 buffer_id = 0; buffer_id < draw.const_buffers[stage].size(); ++buffer_id) {
-            auto& current = cur_state.draw.const_buffers[stage][buffer_id];
-            auto& new_state = draw.const_buffers[stage][buffer_id];
-            if (current.enabled != new_state.enabled || current.bindpoint != new_state.bindpoint ||
-                current.ssbo != new_state.ssbo) {
-                if (new_state.enabled) {
-                    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, new_state.bindpoint, new_state.ssbo);
-                }
-            }
-        }
-    }
-
     // Lighting LUTs
     if (lighting_lut.texture_buffer != cur_state.lighting_lut.texture_buffer) {
         glActiveTexture(TextureUnits::LightingLUT.Enum());