GPU: Assert when finding a texture with a format type other than UNORM.

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.
This mapping will have to be passed to the shader decompiler so it can rewrite the texture accesses.

README.md

@@ -7,7 +7,7 @@ yuzu is an experimental open-source emulator for the Nintendo Switch from the cr
 
 It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.
 
-yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu cannot play any commercial games without major problems. yuzu can boot some games, to varying degrees of success, but does not implement any of the necessary GPU features to render 3D graphics.
+yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu does not run any commercial Switch games. yuzu can boot some games, to varying degrees of success, but does not implement any of the necessary GPU features to render 3D graphics.
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

src/common/CMakeLists.txt

@@ -32,14 +32,14 @@ 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
     common_paths.h
     common_types.h
     file_util.cpp
     file_util.h
+    hash.cpp
     hash.h
     linear_disk_cache.h
     logging/backend.cpp

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;
     }
 
@@ -192,6 +192,11 @@ private:
     static_assert(position < 8 * sizeof(T), "Invalid position");
     static_assert(bits <= 8 * sizeof(T), "Invalid number of bits");
     static_assert(bits > 0, "Invalid number of bits");
-    static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable in a BitField");
+    static_assert(std::is_pod<T>::value, "Invalid base type");
 };
 #pragma pack()
+
+#if (__GNUC__ >= 5) || defined(__clang__) || defined(_MSC_VER)
+static_assert(std::is_trivially_copyable<BitField<0, 1, unsigned>>::value,
+              "BitField must be trivially copyable");
+#endif

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/code_block.h

@@ -0,0 +1,85 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstddef>
+#include "common/common_types.h"
+#include "common/memory_util.h"
+
+// Everything that needs to generate code should inherit from this.
+// You get memory management for free, plus, you can use all emitter functions without
+// having to prefix them with gen-> or something similar.
+// Example implementation:
+// class JIT : public CodeBlock<ARMXEmitter> {}
+template <class T>
+class CodeBlock : public T, NonCopyable {
+private:
+    // A privately used function to set the executable RAM space to something invalid.
+    // For debugging usefulness it should be used to set the RAM to a host specific breakpoint
+    // instruction
+    virtual void PoisonMemory() = 0;
+
+protected:
+    u8* region;
+    size_t region_size;
+
+public:
+    CodeBlock() : region(nullptr), region_size(0) {}
+    virtual ~CodeBlock() {
+        if (region)
+            FreeCodeSpace();
+    }
+
+    // Call this before you generate any code.
+    void AllocCodeSpace(int size) {
+        region_size = size;
+        region = (u8*)AllocateExecutableMemory(region_size);
+        T::SetCodePtr(region);
+    }
+
+    // Always clear code space with breakpoints, so that if someone accidentally executes
+    // uninitialized, it just breaks into the debugger.
+    void ClearCodeSpace() {
+        PoisonMemory();
+        ResetCodePtr();
+    }
+
+    // Call this when shutting down. Don't rely on the destructor, even though it'll do the job.
+    void FreeCodeSpace() {
+#ifdef __SYMBIAN32__
+        ResetExecutableMemory(region);
+#else
+        FreeMemoryPages(region, region_size);
+#endif
+        region = nullptr;
+        region_size = 0;
+    }
+
+    bool IsInSpace(const u8* ptr) {
+        return (ptr >= region) && (ptr < (region + region_size));
+    }
+
+    // Cannot currently be undone. Will write protect the entire code region.
+    // Start over if you need to change the code (call FreeCodeSpace(), AllocCodeSpace()).
+    void WriteProtect() {
+        WriteProtectMemory(region, region_size, true);
+    }
+
+    void ResetCodePtr() {
+        T::SetCodePtr(region);
+    }
+
+    size_t GetSpaceLeft() const {
+        return region_size - (T::GetCodePtr() - region);
+    }
+
+    u8* GetBasePtr() {
+        return region;
+    }
+
+    size_t GetOffset(const u8* ptr) const {
+        return ptr - region;
+    }
+};

src/common/common_funcs.h

@@ -9,6 +9,8 @@
 #endif
 #include "common/common_types.h"
 
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
 /// Textually concatenates two tokens. The double-expansion is required by the C preprocessor.
 #define CONCAT2(x, y) DO_CONCAT2(x, y)
 #define DO_CONCAT2(x, y) x##y
@@ -72,6 +74,11 @@ inline u64 _rotr64(u64 x, unsigned int shift) {
 
 #else // _MSC_VER
 
+#if (_MSC_VER < 1900)
+// Function Cross-Compatibility
+#define snprintf _snprintf
+#endif
+
 // Locale Cross-Compatibility
 #define locale_t _locale_t
 

src/common/common_types.h

@@ -27,23 +27,29 @@
 #include <array>
 #include <cstdint>
 
-using u8 = std::uint8_t;   ///< 8-bit unsigned byte
-using u16 = std::uint16_t; ///< 16-bit unsigned short
-using u32 = std::uint32_t; ///< 32-bit unsigned word
-using u64 = std::uint64_t; ///< 64-bit unsigned int
+#ifdef _MSC_VER
+#ifndef __func__
+#define __func__ __FUNCTION__
+#endif
+#endif
 
-using s8 = std::int8_t;   ///< 8-bit signed byte
-using s16 = std::int16_t; ///< 16-bit signed short
-using s32 = std::int32_t; ///< 32-bit signed word
-using s64 = std::int64_t; ///< 64-bit signed int
+typedef std::uint8_t u8;   ///< 8-bit unsigned byte
+typedef std::uint16_t u16; ///< 16-bit unsigned short
+typedef std::uint32_t u32; ///< 32-bit unsigned word
+typedef std::uint64_t u64; ///< 64-bit unsigned int
 
-using f32 = float;  ///< 32-bit floating point
-using f64 = double; ///< 64-bit floating point
+typedef std::int8_t s8;   ///< 8-bit signed byte
+typedef std::int16_t s16; ///< 16-bit signed short
+typedef std::int32_t s32; ///< 32-bit signed word
+typedef std::int64_t s64; ///< 64-bit signed int
+
+typedef float f32;  ///< 32-bit floating point
+typedef double f64; ///< 64-bit floating point
 
 // TODO: It would be nice to eventually replace these with strong types that prevent accidental
 // conversion between each other.
-using VAddr = u64; ///< Represents a pointer in the userspace virtual address space.
-using PAddr = u64; ///< Represents a pointer in the ARM11 physical address space.
+typedef u64 VAddr; ///< Represents a pointer in the userspace virtual address space.
+typedef u64 PAddr; ///< Represents a pointer in the ARM11 physical address space.
 
 using u128 = std::array<std::uint64_t, 2>;
 static_assert(sizeof(u128) == 16, "u128 must be 128 bits wide");

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

@@ -146,9 +146,8 @@ void LogMessage(Class log_class, Level log_level, const char* filename, unsigned
     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) {
+void LogMessage(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 =

src/common/logging/log.h

@@ -105,15 +105,13 @@ void LogMessage(Class log_class, Level log_level, const char* filename, unsigned
     ;
 
 /// 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);
+void LogMessage(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...));
+    LogMessage(log_class, log_level, filename, line_num, function, format, fmt::make_args(args...));
 }
 
 } // namespace Log

src/common/math_util.h

@@ -17,6 +17,11 @@ inline bool IntervalsIntersect(unsigned start0, unsigned length0, unsigned start
     return (std::max(start0, start1) < std::min(start0 + length0, start1 + length1));
 }
 
+template <typename T>
+inline T Clamp(const T val, const T& min, const T& max) {
+    return std::max(min, std::min(max, val));
+}
+
 template <class T>
 struct Rectangle {
     T left;

src/common/thread.h

@@ -11,6 +11,25 @@
 #include <thread>
 #include "common/common_types.h"
 
+// Support for C++11's thread_local keyword was surprisingly spotty in compilers until very
+// recently. Fortunately, thread local variables have been well supported for compilers for a while,
+// but with semantics supporting only POD types, so we can use a few defines to get some amount of
+// backwards compat support.
+// WARNING: This only works correctly with POD types.
+#if defined(__clang__)
+#if !__has_feature(cxx_thread_local)
+#define thread_local __thread
+#endif
+#elif defined(__GNUC__)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
+#define thread_local __thread
+#endif
+#elif defined(_MSC_VER)
+#if _MSC_VER < 1900
+#define thread_local __declspec(thread)
+#endif
+#endif
+
 namespace Common {
 
 int CurrentThreadId();

src/common/vector_math.h

@@ -55,6 +55,10 @@ public:
     T x;
     T y;
 
+    T* AsArray() {
+        return &x;
+    }
+
     Vec2() = default;
     Vec2(const T& _x, const T& _y) : x(_x), y(_y) {}
 
@@ -67,6 +71,11 @@ public:
         return Vec2<T>(f, f);
     }
 
+    void Write(T a[2]) {
+        a[0] = x;
+        a[1] = y;
+    }
+
     Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
         return MakeVec(x + other.x, y + other.y);
     }
@@ -196,6 +205,10 @@ public:
     T y;
     T z;
 
+    T* AsArray() {
+        return &x;
+    }
+
     Vec3() = default;
     Vec3(const T& _x, const T& _y, const T& _z) : x(_x), y(_y), z(_z) {}
 
@@ -212,6 +225,12 @@ public:
         return MakeVec(f, f, f);
     }
 
+    void Write(T a[3]) {
+        a[0] = x;
+        a[1] = y;
+        a[2] = z;
+    }
+
     Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
         return MakeVec(x + other.x, y + other.y, z + other.z);
     }
@@ -397,6 +416,10 @@ public:
     T z;
     T w;
 
+    T* AsArray() {
+        return &x;
+    }
+
     Vec4() = default;
     Vec4(const T& _x, const T& _y, const T& _z, const T& _w) : x(_x), y(_y), z(_z), w(_w) {}
 
@@ -413,6 +436,13 @@ public:
         return Vec4<T>(f, f, f, f);
     }
 
+    void Write(T a[4]) {
+        a[0] = x;
+        a[1] = y;
+        a[2] = z;
+        a[3] = w;
+    }
+
     Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
         return MakeVec(x + other.x, y + other.y, z + other.z, w + other.w);
     }

src/core/CMakeLists.txt

@@ -12,8 +12,6 @@ add_library(core STATIC
     file_sys/errors.h
     file_sys/filesystem.cpp
     file_sys/filesystem.h
-    file_sys/partition_filesystem.cpp
-    file_sys/partition_filesystem.h
     file_sys/path_parser.cpp
     file_sys/path_parser.h
     file_sys/program_metadata.cpp
@@ -90,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
@@ -138,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

@@ -57,14 +57,10 @@ ResultVal<std::unique_ptr<StorageBackend>> Disk_FileSystem::OpenFile(const std::
         std::make_unique<Disk_Storage>(std::move(file)));
 }
 
-ResultCode Disk_FileSystem::DeleteFile(const std::string& path) const {
-    if (!FileUtil::Exists(path)) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    FileUtil::Delete(path);
-
-    return RESULT_SUCCESS;
+ResultCode Disk_FileSystem::DeleteFile(const Path& path) const {
+    LOG_WARNING(Service_FS, "(STUBBED) called");
+    // TODO(bunnei): Use correct error code
+    return ResultCode(-1);
 }
 
 ResultCode Disk_FileSystem::RenameFile(const Path& src_path, const Path& dest_path) const {
@@ -183,7 +179,7 @@ bool Disk_Storage::SetSize(const u64 size) const {
     return true;
 }
 
-Disk_Directory::Disk_Directory(const std::string& path) {
+Disk_Directory::Disk_Directory(const std::string& path) : directory() {
     unsigned size = FileUtil::ScanDirectoryTree(path, directory);
     directory.size = size;
     directory.isDirectory = true;

src/core/file_sys/disk_filesystem.h

@@ -25,7 +25,7 @@ public:
 
     ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
                                                         Mode mode) const override;
-    ResultCode DeleteFile(const std::string& path) const override;
+    ResultCode DeleteFile(const Path& path) const override;
     ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
     ResultCode DeleteDirectory(const Path& path) const override;
     ResultCode DeleteDirectoryRecursively(const Path& path) const override;
@@ -43,7 +43,7 @@ protected:
 
 class Disk_Storage : public StorageBackend {
 public:
-    explicit Disk_Storage(std::shared_ptr<FileUtil::IOFile> file) : file(std::move(file)) {}
+    Disk_Storage(std::shared_ptr<FileUtil::IOFile> file) : file(std::move(file)) {}
 
     ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const override;
     ResultVal<size_t> Write(u64 offset, size_t length, bool flush, const u8* buffer) const override;
@@ -60,7 +60,7 @@ private:
 
 class Disk_Directory : public DirectoryBackend {
 public:
-    explicit Disk_Directory(const std::string& path);
+    Disk_Directory(const std::string& path);
 
     ~Disk_Directory() override {
         Close();
@@ -74,6 +74,7 @@ public:
     }
 
 protected:
+    u32 total_entries_in_directory;
     FileUtil::FSTEntry directory;
 
     // We need to remember the last entry we returned, so a subsequent call to Read will continue

src/core/file_sys/filesystem.h

@@ -97,7 +97,7 @@ public:
      * @param path Path relative to the archive
      * @return Result of the operation
      */
-    virtual ResultCode DeleteFile(const std::string& path) const = 0;
+    virtual ResultCode DeleteFile(const Path& path) const = 0;
 
     /**
      * Create a directory specified by its path

src/core/file_sys/partition_filesystem.cpp

@@ -1,125 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cinttypes>
-#include <utility>
-#include "common/file_util.h"
-#include "common/logging/log.h"
-#include "core/file_sys/partition_filesystem.h"
-#include "core/loader/loader.h"
-
-namespace FileSys {
-
-Loader::ResultStatus PartitionFilesystem::Load(const std::string& file_path, size_t offset) {
-    FileUtil::IOFile file(file_path, "rb");
-    if (!file.IsOpen())
-        return Loader::ResultStatus::Error;
-
-    // At least be as large as the header
-    if (file.GetSize() < sizeof(Header))
-        return Loader::ResultStatus::Error;
-
-    // For cartridges, HFSs can get very large, so we need to calculate the size up to
-    // the actual content itself instead of just blindly reading in the entire file.
-    Header pfs_header;
-    if (!file.ReadBytes(&pfs_header, sizeof(Header)))
-        return Loader::ResultStatus::Error;
-
-    bool is_hfs = (memcmp(pfs_header.magic.data(), "HFS", 3) == 0);
-    size_t entry_size = is_hfs ? sizeof(HFSEntry) : sizeof(PFSEntry);
-    size_t metadata_size =
-        sizeof(Header) + (pfs_header.num_entries * entry_size) + pfs_header.strtab_size;
-
-    // Actually read in now...
-    file.Seek(offset, SEEK_SET);
-    std::vector<u8> file_data(metadata_size);
-
-    if (!file.ReadBytes(file_data.data(), metadata_size))
-        return Loader::ResultStatus::Error;
-
-    Loader::ResultStatus result = Load(file_data);
-    if (result != Loader::ResultStatus::Success)
-        LOG_ERROR(Service_FS, "Failed to load PFS from file %s!", file_path.c_str());
-
-    return result;
-}
-
-Loader::ResultStatus PartitionFilesystem::Load(const std::vector<u8>& file_data, size_t offset) {
-    size_t total_size = file_data.size() - offset;
-    if (total_size < sizeof(Header))
-        return Loader::ResultStatus::Error;
-
-    memcpy(&pfs_header, &file_data[offset], sizeof(Header));
-    is_hfs = (memcmp(pfs_header.magic.data(), "HFS", 3) == 0);
-
-    size_t entries_offset = offset + sizeof(Header);
-    size_t entry_size = is_hfs ? sizeof(HFSEntry) : sizeof(PFSEntry);
-    size_t strtab_offset = entries_offset + (pfs_header.num_entries * entry_size);
-    for (u16 i = 0; i < pfs_header.num_entries; i++) {
-        FileEntry entry;
-
-        memcpy(&entry.fs_entry, &file_data[entries_offset + (i * entry_size)], sizeof(FSEntry));
-        entry.name = std::string(reinterpret_cast<const char*>(
-            &file_data[strtab_offset + entry.fs_entry.strtab_offset]));
-        pfs_entries.push_back(std::move(entry));
-    }
-
-    content_offset = strtab_offset + pfs_header.strtab_size;
-
-    return Loader::ResultStatus::Success;
-}
-
-u32 PartitionFilesystem::GetNumEntries() const {
-    return pfs_header.num_entries;
-}
-
-u64 PartitionFilesystem::GetEntryOffset(int index) const {
-    if (index > GetNumEntries())
-        return 0;
-
-    return content_offset + pfs_entries[index].fs_entry.offset;
-}
-
-u64 PartitionFilesystem::GetEntrySize(int index) const {
-    if (index > GetNumEntries())
-        return 0;
-
-    return pfs_entries[index].fs_entry.size;
-}
-
-std::string PartitionFilesystem::GetEntryName(int index) const {
-    if (index > GetNumEntries())
-        return "";
-
-    return pfs_entries[index].name;
-}
-
-u64 PartitionFilesystem::GetFileOffset(const std::string& name) const {
-    for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        if (pfs_entries[i].name == name)
-            return content_offset + pfs_entries[i].fs_entry.offset;
-    }
-
-    return 0;
-}
-
-u64 PartitionFilesystem::GetFileSize(const std::string& name) const {
-    for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        if (pfs_entries[i].name == name)
-            return pfs_entries[i].fs_entry.size;
-    }
-
-    return 0;
-}
-
-void PartitionFilesystem::Print() const {
-    NGLOG_DEBUG(Service_FS, "Magic:                  {:.4}", pfs_header.magic.data());
-    NGLOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
-    for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        NGLOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes, at 0x{:X})", i,
-                    pfs_entries[i].name.c_str(), pfs_entries[i].fs_entry.size,
-                    GetFileOffset(pfs_entries[i].name));
-    }
-}
-} // namespace FileSys

src/core/file_sys/partition_filesystem.h

@@ -1,87 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <string>
-#include <vector>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-
-namespace Loader {
-enum class ResultStatus;
-}
-
-namespace FileSys {
-
-/**
- * Helper which implements an interface to parse PFS/HFS filesystems.
- * Data can either be loaded from a file path or data with an offset into it.
- */
-class PartitionFilesystem {
-public:
-    Loader::ResultStatus Load(const std::string& file_path, size_t offset = 0);
-    Loader::ResultStatus Load(const std::vector<u8>& file_data, size_t offset = 0);
-
-    u32 GetNumEntries() const;
-    u64 GetEntryOffset(int index) const;
-    u64 GetEntrySize(int index) const;
-    std::string GetEntryName(int index) const;
-    u64 GetFileOffset(const std::string& name) const;
-    u64 GetFileSize(const std::string& name) const;
-
-    void Print() const;
-
-private:
-    struct Header {
-        std::array<char, 4> magic;
-        u32_le num_entries;
-        u32_le strtab_size;
-        INSERT_PADDING_BYTES(0x4);
-    };
-
-    static_assert(sizeof(Header) == 0x10, "PFS/HFS header structure size is wrong");
-
-#pragma pack(push, 1)
-    struct FSEntry {
-        u64_le offset;
-        u64_le size;
-        u32_le strtab_offset;
-    };
-
-    static_assert(sizeof(FSEntry) == 0x14, "FS entry structure size is wrong");
-
-    struct PFSEntry {
-        FSEntry fs_entry;
-        INSERT_PADDING_BYTES(0x4);
-    };
-
-    static_assert(sizeof(PFSEntry) == 0x18, "PFS entry structure size is wrong");
-
-    struct HFSEntry {
-        FSEntry fs_entry;
-        u32_le hash_region_size;
-        INSERT_PADDING_BYTES(0x8);
-        std::array<char, 0x20> hash;
-    };
-
-    static_assert(sizeof(HFSEntry) == 0x40, "HFS entry structure size is wrong");
-
-#pragma pack(pop)
-
-    struct FileEntry {
-        FSEntry fs_entry;
-        std::string name;
-    };
-
-    Header pfs_header;
-    bool is_hfs;
-    size_t content_offset;
-
-    std::vector<FileEntry> pfs_entries;
-};
-
-} // namespace FileSys

src/core/file_sys/romfs_filesystem.cpp

@@ -20,7 +20,7 @@ ResultVal<std::unique_ptr<StorageBackend>> RomFS_FileSystem::OpenFile(const std:
         std::make_unique<RomFS_Storage>(romfs_file, data_offset, data_size));
 }
 
-ResultCode RomFS_FileSystem::DeleteFile(const std::string& path) const {
+ResultCode RomFS_FileSystem::DeleteFile(const Path& path) const {
     LOG_CRITICAL(Service_FS, "Attempted to delete a file from an ROMFS archive (%s).",
                  GetName().c_str());
     // TODO(bunnei): Use correct error code

src/core/file_sys/romfs_filesystem.h

@@ -31,7 +31,7 @@ public:
 
     ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
                                                         Mode mode) const override;
-    ResultCode DeleteFile(const std::string& path) const override;
+    ResultCode DeleteFile(const Path& path) const override;
     ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
     ResultCode DeleteDirectory(const Path& path) const override;
     ResultCode DeleteDirectoryRecursively(const Path& path) const override;

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

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <cinttypes>
-#include <iterator>
 
 #include "common/logging/log.h"
 #include "common/microprofile.h"
@@ -372,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);
@@ -862,14 +849,14 @@ static const FunctionDef SVC_Table[] = {
     {0x2B, nullptr, "FlushDataCache"},
     {0x2C, nullptr, "MapPhysicalMemory"},
     {0x2D, nullptr, "UnmapPhysicalMemory"},
-    {0x2E, nullptr, "GetNextThreadInfo"},
+    {0x2E, nullptr, "Unknown"},
     {0x2F, nullptr, "GetLastThreadInfo"},
     {0x30, nullptr, "GetResourceLimitLimitValue"},
     {0x31, nullptr, "GetResourceLimitCurrentValue"},
-    {0x32, SvcWrap<SetThreadActivity>, "SetThreadActivity"},
-    {0x33, SvcWrap<GetThreadContext>, "GetThreadContext"},
-    {0x34, nullptr, "WaitForAddress"},
-    {0x35, nullptr, "SignalToAddress"},
+    {0x32, nullptr, "SetThreadActivity"},
+    {0x33, nullptr, "GetThreadContext"},
+    {0x34, nullptr, "Unknown"},
+    {0x35, nullptr, "Unknown"},
     {0x36, nullptr, "Unknown"},
     {0x37, nullptr, "Unknown"},
     {0x38, nullptr, "Unknown"},
@@ -877,7 +864,7 @@ static const FunctionDef SVC_Table[] = {
     {0x3A, nullptr, "Unknown"},
     {0x3B, nullptr, "Unknown"},
     {0x3C, nullptr, "DumpInfo"},
-    {0x3D, nullptr, "DumpInfoNew"},
+    {0x3D, nullptr, "Unknown"},
     {0x3E, nullptr, "Unknown"},
     {0x3F, nullptr, "Unknown"},
     {0x40, nullptr, "CreateSession"},
@@ -888,9 +875,9 @@ static const FunctionDef SVC_Table[] = {
     {0x45, nullptr, "CreateEvent"},
     {0x46, nullptr, "Unknown"},
     {0x47, nullptr, "Unknown"},
-    {0x48, nullptr, "AllocateUnsafeMemory"},
-    {0x49, nullptr, "FreeUnsafeMemory"},
-    {0x4A, nullptr, "SetUnsafeAllocationLimit"},
+    {0x48, nullptr, "Unknown"},
+    {0x49, nullptr, "Unknown"},
+    {0x4A, nullptr, "Unknown"},
     {0x4B, nullptr, "CreateJitMemory"},
     {0x4C, nullptr, "MapJitMemory"},
     {0x4D, nullptr, "SleepSystem"},
@@ -927,7 +914,7 @@ static const FunctionDef SVC_Table[] = {
     {0x6C, nullptr, "SetHardwareBreakPoint"},
     {0x6D, nullptr, "GetDebugThreadParam"},
     {0x6E, nullptr, "Unknown"},
-    {0x6F, nullptr, "GetMemoryInfo"},
+    {0x6F, nullptr, "Unknown"},
     {0x70, nullptr, "CreatePort"},
     {0x71, nullptr, "ManageNamedPort"},
     {0x72, nullptr, "ConnectToPort"},
@@ -947,7 +934,7 @@ static const FunctionDef SVC_Table[] = {
 };
 
 static const FunctionDef* GetSVCInfo(u32 func_num) {
-    if (func_num >= std::size(SVC_Table)) {
+    if (func_num >= ARRAY_SIZE(SVC_Table)) {
         LOG_ERROR(Kernel_SVC, "unknown svc=0x%02X", func_num);
         return nullptr;
     }

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/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,149 +2,15 @@
 // 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::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[] = {
-            {0, nullptr, "Get"},
-            {1, &IProfile::GetBase, "GetBase"},
-            {10, nullptr, "GetImageSize"},
-            {11, nullptr, "LoadImage"},
-        };
-        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"},
-            {2, nullptr, "EnsureIdTokenCacheAsync"},
-            {3, nullptr, "LoadIdTokenCache"},
-            {130, nullptr, "GetNintendoAccountUserResourceCacheForApplication"},
-            {150, nullptr, "CreateAuthorizationRequest"},
-            {160, nullptr, "StoreOpenContext"},
-        };
-        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)) {}
+namespace Service {
+namespace Account {
 
 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 Service::Account
+} // namespace Account
+} // namespace Service

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

@@ -6,28 +6,11 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::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;
-    };
-};
+namespace Service {
+namespace Account {
 
 /// Registers all ACC services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::Account
+} // namespace Account
+} // namespace Service

src/core/hle/service/acc/acc_aa.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/acc/acc_aa.h"
-
-namespace Service::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 Service::Account

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

@@ -1,16 +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::Account {
-
-class ACC_AA final : public Module::Interface {
-public:
-    explicit ACC_AA(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::Account

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

@@ -1,53 +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::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 Service::Account

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,32 +2,123 @@
 // 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::Account {
+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);
 }
 
-} // namespace Service::Account
+} // namespace Account
+} // namespace Service

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

@@ -4,13 +4,37 @@
 
 #pragma once
 
-#include "core/hle/service/acc/acc.h"
+#include "core/hle/service/service.h"
 
-namespace Service::Account {
+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 Service::Account
+} // namespace Account
+} // namespace Service

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

@@ -1,40 +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::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 Service::Account

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

@@ -1,16 +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::Account {
-
-class ACC_U1 final : public Module::Interface {
-public:
-    explicit ACC_U1(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::Account

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

@@ -14,15 +14,13 @@
 #include "core/hle/service/nvflinger/nvflinger.h"
 #include "core/settings.h"
 
-namespace Service::AM {
+namespace Service {
+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);
 }
@@ -80,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,
@@ -93,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);
 
@@ -232,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);
 
@@ -325,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"},
@@ -377,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);
@@ -420,7 +372,6 @@ public:
         : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
         static const FunctionInfo functions[] = {
             {0, &IStorage::Open, "Open"},
-            {1, nullptr, "OpenTransferStorage"},
         };
         RegisterHandlers(functions);
     }
@@ -441,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);
 }
@@ -570,4 +491,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager,
     std::make_shared<AppletOE>(nvflinger)->InstallAsService(service_manager);
 }
 
-} // namespace Service::AM
+} // namespace AM
+} // namespace Service

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

@@ -8,7 +8,8 @@
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 
-namespace Service::AM {
+namespace Service {
+namespace AM {
 
 class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
 public:
@@ -20,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"},
@@ -108,4 +108,5 @@ AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     RegisterHandlers(functions);
 }
 
-} // namespace Service::AM
+} // namespace AM
+} // namespace Service

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

@@ -8,7 +8,8 @@
 #include "core/hle/service/am/applet_oe.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 
-namespace Service::AM {
+namespace Service {
+namespace AM {
 
 class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
@@ -20,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"},
@@ -103,4 +103,5 @@ AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     RegisterHandlers(functions);
 }
 
-} // namespace Service::AM
+} // namespace AM
+} // namespace Service

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

@@ -6,7 +6,8 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/aoc/aoc_u.h"
 
-namespace Service::AOC {
+namespace Service {
+namespace AOC {
 
 AOC_U::AOC_U() : ServiceFramework("aoc:u") {
     static const FunctionInfo functions[] = {
@@ -18,7 +19,6 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u") {
         {5, nullptr, "GetAddOnContentBaseId"},
         {6, nullptr, "PrepareAddOnContentByApplicationId"},
         {7, nullptr, "PrepareAddOnContent"},
-        {8, nullptr, "GetAddOnContentListChangedEvent"},
     };
     RegisterHandlers(functions);
 }
@@ -41,4 +41,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<AOC_U>()->InstallAsService(service_manager);
 }
 
-} // namespace Service::AOC
+} // namespace AOC
+} // namespace Service

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

@@ -6,7 +6,8 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::AOC {
+namespace Service {
+namespace AOC {
 
 class AOC_U final : public ServiceFramework<AOC_U> {
 public:
@@ -21,4 +22,5 @@ private:
 /// Registers all AOC services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::AOC
+} // namespace AOC
+} // namespace Service

src/core/hle/service/apm/apm.cpp

@@ -7,7 +7,8 @@
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/apm/interface.h"
 
-namespace Service::APM {
+namespace Service {
+namespace APM {
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module_ = std::make_shared<Module>();
@@ -15,4 +16,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<APM>(module_, "apm:p")->InstallAsService(service_manager);
 }
 
-} // namespace Service::APM
+} // namespace APM
+} // namespace Service

src/core/hle/service/apm/apm.h

@@ -6,7 +6,8 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::APM {
+namespace Service {
+namespace APM {
 
 enum class PerformanceMode : u8 {
     Handheld = 0,
@@ -22,4 +23,5 @@ public:
 /// Registers all AM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::APM
+} // namespace APM
+} // namespace Service

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

@@ -7,7 +7,8 @@
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/apm/interface.h"
 
-namespace Service::APM {
+namespace Service {
+namespace APM {
 
 class ISession final : public ServiceFramework<ISession> {
 public:
@@ -61,4 +62,5 @@ void APM::OpenSession(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<ISession>();
 }
 
-} // namespace Service::APM
+} // namespace APM
+} // namespace Service

src/core/hle/service/apm/interface.h

@@ -6,7 +6,8 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::APM {
+namespace Service {
+namespace APM {
 
 class APM final : public ServiceFramework<APM> {
 public:
@@ -22,4 +23,5 @@ private:
 /// Registers all AM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::APM
+} // namespace APM
+} // namespace Service

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

@@ -7,26 +7,22 @@
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/audin_u.h"
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 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);
     }
@@ -35,12 +31,11 @@ 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);
 }
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -10,7 +10,8 @@ namespace Kernel {
 class HLERequestContext;
 }
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 class AudInU final : public ServiceFramework<AudInU> {
 public:
@@ -18,4 +19,5 @@ public:
     ~AudInU() = default;
 };
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -9,7 +9,8 @@
 #include "core/hle/service/audio/audren_u.h"
 #include "core/hle/service/audio/codecctl.h"
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<AudOutU>()->InstallAsService(service_manager);
@@ -19,4 +20,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<CodecCtl>()->InstallAsService(service_manager);
 }
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

src/core/hle/service/audio/audio.h

@@ -6,9 +6,11 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 /// Registers all Audio services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -10,7 +10,8 @@
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/audout_u.h"
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 /// Switch sample rate frequency
 constexpr u32 sample_rate{48000};
@@ -24,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);
 
@@ -59,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");
 
@@ -96,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};
 
@@ -107,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
@@ -198,9 +189,10 @@ 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);
 }
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -10,7 +10,8 @@ namespace Kernel {
 class HLERequestContext;
 }
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 class IAudioOut;
 
@@ -36,4 +37,5 @@ private:
     };
 };
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -7,21 +7,20 @@
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/audrec_u.h"
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 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);
     }
@@ -35,4 +34,5 @@ AudRecU::AudRecU() : ServiceFramework("audrec:u") {
     RegisterHandlers(functions);
 }
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -10,7 +10,8 @@ namespace Kernel {
 class HLERequestContext;
 }
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 class AudRecU final : public ServiceFramework<AudRecU> {
 public:
@@ -18,4 +19,5 @@ public:
     ~AudRecU() = default;
 };
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -9,7 +9,8 @@
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/audren_u.h"
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 /// TODO(bunnei): Find a proper value for the audio_ticks
 constexpr u64 audio_ticks{static_cast<u64>(BASE_CLOCK_RATE / 200)};
@@ -18,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);
 
@@ -159,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"},
@@ -200,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");
 
@@ -238,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);
 }
@@ -271,4 +256,5 @@ void AudRenU::GetAudioDevice(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Audio, "called");
 }
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -10,7 +10,8 @@ namespace Kernel {
 class HLERequestContext;
 }
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 class AudRenU final : public ServiceFramework<AudRenU> {
 public:
@@ -23,4 +24,5 @@ private:
     void GetAudioDevice(Kernel::HLERequestContext& ctx);
 };
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -7,7 +7,8 @@
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/codecctl.h"
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 CodecCtl::CodecCtl() : ServiceFramework("codecctl") {
     static const FunctionInfo functions[] = {
@@ -21,11 +22,12 @@ 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);
 }
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

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

@@ -10,7 +10,8 @@ namespace Kernel {
 class HLERequestContext;
 }
 
-namespace Service::Audio {
+namespace Service {
+namespace Audio {
 
 class CodecCtl final : public ServiceFramework<CodecCtl> {
 public:
@@ -18,4 +19,5 @@ public:
     ~CodecCtl() = default;
 };
 
-} // namespace Service::Audio
+} // namespace Audio
+} // namespace Service

src/core/hle/service/fatal/fatal.cpp

@@ -8,7 +8,8 @@
 #include "core/hle/service/fatal/fatal_p.h"
 #include "core/hle/service/fatal/fatal_u.h"
 
-namespace Service::Fatal {
+namespace Service {
+namespace Fatal {
 
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
     : ServiceFramework(name), module(std::move(module)) {}
@@ -33,4 +34,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<Fatal_U>(module)->InstallAsService(service_manager);
 }
 
-} // namespace Service::Fatal
+} // namespace Fatal
+} // namespace Service

src/core/hle/service/fatal/fatal.h

@@ -6,7 +6,8 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::Fatal {
+namespace Service {
+namespace Fatal {
 
 class Module final {
 public:
@@ -24,4 +25,5 @@ public:
 
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::Fatal
+} // namespace Fatal
+} // namespace Service

src/core/hle/service/fatal/fatal_p.cpp

@@ -4,9 +4,11 @@
 
 #include "core/hle/service/fatal/fatal_p.h"
 
-namespace Service::Fatal {
+namespace Service {
+namespace Fatal {
 
 Fatal_P::Fatal_P(std::shared_ptr<Module> module)
     : Module::Interface(std::move(module), "fatal:p") {}
 
-} // namespace Service::Fatal
+} // namespace Fatal
+} // namespace Service

src/core/hle/service/fatal/fatal_p.h

@@ -6,11 +6,13 @@
 
 #include "core/hle/service/fatal/fatal.h"
 
-namespace Service::Fatal {
+namespace Service {
+namespace Fatal {
 
 class Fatal_P final : public Module::Interface {
 public:
     explicit Fatal_P(std::shared_ptr<Module> module);
 };
 
-} // namespace Service::Fatal
+} // namespace Fatal
+} // namespace Service

src/core/hle/service/fatal/fatal_u.cpp

@@ -4,7 +4,8 @@
 
 #include "core/hle/service/fatal/fatal_u.h"
 
-namespace Service::Fatal {
+namespace Service {
+namespace Fatal {
 
 Fatal_U::Fatal_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "fatal:u") {
     static const FunctionInfo functions[] = {
@@ -14,4 +15,5 @@ Fatal_U::Fatal_U(std::shared_ptr<Module> module) : Module::Interface(std::move(m
     RegisterHandlers(functions);
 }
 
-} // namespace Service::Fatal
+} // namespace Fatal
+} // namespace Service

src/core/hle/service/fatal/fatal_u.h

@@ -6,11 +6,13 @@
 
 #include "core/hle/service/fatal/fatal.h"
 
-namespace Service::Fatal {
+namespace Service {
+namespace Fatal {
 
 class Fatal_U final : public Module::Interface {
 public:
     explicit Fatal_U(std::shared_ptr<Module> module);
 };
 
-} // namespace Service::Fatal
+} // namespace Fatal
+} // namespace Service

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

@@ -10,7 +10,8 @@
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
 
-namespace Service::FileSystem {
+namespace Service {
+namespace FileSystem {
 
 /**
  * Map of registered file systems, identified by type. Once an file system is registered here, it
@@ -74,4 +75,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<FSP_SRV>()->InstallAsService(service_manager);
 }
 
-} // namespace Service::FileSystem
+} // namespace FileSystem
+} // namespace Service

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

@@ -14,7 +14,8 @@
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
 
-namespace Service::FileSystem {
+namespace Service {
+namespace FileSystem {
 
 class IStorage final : public ServiceFramework<IStorage> {
 public:
@@ -22,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);
     }
@@ -71,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, &IFile::SetSize, "SetSize"}, {4, &IFile::GetSize, "GetSize"},
         };
         RegisterHandlers(functions);
     }
@@ -151,14 +151,6 @@ private:
         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>();
@@ -235,21 +227,11 @@ public:
         : ServiceFramework("IFileSystem"), backend(std::move(backend)) {
         static const FunctionInfo functions[] = {
             {0, &IFileSystem::CreateFile, "CreateFile"},
-            {1, &IFileSystem::DeleteFile, "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);
     }
@@ -272,20 +254,6 @@ public:
         rb.Push(backend->CreateFile(name, size));
     }
 
-    void DeleteFile(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-
-        auto file_buffer = ctx.ReadBuffer();
-        auto end = std::find(file_buffer.begin(), file_buffer.end(), '\0');
-
-        std::string name(file_buffer.begin(), end);
-
-        LOG_DEBUG(Service_FS, "called file %s", name.c_str());
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(backend->DeleteFile(name));
-    }
-
     void CreateDirectory(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
@@ -388,94 +356,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);
 }
@@ -491,7 +379,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};
@@ -572,4 +460,5 @@ void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
     OpenDataStorageByCurrentProcess(ctx);
 }
 
-} // namespace Service::FileSystem
+} // namespace FileSystem
+} // namespace Service

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

@@ -11,7 +11,8 @@ namespace FileSys {
 class FileSystemBackend;
 }
 
-namespace Service::FileSystem {
+namespace Service {
+namespace FileSystem {
 
 class FSP_SRV final : public ServiceFramework<FSP_SRV> {
 public:
@@ -21,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);
@@ -32,4 +33,5 @@ private:
     std::unique_ptr<FileSys::FileSystemBackend> romfs;
 };
 
-} // namespace Service::FileSystem
+} // namespace FileSystem
+} // namespace Service

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

@@ -6,11 +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::Friend {
+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");
@@ -22,7 +22,7 @@ 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 Service::Friend
+} // namespace Friend
+} // namespace Service

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

@@ -6,7 +6,8 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::Friend {
+namespace Service {
+namespace Friend {
 
 class Module final {
 public:
@@ -14,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;
@@ -24,4 +25,5 @@ public:
 /// Registers all Friend services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::Friend
+} // namespace Friend
+} // namespace Service

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

@@ -4,15 +4,16 @@
 
 #include "core/hle/service/friend/friend_a.h"
 
-namespace Service::Friend {
+namespace Service {
+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);
 }
 
-} // namespace Service::Friend
+} // namespace Friend
+} // namespace Service

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

@@ -6,11 +6,13 @@
 
 #include "core/hle/service/friend/friend.h"
 
-namespace Service::Friend {
+namespace Service {
+namespace Friend {
 
 class Friend_A final : public Module::Interface {
 public:
     explicit Friend_A(std::shared_ptr<Module> module);
 };
 
-} // namespace Service::Friend
+} // namespace Friend
+} // namespace Service

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

@@ -1,18 +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::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 Service::Friend

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

@@ -1,16 +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::Friend {
-
-class Friend_U final : public Module::Interface {
-public:
-    explicit Friend_U(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::Friend

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

@@ -14,7 +14,8 @@
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/service.h"
 
-namespace Service::HID {
+namespace Service {
+namespace HID {
 
 // Updating period for each HID device.
 // TODO(shinyquagsire23): These need better values.
@@ -197,75 +198,25 @@ 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);
 
@@ -357,12 +308,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);
@@ -433,4 +378,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<Hid>()->InstallAsService(service_manager);
 }
 
-} // namespace Service::HID
+} // namespace HID
+} // namespace Service

src/core/hle/service/hid/hid.h

@@ -7,7 +7,8 @@
 #include "core/hle/service/service.h"
 #include "core/settings.h"
 
-namespace Service::HID {
+namespace Service {
+namespace HID {
 
 // Begin enums and output structs
 
@@ -336,4 +337,5 @@ void ReloadInputDevices();
 /// Registers all HID services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::HID
+} // namespace HID
+} // namespace Service

src/core/hle/service/lm/lm.cpp

@@ -9,7 +9,8 @@
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/service/lm/lm.h"
 
-namespace Service::LM {
+namespace Service {
+namespace LM {
 
 class Logger final : public ServiceFramework<Logger> {
 public:
@@ -188,4 +189,5 @@ LM::LM() : ServiceFramework("lm") {
     RegisterHandlers(functions);
 }
 
-} // namespace Service::LM
+} // namespace LM
+} // namespace Service

src/core/hle/service/lm/lm.h

@@ -8,7 +8,8 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/service.h"
 
-namespace Service::LM {
+namespace Service {
+namespace LM {
 
 class LM final : public ServiceFramework<LM> {
 public:
@@ -22,4 +23,5 @@ private:
 /// Registers all LM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::LM
+} // namespace LM
+} // namespace Service

src/core/hle/service/nfp/nfp.cpp

@@ -7,7 +7,8 @@
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nfp/nfp_user.h"
 
-namespace Service::NFP {
+namespace Service {
+namespace NFP {
 
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
     : ServiceFramework(name), module(std::move(module)) {}
@@ -23,4 +24,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<NFP_User>(module)->InstallAsService(service_manager);
 }
 
-} // namespace Service::NFP
+} // namespace NFP
+} // namespace Service

src/core/hle/service/nfp/nfp.h

@@ -6,7 +6,8 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::NFP {
+namespace Service {
+namespace NFP {
 
 class Module final {
 public:
@@ -23,4 +24,5 @@ public:
 
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::NFP
+} // namespace NFP
+} // namespace Service

src/core/hle/service/nfp/nfp_user.cpp

@@ -4,7 +4,8 @@
 
 #include "core/hle/service/nfp/nfp_user.h"
 
-namespace Service::NFP {
+namespace Service {
+namespace NFP {
 
 NFP_User::NFP_User(std::shared_ptr<Module> module)
     : Module::Interface(std::move(module), "nfp:user") {
@@ -14,4 +15,5 @@ NFP_User::NFP_User(std::shared_ptr<Module> module)
     RegisterHandlers(functions);
 }
 
-} // namespace Service::NFP
+} // namespace NFP
+} // namespace Service

src/core/hle/service/nfp/nfp_user.h

@@ -6,11 +6,13 @@
 
 #include "core/hle/service/nfp/nfp.h"
 
-namespace Service::NFP {
+namespace Service {
+namespace NFP {
 
 class NFP_User final : public Module::Interface {
 public:
     explicit NFP_User(std::shared_ptr<Module> module);
 };
 
-} // namespace Service::NFP
+} // namespace NFP
+} // namespace Service

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

@@ -9,7 +9,8 @@
 #include "core/hle/service/nifm/nifm_s.h"
 #include "core/hle/service/nifm/nifm_u.h"
 
-namespace Service::NIFM {
+namespace Service {
+namespace NIFM {
 
 class IScanRequest final : public ServiceFramework<IScanRequest> {
 public:
@@ -69,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");
@@ -207,4 +209,5 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<NIFM_U>(module)->InstallAsService(service_manager);
 }
 
-} // namespace Service::NIFM
+} // namespace NIFM
+} // namespace Service

src/core/hle/service/nifm/nifm.h

@@ -6,7 +6,8 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::NIFM {
+namespace Service {
+namespace NIFM {
 
 class Module final {
 public:
@@ -24,4 +25,5 @@ public:
 
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::NIFM
+} // namespace NIFM
+} // namespace Service

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

@@ -4,7 +4,8 @@
 
 #include "core/hle/service/nifm/nifm_a.h"
 
-namespace Service::NIFM {
+namespace Service {
+namespace NIFM {
 
 NIFM_A::NIFM_A(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:a") {
     static const FunctionInfo functions[] = {
@@ -14,4 +15,5 @@ NIFM_A::NIFM_A(std::shared_ptr<Module> module) : Module::Interface(std::move(mod
     RegisterHandlers(functions);
 }
 
-} // namespace Service::NIFM
+} // namespace NIFM
+} // namespace Service

src/core/hle/service/nifm/nifm_a.h

@@ -6,11 +6,13 @@
 
 #include "core/hle/service/nifm/nifm.h"
 
-namespace Service::NIFM {
+namespace Service {
+namespace NIFM {
 
 class NIFM_A final : public Module::Interface {
 public:
     explicit NIFM_A(std::shared_ptr<Module> module);
 };
 
-} // namespace Service::NIFM
+} // namespace NIFM
+} // namespace Service

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

@@ -4,7 +4,8 @@
 
 #include "core/hle/service/nifm/nifm_s.h"
 
-namespace Service::NIFM {
+namespace Service {
+namespace NIFM {
 
 NIFM_S::NIFM_S(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:s") {
     static const FunctionInfo functions[] = {
@@ -14,4 +15,5 @@ NIFM_S::NIFM_S(std::shared_ptr<Module> module) : Module::Interface(std::move(mod
     RegisterHandlers(functions);
 }
 
-} // namespace Service::NIFM
+} // namespace NIFM
+} // namespace Service

src/core/hle/service/nifm/nifm_s.h

@@ -6,11 +6,13 @@
 
 #include "core/hle/service/nifm/nifm.h"
 
-namespace Service::NIFM {
+namespace Service {
+namespace NIFM {
 
 class NIFM_S final : public Module::Interface {
 public:
     explicit NIFM_S(std::shared_ptr<Module> module);
 };
 
-} // namespace Service::NIFM
+} // namespace NIFM
+} // namespace Service

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

@@ -4,7 +4,8 @@
 
 #include "core/hle/service/nifm/nifm_u.h"
 
-namespace Service::NIFM {
+namespace Service {
+namespace NIFM {
 
 NIFM_U::NIFM_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:u") {
     static const FunctionInfo functions[] = {
@@ -14,4 +15,5 @@ NIFM_U::NIFM_U(std::shared_ptr<Module> module) : Module::Interface(std::move(mod
     RegisterHandlers(functions);
 }
 
-} // namespace Service::NIFM
+} // namespace NIFM
+} // namespace Service

src/core/hle/service/nifm/nifm_u.h

@@ -6,11 +6,13 @@
 
 #include "core/hle/service/nifm/nifm.h"
 
-namespace Service::NIFM {
+namespace Service {
+namespace NIFM {
 
 class NIFM_U final : public Module::Interface {
 public:
     explicit NIFM_U(std::shared_ptr<Module> module);
 };
 
-} // namespace Service::NIFM
+} // namespace NIFM
+} // namespace Service

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

@@ -5,10 +5,12 @@
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/ns/pl_u.h"
 
-namespace Service::NS {
+namespace Service {
+namespace NS {
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<PL_U>()->InstallAsService(service_manager);
 }
 
-} // namespace Service::NS
+} // namespace NS
+} // namespace Service

src/core/hle/service/ns/ns.h

@@ -6,9 +6,11 @@
 
 #include "core/hle/service/service.h"
 
-namespace Service::NS {
+namespace Service {
+namespace NS {
 
 /// Registers all NS services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
-} // namespace Service::NS
+} // namespace NS
+} // namespace Service

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

@@ -8,7 +8,8 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/ns/pl_u.h"
 
-namespace Service::NS {
+namespace Service {
+namespace NS {
 
 struct FontRegion {
     u32 offset;
@@ -36,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
@@ -46,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());
@@ -96,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};
@@ -116,4 +118,5 @@ void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
     rb.PushCopyObjects(shared_font_mem);
 }
 
-} // namespace Service::NS
+} // namespace NS
+} // namespace Service

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

@@ -8,7 +8,8 @@
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/service/service.h"
 
-namespace Service::NS {
+namespace Service {
+namespace NS {
 
 class PL_U final : public ServiceFramework<PL_U> {
 public:
@@ -29,4 +30,5 @@ private:
     std::shared_ptr<std::vector<u8>> shared_font;
 };
 
-} // namespace Service::NS
+} // namespace NS
+} // namespace Service

src/core/hle/service/nvdrv/devices/nvdevice.h

@@ -9,7 +9,9 @@
 #include "common/common_types.h"
 #include "common/swap.h"
 
-namespace Service::Nvidia::Devices {
+namespace Service {
+namespace Nvidia {
+namespace Devices {
 
 /// Represents an abstract nvidia device node. It is to be subclassed by concrete device nodes to
 /// implement the ioctl interface.
@@ -36,4 +38,6 @@ public:
     virtual u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) = 0;
 };
 
-} // namespace Service::Nvidia::Devices
+} // namespace Devices
+} // namespace Nvidia
+} // namespace Service

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -10,7 +10,9 @@
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
-namespace Service::Nvidia::Devices {
+namespace Service {
+namespace Nvidia {
+namespace Devices {
 
 u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     UNIMPLEMENTED();
@@ -33,4 +35,6 @@ void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u3
     VideoCore::g_renderer->SwapBuffers(framebuffer);
 }
 
-} // namespace Service::Nvidia::Devices
+} // namespace Devices
+} // namespace Nvidia
+} // namespace Service

src/core/hle/service/nvdrv/devices/nvdisp_disp0.h

@@ -10,7 +10,9 @@
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 
-namespace Service::Nvidia::Devices {
+namespace Service {
+namespace Nvidia {
+namespace Devices {
 
 class nvmap;
 
@@ -29,4 +31,6 @@ private:
     std::shared_ptr<nvmap> nvmap_dev;
 };
 
-} // namespace Service::Nvidia::Devices
+} // namespace Devices
+} // namespace Nvidia
+} // namespace Service