summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/common/CMakeLists.txt1
-rw-r--r--src/common/fs/file.h11
-rw-r--r--src/common/page_table.cpp1
-rw-r--r--src/common/page_table.h6
-rw-r--r--src/common/point.h57
-rw-r--r--src/core/arm/arm_interface.h3
-rw-r--r--src/core/arm/dynarmic/arm_dynarmic_32.cpp55
-rw-r--r--src/core/arm/dynarmic/arm_dynarmic_32.h13
-rw-r--r--src/core/arm/dynarmic/arm_dynarmic_64.cpp57
-rw-r--r--src/core/arm/dynarmic/arm_dynarmic_64.h9
-rw-r--r--src/core/arm/dynarmic/arm_dynarmic_cp15.h2
-rw-r--r--src/core/arm/dynarmic/arm_exclusive_monitor.h2
-rw-r--r--src/core/hle/kernel/k_class_token.cpp79
-rw-r--r--src/core/hle/kernel/k_client_port.h6
-rw-r--r--src/core/hle/kernel/k_client_session.h4
-rw-r--r--src/core/hle/kernel/k_event.h14
-rw-r--r--src/core/hle/kernel/k_port.h3
-rw-r--r--src/core/hle/kernel/k_process.h8
-rw-r--r--src/core/hle/kernel/k_readable_event.h4
-rw-r--r--src/core/hle/kernel/k_resource_limit.h4
-rw-r--r--src/core/hle/kernel/k_scheduler.cpp1
-rw-r--r--src/core/hle/kernel/k_server_port.h12
-rw-r--r--src/core/hle/kernel/k_server_session.h6
-rw-r--r--src/core/hle/kernel/k_session.h10
-rw-r--r--src/core/hle/kernel/k_shared_memory.h4
-rw-r--r--src/core/hle/kernel/k_slab_heap.h199
-rw-r--r--src/core/hle/kernel/k_synchronization_object.h4
-rw-r--r--src/core/hle/kernel/k_thread.cpp10
-rw-r--r--src/core/hle/kernel/k_thread.h10
-rw-r--r--src/core/hle/kernel/k_transfer_memory.h10
-rw-r--r--src/core/hle/kernel/k_writable_event.h2
-rw-r--r--src/core/hle/kernel/kernel.cpp5
-rw-r--r--src/core/hle/service/am/applets/software_keyboard.cpp25
-rw-r--r--src/core/hle/service/hid/controllers/gesture.h36
-rw-r--r--src/core/hle/service/hid/controllers/touchscreen.cpp13
-rw-r--r--src/core/hle/service/hid/controllers/touchscreen.h7
-rw-r--r--src/core/hle/service/hid/hid.cpp11
-rw-r--r--src/core/hle/service/ldn/ldn.cpp141
-rw-r--r--src/core/memory.cpp43
-rw-r--r--src/video_core/buffer_cache/buffer_cache.h4
-rw-r--r--src/video_core/gpu.cpp12
-rw-r--r--src/video_core/gpu.h2
-rw-r--r--src/video_core/rasterizer_accelerated.cpp6
-rw-r--r--src/video_core/rasterizer_accelerated.h12
-rw-r--r--src/yuzu/applets/software_keyboard.cpp25
-rw-r--r--src/yuzu/configuration/configure_dialog.cpp14
-rw-r--r--src/yuzu/configuration/configure_dialog.h3
-rw-r--r--src/yuzu/configuration/configure_per_game.cpp14
-rw-r--r--src/yuzu/configuration/configure_per_game.h2
-rw-r--r--src/yuzu/main.cpp40
-rw-r--r--src/yuzu/uisettings.h2
51 files changed, 751 insertions, 273 deletions
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index eafb96b0b..7a4d9e354 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -154,6 +154,7 @@ add_library(common STATIC
154 param_package.cpp 154 param_package.cpp
155 param_package.h 155 param_package.h
156 parent_of_member.h 156 parent_of_member.h
157 point.h
157 quaternion.h 158 quaternion.h
158 ring_buffer.h 159 ring_buffer.h
159 scm_rev.cpp 160 scm_rev.cpp
diff --git a/src/common/fs/file.h b/src/common/fs/file.h
index 209f9664b..50e270c5b 100644
--- a/src/common/fs/file.h
+++ b/src/common/fs/file.h
@@ -117,7 +117,7 @@ template <typename Path>
117} 117}
118#endif 118#endif
119 119
120class IOFile final : NonCopyable { 120class IOFile final {
121public: 121public:
122 IOFile(); 122 IOFile();
123 123
@@ -142,7 +142,10 @@ public:
142 FileType type = FileType::BinaryFile, 142 FileType type = FileType::BinaryFile,
143 FileShareFlag flag = FileShareFlag::ShareReadOnly); 143 FileShareFlag flag = FileShareFlag::ShareReadOnly);
144 144
145 virtual ~IOFile(); 145 ~IOFile();
146
147 IOFile(const IOFile&) = delete;
148 IOFile& operator=(const IOFile&) = delete;
146 149
147 IOFile(IOFile&& other) noexcept; 150 IOFile(IOFile&& other) noexcept;
148 IOFile& operator=(IOFile&& other) noexcept; 151 IOFile& operator=(IOFile&& other) noexcept;
@@ -441,8 +444,8 @@ public:
441 444
442private: 445private:
443 std::filesystem::path file_path; 446 std::filesystem::path file_path;
444 FileAccessMode file_access_mode; 447 FileAccessMode file_access_mode{};
445 FileType file_type; 448 FileType file_type{};
446 449
447 std::FILE* file = nullptr; 450 std::FILE* file = nullptr;
448}; 451};
diff --git a/src/common/page_table.cpp b/src/common/page_table.cpp
index 8fd8620fd..9fffd816f 100644
--- a/src/common/page_table.cpp
+++ b/src/common/page_table.cpp
@@ -14,6 +14,7 @@ void PageTable::Resize(size_t address_space_width_in_bits, size_t page_size_in_b
14 const size_t num_page_table_entries{1ULL << (address_space_width_in_bits - page_size_in_bits)}; 14 const size_t num_page_table_entries{1ULL << (address_space_width_in_bits - page_size_in_bits)};
15 pointers.resize(num_page_table_entries); 15 pointers.resize(num_page_table_entries);
16 backing_addr.resize(num_page_table_entries); 16 backing_addr.resize(num_page_table_entries);
17 current_address_space_width_in_bits = address_space_width_in_bits;
17} 18}
18 19
19} // namespace Common 20} // namespace Common
diff --git a/src/common/page_table.h b/src/common/page_table.h
index 61c5552e0..e92b66b2b 100644
--- a/src/common/page_table.h
+++ b/src/common/page_table.h
@@ -98,6 +98,10 @@ struct PageTable {
98 */ 98 */
99 void Resize(size_t address_space_width_in_bits, size_t page_size_in_bits); 99 void Resize(size_t address_space_width_in_bits, size_t page_size_in_bits);
100 100
101 size_t GetAddressSpaceBits() const {
102 return current_address_space_width_in_bits;
103 }
104
101 /** 105 /**
102 * Vector of memory pointers backing each page. An entry can only be non-null if the 106 * Vector of memory pointers backing each page. An entry can only be non-null if the
103 * corresponding attribute element is of type `Memory`. 107 * corresponding attribute element is of type `Memory`.
@@ -105,6 +109,8 @@ struct PageTable {
105 VirtualBuffer<PageInfo> pointers; 109 VirtualBuffer<PageInfo> pointers;
106 110
107 VirtualBuffer<u64> backing_addr; 111 VirtualBuffer<u64> backing_addr;
112
113 size_t current_address_space_width_in_bits;
108}; 114};
109 115
110} // namespace Common 116} // namespace Common
diff --git a/src/common/point.h b/src/common/point.h
new file mode 100644
index 000000000..c0a52ad8d
--- /dev/null
+++ b/src/common/point.h
@@ -0,0 +1,57 @@
1// Copyright 2021 yuzu Emulator Project
2// Licensed under GPLv2 or any later version
3// Refer to the license.txt file included.
4
5#pragma once
6
7#include <type_traits>
8
9namespace Common {
10
11// Represents a point within a 2D space.
12template <typename T>
13struct Point {
14 static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type!");
15
16 T x{};
17 T y{};
18
19#define ARITHMETIC_OP(op, compound_op) \
20 friend constexpr Point operator op(const Point& lhs, const Point& rhs) noexcept { \
21 return { \
22 .x = static_cast<T>(lhs.x op rhs.x), \
23 .y = static_cast<T>(lhs.y op rhs.y), \
24 }; \
25 } \
26 friend constexpr Point operator op(const Point& lhs, T value) noexcept { \
27 return { \
28 .x = static_cast<T>(lhs.x op value), \
29 .y = static_cast<T>(lhs.y op value), \
30 }; \
31 } \
32 friend constexpr Point operator op(T value, const Point& rhs) noexcept { \
33 return { \
34 .x = static_cast<T>(value op rhs.x), \
35 .y = static_cast<T>(value op rhs.y), \
36 }; \
37 } \
38 friend constexpr Point& operator compound_op(Point& lhs, const Point& rhs) noexcept { \
39 lhs.x = static_cast<T>(lhs.x op rhs.x); \
40 lhs.y = static_cast<T>(lhs.y op rhs.y); \
41 return lhs; \
42 } \
43 friend constexpr Point& operator compound_op(Point& lhs, T value) noexcept { \
44 lhs.x = static_cast<T>(lhs.x op value); \
45 lhs.y = static_cast<T>(lhs.y op value); \
46 return lhs; \
47 }
48 ARITHMETIC_OP(+, +=)
49 ARITHMETIC_OP(-, -=)
50 ARITHMETIC_OP(*, *=)
51 ARITHMETIC_OP(/, /=)
52#undef ARITHMETIC_OP
53
54 friend constexpr bool operator==(const Point&, const Point&) = default;
55};
56
57} // namespace Common
diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h
index 77094b48f..689e3ceb5 100644
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -65,9 +65,6 @@ public:
65 /// Step CPU by one instruction 65 /// Step CPU by one instruction
66 virtual void Step() = 0; 66 virtual void Step() = 0;
67 67
68 /// Exits execution from a callback, the callback must rewind the stack
69 virtual void ExceptionalExit() = 0;
70
71 /// Clear all instruction cache 68 /// Clear all instruction cache
72 virtual void ClearInstructionCache() = 0; 69 virtual void ClearInstructionCache() = 0;
73 70
diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.cpp b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
index e401fa825..cea7f0fb1 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -4,9 +4,9 @@
4 4
5#include <cinttypes> 5#include <cinttypes>
6#include <memory> 6#include <memory>
7#include <dynarmic/A32/a32.h> 7#include <dynarmic/interface/A32/a32.h>
8#include <dynarmic/A32/config.h> 8#include <dynarmic/interface/A32/config.h>
9#include <dynarmic/A32/context.h> 9#include <dynarmic/interface/A32/context.h>
10#include "common/assert.h" 10#include "common/assert.h"
11#include "common/logging/log.h" 11#include "common/logging/log.h"
12#include "common/page_table.h" 12#include "common/page_table.h"
@@ -24,45 +24,46 @@ namespace Core {
24 24
25class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks { 25class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
26public: 26public:
27 explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_) : parent{parent_} {} 27 explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
28 : parent{parent_}, memory(parent.system.Memory()) {}
28 29
29 u8 MemoryRead8(u32 vaddr) override { 30 u8 MemoryRead8(u32 vaddr) override {
30 return parent.system.Memory().Read8(vaddr); 31 return memory.Read8(vaddr);
31 } 32 }
32 u16 MemoryRead16(u32 vaddr) override { 33 u16 MemoryRead16(u32 vaddr) override {
33 return parent.system.Memory().Read16(vaddr); 34 return memory.Read16(vaddr);
34 } 35 }
35 u32 MemoryRead32(u32 vaddr) override { 36 u32 MemoryRead32(u32 vaddr) override {
36 return parent.system.Memory().Read32(vaddr); 37 return memory.Read32(vaddr);
37 } 38 }
38 u64 MemoryRead64(u32 vaddr) override { 39 u64 MemoryRead64(u32 vaddr) override {
39 return parent.system.Memory().Read64(vaddr); 40 return memory.Read64(vaddr);
40 } 41 }
41 42
42 void MemoryWrite8(u32 vaddr, u8 value) override { 43 void MemoryWrite8(u32 vaddr, u8 value) override {
43 parent.system.Memory().Write8(vaddr, value); 44 memory.Write8(vaddr, value);
44 } 45 }
45 void MemoryWrite16(u32 vaddr, u16 value) override { 46 void MemoryWrite16(u32 vaddr, u16 value) override {
46 parent.system.Memory().Write16(vaddr, value); 47 memory.Write16(vaddr, value);
47 } 48 }
48 void MemoryWrite32(u32 vaddr, u32 value) override { 49 void MemoryWrite32(u32 vaddr, u32 value) override {
49 parent.system.Memory().Write32(vaddr, value); 50 memory.Write32(vaddr, value);
50 } 51 }
51 void MemoryWrite64(u32 vaddr, u64 value) override { 52 void MemoryWrite64(u32 vaddr, u64 value) override {
52 parent.system.Memory().Write64(vaddr, value); 53 memory.Write64(vaddr, value);
53 } 54 }
54 55
55 bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override { 56 bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override {
56 return parent.system.Memory().WriteExclusive8(vaddr, value, expected); 57 return memory.WriteExclusive8(vaddr, value, expected);
57 } 58 }
58 bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override { 59 bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override {
59 return parent.system.Memory().WriteExclusive16(vaddr, value, expected); 60 return memory.WriteExclusive16(vaddr, value, expected);
60 } 61 }
61 bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override { 62 bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override {
62 return parent.system.Memory().WriteExclusive32(vaddr, value, expected); 63 return memory.WriteExclusive32(vaddr, value, expected);
63 } 64 }
64 bool MemoryWriteExclusive64(u32 vaddr, u64 value, u64 expected) override { 65 bool MemoryWriteExclusive64(u32 vaddr, u64 value, u64 expected) override {
65 return parent.system.Memory().WriteExclusive64(vaddr, value, expected); 66 return memory.WriteExclusive64(vaddr, value, expected);
66 } 67 }
67 68
68 void InterpreterFallback(u32 pc, std::size_t num_instructions) override { 69 void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
@@ -78,7 +79,9 @@ public:
78 } 79 }
79 80
80 void CallSVC(u32 swi) override { 81 void CallSVC(u32 swi) override {
81 Kernel::Svc::Call(parent.system, swi); 82 parent.svc_called = true;
83 parent.svc_swi = swi;
84 parent.jit->HaltExecution();
82 } 85 }
83 86
84 void AddTicks(u64 ticks) override { 87 void AddTicks(u64 ticks) override {
@@ -110,6 +113,7 @@ public:
110 } 113 }
111 114
112 ARM_Dynarmic_32& parent; 115 ARM_Dynarmic_32& parent;
116 Core::Memory::Memory& memory;
113 std::size_t num_interpreted_instructions{}; 117 std::size_t num_interpreted_instructions{};
114 static constexpr u64 minimum_run_cycles = 1000U; 118 static constexpr u64 minimum_run_cycles = 1000U;
115}; 119};
@@ -187,11 +191,17 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
187} 191}
188 192
189void ARM_Dynarmic_32::Run() { 193void ARM_Dynarmic_32::Run() {
190 jit->Run(); 194 while (true) {
191} 195 jit->Run();
192 196 if (!svc_called) {
193void ARM_Dynarmic_32::ExceptionalExit() { 197 break;
194 jit->ExceptionalExit(); 198 }
199 svc_called = false;
200 Kernel::Svc::Call(system, svc_swi);
201 if (shutdown) {
202 break;
203 }
204 }
195} 205}
196 206
197void ARM_Dynarmic_32::Step() { 207void ARM_Dynarmic_32::Step() {
@@ -275,6 +285,7 @@ void ARM_Dynarmic_32::LoadContext(const ThreadContext32& ctx) {
275 285
276void ARM_Dynarmic_32::PrepareReschedule() { 286void ARM_Dynarmic_32::PrepareReschedule() {
277 jit->HaltExecution(); 287 jit->HaltExecution();
288 shutdown = true;
278} 289}
279 290
280void ARM_Dynarmic_32::ClearInstructionCache() { 291void ARM_Dynarmic_32::ClearInstructionCache() {
diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.h b/src/core/arm/dynarmic/arm_dynarmic_32.h
index b882b0c59..063605b46 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_32.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.h
@@ -7,9 +7,9 @@
7#include <memory> 7#include <memory>
8#include <unordered_map> 8#include <unordered_map>
9 9
10#include <dynarmic/A32/a32.h> 10#include <dynarmic/interface/A32/a32.h>
11#include <dynarmic/A64/a64.h> 11#include <dynarmic/interface/A64/a64.h>
12#include <dynarmic/exclusive_monitor.h> 12#include <dynarmic/interface/exclusive_monitor.h>
13#include "common/common_types.h" 13#include "common/common_types.h"
14#include "common/hash.h" 14#include "common/hash.h"
15#include "core/arm/arm_interface.h" 15#include "core/arm/arm_interface.h"
@@ -42,7 +42,6 @@ public:
42 u32 GetPSTATE() const override; 42 u32 GetPSTATE() const override;
43 void SetPSTATE(u32 pstate) override; 43 void SetPSTATE(u32 pstate) override;
44 void Run() override; 44 void Run() override;
45 void ExceptionalExit() override;
46 void Step() override; 45 void Step() override;
47 VAddr GetTlsAddress() const override; 46 VAddr GetTlsAddress() const override;
48 void SetTlsAddress(VAddr address) override; 47 void SetTlsAddress(VAddr address) override;
@@ -82,6 +81,12 @@ private:
82 std::size_t core_index; 81 std::size_t core_index;
83 DynarmicExclusiveMonitor& exclusive_monitor; 82 DynarmicExclusiveMonitor& exclusive_monitor;
84 std::shared_ptr<Dynarmic::A32::Jit> jit; 83 std::shared_ptr<Dynarmic::A32::Jit> jit;
84
85 // SVC callback
86 u32 svc_swi{};
87 bool svc_called{};
88
89 bool shutdown{};
85}; 90};
86 91
87} // namespace Core 92} // namespace Core
diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.cpp b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
index 157051d69..63193dcb1 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@@ -4,8 +4,8 @@
4 4
5#include <cinttypes> 5#include <cinttypes>
6#include <memory> 6#include <memory>
7#include <dynarmic/A64/a64.h> 7#include <dynarmic/interface/A64/a64.h>
8#include <dynarmic/A64/config.h> 8#include <dynarmic/interface/A64/config.h>
9#include "common/assert.h" 9#include "common/assert.h"
10#include "common/logging/log.h" 10#include "common/logging/log.h"
11#include "common/page_table.h" 11#include "common/page_table.h"
@@ -27,57 +27,56 @@ using Vector = Dynarmic::A64::Vector;
27 27
28class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks { 28class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
29public: 29public:
30 explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_) : parent{parent_} {} 30 explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_)
31 : parent{parent_}, memory(parent.system.Memory()) {}
31 32
32 u8 MemoryRead8(u64 vaddr) override { 33 u8 MemoryRead8(u64 vaddr) override {
33 return parent.system.Memory().Read8(vaddr); 34 return memory.Read8(vaddr);
34 } 35 }
35 u16 MemoryRead16(u64 vaddr) override { 36 u16 MemoryRead16(u64 vaddr) override {
36 return parent.system.Memory().Read16(vaddr); 37 return memory.Read16(vaddr);
37 } 38 }
38 u32 MemoryRead32(u64 vaddr) override { 39 u32 MemoryRead32(u64 vaddr) override {
39 return parent.system.Memory().Read32(vaddr); 40 return memory.Read32(vaddr);
40 } 41 }
41 u64 MemoryRead64(u64 vaddr) override { 42 u64 MemoryRead64(u64 vaddr) override {
42 return parent.system.Memory().Read64(vaddr); 43 return memory.Read64(vaddr);
43 } 44 }
44 Vector MemoryRead128(u64 vaddr) override { 45 Vector MemoryRead128(u64 vaddr) override {
45 auto& memory = parent.system.Memory();
46 return {memory.Read64(vaddr), memory.Read64(vaddr + 8)}; 46 return {memory.Read64(vaddr), memory.Read64(vaddr + 8)};
47 } 47 }
48 48
49 void MemoryWrite8(u64 vaddr, u8 value) override { 49 void MemoryWrite8(u64 vaddr, u8 value) override {
50 parent.system.Memory().Write8(vaddr, value); 50 memory.Write8(vaddr, value);
51 } 51 }
52 void MemoryWrite16(u64 vaddr, u16 value) override { 52 void MemoryWrite16(u64 vaddr, u16 value) override {
53 parent.system.Memory().Write16(vaddr, value); 53 memory.Write16(vaddr, value);
54 } 54 }
55 void MemoryWrite32(u64 vaddr, u32 value) override { 55 void MemoryWrite32(u64 vaddr, u32 value) override {
56 parent.system.Memory().Write32(vaddr, value); 56 memory.Write32(vaddr, value);
57 } 57 }
58 void MemoryWrite64(u64 vaddr, u64 value) override { 58 void MemoryWrite64(u64 vaddr, u64 value) override {
59 parent.system.Memory().Write64(vaddr, value); 59 memory.Write64(vaddr, value);
60 } 60 }
61 void MemoryWrite128(u64 vaddr, Vector value) override { 61 void MemoryWrite128(u64 vaddr, Vector value) override {
62 auto& memory = parent.system.Memory();
63 memory.Write64(vaddr, value[0]); 62 memory.Write64(vaddr, value[0]);
64 memory.Write64(vaddr + 8, value[1]); 63 memory.Write64(vaddr + 8, value[1]);
65 } 64 }
66 65
67 bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override { 66 bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override {
68 return parent.system.Memory().WriteExclusive8(vaddr, value, expected); 67 return memory.WriteExclusive8(vaddr, value, expected);
69 } 68 }
70 bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override { 69 bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override {
71 return parent.system.Memory().WriteExclusive16(vaddr, value, expected); 70 return memory.WriteExclusive16(vaddr, value, expected);
72 } 71 }
73 bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, std::uint32_t expected) override { 72 bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, std::uint32_t expected) override {
74 return parent.system.Memory().WriteExclusive32(vaddr, value, expected); 73 return memory.WriteExclusive32(vaddr, value, expected);
75 } 74 }
76 bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, std::uint64_t expected) override { 75 bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, std::uint64_t expected) override {
77 return parent.system.Memory().WriteExclusive64(vaddr, value, expected); 76 return memory.WriteExclusive64(vaddr, value, expected);
78 } 77 }
79 bool MemoryWriteExclusive128(u64 vaddr, Vector value, Vector expected) override { 78 bool MemoryWriteExclusive128(u64 vaddr, Vector value, Vector expected) override {
80 return parent.system.Memory().WriteExclusive128(vaddr, value, expected); 79 return memory.WriteExclusive128(vaddr, value, expected);
81 } 80 }
82 81
83 void InterpreterFallback(u64 pc, std::size_t num_instructions) override { 82 void InterpreterFallback(u64 pc, std::size_t num_instructions) override {
@@ -102,7 +101,9 @@ public:
102 } 101 }
103 102
104 void CallSVC(u32 swi) override { 103 void CallSVC(u32 swi) override {
105 Kernel::Svc::Call(parent.system, swi); 104 parent.svc_called = true;
105 parent.svc_swi = swi;
106 parent.jit->HaltExecution();
106 } 107 }
107 108
108 void AddTicks(u64 ticks) override { 109 void AddTicks(u64 ticks) override {
@@ -137,6 +138,7 @@ public:
137 } 138 }
138 139
139 ARM_Dynarmic_64& parent; 140 ARM_Dynarmic_64& parent;
141 Core::Memory::Memory& memory;
140 u64 tpidrro_el0 = 0; 142 u64 tpidrro_el0 = 0;
141 u64 tpidr_el0 = 0; 143 u64 tpidr_el0 = 0;
142 static constexpr u64 minimum_run_cycles = 1000U; 144 static constexpr u64 minimum_run_cycles = 1000U;
@@ -227,11 +229,17 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
227} 229}
228 230
229void ARM_Dynarmic_64::Run() { 231void ARM_Dynarmic_64::Run() {
230 jit->Run(); 232 while (true) {
231} 233 jit->Run();
232 234 if (!svc_called) {
233void ARM_Dynarmic_64::ExceptionalExit() { 235 break;
234 jit->ExceptionalExit(); 236 }
237 svc_called = false;
238 Kernel::Svc::Call(system, svc_swi);
239 if (shutdown) {
240 break;
241 }
242 }
235} 243}
236 244
237void ARM_Dynarmic_64::Step() { 245void ARM_Dynarmic_64::Step() {
@@ -320,6 +328,7 @@ void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) {
320 328
321void ARM_Dynarmic_64::PrepareReschedule() { 329void ARM_Dynarmic_64::PrepareReschedule() {
322 jit->HaltExecution(); 330 jit->HaltExecution();
331 shutdown = true;
323} 332}
324 333
325void ARM_Dynarmic_64::ClearInstructionCache() { 334void ARM_Dynarmic_64::ClearInstructionCache() {
diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.h b/src/core/arm/dynarmic/arm_dynarmic_64.h
index 92f715f19..0c4e46c64 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_64.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.h
@@ -7,7 +7,7 @@
7#include <memory> 7#include <memory>
8#include <unordered_map> 8#include <unordered_map>
9 9
10#include <dynarmic/A64/a64.h> 10#include <dynarmic/interface/A64/a64.h>
11#include "common/common_types.h" 11#include "common/common_types.h"
12#include "common/hash.h" 12#include "common/hash.h"
13#include "core/arm/arm_interface.h" 13#include "core/arm/arm_interface.h"
@@ -40,7 +40,6 @@ public:
40 void SetPSTATE(u32 pstate) override; 40 void SetPSTATE(u32 pstate) override;
41 void Run() override; 41 void Run() override;
42 void Step() override; 42 void Step() override;
43 void ExceptionalExit() override;
44 VAddr GetTlsAddress() const override; 43 VAddr GetTlsAddress() const override;
45 void SetTlsAddress(VAddr address) override; 44 void SetTlsAddress(VAddr address) override;
46 void SetTPIDR_EL0(u64 value) override; 45 void SetTPIDR_EL0(u64 value) override;
@@ -75,6 +74,12 @@ private:
75 DynarmicExclusiveMonitor& exclusive_monitor; 74 DynarmicExclusiveMonitor& exclusive_monitor;
76 75
77 std::shared_ptr<Dynarmic::A64::Jit> jit; 76 std::shared_ptr<Dynarmic::A64::Jit> jit;
77
78 // SVC callback
79 u32 svc_swi{};
80 bool svc_called{};
81
82 bool shutdown{};
78}; 83};
79 84
80} // namespace Core 85} // namespace Core
diff --git a/src/core/arm/dynarmic/arm_dynarmic_cp15.h b/src/core/arm/dynarmic/arm_dynarmic_cp15.h
index 8597beddf..7c7ede79e 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_cp15.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_cp15.h
@@ -7,7 +7,7 @@
7#include <memory> 7#include <memory>
8#include <optional> 8#include <optional>
9 9
10#include <dynarmic/A32/coprocessor.h> 10#include <dynarmic/interface/A32/coprocessor.h>
11#include "common/common_types.h" 11#include "common/common_types.h"
12 12
13namespace Core { 13namespace Core {
diff --git a/src/core/arm/dynarmic/arm_exclusive_monitor.h b/src/core/arm/dynarmic/arm_exclusive_monitor.h
index f9f056a59..73d41f223 100644
--- a/src/core/arm/dynarmic/arm_exclusive_monitor.h
+++ b/src/core/arm/dynarmic/arm_exclusive_monitor.h
@@ -7,7 +7,7 @@
7#include <memory> 7#include <memory>
8#include <unordered_map> 8#include <unordered_map>
9 9
10#include <dynarmic/exclusive_monitor.h> 10#include <dynarmic/interface/exclusive_monitor.h>
11 11
12#include "common/common_types.h" 12#include "common/common_types.h"
13#include "core/arm/dynarmic/arm_dynarmic_32.h" 13#include "core/arm/dynarmic/arm_dynarmic_32.h"
diff --git a/src/core/hle/kernel/k_class_token.cpp b/src/core/hle/kernel/k_class_token.cpp
index beb8a2a05..0be0027be 100644
--- a/src/core/hle/kernel/k_class_token.cpp
+++ b/src/core/hle/kernel/k_class_token.cpp
@@ -84,50 +84,43 @@ static_assert(ClassToken<KTransferMemory> == ((0b10010001 << 8) | ClassToken<KAu
84// Ensure that the token hierarchy reflects the class hierarchy. 84// Ensure that the token hierarchy reflects the class hierarchy.
85 85
86// Base classes. 86// Base classes.
87static_assert(!std::is_final<KSynchronizationObject>::value && 87static_assert(!std::is_final_v<KSynchronizationObject> &&
88 std::is_base_of<KAutoObject, KSynchronizationObject>::value); 88 std::is_base_of_v<KAutoObject, KSynchronizationObject>);
89static_assert(!std::is_final<KReadableEvent>::value && 89static_assert(!std::is_final_v<KReadableEvent> &&
90 std::is_base_of<KSynchronizationObject, KReadableEvent>::value); 90 std::is_base_of_v<KSynchronizationObject, KReadableEvent>);
91 91
92// Final classes 92// Final classes
93// static_assert(std::is_final<KInterruptEvent>::value && 93// static_assert(std::is_final_v<KInterruptEvent> &&
94// std::is_base_of<KReadableEvent, KInterruptEvent>::value); 94// std::is_base_of_v<KReadableEvent, KInterruptEvent>);
95// static_assert(std::is_final<KDebug>::value && 95// static_assert(std::is_final_v<KDebug> &&
96// std::is_base_of<KSynchronizationObject, KDebug>::value); 96// std::is_base_of_v<KSynchronizationObject, KDebug>);
97static_assert(std::is_final<KThread>::value && 97static_assert(std::is_final_v<KThread> && std::is_base_of_v<KSynchronizationObject, KThread>);
98 std::is_base_of<KSynchronizationObject, KThread>::value); 98static_assert(std::is_final_v<KServerPort> &&
99static_assert(std::is_final<KServerPort>::value && 99 std::is_base_of_v<KSynchronizationObject, KServerPort>);
100 std::is_base_of<KSynchronizationObject, KServerPort>::value); 100static_assert(std::is_final_v<KServerSession> &&
101static_assert(std::is_final<KServerSession>::value && 101 std::is_base_of_v<KSynchronizationObject, KServerSession>);
102 std::is_base_of<KSynchronizationObject, KServerSession>::value); 102static_assert(std::is_final_v<KClientPort> &&
103static_assert(std::is_final<KClientPort>::value && 103 std::is_base_of_v<KSynchronizationObject, KClientPort>);
104 std::is_base_of<KSynchronizationObject, KClientPort>::value); 104static_assert(std::is_final_v<KClientSession> && std::is_base_of_v<KAutoObject, KClientSession>);
105static_assert(std::is_final<KClientSession>::value && 105static_assert(std::is_final_v<KProcess> && std::is_base_of_v<KSynchronizationObject, KProcess>);
106 std::is_base_of<KAutoObject, KClientSession>::value); 106static_assert(std::is_final_v<KResourceLimit> && std::is_base_of_v<KAutoObject, KResourceLimit>);
107static_assert(std::is_final<KProcess>::value && 107// static_assert(std::is_final_v<KLightSession> &&
108 std::is_base_of<KSynchronizationObject, KProcess>::value); 108// std::is_base_of_v<KAutoObject, KLightSession>);
109static_assert(std::is_final<KResourceLimit>::value && 109static_assert(std::is_final_v<KPort> && std::is_base_of_v<KAutoObject, KPort>);
110 std::is_base_of<KAutoObject, KResourceLimit>::value); 110static_assert(std::is_final_v<KSession> && std::is_base_of_v<KAutoObject, KSession>);
111// static_assert(std::is_final<KLightSession>::value && 111static_assert(std::is_final_v<KSharedMemory> && std::is_base_of_v<KAutoObject, KSharedMemory>);
112// std::is_base_of<KAutoObject, KLightSession>::value); 112static_assert(std::is_final_v<KEvent> && std::is_base_of_v<KAutoObject, KEvent>);
113static_assert(std::is_final<KPort>::value && std::is_base_of<KAutoObject, KPort>::value); 113static_assert(std::is_final_v<KWritableEvent> && std::is_base_of_v<KAutoObject, KWritableEvent>);
114static_assert(std::is_final<KSession>::value && std::is_base_of<KAutoObject, KSession>::value); 114// static_assert(std::is_final_v<KLightClientSession> &&
115static_assert(std::is_final<KSharedMemory>::value && 115// std::is_base_of_v<KAutoObject, KLightClientSession>);
116 std::is_base_of<KAutoObject, KSharedMemory>::value); 116// static_assert(std::is_final_v<KLightServerSession> &&
117static_assert(std::is_final<KEvent>::value && std::is_base_of<KAutoObject, KEvent>::value); 117// std::is_base_of_v<KAutoObject, KLightServerSession>);
118static_assert(std::is_final<KWritableEvent>::value && 118static_assert(std::is_final_v<KTransferMemory> && std::is_base_of_v<KAutoObject, KTransferMemory>);
119 std::is_base_of<KAutoObject, KWritableEvent>::value); 119// static_assert(std::is_final_v<KDeviceAddressSpace> &&
120// static_assert(std::is_final<KLightClientSession>::value && 120// std::is_base_of_v<KAutoObject, KDeviceAddressSpace>);
121// std::is_base_of<KAutoObject, KLightClientSession>::value); 121// static_assert(std::is_final_v<KSessionRequest> &&
122// static_assert(std::is_final<KLightServerSession>::value && 122// std::is_base_of_v<KAutoObject, KSessionRequest>);
123// std::is_base_of<KAutoObject, KLightServerSession>::value); 123// static_assert(std::is_final_v<KCodeMemory> &&
124static_assert(std::is_final<KTransferMemory>::value && 124// std::is_base_of_v<KAutoObject, KCodeMemory>);
125 std::is_base_of<KAutoObject, KTransferMemory>::value);
126// static_assert(std::is_final<KDeviceAddressSpace>::value &&
127// std::is_base_of<KAutoObject, KDeviceAddressSpace>::value);
128// static_assert(std::is_final<KSessionRequest>::value &&
129// std::is_base_of<KAutoObject, KSessionRequest>::value);
130// static_assert(std::is_final<KCodeMemory>::value &&
131// std::is_base_of<KAutoObject, KCodeMemory>::value);
132 125
133} // namespace Kernel 126} // namespace Kernel
diff --git a/src/core/hle/kernel/k_client_port.h b/src/core/hle/kernel/k_client_port.h
index 8501156e8..f2fff3b01 100644
--- a/src/core/hle/kernel/k_client_port.h
+++ b/src/core/hle/kernel/k_client_port.h
@@ -22,7 +22,7 @@ class KClientPort final : public KSynchronizationObject {
22 22
23public: 23public:
24 explicit KClientPort(KernelCore& kernel_); 24 explicit KClientPort(KernelCore& kernel_);
25 virtual ~KClientPort() override; 25 ~KClientPort() override;
26 26
27 void Initialize(KPort* parent_, s32 max_sessions_, std::string&& name_); 27 void Initialize(KPort* parent_, s32 max_sessions_, std::string&& name_);
28 void OnSessionFinalized(); 28 void OnSessionFinalized();
@@ -49,8 +49,8 @@ public:
49 bool IsServerClosed() const; 49 bool IsServerClosed() const;
50 50
51 // Overridden virtual functions. 51 // Overridden virtual functions.
52 virtual void Destroy() override; 52 void Destroy() override;
53 virtual bool IsSignaled() const override; 53 bool IsSignaled() const override;
54 54
55 ResultCode CreateSession(KClientSession** out); 55 ResultCode CreateSession(KClientSession** out);
56 56
diff --git a/src/core/hle/kernel/k_client_session.h b/src/core/hle/kernel/k_client_session.h
index 720a8c243..b11d5b4e3 100644
--- a/src/core/hle/kernel/k_client_session.h
+++ b/src/core/hle/kernel/k_client_session.h
@@ -34,7 +34,7 @@ class KClientSession final
34 34
35public: 35public:
36 explicit KClientSession(KernelCore& kernel_); 36 explicit KClientSession(KernelCore& kernel_);
37 virtual ~KClientSession(); 37 ~KClientSession() override;
38 38
39 void Initialize(KSession* parent_, std::string&& name_) { 39 void Initialize(KSession* parent_, std::string&& name_) {
40 // Set member variables. 40 // Set member variables.
@@ -42,7 +42,7 @@ public:
42 name = std::move(name_); 42 name = std::move(name_);
43 } 43 }
44 44
45 virtual void Destroy() override; 45 void Destroy() override;
46 static void PostDestroy([[maybe_unused]] uintptr_t arg) {} 46 static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
47 47
48 KSession* GetParent() const { 48 KSession* GetParent() const {
diff --git a/src/core/hle/kernel/k_event.h b/src/core/hle/kernel/k_event.h
index 9a59ffb70..3d3ec99e2 100644
--- a/src/core/hle/kernel/k_event.h
+++ b/src/core/hle/kernel/k_event.h
@@ -20,23 +20,21 @@ class KEvent final : public KAutoObjectWithSlabHeapAndContainer<KEvent, KAutoObj
20 20
21public: 21public:
22 explicit KEvent(KernelCore& kernel_); 22 explicit KEvent(KernelCore& kernel_);
23 virtual ~KEvent(); 23 ~KEvent() override;
24 24
25 void Initialize(std::string&& name); 25 void Initialize(std::string&& name);
26 26
27 virtual void Finalize() override; 27 void Finalize() override;
28 28
29 virtual bool IsInitialized() const override { 29 bool IsInitialized() const override {
30 return initialized; 30 return initialized;
31 } 31 }
32 32
33 virtual uintptr_t GetPostDestroyArgument() const override { 33 uintptr_t GetPostDestroyArgument() const override {
34 return reinterpret_cast<uintptr_t>(owner); 34 return reinterpret_cast<uintptr_t>(owner);
35 } 35 }
36 36
37 static void PostDestroy(uintptr_t arg); 37 KProcess* GetOwner() const override {
38
39 virtual KProcess* GetOwner() const override {
40 return owner; 38 return owner;
41 } 39 }
42 40
@@ -48,6 +46,8 @@ public:
48 return writable_event; 46 return writable_event;
49 } 47 }
50 48
49 static void PostDestroy(uintptr_t arg);
50
51private: 51private:
52 KReadableEvent readable_event; 52 KReadableEvent readable_event;
53 KWritableEvent writable_event; 53 KWritableEvent writable_event;
diff --git a/src/core/hle/kernel/k_port.h b/src/core/hle/kernel/k_port.h
index 960f1f3a3..4018ea2df 100644
--- a/src/core/hle/kernel/k_port.h
+++ b/src/core/hle/kernel/k_port.h
@@ -22,7 +22,7 @@ class KPort final : public KAutoObjectWithSlabHeapAndContainer<KPort, KAutoObjec
22 22
23public: 23public:
24 explicit KPort(KernelCore& kernel_); 24 explicit KPort(KernelCore& kernel_);
25 virtual ~KPort(); 25 ~KPort() override;
26 26
27 static void PostDestroy([[maybe_unused]] uintptr_t arg) {} 27 static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
28 28
@@ -59,7 +59,6 @@ private:
59 ServerClosed = 3, 59 ServerClosed = 3,
60 }; 60 };
61 61
62private:
63 KServerPort server; 62 KServerPort server;
64 KClientPort client; 63 KClientPort client;
65 State state{State::Invalid}; 64 State state{State::Invalid};
diff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.h
index 123d71cd3..c0656b9af 100644
--- a/src/core/hle/kernel/k_process.h
+++ b/src/core/hle/kernel/k_process.h
@@ -331,19 +331,19 @@ public:
331 331
332 void LoadModule(CodeSet code_set, VAddr base_addr); 332 void LoadModule(CodeSet code_set, VAddr base_addr);
333 333
334 virtual bool IsInitialized() const override { 334 bool IsInitialized() const override {
335 return is_initialized; 335 return is_initialized;
336 } 336 }
337 337
338 static void PostDestroy([[maybe_unused]] uintptr_t arg) {} 338 static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
339 339
340 virtual void Finalize(); 340 void Finalize() override;
341 341
342 virtual u64 GetId() const override final { 342 u64 GetId() const override {
343 return GetProcessID(); 343 return GetProcessID();
344 } 344 }
345 345
346 virtual bool IsSignaled() const override; 346 bool IsSignaled() const override;
347 347
348 void PinCurrentThread(); 348 void PinCurrentThread();
349 void UnpinCurrentThread(); 349 void UnpinCurrentThread();
diff --git a/src/core/hle/kernel/k_readable_event.h b/src/core/hle/kernel/k_readable_event.h
index 33cd1dd3e..b2850ac7b 100644
--- a/src/core/hle/kernel/k_readable_event.h
+++ b/src/core/hle/kernel/k_readable_event.h
@@ -31,8 +31,8 @@ public:
31 return parent; 31 return parent;
32 } 32 }
33 33
34 virtual bool IsSignaled() const override; 34 bool IsSignaled() const override;
35 virtual void Destroy() override; 35 void Destroy() override;
36 36
37 ResultCode Signal(); 37 ResultCode Signal();
38 ResultCode Clear(); 38 ResultCode Clear();
diff --git a/src/core/hle/kernel/k_resource_limit.h b/src/core/hle/kernel/k_resource_limit.h
index 0debbbb51..fab6005ff 100644
--- a/src/core/hle/kernel/k_resource_limit.h
+++ b/src/core/hle/kernel/k_resource_limit.h
@@ -37,10 +37,10 @@ class KResourceLimit final
37 37
38public: 38public:
39 explicit KResourceLimit(KernelCore& kernel_); 39 explicit KResourceLimit(KernelCore& kernel_);
40 virtual ~KResourceLimit(); 40 ~KResourceLimit() override;
41 41
42 void Initialize(const Core::Timing::CoreTiming* core_timing_); 42 void Initialize(const Core::Timing::CoreTiming* core_timing_);
43 virtual void Finalize() override; 43 void Finalize() override;
44 44
45 s64 GetLimitValue(LimitableResource which) const; 45 s64 GetLimitValue(LimitableResource which) const;
46 s64 GetCurrentValue(LimitableResource which) const; 46 s64 GetCurrentValue(LimitableResource which) const;
diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cpp
index 2f82fbcd6..6a7d80d03 100644
--- a/src/core/hle/kernel/k_scheduler.cpp
+++ b/src/core/hle/kernel/k_scheduler.cpp
@@ -659,7 +659,6 @@ void KScheduler::Unload(KThread* thread) {
659 659
660 if (thread) { 660 if (thread) {
661 if (thread->IsCallingSvc()) { 661 if (thread->IsCallingSvc()) {
662 system.ArmInterface(core_id).ExceptionalExit();
663 thread->ClearIsCallingSvc(); 662 thread->ClearIsCallingSvc();
664 } 663 }
665 if (!thread->IsTerminationRequested()) { 664 if (!thread->IsTerminationRequested()) {
diff --git a/src/core/hle/kernel/k_server_port.h b/src/core/hle/kernel/k_server_port.h
index d1a757ec3..55481d63f 100644
--- a/src/core/hle/kernel/k_server_port.h
+++ b/src/core/hle/kernel/k_server_port.h
@@ -25,12 +25,9 @@ class SessionRequestHandler;
25class KServerPort final : public KSynchronizationObject { 25class KServerPort final : public KSynchronizationObject {
26 KERNEL_AUTOOBJECT_TRAITS(KServerPort, KSynchronizationObject); 26 KERNEL_AUTOOBJECT_TRAITS(KServerPort, KSynchronizationObject);
27 27
28private:
29 using SessionList = boost::intrusive::list<KServerSession>;
30
31public: 28public:
32 explicit KServerPort(KernelCore& kernel_); 29 explicit KServerPort(KernelCore& kernel_);
33 virtual ~KServerPort() override; 30 ~KServerPort() override;
34 31
35 void Initialize(KPort* parent_, std::string&& name_); 32 void Initialize(KPort* parent_, std::string&& name_);
36 33
@@ -63,13 +60,14 @@ public:
63 bool IsLight() const; 60 bool IsLight() const;
64 61
65 // Overridden virtual functions. 62 // Overridden virtual functions.
66 virtual void Destroy() override; 63 void Destroy() override;
67 virtual bool IsSignaled() const override; 64 bool IsSignaled() const override;
68 65
69private: 66private:
67 using SessionList = boost::intrusive::list<KServerSession>;
68
70 void CleanupSessions(); 69 void CleanupSessions();
71 70
72private:
73 SessionList session_list; 71 SessionList session_list;
74 SessionRequestHandlerPtr session_handler; 72 SessionRequestHandlerPtr session_handler;
75 KPort* parent{}; 73 KPort* parent{};
diff --git a/src/core/hle/kernel/k_server_session.h b/src/core/hle/kernel/k_server_session.h
index dd4de2904..27b757ad2 100644
--- a/src/core/hle/kernel/k_server_session.h
+++ b/src/core/hle/kernel/k_server_session.h
@@ -42,9 +42,9 @@ class KServerSession final : public KSynchronizationObject,
42 42
43public: 43public:
44 explicit KServerSession(KernelCore& kernel_); 44 explicit KServerSession(KernelCore& kernel_);
45 virtual ~KServerSession() override; 45 ~KServerSession() override;
46 46
47 virtual void Destroy() override; 47 void Destroy() override;
48 48
49 void Initialize(KSession* parent_, std::string&& name_); 49 void Initialize(KSession* parent_, std::string&& name_);
50 50
@@ -56,7 +56,7 @@ public:
56 return parent; 56 return parent;
57 } 57 }
58 58
59 virtual bool IsSignaled() const override; 59 bool IsSignaled() const override;
60 60
61 void OnClientClosed(); 61 void OnClientClosed();
62 62
diff --git a/src/core/hle/kernel/k_session.h b/src/core/hle/kernel/k_session.h
index a981fd1f6..4ddd080d2 100644
--- a/src/core/hle/kernel/k_session.h
+++ b/src/core/hle/kernel/k_session.h
@@ -18,17 +18,17 @@ class KSession final : public KAutoObjectWithSlabHeapAndContainer<KSession, KAut
18 18
19public: 19public:
20 explicit KSession(KernelCore& kernel_); 20 explicit KSession(KernelCore& kernel_);
21 virtual ~KSession() override; 21 ~KSession() override;
22 22
23 void Initialize(KClientPort* port_, const std::string& name_); 23 void Initialize(KClientPort* port_, const std::string& name_);
24 24
25 virtual void Finalize() override; 25 void Finalize() override;
26 26
27 virtual bool IsInitialized() const override { 27 bool IsInitialized() const override {
28 return initialized; 28 return initialized;
29 } 29 }
30 30
31 virtual uintptr_t GetPostDestroyArgument() const override { 31 uintptr_t GetPostDestroyArgument() const override {
32 return reinterpret_cast<uintptr_t>(process); 32 return reinterpret_cast<uintptr_t>(process);
33 } 33 }
34 34
@@ -78,7 +78,6 @@ private:
78 ServerClosed = 3, 78 ServerClosed = 3,
79 }; 79 };
80 80
81private:
82 void SetState(State state) { 81 void SetState(State state) {
83 atomic_state = static_cast<u8>(state); 82 atomic_state = static_cast<u8>(state);
84 } 83 }
@@ -87,7 +86,6 @@ private:
87 return static_cast<State>(atomic_state.load(std::memory_order_relaxed)); 86 return static_cast<State>(atomic_state.load(std::memory_order_relaxed));
88 } 87 }
89 88
90private:
91 KServerSession server; 89 KServerSession server;
92 KClientSession client; 90 KClientSession client;
93 std::atomic<std::underlying_type_t<State>> atomic_state{ 91 std::atomic<std::underlying_type_t<State>> atomic_state{
diff --git a/src/core/hle/kernel/k_shared_memory.h b/src/core/hle/kernel/k_shared_memory.h
index 553a56327..e9815f90b 100644
--- a/src/core/hle/kernel/k_shared_memory.h
+++ b/src/core/hle/kernel/k_shared_memory.h
@@ -68,9 +68,9 @@ public:
68 return device_memory->GetPointer(physical_address + offset); 68 return device_memory->GetPointer(physical_address + offset);
69 } 69 }
70 70
71 virtual void Finalize() override; 71 void Finalize() override;
72 72
73 virtual bool IsInitialized() const override { 73 bool IsInitialized() const override {
74 return is_initialized; 74 return is_initialized;
75 } 75 }
76 static void PostDestroy([[maybe_unused]] uintptr_t arg) {} 76 static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
diff --git a/src/core/hle/kernel/k_slab_heap.h b/src/core/hle/kernel/k_slab_heap.h
index 81d472a3e..0ad74b0a0 100644
--- a/src/core/hle/kernel/k_slab_heap.h
+++ b/src/core/hle/kernel/k_slab_heap.h
@@ -4,34 +4,213 @@
4 4
5#pragma once 5#pragma once
6 6
7#include <atomic>
8
9#include "common/assert.h"
10#include "common/common_types.h"
11
7namespace Kernel { 12namespace Kernel {
8 13
9class KernelCore; 14class KernelCore;
10 15
11/// This is a placeholder class to manage slab heaps for kernel objects. For now, we just allocate 16namespace impl {
12/// these with new/delete, but this can be re-implemented later to allocate these in emulated 17
13/// memory. 18class KSlabHeapImpl final : NonCopyable {
19public:
20 struct Node {
21 Node* next{};
22 };
23
24 constexpr KSlabHeapImpl() = default;
25
26 void Initialize(std::size_t size) {
27 ASSERT(head == nullptr);
28 obj_size = size;
29 }
30
31 constexpr std::size_t GetObjectSize() const {
32 return obj_size;
33 }
34
35 Node* GetHead() const {
36 return head;
37 }
38
39 void* Allocate() {
40 Node* ret = head.load();
41
42 do {
43 if (ret == nullptr) {
44 break;
45 }
46 } while (!head.compare_exchange_weak(ret, ret->next));
47
48 return ret;
49 }
50
51 void Free(void* obj) {
52 Node* node = static_cast<Node*>(obj);
53
54 Node* cur_head = head.load();
55 do {
56 node->next = cur_head;
57 } while (!head.compare_exchange_weak(cur_head, node));
58 }
59
60private:
61 std::atomic<Node*> head{};
62 std::size_t obj_size{};
63};
64
65} // namespace impl
66
67class KSlabHeapBase : NonCopyable {
68public:
69 constexpr KSlabHeapBase() = default;
70
71 constexpr bool Contains(uintptr_t addr) const {
72 return start <= addr && addr < end;
73 }
74
75 constexpr std::size_t GetSlabHeapSize() const {
76 return (end - start) / GetObjectSize();
77 }
78
79 constexpr std::size_t GetObjectSize() const {
80 return impl.GetObjectSize();
81 }
82
83 constexpr uintptr_t GetSlabHeapAddress() const {
84 return start;
85 }
86
87 std::size_t GetObjectIndexImpl(const void* obj) const {
88 return (reinterpret_cast<uintptr_t>(obj) - start) / GetObjectSize();
89 }
90
91 std::size_t GetPeakIndex() const {
92 return GetObjectIndexImpl(reinterpret_cast<const void*>(peak));
93 }
94
95 void* AllocateImpl() {
96 return impl.Allocate();
97 }
98
99 void FreeImpl(void* obj) {
100 // Don't allow freeing an object that wasn't allocated from this heap
101 ASSERT(Contains(reinterpret_cast<uintptr_t>(obj)));
102
103 impl.Free(obj);
104 }
105
106 void InitializeImpl(std::size_t obj_size, void* memory, std::size_t memory_size) {
107 // Ensure we don't initialize a slab using null memory
108 ASSERT(memory != nullptr);
109
110 // Initialize the base allocator
111 impl.Initialize(obj_size);
112
113 // Set our tracking variables
114 const std::size_t num_obj = (memory_size / obj_size);
115 start = reinterpret_cast<uintptr_t>(memory);
116 end = start + num_obj * obj_size;
117 peak = start;
118
119 // Free the objects
120 u8* cur = reinterpret_cast<u8*>(end);
121
122 for (std::size_t i{}; i < num_obj; i++) {
123 cur -= obj_size;
124 impl.Free(cur);
125 }
126 }
127
128private:
129 using Impl = impl::KSlabHeapImpl;
130
131 Impl impl;
132 uintptr_t peak{};
133 uintptr_t start{};
134 uintptr_t end{};
135};
14 136
15template <typename T> 137template <typename T>
16class KSlabHeap final : NonCopyable { 138class KSlabHeap final : public KSlabHeapBase {
17public: 139public:
18 KSlabHeap() = default; 140 enum class AllocationType {
141 Host,
142 Guest,
143 };
19 144
20 void Initialize([[maybe_unused]] void* memory, [[maybe_unused]] std::size_t memory_size) { 145 explicit constexpr KSlabHeap(AllocationType allocation_type_ = AllocationType::Host)
21 // Placeholder that should initialize the backing slab heap implementation. 146 : KSlabHeapBase(), allocation_type{allocation_type_} {}
147
148 void Initialize(void* memory, std::size_t memory_size) {
149 if (allocation_type == AllocationType::Guest) {
150 InitializeImpl(sizeof(T), memory, memory_size);
151 }
22 } 152 }
23 153
24 T* Allocate() { 154 T* Allocate() {
25 return new T(); 155 switch (allocation_type) {
156 case AllocationType::Host:
157 // Fallback for cases where we do not yet support allocating guest memory from the slab
158 // heap, such as for kernel memory regions.
159 return new T;
160
161 case AllocationType::Guest:
162 T* obj = static_cast<T*>(AllocateImpl());
163 if (obj != nullptr) {
164 new (obj) T();
165 }
166 return obj;
167 }
168
169 UNREACHABLE_MSG("Invalid AllocationType {}", allocation_type);
170 return nullptr;
26 } 171 }
27 172
28 T* AllocateWithKernel(KernelCore& kernel) { 173 T* AllocateWithKernel(KernelCore& kernel) {
29 return new T(kernel); 174 switch (allocation_type) {
175 case AllocationType::Host:
176 // Fallback for cases where we do not yet support allocating guest memory from the slab
177 // heap, such as for kernel memory regions.
178 return new T(kernel);
179
180 case AllocationType::Guest:
181 T* obj = static_cast<T*>(AllocateImpl());
182 if (obj != nullptr) {
183 new (obj) T(kernel);
184 }
185 return obj;
186 }
187
188 UNREACHABLE_MSG("Invalid AllocationType {}", allocation_type);
189 return nullptr;
30 } 190 }
31 191
32 void Free(T* obj) { 192 void Free(T* obj) {
33 delete obj; 193 switch (allocation_type) {
194 case AllocationType::Host:
195 // Fallback for cases where we do not yet support allocating guest memory from the slab
196 // heap, such as for kernel memory regions.
197 delete obj;
198 return;
199
200 case AllocationType::Guest:
201 FreeImpl(obj);
202 return;
203 }
204
205 UNREACHABLE_MSG("Invalid AllocationType {}", allocation_type);
34 } 206 }
207
208 constexpr std::size_t GetObjectIndex(const T* obj) const {
209 return GetObjectIndexImpl(obj);
210 }
211
212private:
213 const AllocationType allocation_type;
35}; 214};
36 215
37} // namespace Kernel 216} // namespace Kernel
diff --git a/src/core/hle/kernel/k_synchronization_object.h b/src/core/hle/kernel/k_synchronization_object.h
index a41dd1220..3d4ce1fbc 100644
--- a/src/core/hle/kernel/k_synchronization_object.h
+++ b/src/core/hle/kernel/k_synchronization_object.h
@@ -29,7 +29,7 @@ public:
29 KSynchronizationObject** objects, const s32 num_objects, 29 KSynchronizationObject** objects, const s32 num_objects,
30 s64 timeout); 30 s64 timeout);
31 31
32 virtual void Finalize() override; 32 void Finalize() override;
33 33
34 [[nodiscard]] virtual bool IsSignaled() const = 0; 34 [[nodiscard]] virtual bool IsSignaled() const = 0;
35 35
@@ -37,7 +37,7 @@ public:
37 37
38protected: 38protected:
39 explicit KSynchronizationObject(KernelCore& kernel); 39 explicit KSynchronizationObject(KernelCore& kernel);
40 virtual ~KSynchronizationObject(); 40 ~KSynchronizationObject() override;
41 41
42 virtual void OnFinalizeSynchronizationObject() {} 42 virtual void OnFinalizeSynchronizationObject() {}
43 43
diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cpp
index e3f08f256..3cf43d290 100644
--- a/src/core/hle/kernel/k_thread.cpp
+++ b/src/core/hle/kernel/k_thread.cpp
@@ -168,13 +168,13 @@ ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_s
168 std::memset(static_cast<void*>(std::addressof(GetStackParameters())), 0, 168 std::memset(static_cast<void*>(std::addressof(GetStackParameters())), 0,
169 sizeof(StackParameters)); 169 sizeof(StackParameters));
170 170
171 // Setup the TLS, if needed.
172 if (type == ThreadType::User) {
173 tls_address = owner->CreateTLSRegion();
174 }
175
176 // Set parent, if relevant. 171 // Set parent, if relevant.
177 if (owner != nullptr) { 172 if (owner != nullptr) {
173 // Setup the TLS, if needed.
174 if (type == ThreadType::User) {
175 tls_address = owner->CreateTLSRegion();
176 }
177
178 parent = owner; 178 parent = owner;
179 parent->Open(); 179 parent->Open();
180 parent->IncrementThreadCount(); 180 parent->IncrementThreadCount();
diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h
index 4abfc2b49..01eebb165 100644
--- a/src/core/hle/kernel/k_thread.h
+++ b/src/core/hle/kernel/k_thread.h
@@ -358,21 +358,21 @@ public:
358 return termination_requested || GetRawState() == ThreadState::Terminated; 358 return termination_requested || GetRawState() == ThreadState::Terminated;
359 } 359 }
360 360
361 [[nodiscard]] virtual u64 GetId() const override final { 361 [[nodiscard]] u64 GetId() const override {
362 return this->GetThreadID(); 362 return this->GetThreadID();
363 } 363 }
364 364
365 [[nodiscard]] virtual bool IsInitialized() const override { 365 [[nodiscard]] bool IsInitialized() const override {
366 return initialized; 366 return initialized;
367 } 367 }
368 368
369 [[nodiscard]] virtual uintptr_t GetPostDestroyArgument() const override { 369 [[nodiscard]] uintptr_t GetPostDestroyArgument() const override {
370 return reinterpret_cast<uintptr_t>(parent) | (resource_limit_release_hint ? 1 : 0); 370 return reinterpret_cast<uintptr_t>(parent) | (resource_limit_release_hint ? 1 : 0);
371 } 371 }
372 372
373 virtual void Finalize() override; 373 void Finalize() override;
374 374
375 [[nodiscard]] virtual bool IsSignaled() const override; 375 [[nodiscard]] bool IsSignaled() const override;
376 376
377 static void PostDestroy(uintptr_t arg); 377 static void PostDestroy(uintptr_t arg);
378 378
diff --git a/src/core/hle/kernel/k_transfer_memory.h b/src/core/hle/kernel/k_transfer_memory.h
index c2d0f1eaf..31029a5c2 100644
--- a/src/core/hle/kernel/k_transfer_memory.h
+++ b/src/core/hle/kernel/k_transfer_memory.h
@@ -27,23 +27,23 @@ class KTransferMemory final
27 27
28public: 28public:
29 explicit KTransferMemory(KernelCore& kernel_); 29 explicit KTransferMemory(KernelCore& kernel_);
30 virtual ~KTransferMemory() override; 30 ~KTransferMemory() override;
31 31
32 ResultCode Initialize(VAddr address_, std::size_t size_, Svc::MemoryPermission owner_perm_); 32 ResultCode Initialize(VAddr address_, std::size_t size_, Svc::MemoryPermission owner_perm_);
33 33
34 virtual void Finalize() override; 34 void Finalize() override;
35 35
36 virtual bool IsInitialized() const override { 36 bool IsInitialized() const override {
37 return is_initialized; 37 return is_initialized;
38 } 38 }
39 39
40 virtual uintptr_t GetPostDestroyArgument() const override { 40 uintptr_t GetPostDestroyArgument() const override {
41 return reinterpret_cast<uintptr_t>(owner); 41 return reinterpret_cast<uintptr_t>(owner);
42 } 42 }
43 43
44 static void PostDestroy(uintptr_t arg); 44 static void PostDestroy(uintptr_t arg);
45 45
46 KProcess* GetOwner() const { 46 KProcess* GetOwner() const override {
47 return owner; 47 return owner;
48 } 48 }
49 49
diff --git a/src/core/hle/kernel/k_writable_event.h b/src/core/hle/kernel/k_writable_event.h
index 607b0eadb..858d982c4 100644
--- a/src/core/hle/kernel/k_writable_event.h
+++ b/src/core/hle/kernel/k_writable_event.h
@@ -21,7 +21,7 @@ public:
21 explicit KWritableEvent(KernelCore& kernel_); 21 explicit KWritableEvent(KernelCore& kernel_);
22 ~KWritableEvent() override; 22 ~KWritableEvent() override;
23 23
24 virtual void Destroy() override; 24 void Destroy() override;
25 25
26 static void PostDestroy([[maybe_unused]] uintptr_t arg) {} 26 static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
27 27
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 8b55df82e..0ffb78d51 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -258,7 +258,7 @@ struct KernelCore::Impl {
258 KAutoObject::Create(thread.get()); 258 KAutoObject::Create(thread.get());
259 ASSERT(KThread::InitializeDummyThread(thread.get()).IsSuccess()); 259 ASSERT(KThread::InitializeDummyThread(thread.get()).IsSuccess());
260 thread->SetName(fmt::format("DummyThread:{}", GetHostThreadId())); 260 thread->SetName(fmt::format("DummyThread:{}", GetHostThreadId()));
261 return std::move(thread); 261 return thread;
262 }; 262 };
263 263
264 thread_local auto thread = make_thread(); 264 thread_local auto thread = make_thread();
@@ -620,7 +620,8 @@ struct KernelCore::Impl {
620 620
621 void InitializePageSlab() { 621 void InitializePageSlab() {
622 // Allocate slab heaps 622 // Allocate slab heaps
623 user_slab_heap_pages = std::make_unique<KSlabHeap<Page>>(); 623 user_slab_heap_pages =
624 std::make_unique<KSlabHeap<Page>>(KSlabHeap<Page>::AllocationType::Guest);
624 625
625 // TODO(ameerj): This should be derived, not hardcoded within the kernel 626 // TODO(ameerj): This should be derived, not hardcoded within the kernel
626 constexpr u64 user_slab_heap_size{0x3de000}; 627 constexpr u64 user_slab_heap_size{0x3de000};
diff --git a/src/core/hle/service/am/applets/software_keyboard.cpp b/src/core/hle/service/am/applets/software_keyboard.cpp
index b05a5da04..b1a81810b 100644
--- a/src/core/hle/service/am/applets/software_keyboard.cpp
+++ b/src/core/hle/service/am/applets/software_keyboard.cpp
@@ -273,8 +273,13 @@ void SoftwareKeyboard::ProcessTextCheck() {
273 273
274 std::memcpy(&swkbd_text_check, text_check_data.data(), sizeof(SwkbdTextCheck)); 274 std::memcpy(&swkbd_text_check, text_check_data.data(), sizeof(SwkbdTextCheck));
275 275
276 std::u16string text_check_message = Common::UTF16StringFromFixedZeroTerminatedBuffer( 276 std::u16string text_check_message =
277 swkbd_text_check.text_check_message.data(), swkbd_text_check.text_check_message.size()); 277 swkbd_text_check.text_check_result == SwkbdTextCheckResult::Failure ||
278 swkbd_text_check.text_check_result == SwkbdTextCheckResult::Confirm
279 ? Common::UTF16StringFromFixedZeroTerminatedBuffer(
280 swkbd_text_check.text_check_message.data(),
281 swkbd_text_check.text_check_message.size())
282 : u"";
278 283
279 LOG_INFO(Service_AM, "\nTextCheckResult: {}\nTextCheckMessage: {}", 284 LOG_INFO(Service_AM, "\nTextCheckResult: {}\nTextCheckMessage: {}",
280 GetTextCheckResultName(swkbd_text_check.text_check_result), 285 GetTextCheckResultName(swkbd_text_check.text_check_result),
@@ -285,10 +290,10 @@ void SoftwareKeyboard::ProcessTextCheck() {
285 SubmitNormalOutputAndExit(SwkbdResult::Ok, current_text); 290 SubmitNormalOutputAndExit(SwkbdResult::Ok, current_text);
286 break; 291 break;
287 case SwkbdTextCheckResult::Failure: 292 case SwkbdTextCheckResult::Failure:
288 ShowTextCheckDialog(SwkbdTextCheckResult::Failure, text_check_message); 293 ShowTextCheckDialog(SwkbdTextCheckResult::Failure, std::move(text_check_message));
289 break; 294 break;
290 case SwkbdTextCheckResult::Confirm: 295 case SwkbdTextCheckResult::Confirm:
291 ShowTextCheckDialog(SwkbdTextCheckResult::Confirm, text_check_message); 296 ShowTextCheckDialog(SwkbdTextCheckResult::Confirm, std::move(text_check_message));
292 break; 297 break;
293 case SwkbdTextCheckResult::Silent: 298 case SwkbdTextCheckResult::Silent:
294 default: 299 default:
@@ -482,7 +487,7 @@ void SoftwareKeyboard::InitializeFrontendKeyboard() {
482 max_text_length <= 32 ? SwkbdTextDrawType::Line : SwkbdTextDrawType::Box; 487 max_text_length <= 32 ? SwkbdTextDrawType::Line : SwkbdTextDrawType::Box;
483 488
484 Core::Frontend::KeyboardInitializeParameters initialize_parameters{ 489 Core::Frontend::KeyboardInitializeParameters initialize_parameters{
485 .ok_text{ok_text}, 490 .ok_text{std::move(ok_text)},
486 .header_text{}, 491 .header_text{},
487 .sub_text{}, 492 .sub_text{},
488 .guide_text{}, 493 .guide_text{},
@@ -558,10 +563,10 @@ void SoftwareKeyboard::InitializeFrontendKeyboard() {
558 : false; 563 : false;
559 564
560 Core::Frontend::KeyboardInitializeParameters initialize_parameters{ 565 Core::Frontend::KeyboardInitializeParameters initialize_parameters{
561 .ok_text{ok_text}, 566 .ok_text{std::move(ok_text)},
562 .header_text{header_text}, 567 .header_text{std::move(header_text)},
563 .sub_text{sub_text}, 568 .sub_text{std::move(sub_text)},
564 .guide_text{guide_text}, 569 .guide_text{std::move(guide_text)},
565 .initial_text{initial_text}, 570 .initial_text{initial_text},
566 .max_text_length{max_text_length}, 571 .max_text_length{max_text_length},
567 .min_text_length{min_text_length}, 572 .min_text_length{min_text_length},
@@ -590,7 +595,7 @@ void SoftwareKeyboard::ShowNormalKeyboard() {
590 595
591void SoftwareKeyboard::ShowTextCheckDialog(SwkbdTextCheckResult text_check_result, 596void SoftwareKeyboard::ShowTextCheckDialog(SwkbdTextCheckResult text_check_result,
592 std::u16string text_check_message) { 597 std::u16string text_check_message) {
593 frontend.ShowTextCheckDialog(text_check_result, text_check_message); 598 frontend.ShowTextCheckDialog(text_check_result, std::move(text_check_message));
594} 599}
595 600
596void SoftwareKeyboard::ShowInlineKeyboard() { 601void SoftwareKeyboard::ShowInlineKeyboard() {
diff --git a/src/core/hle/service/hid/controllers/gesture.h b/src/core/hle/service/hid/controllers/gesture.h
index eecfeaad5..7e7ae6625 100644
--- a/src/core/hle/service/hid/controllers/gesture.h
+++ b/src/core/hle/service/hid/controllers/gesture.h
@@ -7,6 +7,7 @@
7#include <array> 7#include <array>
8#include "common/bit_field.h" 8#include "common/bit_field.h"
9#include "common/common_types.h" 9#include "common/common_types.h"
10#include "common/point.h"
10#include "core/frontend/input.h" 11#include "core/frontend/input.h"
11#include "core/hle/service/hid/controllers/controller_base.h" 12#include "core/hle/service/hid/controllers/controller_base.h"
12 13
@@ -63,44 +64,21 @@ private:
63 }; 64 };
64 static_assert(sizeof(Attribute) == 4, "Attribute is an invalid size"); 65 static_assert(sizeof(Attribute) == 4, "Attribute is an invalid size");
65 66
66 template <typename T>
67 struct Point {
68 T x{};
69 T y{};
70
71 friend Point operator+(const Point& lhs, const Point& rhs) {
72 return {
73 .x = lhs.x + rhs.x,
74 .y = lhs.y + rhs.y,
75 };
76 }
77
78 friend Point operator-(const Point& lhs, const Point& rhs) {
79 return {
80 .x = lhs.x - rhs.x,
81 .y = lhs.y - rhs.y,
82 };
83 }
84
85 friend bool operator==(const Point&, const Point&) = default;
86 };
87 static_assert(sizeof(Point<s32_le>) == 8, "Point is an invalid size");
88
89 struct GestureState { 67 struct GestureState {
90 s64_le sampling_number; 68 s64_le sampling_number;
91 s64_le sampling_number2; 69 s64_le sampling_number2;
92 s64_le detection_count; 70 s64_le detection_count;
93 TouchType type; 71 TouchType type;
94 Direction direction; 72 Direction direction;
95 Point<s32_le> pos; 73 Common::Point<s32_le> pos;
96 Point<s32_le> delta; 74 Common::Point<s32_le> delta;
97 f32 vel_x; 75 f32 vel_x;
98 f32 vel_y; 76 f32 vel_y;
99 Attribute attributes; 77 Attribute attributes;
100 f32 scale; 78 f32 scale;
101 f32 rotation_angle; 79 f32 rotation_angle;
102 s32_le point_count; 80 s32_le point_count;
103 std::array<Point<s32_le>, 4> points; 81 std::array<Common::Point<s32_le>, 4> points;
104 }; 82 };
105 static_assert(sizeof(GestureState) == 0x68, "GestureState is an invalid size"); 83 static_assert(sizeof(GestureState) == 0x68, "GestureState is an invalid size");
106 84
@@ -111,14 +89,14 @@ private:
111 static_assert(sizeof(SharedMemory) == 0x708, "SharedMemory is an invalid size"); 89 static_assert(sizeof(SharedMemory) == 0x708, "SharedMemory is an invalid size");
112 90
113 struct Finger { 91 struct Finger {
114 Point<f32> pos{}; 92 Common::Point<f32> pos{};
115 bool pressed{}; 93 bool pressed{};
116 }; 94 };
117 95
118 struct GestureProperties { 96 struct GestureProperties {
119 std::array<Point<s32_le>, MAX_POINTS> points{}; 97 std::array<Common::Point<s32_le>, MAX_POINTS> points{};
120 std::size_t active_points{}; 98 std::size_t active_points{};
121 Point<s32_le> mid_point{}; 99 Common::Point<s32_le> mid_point{};
122 s64_le detection_count{}; 100 s64_le detection_count{};
123 u64_le delta_time{}; 101 u64_le delta_time{};
124 f32 average_distance{}; 102 f32 average_distance{};
diff --git a/src/core/hle/service/hid/controllers/touchscreen.cpp b/src/core/hle/service/hid/controllers/touchscreen.cpp
index ac9112c40..6ef17acc5 100644
--- a/src/core/hle/service/hid/controllers/touchscreen.cpp
+++ b/src/core/hle/service/hid/controllers/touchscreen.cpp
@@ -74,8 +74,11 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
74 for (std::size_t id = 0; id < MAX_FINGERS; ++id) { 74 for (std::size_t id = 0; id < MAX_FINGERS; ++id) {
75 auto& touch_entry = cur_entry.states[id]; 75 auto& touch_entry = cur_entry.states[id];
76 if (id < active_fingers_count) { 76 if (id < active_fingers_count) {
77 touch_entry.x = static_cast<u16>(active_fingers[id].x * Layout::ScreenUndocked::Width); 77 const auto& [active_x, active_y] = active_fingers[id].position;
78 touch_entry.y = static_cast<u16>(active_fingers[id].y * Layout::ScreenUndocked::Height); 78 touch_entry.position = {
79 .x = static_cast<u16>(active_x * Layout::ScreenUndocked::Width),
80 .y = static_cast<u16>(active_y * Layout::ScreenUndocked::Height),
81 };
79 touch_entry.diameter_x = Settings::values.touchscreen.diameter_x; 82 touch_entry.diameter_x = Settings::values.touchscreen.diameter_x;
80 touch_entry.diameter_y = Settings::values.touchscreen.diameter_y; 83 touch_entry.diameter_y = Settings::values.touchscreen.diameter_y;
81 touch_entry.rotation_angle = Settings::values.touchscreen.rotation_angle; 84 touch_entry.rotation_angle = Settings::values.touchscreen.rotation_angle;
@@ -86,8 +89,7 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
86 } else { 89 } else {
87 // Clear touch entry 90 // Clear touch entry
88 touch_entry.attribute.raw = 0; 91 touch_entry.attribute.raw = 0;
89 touch_entry.x = 0; 92 touch_entry.position = {};
90 touch_entry.y = 0;
91 touch_entry.diameter_x = 0; 93 touch_entry.diameter_x = 0;
92 touch_entry.diameter_y = 0; 94 touch_entry.diameter_y = 0;
93 touch_entry.rotation_angle = 0; 95 touch_entry.rotation_angle = 0;
@@ -140,8 +142,7 @@ std::size_t Controller_Touchscreen::UpdateTouchInputEvent(
140 fingers[finger_id].id = static_cast<u32_le>(finger_id); 142 fingers[finger_id].id = static_cast<u32_le>(finger_id);
141 attribute.start_touch.Assign(1); 143 attribute.start_touch.Assign(1);
142 } 144 }
143 fingers[finger_id].x = x; 145 fingers[finger_id].position = {x, y};
144 fingers[finger_id].y = y;
145 fingers[finger_id].attribute = attribute; 146 fingers[finger_id].attribute = attribute;
146 return finger_id; 147 return finger_id;
147 } 148 }
diff --git a/src/core/hle/service/hid/controllers/touchscreen.h b/src/core/hle/service/hid/controllers/touchscreen.h
index 2869d0cfd..ef2becefd 100644
--- a/src/core/hle/service/hid/controllers/touchscreen.h
+++ b/src/core/hle/service/hid/controllers/touchscreen.h
@@ -7,6 +7,7 @@
7#include "common/bit_field.h" 7#include "common/bit_field.h"
8#include "common/common_funcs.h" 8#include "common/common_funcs.h"
9#include "common/common_types.h" 9#include "common/common_types.h"
10#include "common/point.h"
10#include "common/swap.h" 11#include "common/swap.h"
11#include "core/frontend/input.h" 12#include "core/frontend/input.h"
12#include "core/hle/service/hid/controllers/controller_base.h" 13#include "core/hle/service/hid/controllers/controller_base.h"
@@ -55,8 +56,7 @@ private:
55 u64_le delta_time; 56 u64_le delta_time;
56 Attributes attribute; 57 Attributes attribute;
57 u32_le finger; 58 u32_le finger;
58 u32_le x; 59 Common::Point<u32_le> position;
59 u32_le y;
60 u32_le diameter_x; 60 u32_le diameter_x;
61 u32_le diameter_y; 61 u32_le diameter_y;
62 u32_le rotation_angle; 62 u32_le rotation_angle;
@@ -81,8 +81,7 @@ private:
81 81
82 struct Finger { 82 struct Finger {
83 u64_le last_touch{}; 83 u64_le last_touch{};
84 float x{}; 84 Common::Point<float> position;
85 float y{};
86 u32_le id{}; 85 u32_le id{};
87 bool pressed{}; 86 bool pressed{};
88 Attributes attribute; 87 Attributes attribute;
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 49c17fd14..df0fe1c8e 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -1770,7 +1770,7 @@ public:
1770 {232, nullptr, "GetIrSensorState"}, 1770 {232, nullptr, "GetIrSensorState"},
1771 {233, nullptr, "GetXcdHandleForNpadWithIrSensor"}, 1771 {233, nullptr, "GetXcdHandleForNpadWithIrSensor"},
1772 {301, nullptr, "ActivateNpadSystem"}, 1772 {301, nullptr, "ActivateNpadSystem"},
1773 {303, nullptr, "ApplyNpadSystemCommonPolicy"}, 1773 {303, &HidSys::ApplyNpadSystemCommonPolicy, "ApplyNpadSystemCommonPolicy"},
1774 {304, nullptr, "EnableAssigningSingleOnSlSrPress"}, 1774 {304, nullptr, "EnableAssigningSingleOnSlSrPress"},
1775 {305, nullptr, "DisableAssigningSingleOnSlSrPress"}, 1775 {305, nullptr, "DisableAssigningSingleOnSlSrPress"},
1776 {306, nullptr, "GetLastActiveNpad"}, 1776 {306, nullptr, "GetLastActiveNpad"},
@@ -1949,6 +1949,15 @@ public:
1949 1949
1950 RegisterHandlers(functions); 1950 RegisterHandlers(functions);
1951 } 1951 }
1952
1953private:
1954 void ApplyNpadSystemCommonPolicy(Kernel::HLERequestContext& ctx) {
1955 // We already do this for homebrew so we can just stub it out
1956 LOG_WARNING(Service_HID, "called");
1957
1958 IPC::ResponseBuilder rb{ctx, 2};
1959 rb.Push(RESULT_SUCCESS);
1960 }
1952}; 1961};
1953 1962
1954class HidTmp final : public ServiceFramework<HidTmp> { 1963class HidTmp final : public ServiceFramework<HidTmp> {
diff --git a/src/core/hle/service/ldn/ldn.cpp b/src/core/hle/service/ldn/ldn.cpp
index d160ffe87..c709a8028 100644
--- a/src/core/hle/service/ldn/ldn.cpp
+++ b/src/core/hle/service/ldn/ldn.cpp
@@ -215,10 +215,151 @@ public:
215 } 215 }
216}; 216};
217 217
218class INetworkService final : public ServiceFramework<INetworkService> {
219public:
220 explicit INetworkService(Core::System& system_) : ServiceFramework{system_, "INetworkService"} {
221 // clang-format off
222 static const FunctionInfo functions[] = {
223 {0, nullptr, "Initialize"},
224 {256, nullptr, "AttachNetworkInterfaceStateChangeEvent"},
225 {264, nullptr, "GetNetworkInterfaceLastError"},
226 {272, nullptr, "GetRole"},
227 {280, nullptr, "GetAdvertiseData"},
228 {288, nullptr, "GetGroupInfo"},
229 {296, nullptr, "GetGroupInfo2"},
230 {304, nullptr, "GetGroupOwner"},
231 {312, nullptr, "GetIpConfig"},
232 {320, nullptr, "GetLinkLevel"},
233 {512, nullptr, "Scan"},
234 {768, nullptr, "CreateGroup"},
235 {776, nullptr, "DestroyGroup"},
236 {784, nullptr, "SetAdvertiseData"},
237 {1536, nullptr, "SendToOtherGroup"},
238 {1544, nullptr, "RecvFromOtherGroup"},
239 {1552, nullptr, "AddAcceptableGroupId"},
240 {1560, nullptr, "ClearAcceptableGroupId"},
241 };
242 // clang-format on
243
244 RegisterHandlers(functions);
245 }
246};
247
248class INetworkServiceMonitor final : public ServiceFramework<INetworkServiceMonitor> {
249public:
250 explicit INetworkServiceMonitor(Core::System& system_)
251 : ServiceFramework{system_, "INetworkServiceMonitor"} {
252 // clang-format off
253 static const FunctionInfo functions[] = {
254 {0, &INetworkServiceMonitor::Initialize, "Initialize"},
255 {256, nullptr, "AttachNetworkInterfaceStateChangeEvent"},
256 {264, nullptr, "GetNetworkInterfaceLastError"},
257 {272, nullptr, "GetRole"},
258 {280, nullptr, "GetAdvertiseData"},
259 {281, nullptr, "GetAdvertiseData2"},
260 {288, nullptr, "GetGroupInfo"},
261 {296, nullptr, "GetGroupInfo2"},
262 {304, nullptr, "GetGroupOwner"},
263 {312, nullptr, "GetIpConfig"},
264 {320, nullptr, "GetLinkLevel"},
265 {328, nullptr, "AttachJoinEvent"},
266 {336, nullptr, "GetMembers"},
267 };
268 // clang-format on
269
270 RegisterHandlers(functions);
271 }
272
273 void Initialize(Kernel::HLERequestContext& ctx) {
274 LOG_WARNING(Service_LDN, "(STUBBED) called");
275
276 IPC::ResponseBuilder rb{ctx, 2};
277 rb.Push(ERROR_DISABLED);
278 }
279};
280
281class LP2PAPP final : public ServiceFramework<LP2PAPP> {
282public:
283 explicit LP2PAPP(Core::System& system_) : ServiceFramework{system_, "lp2p:app"} {
284 // clang-format off
285 static const FunctionInfo functions[] = {
286 {0, &LP2PAPP::CreateMonitorService, "CreateNetworkService"},
287 {8, &LP2PAPP::CreateMonitorService, "CreateNetworkServiceMonitor"},
288 };
289 // clang-format on
290
291 RegisterHandlers(functions);
292 }
293
294 void CreateNetworkervice(Kernel::HLERequestContext& ctx) {
295 IPC::RequestParser rp{ctx};
296 const u64 reserved_input = rp.Pop<u64>();
297 const u32 input = rp.Pop<u32>();
298
299 LOG_WARNING(Service_LDN, "(STUBBED) called reserved_input={} input={}", reserved_input,
300 input);
301
302 IPC::ResponseBuilder rb{ctx, 2, 0, 1};
303 rb.Push(RESULT_SUCCESS);
304 rb.PushIpcInterface<INetworkService>(system);
305 }
306
307 void CreateMonitorService(Kernel::HLERequestContext& ctx) {
308 IPC::RequestParser rp{ctx};
309 const u64 reserved_input = rp.Pop<u64>();
310
311 LOG_WARNING(Service_LDN, "(STUBBED) called reserved_input={}", reserved_input);
312
313 IPC::ResponseBuilder rb{ctx, 2, 0, 1};
314 rb.Push(RESULT_SUCCESS);
315 rb.PushIpcInterface<INetworkServiceMonitor>(system);
316 }
317};
318
319class LP2PSYS final : public ServiceFramework<LP2PSYS> {
320public:
321 explicit LP2PSYS(Core::System& system_) : ServiceFramework{system_, "lp2p:sys"} {
322 // clang-format off
323 static const FunctionInfo functions[] = {
324 {0, &LP2PSYS::CreateMonitorService, "CreateNetworkService"},
325 {8, &LP2PSYS::CreateMonitorService, "CreateNetworkServiceMonitor"},
326 };
327 // clang-format on
328
329 RegisterHandlers(functions);
330 }
331
332 void CreateNetworkervice(Kernel::HLERequestContext& ctx) {
333 IPC::RequestParser rp{ctx};
334 const u64 reserved_input = rp.Pop<u64>();
335 const u32 input = rp.Pop<u32>();
336
337 LOG_WARNING(Service_LDN, "(STUBBED) called reserved_input={} input={}", reserved_input,
338 input);
339
340 IPC::ResponseBuilder rb{ctx, 2, 0, 1};
341 rb.Push(RESULT_SUCCESS);
342 rb.PushIpcInterface<INetworkService>(system);
343 }
344
345 void CreateMonitorService(Kernel::HLERequestContext& ctx) {
346 IPC::RequestParser rp{ctx};
347 const u64 reserved_input = rp.Pop<u64>();
348
349 LOG_WARNING(Service_LDN, "(STUBBED) called reserved_input={}", reserved_input);
350
351 IPC::ResponseBuilder rb{ctx, 2, 0, 1};
352 rb.Push(RESULT_SUCCESS);
353 rb.PushIpcInterface<INetworkServiceMonitor>(system);
354 }
355};
356
218void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) { 357void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
219 std::make_shared<LDNM>(system)->InstallAsService(sm); 358 std::make_shared<LDNM>(system)->InstallAsService(sm);
220 std::make_shared<LDNS>(system)->InstallAsService(sm); 359 std::make_shared<LDNS>(system)->InstallAsService(sm);
221 std::make_shared<LDNU>(system)->InstallAsService(sm); 360 std::make_shared<LDNU>(system)->InstallAsService(sm);
361 std::make_shared<LP2PAPP>(system)->InstallAsService(sm);
362 std::make_shared<LP2PSYS>(system)->InstallAsService(sm);
222} 363}
223 364
224} // namespace Service::LDN 365} // namespace Service::LDN
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index bf2ef7816..9857278f6 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -591,7 +591,15 @@ struct Memory::Impl {
591 * @returns The instance of T read from the specified virtual address. 591 * @returns The instance of T read from the specified virtual address.
592 */ 592 */
593 template <typename T> 593 template <typename T>
594 T Read(const VAddr vaddr) { 594 T Read(VAddr vaddr) {
595 // AARCH64 masks the upper 16 bit of all memory accesses
596 vaddr &= 0xffffffffffffLL;
597
598 if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
599 LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
600 return 0;
601 }
602
595 // Avoid adding any extra logic to this fast-path block 603 // Avoid adding any extra logic to this fast-path block
596 const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw(); 604 const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
597 if (const u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) { 605 if (const u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
@@ -629,7 +637,16 @@ struct Memory::Impl {
629 * is undefined. 637 * is undefined.
630 */ 638 */
631 template <typename T> 639 template <typename T>
632 void Write(const VAddr vaddr, const T data) { 640 void Write(VAddr vaddr, const T data) {
641 // AARCH64 masks the upper 16 bit of all memory accesses
642 vaddr &= 0xffffffffffffLL;
643
644 if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
645 LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
646 static_cast<u32>(data), vaddr);
647 return;
648 }
649
633 // Avoid adding any extra logic to this fast-path block 650 // Avoid adding any extra logic to this fast-path block
634 const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw(); 651 const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
635 if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) { 652 if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
@@ -656,7 +673,16 @@ struct Memory::Impl {
656 } 673 }
657 674
658 template <typename T> 675 template <typename T>
659 bool WriteExclusive(const VAddr vaddr, const T data, const T expected) { 676 bool WriteExclusive(VAddr vaddr, const T data, const T expected) {
677 // AARCH64 masks the upper 16 bit of all memory accesses
678 vaddr &= 0xffffffffffffLL;
679
680 if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
681 LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
682 static_cast<u32>(data), vaddr);
683 return true;
684 }
685
660 const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw(); 686 const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
661 if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) { 687 if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
662 // NOTE: Avoid adding any extra logic to this fast-path block 688 // NOTE: Avoid adding any extra logic to this fast-path block
@@ -683,7 +709,16 @@ struct Memory::Impl {
683 return true; 709 return true;
684 } 710 }
685 711
686 bool WriteExclusive128(const VAddr vaddr, const u128 data, const u128 expected) { 712 bool WriteExclusive128(VAddr vaddr, const u128 data, const u128 expected) {
713 // AARCH64 masks the upper 16 bit of all memory accesses
714 vaddr &= 0xffffffffffffLL;
715
716 if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
717 LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
718 static_cast<u32>(data[0]), vaddr);
719 return true;
720 }
721
687 const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw(); 722 const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
688 if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) { 723 if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
689 // NOTE: Avoid adding any extra logic to this fast-path block 724 // NOTE: Avoid adding any extra logic to this fast-path block
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index de971041f..9e6b87960 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -596,7 +596,7 @@ void BufferCache<P>::PopAsyncFlushes() {
596 runtime.CopyBuffer(download_staging.buffer, slot_buffers[buffer_id], copies); 596 runtime.CopyBuffer(download_staging.buffer, slot_buffers[buffer_id], copies);
597 } 597 }
598 runtime.Finish(); 598 runtime.Finish();
599 for (const auto [copy, buffer_id] : downloads) { 599 for (const auto& [copy, buffer_id] : downloads) {
600 const Buffer& buffer = slot_buffers[buffer_id]; 600 const Buffer& buffer = slot_buffers[buffer_id];
601 const VAddr cpu_addr = buffer.CpuAddr() + copy.src_offset; 601 const VAddr cpu_addr = buffer.CpuAddr() + copy.src_offset;
602 // Undo the modified offset 602 // Undo the modified offset
@@ -606,7 +606,7 @@ void BufferCache<P>::PopAsyncFlushes() {
606 } 606 }
607 } else { 607 } else {
608 const std::span<u8> immediate_buffer = ImmediateBuffer(largest_copy); 608 const std::span<u8> immediate_buffer = ImmediateBuffer(largest_copy);
609 for (const auto [copy, buffer_id] : downloads) { 609 for (const auto& [copy, buffer_id] : downloads) {
610 Buffer& buffer = slot_buffers[buffer_id]; 610 Buffer& buffer = slot_buffers[buffer_id];
611 buffer.ImmediateDownload(copy.src_offset, immediate_buffer.subspan(0, copy.size)); 611 buffer.ImmediateDownload(copy.src_offset, immediate_buffer.subspan(0, copy.size));
612 const VAddr cpu_addr = buffer.CpuAddr() + copy.src_offset; 612 const VAddr cpu_addr = buffer.CpuAddr() + copy.src_offset;
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index 37f7b24e1..35cc561be 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -104,7 +104,13 @@ void GPU::WaitFence(u32 syncpoint_id, u32 value) {
104 } 104 }
105 MICROPROFILE_SCOPE(GPU_wait); 105 MICROPROFILE_SCOPE(GPU_wait);
106 std::unique_lock lock{sync_mutex}; 106 std::unique_lock lock{sync_mutex};
107 sync_cv.wait(lock, [=, this] { return syncpoints.at(syncpoint_id).load() >= value; }); 107 sync_cv.wait(lock, [=, this] {
108 if (shutting_down.load(std::memory_order_relaxed)) {
109 // We're shutting down, ensure no threads continue to wait for the next syncpoint
110 return true;
111 }
112 return syncpoints.at(syncpoint_id).load() >= value;
113 });
108} 114}
109 115
110void GPU::IncrementSyncPoint(const u32 syncpoint_id) { 116void GPU::IncrementSyncPoint(const u32 syncpoint_id) {
@@ -523,6 +529,10 @@ void GPU::TriggerCpuInterrupt(const u32 syncpoint_id, const u32 value) const {
523} 529}
524 530
525void GPU::ShutDown() { 531void GPU::ShutDown() {
532 // Signal that threads should no longer block on syncpoint fences
533 shutting_down.store(true, std::memory_order_relaxed);
534 sync_cv.notify_all();
535
526 gpu_thread.ShutDown(); 536 gpu_thread.ShutDown();
527} 537}
528 538
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index 29a867863..a8e98e51b 100644
--- a/src/video_core/gpu.h
+++ b/src/video_core/gpu.h
@@ -389,6 +389,8 @@ private:
389 std::unique_ptr<Engines::KeplerMemory> kepler_memory; 389 std::unique_ptr<Engines::KeplerMemory> kepler_memory;
390 /// Shader build notifier 390 /// Shader build notifier
391 std::unique_ptr<VideoCore::ShaderNotify> shader_notify; 391 std::unique_ptr<VideoCore::ShaderNotify> shader_notify;
392 /// When true, we are about to shut down emulation session, so terminate outstanding tasks
393 std::atomic_bool shutting_down{};
392 394
393 std::array<std::atomic<u32>, Service::Nvidia::MaxSyncPoints> syncpoints{}; 395 std::array<std::atomic<u32>, Service::Nvidia::MaxSyncPoints> syncpoints{};
394 396
diff --git a/src/video_core/rasterizer_accelerated.cpp b/src/video_core/rasterizer_accelerated.cpp
index 62d84c0f8..6decd2546 100644
--- a/src/video_core/rasterizer_accelerated.cpp
+++ b/src/video_core/rasterizer_accelerated.cpp
@@ -18,10 +18,10 @@ RasterizerAccelerated::~RasterizerAccelerated() = default;
18void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, int delta) { 18void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {
19 const auto page_end = Common::DivCeil(addr + size, Core::Memory::PAGE_SIZE); 19 const auto page_end = Common::DivCeil(addr + size, Core::Memory::PAGE_SIZE);
20 for (auto page = addr >> Core::Memory::PAGE_BITS; page != page_end; ++page) { 20 for (auto page = addr >> Core::Memory::PAGE_BITS; page != page_end; ++page) {
21 auto& count = cached_pages.at(page >> 3).Count(page); 21 auto& count = cached_pages.at(page >> 2).Count(page);
22 22
23 if (delta > 0) { 23 if (delta > 0) {
24 ASSERT_MSG(count < UINT8_MAX, "Count may overflow!"); 24 ASSERT_MSG(count < UINT16_MAX, "Count may overflow!");
25 } else if (delta < 0) { 25 } else if (delta < 0) {
26 ASSERT_MSG(count > 0, "Count may underflow!"); 26 ASSERT_MSG(count > 0, "Count may underflow!");
27 } else { 27 } else {
@@ -29,7 +29,7 @@ void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, int del
29 } 29 }
30 30
31 // Adds or subtracts 1, as count is a unsigned 8-bit value 31 // Adds or subtracts 1, as count is a unsigned 8-bit value
32 count += static_cast<u8>(delta); 32 count += static_cast<u16>(delta);
33 33
34 // Assume delta is either -1 or 1 34 // Assume delta is either -1 or 1
35 if (count == 0) { 35 if (count == 0) {
diff --git a/src/video_core/rasterizer_accelerated.h b/src/video_core/rasterizer_accelerated.h
index 9227a4adc..ea879bfdd 100644
--- a/src/video_core/rasterizer_accelerated.h
+++ b/src/video_core/rasterizer_accelerated.h
@@ -29,20 +29,20 @@ private:
29 public: 29 public:
30 CacheEntry() = default; 30 CacheEntry() = default;
31 31
32 std::atomic_uint8_t& Count(std::size_t page) { 32 std::atomic_uint16_t& Count(std::size_t page) {
33 return values[page & 7]; 33 return values[page & 3];
34 } 34 }
35 35
36 const std::atomic_uint8_t& Count(std::size_t page) const { 36 const std::atomic_uint16_t& Count(std::size_t page) const {
37 return values[page & 7]; 37 return values[page & 3];
38 } 38 }
39 39
40 private: 40 private:
41 std::array<std::atomic_uint8_t, 8> values{}; 41 std::array<std::atomic_uint16_t, 4> values{};
42 }; 42 };
43 static_assert(sizeof(CacheEntry) == 8, "CacheEntry should be 8 bytes!"); 43 static_assert(sizeof(CacheEntry) == 8, "CacheEntry should be 8 bytes!");
44 44
45 std::array<CacheEntry, 0x800000> cached_pages; 45 std::array<CacheEntry, 0x1000000> cached_pages;
46 Core::Memory::Memory& cpu_memory; 46 Core::Memory::Memory& cpu_memory;
47}; 47};
48 48
diff --git a/src/yuzu/applets/software_keyboard.cpp b/src/yuzu/applets/software_keyboard.cpp
index a9a095d58..aa453a79f 100644
--- a/src/yuzu/applets/software_keyboard.cpp
+++ b/src/yuzu/applets/software_keyboard.cpp
@@ -1101,12 +1101,11 @@ void QtSoftwareKeyboardDialog::NormalKeyboardButtonClicked(QPushButton* button)
1101 } 1101 }
1102 1102
1103 if (button == ui->button_ok || button == ui->button_ok_shift || button == ui->button_ok_num) { 1103 if (button == ui->button_ok || button == ui->button_ok_shift || button == ui->button_ok_num) {
1104 if (ui->topOSK->currentIndex() == 1) { 1104 auto text = ui->topOSK->currentIndex() == 1
1105 emit SubmitNormalText(SwkbdResult::Ok, 1105 ? ui->text_edit_osk->toPlainText().toStdU16String()
1106 ui->text_edit_osk->toPlainText().toStdU16String()); 1106 : ui->line_edit_osk->text().toStdU16String();
1107 } else { 1107
1108 emit SubmitNormalText(SwkbdResult::Ok, ui->line_edit_osk->text().toStdU16String()); 1108 emit SubmitNormalText(SwkbdResult::Ok, std::move(text));
1109 }
1110 return; 1109 return;
1111 } 1110 }
1112 1111
@@ -1265,13 +1264,11 @@ void QtSoftwareKeyboardDialog::TranslateButtonPress(HIDButton button) {
1265 if (is_inline) { 1264 if (is_inline) {
1266 emit SubmitInlineText(SwkbdReplyType::DecidedCancel, current_text, cursor_position); 1265 emit SubmitInlineText(SwkbdReplyType::DecidedCancel, current_text, cursor_position);
1267 } else { 1266 } else {
1268 if (ui->topOSK->currentIndex() == 1) { 1267 auto text = ui->topOSK->currentIndex() == 1
1269 emit SubmitNormalText(SwkbdResult::Cancel, 1268 ? ui->text_edit_osk->toPlainText().toStdU16String()
1270 ui->text_edit_osk->toPlainText().toStdU16String()); 1269 : ui->line_edit_osk->text().toStdU16String();
1271 } else { 1270
1272 emit SubmitNormalText(SwkbdResult::Cancel, 1271 emit SubmitNormalText(SwkbdResult::Cancel, std::move(text));
1273 ui->line_edit_osk->text().toStdU16String());
1274 }
1275 } 1272 }
1276 break; 1273 break;
1277 case HIDButton::Y: 1274 case HIDButton::Y:
@@ -1563,7 +1560,7 @@ void QtSoftwareKeyboard::ShowNormalKeyboard() const {
1563void QtSoftwareKeyboard::ShowTextCheckDialog( 1560void QtSoftwareKeyboard::ShowTextCheckDialog(
1564 Service::AM::Applets::SwkbdTextCheckResult text_check_result, 1561 Service::AM::Applets::SwkbdTextCheckResult text_check_result,
1565 std::u16string text_check_message) const { 1562 std::u16string text_check_message) const {
1566 emit MainWindowShowTextCheckDialog(text_check_result, text_check_message); 1563 emit MainWindowShowTextCheckDialog(text_check_result, std::move(text_check_message));
1567} 1564}
1568 1565
1569void QtSoftwareKeyboard::ShowInlineKeyboard( 1566void QtSoftwareKeyboard::ShowInlineKeyboard(
diff --git a/src/yuzu/configuration/configure_dialog.cpp b/src/yuzu/configuration/configure_dialog.cpp
index 3ad40d2b3..6028135c5 100644
--- a/src/yuzu/configuration/configure_dialog.cpp
+++ b/src/yuzu/configuration/configure_dialog.cpp
@@ -2,8 +2,11 @@
2// Licensed under GPLv2 or any later version 2// Licensed under GPLv2 or any later version
3// Refer to the license.txt file included. 3// Refer to the license.txt file included.
4 4
5#include <QAbstractButton>
6#include <QDialogButtonBox>
5#include <QHash> 7#include <QHash>
6#include <QListWidgetItem> 8#include <QListWidgetItem>
9#include <QPushButton>
7#include <QSignalBlocker> 10#include <QSignalBlocker>
8#include "common/settings.h" 11#include "common/settings.h"
9#include "core/core.h" 12#include "core/core.h"
@@ -31,6 +34,12 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry,
31 connect(ui->selectorList, &QListWidget::itemSelectionChanged, this, 34 connect(ui->selectorList, &QListWidget::itemSelectionChanged, this,
32 &ConfigureDialog::UpdateVisibleTabs); 35 &ConfigureDialog::UpdateVisibleTabs);
33 36
37 if (Core::System::GetInstance().IsPoweredOn()) {
38 QPushButton* apply_button = ui->buttonBox->addButton(QDialogButtonBox::Apply);
39 connect(apply_button, &QAbstractButton::clicked, this,
40 &ConfigureDialog::HandleApplyButtonClicked);
41 }
42
34 adjustSize(); 43 adjustSize();
35 ui->selectorList->setCurrentRow(0); 44 ui->selectorList->setCurrentRow(0);
36} 45}
@@ -80,6 +89,11 @@ void ConfigureDialog::RetranslateUI() {
80 ui->tabWidget->setCurrentIndex(old_index); 89 ui->tabWidget->setCurrentIndex(old_index);
81} 90}
82 91
92void ConfigureDialog::HandleApplyButtonClicked() {
93 UISettings::values.configuration_applied = true;
94 ApplyConfiguration();
95}
96
83Q_DECLARE_METATYPE(QList<QWidget*>); 97Q_DECLARE_METATYPE(QList<QWidget*>);
84 98
85void ConfigureDialog::PopulateSelectionList() { 99void ConfigureDialog::PopulateSelectionList() {
diff --git a/src/yuzu/configuration/configure_dialog.h b/src/yuzu/configuration/configure_dialog.h
index 570c3b941..abe019635 100644
--- a/src/yuzu/configuration/configure_dialog.h
+++ b/src/yuzu/configuration/configure_dialog.h
@@ -35,9 +35,10 @@ signals:
35 35
36private: 36private:
37 void changeEvent(QEvent* event) override; 37 void changeEvent(QEvent* event) override;
38
39 void RetranslateUI(); 38 void RetranslateUI();
40 39
40 void HandleApplyButtonClicked();
41
41 void SetConfiguration(); 42 void SetConfiguration();
42 void UpdateVisibleTabs(); 43 void UpdateVisibleTabs();
43 void PopulateSelectionList(); 44 void PopulateSelectionList();
diff --git a/src/yuzu/configuration/configure_per_game.cpp b/src/yuzu/configuration/configure_per_game.cpp
index 3e13bd438..d89f1ad4b 100644
--- a/src/yuzu/configuration/configure_per_game.cpp
+++ b/src/yuzu/configuration/configure_per_game.cpp
@@ -6,9 +6,12 @@
6#include <memory> 6#include <memory>
7#include <utility> 7#include <utility>
8 8
9#include <QAbstractButton>
9#include <QCheckBox> 10#include <QCheckBox>
11#include <QDialogButtonBox>
10#include <QHeaderView> 12#include <QHeaderView>
11#include <QMenu> 13#include <QMenu>
14#include <QPushButton>
12#include <QStandardItemModel> 15#include <QStandardItemModel>
13#include <QString> 16#include <QString>
14#include <QTimer> 17#include <QTimer>
@@ -42,6 +45,12 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id)
42 scene = new QGraphicsScene; 45 scene = new QGraphicsScene;
43 ui->icon_view->setScene(scene); 46 ui->icon_view->setScene(scene);
44 47
48 if (Core::System::GetInstance().IsPoweredOn()) {
49 QPushButton* apply_button = ui->buttonBox->addButton(QDialogButtonBox::Apply);
50 connect(apply_button, &QAbstractButton::clicked, this,
51 &ConfigurePerGame::HandleApplyButtonClicked);
52 }
53
45 LoadConfiguration(); 54 LoadConfiguration();
46} 55}
47 56
@@ -74,6 +83,11 @@ void ConfigurePerGame::RetranslateUI() {
74 ui->retranslateUi(this); 83 ui->retranslateUi(this);
75} 84}
76 85
86void ConfigurePerGame::HandleApplyButtonClicked() {
87 UISettings::values.configuration_applied = true;
88 ApplyConfiguration();
89}
90
77void ConfigurePerGame::LoadFromFile(FileSys::VirtualFile file) { 91void ConfigurePerGame::LoadFromFile(FileSys::VirtualFile file) {
78 this->file = std::move(file); 92 this->file = std::move(file);
79 LoadConfiguration(); 93 LoadConfiguration();
diff --git a/src/yuzu/configuration/configure_per_game.h b/src/yuzu/configuration/configure_per_game.h
index 5f9a08cef..f6e6ab7c4 100644
--- a/src/yuzu/configuration/configure_per_game.h
+++ b/src/yuzu/configuration/configure_per_game.h
@@ -39,6 +39,8 @@ private:
39 void changeEvent(QEvent* event) override; 39 void changeEvent(QEvent* event) override;
40 void RetranslateUI(); 40 void RetranslateUI();
41 41
42 void HandleApplyButtonClicked();
43
42 void LoadConfiguration(); 44 void LoadConfiguration();
43 45
44 std::unique_ptr<Ui::ConfigurePerGame> ui; 46 std::unique_ptr<Ui::ConfigurePerGame> ui;
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 37ef62967..0f0e228b0 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -2587,12 +2587,12 @@ void GMainWindow::OnConfigure() {
2587 &GMainWindow::OnLanguageChanged); 2587 &GMainWindow::OnLanguageChanged);
2588 2588
2589 const auto result = configure_dialog.exec(); 2589 const auto result = configure_dialog.exec();
2590 if (result != QDialog::Accepted) { 2590 if (result != QDialog::Accepted && !UISettings::values.configuration_applied) {
2591 return; 2591 return;
2592 } else if (result == QDialog::Accepted) {
2593 configure_dialog.ApplyConfiguration();
2594 controller_dialog->refreshConfiguration();
2592 } 2595 }
2593
2594 configure_dialog.ApplyConfiguration();
2595 controller_dialog->refreshConfiguration();
2596 InitializeHotkeys(); 2596 InitializeHotkeys();
2597 if (UISettings::values.theme != old_theme) { 2597 if (UISettings::values.theme != old_theme) {
2598 UpdateUITheme(); 2598 UpdateUITheme();
@@ -2607,6 +2607,8 @@ void GMainWindow::OnConfigure() {
2607 game_list->PopulateAsync(UISettings::values.game_dirs); 2607 game_list->PopulateAsync(UISettings::values.game_dirs);
2608 } 2608 }
2609 2609
2610 UISettings::values.configuration_applied = false;
2611
2610 config->Save(); 2612 config->Save();
2611 2613
2612 if ((UISettings::values.hide_mouse || Settings::values.mouse_panning) && emulation_running) { 2614 if ((UISettings::values.hide_mouse || Settings::values.mouse_panning) && emulation_running) {
@@ -2636,23 +2638,27 @@ void GMainWindow::OpenPerGameConfiguration(u64 title_id, const std::string& file
2636 ConfigurePerGame dialog(this, title_id); 2638 ConfigurePerGame dialog(this, title_id);
2637 dialog.LoadFromFile(v_file); 2639 dialog.LoadFromFile(v_file);
2638 const auto result = dialog.exec(); 2640 const auto result = dialog.exec();
2639 if (result == QDialog::Accepted) { 2641
2642 if (result != QDialog::Accepted && !UISettings::values.configuration_applied) {
2643 Settings::RestoreGlobalState(system.IsPoweredOn());
2644 return;
2645 } else if (result == QDialog::Accepted) {
2640 dialog.ApplyConfiguration(); 2646 dialog.ApplyConfiguration();
2647 }
2641 2648
2642 const auto reload = UISettings::values.is_game_list_reload_pending.exchange(false); 2649 const auto reload = UISettings::values.is_game_list_reload_pending.exchange(false);
2643 if (reload) { 2650 if (reload) {
2644 game_list->PopulateAsync(UISettings::values.game_dirs); 2651 game_list->PopulateAsync(UISettings::values.game_dirs);
2645 } 2652 }
2646 2653
2647 // Do not cause the global config to write local settings into the config file 2654 // Do not cause the global config to write local settings into the config file
2648 const bool is_powered_on = system.IsPoweredOn(); 2655 const bool is_powered_on = system.IsPoweredOn();
2649 Settings::RestoreGlobalState(is_powered_on); 2656 Settings::RestoreGlobalState(is_powered_on);
2650 2657
2651 if (!is_powered_on) { 2658 UISettings::values.configuration_applied = false;
2652 config->Save(); 2659
2653 } 2660 if (!is_powered_on) {
2654 } else { 2661 config->Save();
2655 Settings::RestoreGlobalState(system.IsPoweredOn());
2656 } 2662 }
2657} 2663}
2658 2664
diff --git a/src/yuzu/uisettings.h b/src/yuzu/uisettings.h
index 5ba00b8c8..49122ec32 100644
--- a/src/yuzu/uisettings.h
+++ b/src/yuzu/uisettings.h
@@ -95,6 +95,8 @@ struct Values {
95 uint8_t row_2_text_id; 95 uint8_t row_2_text_id;
96 std::atomic_bool is_game_list_reload_pending{false}; 96 std::atomic_bool is_game_list_reload_pending{false};
97 bool cache_game_list; 97 bool cache_game_list;
98
99 bool configuration_applied;
98}; 100};
99 101
100extern Values values; 102extern Values values;
HIC SVNT DRACONES