applet: controller: Implement cancel button

applets: implement RequestExit

.ci/scripts/windows/scan_dll.py

@@ -40,7 +40,7 @@ def parse_imports(file_name):
 
 def parse_imports_recursive(file_name, path_list=[]):
     q = queue.Queue()  # create a FIFO queue
-    # file_name can be a string or a list for the convience
+    # file_name can be a string or a list for the convenience
     if isinstance(file_name, str):
         q.put(file_name)
     elif isinstance(file_name, list):

.codespellrc

@@ -0,0 +1,6 @@
+; SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+; SPDX-License-Identifier: GPL-2.0-or-later
+
+[codespell]
+skip = ./.git,./build,./dist,./Doxyfile,./externals,./LICENSES
+ignore-words-list = aci,allright,ba,deques,froms,hda,inout,lod,masia,nam,nax,nd,pullrequests,pullrequest,te,transfered,unstall,uscaled,zink

.github/workflows/codespell.yml

@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+# GitHub Action to automate the identification of common misspellings in text files.
+# https://github.com/codespell-project/actions-codespell
+# https://github.com/codespell-project/codespell
+name: codespell
+on: pull_request
+permissions: {}
+jobs:
+  codespell:
+    name: Check for spelling errors
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+      - uses: codespell-project/actions-codespell@master

CMakeLists.txt

@@ -210,7 +210,7 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 # =======================================================================
 
 # Enforce the search mode of non-required packages for better and shorter failure messages
-find_package(Boost 1.73.0 REQUIRED context)
+find_package(Boost 1.79.0 REQUIRED context)
 find_package(enet 1.3 MODULE)
 find_package(fmt 9 REQUIRED)
 find_package(inih 52 MODULE COMPONENTS INIReader)
@@ -344,12 +344,12 @@ if(ENABLE_QT)
                 find_package(PkgConfig REQUIRED)
                 pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
                 if (NOT QT_DEP_GLU_FOUND)
-                    message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
+                    message(FATAL_ERROR "Qt bundled package dependency `glu` not found. \
                         Perhaps `libglu1-mesa-dev` needs to be installed?")
                 endif()
                 pkg_check_modules(QT_DEP_MESA QUIET dri>=20.0.8)
                 if (NOT QT_DEP_MESA_FOUND)
-                    message(FATAL_ERROR "Qt bundled pacakge dependency `dri` not found. \
+                    message(FATAL_ERROR "Qt bundled package dependency `dri` not found. \
                         Perhaps `mesa-common-dev` needs to be installed?")
                 endif()
 

CMakeModules/FindFFmpeg.cmake

@@ -14,7 +14,7 @@
 #  FFmpeg_LIBRARIES: aggregate all the paths to the libraries
 #  FFmpeg_FOUND: True if all components have been found
 #
-# This module defines the following targets, which are prefered over variables:
+# This module defines the following targets, which are preferred over variables:
 #
 #  FFmpeg::<component>: Target to use <component> directly, with include path,
 #    library and dependencies set up. If you are using a static build, you are

src/CMakeLists.txt

@@ -83,7 +83,7 @@ if (MSVC)
     )
 
     if (USE_CCACHE OR YUZU_USE_PRECOMPILED_HEADERS)
-    # when caching, we need to use /Z7 to downgrade debug info to use an older but more cachable format
+    # when caching, we need to use /Z7 to downgrade debug info to use an older but more cacheable format
     # Precompiled headers are deleted if not using /Z7. See https://github.com/nanoant/CMakePCHCompiler/issues/21
         add_compile_options(/Z7)
     else()

src/audio_core/audio_out_manager.h

@@ -58,7 +58,7 @@ public:
     /**
      * Get a list of audio out device names.
      *
-     * @oaram names     - Output container to write names to.
+     * @param names     - Output container to write names to.
      * @return Number of names written.
      */
     u32 GetAudioOutDeviceNames(

src/audio_core/device/audio_buffer.h

@@ -16,7 +16,7 @@ struct AudioBuffer {
     s64 played_timestamp;
     /// Game memory address for these samples.
     VAddr samples;
-    /// Unqiue identifier for this buffer.
+    /// Unique identifier for this buffer.
     u64 tag;
     /// Size of the samples buffer.
     u64 size;

src/audio_core/device/device_session.cpp

@@ -93,7 +93,7 @@ void DeviceSession::AppendBuffers(std::span<const AudioBuffer> buffers) const {
             stream->AppendBuffer(new_buffer, samples);
         } else {
             std::vector<s16> samples(buffer.size / sizeof(s16));
-            system.Memory().ReadBlockUnsafe(buffer.samples, samples.data(), buffer.size);
+            system.ApplicationMemory().ReadBlockUnsafe(buffer.samples, samples.data(), buffer.size);
             stream->AppendBuffer(new_buffer, samples);
         }
     }
@@ -102,7 +102,7 @@ void DeviceSession::AppendBuffers(std::span<const AudioBuffer> buffers) const {
 void DeviceSession::ReleaseBuffer(const AudioBuffer& buffer) const {
     if (type == Sink::StreamType::In) {
         auto samples{stream->ReleaseBuffer(buffer.size / sizeof(s16))};
-        system.Memory().WriteBlockUnsafe(buffer.samples, samples.data(), buffer.size);
+        system.ApplicationMemory().WriteBlockUnsafe(buffer.samples, samples.data(), buffer.size);
     }
 }
 

src/audio_core/renderer/adsp/adsp.cpp

@@ -13,7 +13,7 @@
 namespace AudioCore::AudioRenderer::ADSP {
 
 ADSP::ADSP(Core::System& system_, Sink::Sink& sink_)
-    : system{system_}, memory{system.Memory()}, sink{sink_} {}
+    : system{system_}, memory{system.ApplicationMemory()}, sink{sink_} {}
 
 ADSP::~ADSP() {
     ClearCommandBuffers();

src/audio_core/renderer/adsp/audio_renderer.cpp

@@ -135,7 +135,7 @@ void AudioRenderer::ThreadFunc() {
     static constexpr char name[]{"AudioRenderer"};
     MicroProfileOnThreadCreate(name);
     Common::SetCurrentThreadName(name);
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
     if (mailbox->ADSPWaitMessage() != RenderMessage::AudioRenderer_InitializeOK) {
         LOG_ERROR(Service_Audio,
                   "ADSP Audio Renderer -- Failed to receive initialize message from host!");
@@ -165,7 +165,7 @@ void AudioRenderer::ThreadFunc() {
                 // Check this buffer is valid, as it may not be used.
                 if (command_buffer.buffer != 0) {
                     // If there are no remaining commands (from the previous list),
-                    // this is a new command list, initalize it.
+                    // this is a new command list, initialize it.
                     if (command_buffer.remaining_command_count == 0) {
                         command_list_processor.Initialize(system, command_buffer.buffer,
                                                           command_buffer.size, streams[index]);

src/audio_core/renderer/adsp/command_list_processor.cpp

@@ -17,7 +17,7 @@ namespace AudioCore::AudioRenderer::ADSP {
 void CommandListProcessor::Initialize(Core::System& system_, CpuAddr buffer, u64 size,
                                       Sink::SinkStream* stream_) {
     system = &system_;
-    memory = &system->Memory();
+    memory = &system->ApplicationMemory();
     stream = stream_;
     header = reinterpret_cast<CommandListHeader*>(buffer);
     commands = reinterpret_cast<u8*>(buffer + sizeof(CommandListHeader));

src/audio_core/renderer/behavior/behavior_info.h

@@ -155,7 +155,7 @@ public:
     /**
      * Check if a variadic command buffer is supported.
      * As of Rev 5 with the added optional performance metric logging, the command
-     * buffer can be a variable size, so take that into account for calcualting its size.
+     * buffer can be a variable size, so take that into account for calculating its size.
      *
      * @return True if supported, otherwise false.
      */

src/audio_core/renderer/effect/effect_info_base.h

@@ -192,7 +192,7 @@ public:
     /**
      * Get this effect's parameter data.
      *
-     * @return Pointer to the parametter, must be cast to the correct type.
+     * @return Pointer to the parameter, must be cast to the correct type.
      */
     u8* GetParameter() {
         return parameter.data();
@@ -201,7 +201,7 @@ public:
     /**
      * Get this effect's parameter data.
      *
-     * @return Pointer to the parametter, must be cast to the correct type.
+     * @return Pointer to the parameter, must be cast to the correct type.
      */
     u8* GetStateBuffer() {
         return state.data();

src/audio_core/renderer/memory/memory_pool_info.h

@@ -29,7 +29,7 @@ public:
      */
     enum class State {
         Invalid,
-        Aquired,
+        Acquired,
         RequestDetach,
         Detached,
         RequestAttach,

src/audio_core/renderer/mix/mix_context.h

@@ -93,7 +93,7 @@ public:
      * Splitter sort, traverse the splitter node graph and sort the sorted mixes from results.
      *
      * @param splitter_context - Splitter context for the sort.
-     * @return True if the sort was successful, othewise false.
+     * @return True if the sort was successful, otherwise false.
      */
     bool TSortInfo(const SplitterContext& splitter_context);
 

src/audio_core/renderer/performance/performance_detail.h

@@ -33,7 +33,7 @@ struct PerformanceDetailVersion1 {
     /* 0x0D */ PerformanceEntryType entry_type;
 };
 static_assert(sizeof(PerformanceDetailVersion1) == 0x10,
-              "PerformanceDetailVersion1 has the worng size!");
+              "PerformanceDetailVersion1 has the wrong size!");
 
 struct PerformanceDetailVersion2 {
     /* 0x00 */ u32 node_id;
@@ -45,6 +45,6 @@ struct PerformanceDetailVersion2 {
     /* 0x14 */ char unk14[0x4];
 };
 static_assert(sizeof(PerformanceDetailVersion2) == 0x18,
-              "PerformanceDetailVersion2 has the worng size!");
+              "PerformanceDetailVersion2 has the wrong size!");
 
 } // namespace AudioCore::AudioRenderer

src/audio_core/renderer/performance/performance_entry.h

@@ -22,7 +22,7 @@ struct PerformanceEntryVersion1 {
     /* 0x0C */ PerformanceEntryType entry_type;
 };
 static_assert(sizeof(PerformanceEntryVersion1) == 0x10,
-              "PerformanceEntryVersion1 has the worng size!");
+              "PerformanceEntryVersion1 has the wrong size!");
 
 struct PerformanceEntryVersion2 {
     /* 0x00 */ u32 node_id;
@@ -32,6 +32,6 @@ struct PerformanceEntryVersion2 {
     /* 0x0D */ char unk0D[0xB];
 };
 static_assert(sizeof(PerformanceEntryVersion2) == 0x18,
-              "PerformanceEntryVersion2 has the worng size!");
+              "PerformanceEntryVersion2 has the wrong size!");
 
 } // namespace AudioCore::AudioRenderer

src/audio_core/renderer/performance/performance_frame_header.h

@@ -16,7 +16,7 @@ struct PerformanceFrameHeaderVersion1 {
     /* 0x14 */ u32 frame_index;
 };
 static_assert(sizeof(PerformanceFrameHeaderVersion1) == 0x18,
-              "PerformanceFrameHeaderVersion1 has the worng size!");
+              "PerformanceFrameHeaderVersion1 has the wrong size!");
 
 struct PerformanceFrameHeaderVersion2 {
     /* 0x00 */ u32 magic; // "PERF"
@@ -31,6 +31,6 @@ struct PerformanceFrameHeaderVersion2 {
     /* 0x25 */ char unk25[0xB];
 };
 static_assert(sizeof(PerformanceFrameHeaderVersion2) == 0x30,
-              "PerformanceFrameHeaderVersion2 has the worng size!");
+              "PerformanceFrameHeaderVersion2 has the wrong size!");
 
 } // namespace AudioCore::AudioRenderer

src/audio_core/renderer/splitter/splitter_context.h

@@ -55,7 +55,7 @@ public:
     /**
      * Get the total number of splitter destinations.
      *
-     * @return Number of destiantions.
+     * @return Number of destinations.
      */
     u32 GetDataCount() const;
 

src/audio_core/renderer/splitter/splitter_destinations_data.h

@@ -87,7 +87,7 @@ public:
     /**
      * Update this destination.
      *
-     * @param params - Inpout parameters to update the destination.
+     * @param params - Input parameters to update the destination.
      */
     void Update(const InParameter& params);
 
@@ -126,9 +126,9 @@ private:
     std::array<f32, MaxMixBuffers> prev_mix_volumes{0.0f};
     /// Next destination in the mix chain
     SplitterDestinationData* next{};
-    /// Is this destiantion in use?
+    /// Is this destination in use?
     bool in_use{};
-    /// Does this destiantion need its volumes updated?
+    /// Does this destination need its volumes updated?
     bool need_update{};
 };
 

src/audio_core/renderer/splitter/splitter_info.h

@@ -49,14 +49,14 @@ public:
     /**
      * Get the number of destinations in this splitter.
      *
-     * @return The number of destiantions.
+     * @return The number of destinations.
      */
     u32 GetDestinationCount() const;
 
     /**
      * Set the number of destinations in this splitter.
      *
-     * @param count - The new number of destiantions.
+     * @param count - The new number of destinations.
      */
     void SetDestinationCount(u32 count);
 

src/audio_core/renderer/system.cpp

@@ -127,8 +127,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     render_device = params.rendering_device;
     execution_mode = params.execution_mode;
 
-    core.Memory().ZeroBlock(*core.ApplicationProcess(), transfer_memory->GetSourceAddress(),
-                            transfer_memory_size);
+    core.ApplicationMemory().ZeroBlock(transfer_memory->GetSourceAddress(), transfer_memory_size);
 
     // Note: We're not actually using the transfer memory because it's a pain to code for.
     // Allocate the memory normally instead and hope the game doesn't try to read anything back

src/audio_core/renderer/system.h

@@ -154,7 +154,7 @@ public:
     ExecutionMode GetExecutionMode() const;
 
     /**
-     * Get the rendering deivce for this system.
+     * Get the rendering device for this system.
      * This is unused.
      *
      * @return Rendering device for this system.
@@ -241,7 +241,7 @@ private:
     std::span<u8> command_workbuffer{};
     /// Size of command workbuffer
     u64 command_workbuffer_size{};
-    /// Numebr of commands in the workbuffer
+    /// Number of commands in the workbuffer
     u64 command_buffer_size{};
     /// Manager for upsamplers
     UpsamplerManager* upsampler_manager{};

src/audio_core/renderer/system_manager.h

@@ -36,7 +36,7 @@ public:
     /**
      * Initialize the system manager, called when any system is registered.
      *
-     * @return True if sucessfully initialized, otherwise false.
+     * @return True if successfully initialized, otherwise false.
      */
     bool InitializeUnsafe();
 
@@ -50,7 +50,7 @@ public:
      * The manager does not own the system, so do not free it without calling Remove.
      *
      * @param system - The system to add.
-     * @return True if succesfully added, otherwise false.
+     * @return True if successfully added, otherwise false.
      */
     bool Add(System& system);
 
@@ -58,7 +58,7 @@ public:
      * Remove an audio render system from the manager.
      *
      * @param system - The system to remove.
-     * @return True if succesfully removed, otherwise false.
+     * @return True if successfully removed, otherwise false.
      */
     bool Remove(System& system);
 

src/audio_core/renderer/voice/voice_info.h

@@ -183,7 +183,7 @@ public:
     void Initialize();
 
     /**
-     * Does this voice ned an update?
+     * Does this voice need an update?
      *
      * @param params - Input parameters to check matching.
      *
@@ -236,7 +236,7 @@ public:
      *
      * @param error_info           - Output array of errors.
      * @param wave_buffer          - The wavebuffer to be updated.
-     * @param wave_buffer_internal - Input parametters to be used for the update.
+     * @param wave_buffer_internal - Input parameters to be used for the update.
      * @param sample_format        - Sample format of the wavebuffer.
      * @param valid                - Is this wavebuffer valid?
      * @param pool_mapper          - Used to map the wavebuffers.

src/common/CMakeLists.txt

@@ -38,6 +38,7 @@ add_library(common STATIC
     common_precompiled_headers.h
     common_types.h
     concepts.h
+    container_hash.h
     demangle.cpp
     demangle.h
     div_ceil.h
@@ -132,6 +133,7 @@ add_library(common STATIC
     time_zone.h
     tiny_mt.h
     tree.h
+    typed_address.h
     uint128.h
     unique_function.h
     uuid.cpp
@@ -158,6 +160,8 @@ if(ARCHITECTURE_x86_64)
         PRIVATE
             x64/cpu_detect.cpp
             x64/cpu_detect.h
+            x64/cpu_wait.cpp
+            x64/cpu_wait.h
             x64/native_clock.cpp
             x64/native_clock.h
             x64/xbyak_abi.h

src/common/announce_multiplayer_room.h

@@ -66,7 +66,7 @@ public:
      * @param description The room description
      * @param port The port of the room
      * @param net_version The version of the libNetwork that gets used
-     * @param has_password True if the room is passowrd protected
+     * @param has_password True if the room is password protected
      * @param preferred_game The preferred game of the room
      * @param preferred_game_id The title id of the preferred game
      */

src/common/bounded_threadsafe_queue.h

@@ -1,158 +1,249 @@
-// SPDX-FileCopyrightText: Copyright (c) 2020 Erik Rigtorp <erik@rigtorp.se>
-// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
 #include <atomic>
-#include <bit>
 #include <condition_variable>
-#include <memory>
+#include <cstddef>
 #include <mutex>
 #include <new>
-#include <stop_token>
-#include <type_traits>
-#include <utility>
+
+#include "common/polyfill_thread.h"
 
 namespace Common {
 
-#if defined(__cpp_lib_hardware_interference_size)
-constexpr size_t hardware_interference_size = std::hardware_destructive_interference_size;
-#else
-constexpr size_t hardware_interference_size = 64;
-#endif
+namespace detail {
+constexpr size_t DefaultCapacity = 0x1000;
+} // namespace detail
+
+template <typename T, size_t Capacity = detail::DefaultCapacity>
+class SPSCQueue {
+    static_assert((Capacity & (Capacity - 1)) == 0, "Capacity must be a power of two.");
 
-template <typename T, size_t capacity = 0x400>
-class MPSCQueue {
 public:
-    explicit MPSCQueue() : allocator{std::allocator<Slot<T>>()} {
-        // Allocate one extra slot to prevent false sharing on the last slot
-        slots = allocator.allocate(capacity + 1);
-        // Allocators are not required to honor alignment for over-aligned types
-        // (see http://eel.is/c++draft/allocator.requirements#10) so we verify
-        // alignment here
-        if (reinterpret_cast<uintptr_t>(slots) % alignof(Slot<T>) != 0) {
-            allocator.deallocate(slots, capacity + 1);
-            throw std::bad_alloc();
-        }
-        for (size_t i = 0; i < capacity; ++i) {
-            std::construct_at(&slots[i]);
-        }
-        static_assert(std::has_single_bit(capacity), "capacity must be an integer power of 2");
-        static_assert(alignof(Slot<T>) == hardware_interference_size,
-                      "Slot must be aligned to cache line boundary to prevent false sharing");
-        static_assert(sizeof(Slot<T>) % hardware_interference_size == 0,
-                      "Slot size must be a multiple of cache line size to prevent "
-                      "false sharing between adjacent slots");
-        static_assert(sizeof(MPSCQueue) % hardware_interference_size == 0,
-                      "Queue size must be a multiple of cache line size to "
-                      "prevent false sharing between adjacent queues");
+    template <typename... Args>
+    bool TryEmplace(Args&&... args) {
+        return Emplace<PushMode::Try>(std::forward<Args>(args)...);
     }
 
-    ~MPSCQueue() noexcept {
-        for (size_t i = 0; i < capacity; ++i) {
-            std::destroy_at(&slots[i]);
-        }
-        allocator.deallocate(slots, capacity + 1);
+    template <typename... Args>
+    void EmplaceWait(Args&&... args) {
+        Emplace<PushMode::Wait>(std::forward<Args>(args)...);
     }
 
-    // The queue must be both non-copyable and non-movable
-    MPSCQueue(const MPSCQueue&) = delete;
-    MPSCQueue& operator=(const MPSCQueue&) = delete;
-
-    MPSCQueue(MPSCQueue&&) = delete;
-    MPSCQueue& operator=(MPSCQueue&&) = delete;
-
-    void Push(const T& v) noexcept {
-        static_assert(std::is_nothrow_copy_constructible_v<T>,
-                      "T must be nothrow copy constructible");
-        emplace(v);
+    bool TryPop(T& t) {
+        return Pop<PopMode::Try>(t);
     }
 
-    template <typename P, typename = std::enable_if_t<std::is_nothrow_constructible_v<T, P&&>>>
-    void Push(P&& v) noexcept {
-        emplace(std::forward<P>(v));
+    void PopWait(T& t) {
+        Pop<PopMode::Wait>(t);
     }
 
-    void Pop(T& v, std::stop_token stop) noexcept {
-        auto const tail = tail_.fetch_add(1);
-        auto& slot = slots[idx(tail)];
-        if (!slot.turn.test()) {
-            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, stop, [&slot] { return slot.turn.test(); });
-        }
-        v = slot.move();
-        slot.destroy();
-        slot.turn.clear();
-        slot.turn.notify_one();
+    void PopWait(T& t, std::stop_token stop_token) {
+        Pop<PopMode::WaitWithStopToken>(t, stop_token);
+    }
+
+    T PopWait() {
+        T t;
+        Pop<PopMode::Wait>(t);
+        return t;
+    }
+
+    T PopWait(std::stop_token stop_token) {
+        T t;
+        Pop<PopMode::WaitWithStopToken>(t, stop_token);
+        return t;
     }
 
 private:
-    template <typename U = T>
-    struct Slot {
-        ~Slot() noexcept {
-            if (turn.test()) {
-                destroy();
-            }
-        }
-
-        template <typename... Args>
-        void construct(Args&&... args) noexcept {
-            static_assert(std::is_nothrow_constructible_v<U, Args&&...>,
-                          "T must be nothrow constructible with Args&&...");
-            std::construct_at(reinterpret_cast<U*>(&storage), std::forward<Args>(args)...);
-        }
-
-        void destroy() noexcept {
-            static_assert(std::is_nothrow_destructible_v<U>, "T must be nothrow destructible");
-            std::destroy_at(reinterpret_cast<U*>(&storage));
-        }
-
-        U&& move() noexcept {
-            return reinterpret_cast<U&&>(storage);
-        }
-
-        // Align to avoid false sharing between adjacent slots
-        alignas(hardware_interference_size) std::atomic_flag turn{};
-        struct aligned_store {
-            struct type {
-                alignas(U) unsigned char data[sizeof(U)];
-            };
-        };
-        typename aligned_store::type storage;
+    enum class PushMode {
+        Try,
+        Wait,
+        Count,
     };
 
+    enum class PopMode {
+        Try,
+        Wait,
+        WaitWithStopToken,
+        Count,
+    };
+
+    template <PushMode Mode, typename... Args>
+    bool Emplace(Args&&... args) {
+        const size_t write_index = m_write_index.load(std::memory_order::relaxed);
+
+        if constexpr (Mode == PushMode::Try) {
+            // Check if we have free slots to write to.
+            if ((write_index - m_read_index.load(std::memory_order::acquire)) == Capacity) {
+                return false;
+            }
+        } else if constexpr (Mode == PushMode::Wait) {
+            // Wait until we have free slots to write to.
+            std::unique_lock lock{producer_cv_mutex};
+            producer_cv.wait(lock, [this, write_index] {
+                return (write_index - m_read_index.load(std::memory_order::acquire)) < Capacity;
+            });
+        } else {
+            static_assert(Mode < PushMode::Count, "Invalid PushMode.");
+        }
+
+        // Determine the position to write to.
+        const size_t pos = write_index % Capacity;
+
+        // Emplace into the queue.
+        std::construct_at(std::addressof(m_data[pos]), std::forward<Args>(args)...);
+
+        // Increment the write index.
+        ++m_write_index;
+
+        // Notify the consumer that we have pushed into the queue.
+        std::scoped_lock lock{consumer_cv_mutex};
+        consumer_cv.notify_one();
+
+        return true;
+    }
+
+    template <PopMode Mode>
+    bool Pop(T& t, [[maybe_unused]] std::stop_token stop_token = {}) {
+        const size_t read_index = m_read_index.load(std::memory_order::relaxed);
+
+        if constexpr (Mode == PopMode::Try) {
+            // Check if the queue is empty.
+            if (read_index == m_write_index.load(std::memory_order::acquire)) {
+                return false;
+            }
+        } else if constexpr (Mode == PopMode::Wait) {
+            // Wait until the queue is not empty.
+            std::unique_lock lock{consumer_cv_mutex};
+            consumer_cv.wait(lock, [this, read_index] {
+                return read_index != m_write_index.load(std::memory_order::acquire);
+            });
+        } else if constexpr (Mode == PopMode::WaitWithStopToken) {
+            // Wait until the queue is not empty.
+            std::unique_lock lock{consumer_cv_mutex};
+            Common::CondvarWait(consumer_cv, lock, stop_token, [this, read_index] {
+                return read_index != m_write_index.load(std::memory_order::acquire);
+            });
+            if (stop_token.stop_requested()) {
+                return false;
+            }
+        } else {
+            static_assert(Mode < PopMode::Count, "Invalid PopMode.");
+        }
+
+        // Determine the position to read from.
+        const size_t pos = read_index % Capacity;
+
+        // Pop the data off the queue, moving it.
+        t = std::move(m_data[pos]);
+
+        // Increment the read index.
+        ++m_read_index;
+
+        // Notify the producer that we have popped off the queue.
+        std::scoped_lock lock{producer_cv_mutex};
+        producer_cv.notify_one();
+
+        return true;
+    }
+
+    alignas(128) std::atomic_size_t m_read_index{0};
+    alignas(128) std::atomic_size_t m_write_index{0};
+
+    std::array<T, Capacity> m_data;
+
+    std::condition_variable_any producer_cv;
+    std::mutex producer_cv_mutex;
+    std::condition_variable_any consumer_cv;
+    std::mutex consumer_cv_mutex;
+};
+
+template <typename T, size_t Capacity = detail::DefaultCapacity>
+class MPSCQueue {
+public:
     template <typename... Args>
-    void emplace(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible_v<T, Args&&...>,
-                      "T must be nothrow constructible with Args&&...");
-        auto const head = head_.fetch_add(1);
-        auto& slot = slots[idx(head)];
-        slot.turn.wait(true);
-        slot.construct(std::forward<Args>(args)...);
-        slot.turn.test_and_set();
-        cv.notify_one();
+    bool TryEmplace(Args&&... args) {
+        std::scoped_lock lock{write_mutex};
+        return spsc_queue.TryEmplace(std::forward<Args>(args)...);
     }
 
-    constexpr size_t idx(size_t i) const noexcept {
-        return i & mask;
+    template <typename... Args>
+    void EmplaceWait(Args&&... args) {
+        std::scoped_lock lock{write_mutex};
+        spsc_queue.EmplaceWait(std::forward<Args>(args)...);
     }
 
-    static constexpr size_t mask = capacity - 1;
+    bool TryPop(T& t) {
+        return spsc_queue.TryPop(t);
+    }
 
-    // Align to avoid false sharing between head_ and tail_
-    alignas(hardware_interference_size) std::atomic<size_t> head_{0};
-    alignas(hardware_interference_size) std::atomic<size_t> tail_{0};
+    void PopWait(T& t) {
+        spsc_queue.PopWait(t);
+    }
 
-    std::mutex cv_mutex;
-    std::condition_variable_any cv;
+    void PopWait(T& t, std::stop_token stop_token) {
+        spsc_queue.PopWait(t, stop_token);
+    }
 
-    Slot<T>* slots;
-    [[no_unique_address]] std::allocator<Slot<T>> allocator;
+    T PopWait() {
+        return spsc_queue.PopWait();
+    }
 
-    static_assert(std::is_nothrow_copy_assignable_v<T> || std::is_nothrow_move_assignable_v<T>,
-                  "T must be nothrow copy or move assignable");
+    T PopWait(std::stop_token stop_token) {
+        return spsc_queue.PopWait(stop_token);
+    }
 
-    static_assert(std::is_nothrow_destructible_v<T>, "T must be nothrow destructible");
+private:
+    SPSCQueue<T, Capacity> spsc_queue;
+    std::mutex write_mutex;
+};
+
+template <typename T, size_t Capacity = detail::DefaultCapacity>
+class MPMCQueue {
+public:
+    template <typename... Args>
+    bool TryEmplace(Args&&... args) {
+        std::scoped_lock lock{write_mutex};
+        return spsc_queue.TryEmplace(std::forward<Args>(args)...);
+    }
+
+    template <typename... Args>
+    void EmplaceWait(Args&&... args) {
+        std::scoped_lock lock{write_mutex};
+        spsc_queue.EmplaceWait(std::forward<Args>(args)...);
+    }
+
+    bool TryPop(T& t) {
+        std::scoped_lock lock{read_mutex};
+        return spsc_queue.TryPop(t);
+    }
+
+    void PopWait(T& t) {
+        std::scoped_lock lock{read_mutex};
+        spsc_queue.PopWait(t);
+    }
+
+    void PopWait(T& t, std::stop_token stop_token) {
+        std::scoped_lock lock{read_mutex};
+        spsc_queue.PopWait(t, stop_token);
+    }
+
+    T PopWait() {
+        std::scoped_lock lock{read_mutex};
+        return spsc_queue.PopWait();
+    }
+
+    T PopWait(std::stop_token stop_token) {
+        std::scoped_lock lock{read_mutex};
+        return spsc_queue.PopWait(stop_token);
+    }
+
+private:
+    SPSCQueue<T, Capacity> spsc_queue;
+    std::mutex write_mutex;
+    std::mutex read_mutex;
 };
 
 } // namespace Common

src/common/container_hash.h

@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: 2005-2014 Daniel James
+// SPDX-FileCopyrightText: 2016 Austin Appleby
+// SPDX-License-Identifier: BSL-1.0
+
+#include <array>
+#include <climits>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+#include <vector>
+
+namespace Common {
+
+namespace detail {
+
+template <typename T>
+    requires std::is_unsigned_v<T>
+inline std::size_t HashValue(T val) {
+    const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
+    const unsigned int length =
+        (std::numeric_limits<T>::digits - 1) / static_cast<unsigned int>(size_t_bits);
+
+    std::size_t seed = 0;
+
+    for (unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits) {
+        seed ^= static_cast<size_t>(val >> i) + (seed << 6) + (seed >> 2);
+    }
+
+    seed ^= static_cast<size_t>(val) + (seed << 6) + (seed >> 2);
+
+    return seed;
+}
+
+template <size_t Bits>
+struct HashCombineImpl {
+    template <typename T>
+    static inline T fn(T seed, T value) {
+        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        return seed;
+    }
+};
+
+template <>
+struct HashCombineImpl<64> {
+    static inline std::uint64_t fn(std::uint64_t h, std::uint64_t k) {
+        const std::uint64_t m = (std::uint64_t(0xc6a4a793) << 32) + 0x5bd1e995;
+        const int r = 47;
+
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+
+        h ^= k;
+        h *= m;
+
+        // Completely arbitrary number, to prevent 0's
+        // from hashing to 0.
+        h += 0xe6546b64;
+
+        return h;
+    }
+};
+
+} // namespace detail
+
+template <typename T>
+inline void HashCombine(std::size_t& seed, const T& v) {
+    seed = detail::HashCombineImpl<sizeof(std::size_t) * CHAR_BIT>::fn(seed, detail::HashValue(v));
+}
+
+template <typename It>
+inline std::size_t HashRange(It first, It last) {
+    std::size_t seed = 0;
+
+    for (; first != last; ++first) {
+        HashCombine<typename std::iterator_traits<It>::value_type>(seed, *first);
+    }
+
+    return seed;
+}
+
+template <typename T, size_t Size>
+std::size_t HashValue(const std::array<T, Size>& v) {
+    return HashRange(v.cbegin(), v.cend());
+}
+
+template <typename T, typename Allocator>
+std::size_t HashValue(const std::vector<T, Allocator>& v) {
+    return HashRange(v.cbegin(), v.cend());
+}
+
+} // namespace Common

src/common/fiber.cpp

@@ -90,7 +90,7 @@ Fiber::~Fiber() {
 }
 
 void Fiber::Exit() {
-    ASSERT_MSG(impl->is_thread_fiber, "Exitting non main thread fiber");
+    ASSERT_MSG(impl->is_thread_fiber, "Exiting non main thread fiber");
     if (!impl->is_thread_fiber) {
         return;
     }

src/common/fixed_point.h

@@ -22,7 +22,7 @@ class FixedPoint;
 namespace detail {
 
 // helper templates to make magic with types :)
-// these allow us to determine resonable types from
+// these allow us to determine reasonable types from
 // a desired size, they also let us infer the next largest type
 // from a type which is nice for the division op
 template <size_t T>

src/common/host_memory.cpp

@@ -322,7 +322,7 @@ private:
     }
 
     /// Return true when a given memory region is a "nieche" and the placeholders don't have to be
-    /// splitted.
+    /// split.
     bool IsNiechePlaceholder(size_t virtual_offset, size_t length) const {
         const auto it = placeholders.upper_bound({virtual_offset, virtual_offset + length});
         if (it != placeholders.end() && it->lower() == virtual_offset + length) {
@@ -484,7 +484,7 @@ class HostMemory::Impl {
 public:
     explicit Impl(size_t /*backing_size */, size_t /* virtual_size */) {
         // This is just a place holder.
-        // Please implement fastmem in a propper way on your platform.
+        // Please implement fastmem in a proper way on your platform.
         throw std::bad_alloc{};
     }
 

src/common/input.h

@@ -15,7 +15,7 @@
 
 namespace Common::Input {
 
-// Type of data that is expected to recieve or send
+// Type of data that is expected to receive or send
 enum class InputType {
     None,
     Battery,
@@ -103,7 +103,7 @@ enum class VibrationAmplificationType {
 struct AnalogProperties {
     // Anything below this value will be detected as zero
     float deadzone{};
-    // Anyting above this values will be detected as one
+    // Anything above this values will be detected as one
     float range{1.0f};
     // Minimum value to be detected as active
     float threshold{0.5f};
@@ -209,7 +209,7 @@ struct LedStatus {
     bool led_4{};
 };
 
-// Raw data fom camera
+// Raw data from camera
 struct CameraStatus {
     CameraFormat format{CameraFormat::None};
     std::vector<u8> data{};
@@ -428,7 +428,7 @@ inline void UnregisterOutputFactory(const std::string& name) {
 }
 
 /**
- * Create an input device from given paramters.
+ * Create an input device from given parameters.
  * @tparam InputDeviceType the type of input devices to create
  * @param params a serialized ParamPackage string that contains all parameters for creating the
  * device

src/common/logging/backend.cpp

@@ -28,7 +28,7 @@
 #ifdef _WIN32
 #include "common/string_util.h"
 #endif
-#include "common/threadsafe_queue.h"
+#include "common/bounded_threadsafe_queue.h"
 
 namespace Common::Log {
 
@@ -204,11 +204,11 @@ public:
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
                    const char* function, std::string&& message) {
-        if (!filter.CheckMessage(log_class, log_level))
+        if (!filter.CheckMessage(log_class, log_level)) {
             return;
-        const Entry& entry =
-            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message));
-        message_queue.Push(entry);
+        }
+        message_queue.EmplaceWait(
+            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message)));
     }
 
 private:
@@ -225,7 +225,7 @@ private:
                 ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
             };
             while (!stop_token.stop_requested()) {
-                entry = message_queue.PopWait(stop_token);
+                message_queue.PopWait(entry, stop_token);
                 if (entry.filename != nullptr) {
                     write_logs();
                 }
@@ -233,7 +233,7 @@ private:
             // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
             // case where a system is repeatedly spamming logs even on close.
             int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-            while (max_logs_to_write-- && message_queue.Pop(entry)) {
+            while (max_logs_to_write-- && message_queue.TryPop(entry)) {
                 write_logs();
             }
         });
@@ -273,7 +273,7 @@ private:
     ColorConsoleBackend color_console_backend{};
     FileBackend file_backend;
 
-    MPSCQueue<Entry, true> message_queue{};
+    MPSCQueue<Entry> message_queue{};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
     std::jthread backend_thread;
 };

src/common/steady_clock.cpp

@@ -23,6 +23,19 @@ static s64 WindowsQueryPerformanceCounter() {
     QueryPerformanceCounter(&counter);
     return counter.QuadPart;
 }
+
+static s64 GetSystemTimeNS() {
+    // GetSystemTimePreciseAsFileTime returns the file time in 100ns units.
+    static constexpr s64 Multiplier = 100;
+    // Convert Windows epoch to Unix epoch.
+    static constexpr s64 WindowsEpochToUnixEpochNS = 0x19DB1DED53E8000LL;
+
+    FILETIME filetime;
+    GetSystemTimePreciseAsFileTime(&filetime);
+    return Multiplier * ((static_cast<s64>(filetime.dwHighDateTime) << 32) +
+                         static_cast<s64>(filetime.dwLowDateTime)) -
+           WindowsEpochToUnixEpochNS;
+}
 #endif
 
 SteadyClock::time_point SteadyClock::Now() noexcept {
@@ -53,4 +66,16 @@ SteadyClock::time_point SteadyClock::Now() noexcept {
 #endif
 }
 
+RealTimeClock::time_point RealTimeClock::Now() noexcept {
+#if defined(_WIN32)
+    return time_point{duration{GetSystemTimeNS()}};
+#elif defined(__APPLE__)
+    return time_point{duration{clock_gettime_nsec_np(CLOCK_REALTIME)}};
+#else
+    timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    return time_point{std::chrono::seconds{ts.tv_sec} + std::chrono::nanoseconds{ts.tv_nsec}};
+#endif
+}
+
 }; // namespace Common

src/common/steady_clock.h

@@ -20,4 +20,15 @@ struct SteadyClock {
     [[nodiscard]] static time_point Now() noexcept;
 };
 
+struct RealTimeClock {
+    using rep = s64;
+    using period = std::nano;
+    using duration = std::chrono::nanoseconds;
+    using time_point = std::chrono::time_point<RealTimeClock>;
+
+    static constexpr bool is_steady = false;
+
+    [[nodiscard]] static time_point Now() noexcept;
+};
+
 } // namespace Common

src/common/string_util.cpp

@@ -125,18 +125,18 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
     return result;
 }
 
-std::string UTF16ToUTF8(const std::u16string& input) {
+std::string UTF16ToUTF8(std::u16string_view input) {
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-    return convert.to_bytes(input);
+    return convert.to_bytes(input.data(), input.data() + input.size());
 }
 
-std::u16string UTF8ToUTF16(const std::string& input) {
+std::u16string UTF8ToUTF16(std::string_view input) {
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-    return convert.from_bytes(input);
+    return convert.from_bytes(input.data(), input.data() + input.size());
 }
 
 #ifdef _WIN32
-static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
+static std::wstring CPToUTF16(u32 code_page, std::string_view input) {
     const auto size =
         MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
 
@@ -154,7 +154,7 @@ static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
     return output;
 }
 
-std::string UTF16ToUTF8(const std::wstring& input) {
+std::string UTF16ToUTF8(std::wstring_view input) {
     const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
                                           nullptr, 0, nullptr, nullptr);
     if (size == 0) {
@@ -172,7 +172,7 @@ std::string UTF16ToUTF8(const std::wstring& input) {
     return output;
 }
 
-std::wstring UTF8ToUTF16W(const std::string& input) {
+std::wstring UTF8ToUTF16W(std::string_view input) {
     return CPToUTF16(CP_UTF8, input);
 }
 

src/common/string_util.h

@@ -36,12 +36,12 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
 [[nodiscard]] std::string ReplaceAll(std::string result, const std::string& src,
                                      const std::string& dest);
 
-[[nodiscard]] std::string UTF16ToUTF8(const std::u16string& input);
-[[nodiscard]] std::u16string UTF8ToUTF16(const std::string& input);
+[[nodiscard]] std::string UTF16ToUTF8(std::u16string_view input);
+[[nodiscard]] std::u16string UTF8ToUTF16(std::string_view input);
 
 #ifdef _WIN32
-[[nodiscard]] std::string UTF16ToUTF8(const std::wstring& input);
-[[nodiscard]] std::wstring UTF8ToUTF16W(const std::string& str);
+[[nodiscard]] std::string UTF16ToUTF8(std::wstring_view input);
+[[nodiscard]] std::wstring UTF8ToUTF16W(std::string_view str);
 
 #endif
 

src/common/swap.h

@@ -229,7 +229,7 @@ public:
         value = swap(swap() - 1);
         return old;
     }
-    // Comparaison
+    // Comparison
     // v == i
     bool operator==(const swapped_t& i) const {
         return swap() == i.swap();
@@ -368,7 +368,7 @@ public:
     // Member
     /** todo **/
 
-    // Arithmetics
+    // Arithmetic
     template <typename S, typename T2, typename F2>
     friend S operator+(const S& p, const swapped_t v);
 
@@ -384,7 +384,7 @@ public:
     template <typename S, typename T2, typename F2>
     friend S operator%(const S& p, const swapped_t v);
 
-    // Arithmetics + assignments
+    // Arithmetic + assignments
     template <typename S, typename T2, typename F2>
     friend S operator+=(const S& p, const swapped_t v);
 
@@ -415,7 +415,7 @@ public:
     friend bool operator==(const S& p, const swapped_t v);
 };
 
-// Arithmetics
+// Arithmetic
 template <typename S, typename T, typename F>
 S operator+(const S& i, const swap_struct_t<T, F> v) {
     return i + v.swap();
@@ -441,7 +441,7 @@ S operator%(const S& i, const swap_struct_t<T, F> v) {
     return i % v.swap();
 }
 
-// Arithmetics + assignments
+// Arithmetic + assignments
 template <typename S, typename T, typename F>
 S& operator+=(S& i, const swap_struct_t<T, F> v) {
     i += v.swap();
@@ -465,7 +465,7 @@ S operator&(const swap_struct_t<T, F> v, const S& i) {
     return static_cast<S>(v.swap() & i);
 }
 
-// Comparaison
+// Comparison
 template <typename S, typename T, typename F>
 bool operator<(const S& p, const swap_struct_t<T, F> v) {
     return p < v.swap();

src/common/telemetry.cpp

@@ -97,6 +97,7 @@ void AppendCPUInfo(FieldCollection& fc) {
     add_field("CPU_Extension_x64_PCLMULQDQ", caps.pclmulqdq);
     add_field("CPU_Extension_x64_POPCNT", caps.popcnt);
     add_field("CPU_Extension_x64_SHA", caps.sha);
+    add_field("CPU_Extension_x64_WAITPKG", caps.waitpkg);
 #else
     fc.AddField(FieldType::UserSystem, "CPU_Model", "Other");
 #endif

src/common/typed_address.h

@@ -0,0 +1,320 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <compare>
+#include <type_traits>
+#include <fmt/format.h>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+template <bool Virtual, typename T>
+class TypedAddress {
+public:
+    // Constructors.
+    constexpr inline TypedAddress() : m_address(0) {}
+    constexpr inline TypedAddress(uint64_t a) : m_address(a) {}
+
+    template <typename U>
+    constexpr inline explicit TypedAddress(const U* ptr)
+        : m_address(reinterpret_cast<uint64_t>(ptr)) {}
+
+    // Copy constructor.
+    constexpr inline TypedAddress(const TypedAddress& rhs) = default;
+
+    // Assignment operator.
+    constexpr inline TypedAddress& operator=(const TypedAddress& rhs) = default;
+
+    // Arithmetic operators.
+    template <typename I>
+    constexpr inline TypedAddress operator+(I rhs) const {
+        static_assert(std::is_integral_v<I>);
+        return m_address + rhs;
+    }
+
+    constexpr inline TypedAddress operator+(TypedAddress rhs) const {
+        return m_address + rhs.m_address;
+    }
+
+    constexpr inline TypedAddress operator++() {
+        return ++m_address;
+    }
+
+    constexpr inline TypedAddress operator++(int) {
+        return m_address++;
+    }
+
+    template <typename I>
+    constexpr inline TypedAddress operator-(I rhs) const {
+        static_assert(std::is_integral_v<I>);
+        return m_address - rhs;
+    }
+
+    constexpr inline ptrdiff_t operator-(TypedAddress rhs) const {
+        return m_address - rhs.m_address;
+    }
+
+    constexpr inline TypedAddress operator--() {
+        return --m_address;
+    }
+
+    constexpr inline TypedAddress operator--(int) {
+        return m_address--;
+    }
+
+    template <typename I>
+    constexpr inline TypedAddress operator+=(I rhs) {
+        static_assert(std::is_integral_v<I>);
+        m_address += rhs;
+        return *this;
+    }
+
+    template <typename I>
+    constexpr inline TypedAddress operator-=(I rhs) {
+        static_assert(std::is_integral_v<I>);
+        m_address -= rhs;
+        return *this;
+    }
+
+    // Logical operators.
+    constexpr inline uint64_t operator&(uint64_t mask) const {
+        return m_address & mask;
+    }
+
+    constexpr inline uint64_t operator|(uint64_t mask) const {
+        return m_address | mask;
+    }
+
+    template <typename I>
+    constexpr inline TypedAddress operator|=(I rhs) {
+        static_assert(std::is_integral_v<I>);
+        m_address |= rhs;
+        return *this;
+    }
+
+    constexpr inline uint64_t operator<<(int shift) const {
+        return m_address << shift;
+    }
+
+    constexpr inline uint64_t operator>>(int shift) const {
+        return m_address >> shift;
+    }
+
+    template <typename U>
+    constexpr inline size_t operator/(U size) const {
+        return m_address / size;
+    }
+
+    constexpr explicit operator bool() const {
+        return m_address != 0;
+    }
+
+    // constexpr inline uint64_t operator%(U align) const { return m_address % align; }
+
+    // Comparison operators.
+    constexpr bool operator==(const TypedAddress&) const = default;
+    constexpr bool operator!=(const TypedAddress&) const = default;
+    constexpr auto operator<=>(const TypedAddress&) const = default;
+
+    // For convenience, also define comparison operators versus uint64_t.
+    constexpr inline bool operator==(uint64_t rhs) const {
+        return m_address == rhs;
+    }
+
+    constexpr inline bool operator!=(uint64_t rhs) const {
+        return m_address != rhs;
+    }
+
+    // Allow getting the address explicitly, for use in accessors.
+    constexpr inline uint64_t GetValue() const {
+        return m_address;
+    }
+
+private:
+    uint64_t m_address{};
+};
+
+struct PhysicalAddressTag {};
+struct VirtualAddressTag {};
+struct ProcessAddressTag {};
+
+using PhysicalAddress = TypedAddress<false, PhysicalAddressTag>;
+using VirtualAddress = TypedAddress<true, VirtualAddressTag>;
+using ProcessAddress = TypedAddress<true, ProcessAddressTag>;
+
+// Define accessors.
+template <typename T>
+concept IsTypedAddress = std::same_as<T, PhysicalAddress> || std::same_as<T, VirtualAddress> ||
+                         std::same_as<T, ProcessAddress>;
+
+template <typename T>
+constexpr inline T Null = [] {
+    if constexpr (std::is_same<T, uint64_t>::value) {
+        return 0;
+    } else {
+        static_assert(std::is_same<T, PhysicalAddress>::value ||
+                      std::is_same<T, VirtualAddress>::value ||
+                      std::is_same<T, ProcessAddress>::value);
+        return T(0);
+    }
+}();
+
+// Basic type validations.
+static_assert(sizeof(PhysicalAddress) == sizeof(uint64_t));
+static_assert(sizeof(VirtualAddress) == sizeof(uint64_t));
+static_assert(sizeof(ProcessAddress) == sizeof(uint64_t));
+
+static_assert(std::is_trivially_copyable_v<PhysicalAddress>);
+static_assert(std::is_trivially_copyable_v<VirtualAddress>);
+static_assert(std::is_trivially_copyable_v<ProcessAddress>);
+
+static_assert(std::is_trivially_copy_constructible_v<PhysicalAddress>);
+static_assert(std::is_trivially_copy_constructible_v<VirtualAddress>);
+static_assert(std::is_trivially_copy_constructible_v<ProcessAddress>);
+
+static_assert(std::is_trivially_move_constructible_v<PhysicalAddress>);
+static_assert(std::is_trivially_move_constructible_v<VirtualAddress>);
+static_assert(std::is_trivially_move_constructible_v<ProcessAddress>);
+
+static_assert(std::is_trivially_copy_assignable_v<PhysicalAddress>);
+static_assert(std::is_trivially_copy_assignable_v<VirtualAddress>);
+static_assert(std::is_trivially_copy_assignable_v<ProcessAddress>);
+
+static_assert(std::is_trivially_move_assignable_v<PhysicalAddress>);
+static_assert(std::is_trivially_move_assignable_v<VirtualAddress>);
+static_assert(std::is_trivially_move_assignable_v<ProcessAddress>);
+
+static_assert(std::is_trivially_destructible_v<PhysicalAddress>);
+static_assert(std::is_trivially_destructible_v<VirtualAddress>);
+static_assert(std::is_trivially_destructible_v<ProcessAddress>);
+
+static_assert(Null<uint64_t> == 0);
+static_assert(Null<PhysicalAddress> == Null<uint64_t>);
+static_assert(Null<VirtualAddress> == Null<uint64_t>);
+static_assert(Null<ProcessAddress> == Null<uint64_t>);
+
+// Constructor/assignment validations.
+static_assert([] {
+    const PhysicalAddress a(5);
+    PhysicalAddress b(a);
+    return b;
+}() == PhysicalAddress(5));
+static_assert([] {
+    const PhysicalAddress a(5);
+    PhysicalAddress b(10);
+    b = a;
+    return b;
+}() == PhysicalAddress(5));
+
+// Arithmetic validations.
+static_assert(PhysicalAddress(10) + 5 == PhysicalAddress(15));
+static_assert(PhysicalAddress(10) - 5 == PhysicalAddress(5));
+static_assert([] {
+    PhysicalAddress v(10);
+    v += 5;
+    return v;
+}() == PhysicalAddress(15));
+static_assert([] {
+    PhysicalAddress v(10);
+    v -= 5;
+    return v;
+}() == PhysicalAddress(5));
+static_assert(PhysicalAddress(10)++ == PhysicalAddress(10));
+static_assert(++PhysicalAddress(10) == PhysicalAddress(11));
+static_assert(PhysicalAddress(10)-- == PhysicalAddress(10));
+static_assert(--PhysicalAddress(10) == PhysicalAddress(9));
+
+// Logical validations.
+static_assert((PhysicalAddress(0b11111111) >> 1) == 0b01111111);
+static_assert((PhysicalAddress(0b10101010) >> 1) == 0b01010101);
+static_assert((PhysicalAddress(0b11111111) << 1) == 0b111111110);
+static_assert((PhysicalAddress(0b01010101) << 1) == 0b10101010);
+static_assert((PhysicalAddress(0b11111111) & 0b01010101) == 0b01010101);
+static_assert((PhysicalAddress(0b11111111) & 0b10101010) == 0b10101010);
+static_assert((PhysicalAddress(0b01010101) & 0b10101010) == 0b00000000);
+static_assert((PhysicalAddress(0b00000000) | 0b01010101) == 0b01010101);
+static_assert((PhysicalAddress(0b11111111) | 0b01010101) == 0b11111111);
+static_assert((PhysicalAddress(0b10101010) | 0b01010101) == 0b11111111);
+
+// Comparisons.
+static_assert(PhysicalAddress(0) == PhysicalAddress(0));
+static_assert(PhysicalAddress(0) != PhysicalAddress(1));
+static_assert(PhysicalAddress(0) < PhysicalAddress(1));
+static_assert(PhysicalAddress(0) <= PhysicalAddress(1));
+static_assert(PhysicalAddress(1) > PhysicalAddress(0));
+static_assert(PhysicalAddress(1) >= PhysicalAddress(0));
+
+static_assert(!(PhysicalAddress(0) == PhysicalAddress(1)));
+static_assert(!(PhysicalAddress(0) != PhysicalAddress(0)));
+static_assert(!(PhysicalAddress(1) < PhysicalAddress(0)));
+static_assert(!(PhysicalAddress(1) <= PhysicalAddress(0)));
+static_assert(!(PhysicalAddress(0) > PhysicalAddress(1)));
+static_assert(!(PhysicalAddress(0) >= PhysicalAddress(1)));
+
+} // namespace Common
+
+template <bool Virtual, typename T>
+constexpr inline uint64_t GetInteger(Common::TypedAddress<Virtual, T> address) {
+    return address.GetValue();
+}
+
+template <>
+struct fmt::formatter<Common::PhysicalAddress> {
+    constexpr auto parse(fmt::format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Common::PhysicalAddress& addr, FormatContext& ctx) {
+        return fmt::format_to(ctx.out(), "{:#x}", static_cast<u64>(addr.GetValue()));
+    }
+};
+
+template <>
+struct fmt::formatter<Common::ProcessAddress> {
+    constexpr auto parse(fmt::format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Common::ProcessAddress& addr, FormatContext& ctx) {
+        return fmt::format_to(ctx.out(), "{:#x}", static_cast<u64>(addr.GetValue()));
+    }
+};
+
+template <>
+struct fmt::formatter<Common::VirtualAddress> {
+    constexpr auto parse(fmt::format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const Common::VirtualAddress& addr, FormatContext& ctx) {
+        return fmt::format_to(ctx.out(), "{:#x}", static_cast<u64>(addr.GetValue()));
+    }
+};
+
+namespace std {
+
+template <>
+struct hash<Common::PhysicalAddress> {
+    size_t operator()(const Common::PhysicalAddress& k) const noexcept {
+        return k.GetValue();
+    }
+};
+
+template <>
+struct hash<Common::ProcessAddress> {
+    size_t operator()(const Common::ProcessAddress& k) const noexcept {
+        return k.GetValue();
+    }
+};
+
+template <>
+struct hash<Common::VirtualAddress> {
+    size_t operator()(const Common::VirtualAddress& k) const noexcept {
+        return k.GetValue();
+    }
+};
+
+} // namespace std

src/common/x64/cpu_detect.cpp

@@ -144,6 +144,7 @@ static CPUCaps Detect() {
             caps.bmi2 = Common::Bit<8>(cpu_id[1]);
             caps.sha = Common::Bit<29>(cpu_id[1]);
 
+            caps.waitpkg = Common::Bit<5>(cpu_id[2]);
             caps.gfni = Common::Bit<8>(cpu_id[2]);
 
             __cpuidex(cpu_id, 0x00000007, 0x00000001);

src/common/x64/cpu_detect.h

@@ -67,6 +67,7 @@ struct CPUCaps {
     bool pclmulqdq : 1;
     bool popcnt : 1;
     bool sha : 1;
+    bool waitpkg : 1;
 };
 
 /**

src/common/x64/cpu_wait.cpp

@@ -0,0 +1,69 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <thread>
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+#include "common/x64/cpu_detect.h"
+#include "common/x64/cpu_wait.h"
+
+namespace Common::X64 {
+
+#ifdef _MSC_VER
+__forceinline static u64 FencedRDTSC() {
+    _mm_lfence();
+    _ReadWriteBarrier();
+    const u64 result = __rdtsc();
+    _mm_lfence();
+    _ReadWriteBarrier();
+    return result;
+}
+
+__forceinline static void TPAUSE() {
+    // 100,000 cycles is a reasonable amount of time to wait to save on CPU resources.
+    // For reference:
+    // At 1 GHz, 100K cycles is 100us
+    // At 2 GHz, 100K cycles is 50us
+    // At 4 GHz, 100K cycles is 25us
+    static constexpr auto PauseCycles = 100'000;
+    _tpause(0, FencedRDTSC() + PauseCycles);
+}
+#else
+static u64 FencedRDTSC() {
+    u64 eax;
+    u64 edx;
+    asm volatile("lfence\n\t"
+                 "rdtsc\n\t"
+                 "lfence\n\t"
+                 : "=a"(eax), "=d"(edx));
+    return (edx << 32) | eax;
+}
+
+static void TPAUSE() {
+    // 100,000 cycles is a reasonable amount of time to wait to save on CPU resources.
+    // For reference:
+    // At 1 GHz, 100K cycles is 100us
+    // At 2 GHz, 100K cycles is 50us
+    // At 4 GHz, 100K cycles is 25us
+    static constexpr auto PauseCycles = 100'000;
+    const auto tsc = FencedRDTSC() + PauseCycles;
+    const auto eax = static_cast<u32>(tsc & 0xFFFFFFFF);
+    const auto edx = static_cast<u32>(tsc >> 32);
+    asm volatile("tpause %0" : : "r"(0), "d"(edx), "a"(eax));
+}
+#endif
+
+void MicroSleep() {
+    static const bool has_waitpkg = GetCPUCaps().waitpkg;
+
+    if (has_waitpkg) {
+        TPAUSE();
+    } else {
+        std::this_thread::yield();
+    }
+}
+
+} // namespace Common::X64

src/common/x64/cpu_wait.h

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+namespace Common::X64 {
+
+void MicroSleep();
+
+} // namespace Common::X64

src/common/x64/native_clock.cpp

@@ -27,16 +27,13 @@ __forceinline static u64 FencedRDTSC() {
 }
 #else
 static u64 FencedRDTSC() {
-    u64 result;
+    u64 eax;
+    u64 edx;
     asm volatile("lfence\n\t"
                  "rdtsc\n\t"
-                 "shl $32, %%rdx\n\t"
-                 "or %%rdx, %0\n\t"
-                 "lfence"
-                 : "=a"(result)
-                 :
-                 : "rdx", "memory", "cc");
-    return result;
+                 "lfence\n\t"
+                 : "=a"(eax), "=d"(edx));
+    return (edx << 32) | eax;
 }
 #endif
 
@@ -53,11 +50,11 @@ u64 EstimateRDTSCFrequency() {
     FencedRDTSC();
 
     // Get the current time.
-    const auto start_time = Common::SteadyClock::Now();
+    const auto start_time = Common::RealTimeClock::Now();
     const u64 tsc_start = FencedRDTSC();
     // Wait for 250 milliseconds.
     std::this_thread::sleep_for(std::chrono::milliseconds{250});
-    const auto end_time = Common::SteadyClock::Now();
+    const auto end_time = Common::RealTimeClock::Now();
     const u64 tsc_end = FencedRDTSC();
     // Calculate differences.
     const u64 timer_diff = static_cast<u64>(
@@ -72,13 +69,29 @@ NativeClock::NativeClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequen
                          u64 rtsc_frequency_)
     : WallClock(emulated_cpu_frequency_, emulated_clock_frequency_, true), rtsc_frequency{
                                                                                rtsc_frequency_} {
+    // Thread to re-adjust the RDTSC frequency after 10 seconds has elapsed.
+    time_sync_thread = std::jthread{[this](std::stop_token token) {
+        // Get the current time.
+        const auto start_time = Common::RealTimeClock::Now();
+        const u64 tsc_start = FencedRDTSC();
+        // Wait for 10 seconds.
+        if (!Common::StoppableTimedWait(token, std::chrono::seconds{10})) {
+            return;
+        }
+        const auto end_time = Common::RealTimeClock::Now();
+        const u64 tsc_end = FencedRDTSC();
+        // Calculate differences.
+        const u64 timer_diff = static_cast<u64>(
+            std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time).count());
+        const u64 tsc_diff = tsc_end - tsc_start;
+        const u64 tsc_freq = MultiplyAndDivide64(tsc_diff, 1000000000ULL, timer_diff);
+        rtsc_frequency = tsc_freq;
+        CalculateAndSetFactors();
+    }};
+
     time_point.inner.last_measure = FencedRDTSC();
     time_point.inner.accumulated_ticks = 0U;
-    ns_rtsc_factor = GetFixedPoint64Factor(NS_RATIO, rtsc_frequency);
-    us_rtsc_factor = GetFixedPoint64Factor(US_RATIO, rtsc_frequency);
-    ms_rtsc_factor = GetFixedPoint64Factor(MS_RATIO, rtsc_frequency);
-    clock_rtsc_factor = GetFixedPoint64Factor(emulated_clock_frequency, rtsc_frequency);
-    cpu_rtsc_factor = GetFixedPoint64Factor(emulated_cpu_frequency, rtsc_frequency);
+    CalculateAndSetFactors();
 }
 
 u64 NativeClock::GetRTSC() {
@@ -138,6 +151,14 @@ u64 NativeClock::GetCPUCycles() {
     return MultiplyHigh(rtsc_value, cpu_rtsc_factor);
 }
 
+void NativeClock::CalculateAndSetFactors() {
+    ns_rtsc_factor = GetFixedPoint64Factor(NS_RATIO, rtsc_frequency);
+    us_rtsc_factor = GetFixedPoint64Factor(US_RATIO, rtsc_frequency);
+    ms_rtsc_factor = GetFixedPoint64Factor(MS_RATIO, rtsc_frequency);
+    clock_rtsc_factor = GetFixedPoint64Factor(emulated_clock_frequency, rtsc_frequency);
+    cpu_rtsc_factor = GetFixedPoint64Factor(emulated_cpu_frequency, rtsc_frequency);
+}
+
 } // namespace X64
 
 } // namespace Common

src/common/x64/native_clock.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "common/polyfill_thread.h"
 #include "common/wall_clock.h"
 
 namespace Common {
@@ -28,6 +29,8 @@ public:
 private:
     u64 GetRTSC();
 
+    void CalculateAndSetFactors();
+
     union alignas(16) TimePoint {
         TimePoint() : pack{} {}
         u128 pack{};
@@ -47,6 +50,8 @@ private:
     u64 ms_rtsc_factor{};
 
     u64 rtsc_frequency;
+
+    std::jthread time_sync_thread;
 };
 } // namespace X64
 

src/common/zstd_compression.cpp

@@ -33,7 +33,7 @@ std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_siz
 
 std::vector<u8> DecompressDataZSTD(std::span<const u8> compressed) {
     const std::size_t decompressed_size =
-        ZSTD_getDecompressedSize(compressed.data(), compressed.size());
+        ZSTD_getFrameContentSize(compressed.data(), compressed.size());
     std::vector<u8> decompressed(decompressed_size);
 
     const std::size_t uncompressed_result_size = ZSTD_decompress(

src/core/CMakeLists.txt

@@ -158,6 +158,7 @@ add_library(core STATIC
     hid/motion_input.h
     hle/api_version.h
     hle/ipc.h
+    hle/kernel/board/nintendo/nx/k_memory_layout.cpp
     hle/kernel/board/nintendo/nx/k_memory_layout.h
     hle/kernel/board/nintendo/nx/k_system_control.cpp
     hle/kernel/board/nintendo/nx/k_system_control.h
@@ -211,12 +212,10 @@ add_library(core STATIC
     hle/kernel/k_light_condition_variable.h
     hle/kernel/k_light_lock.cpp
     hle/kernel/k_light_lock.h
-    hle/kernel/k_linked_list.h
     hle/kernel/k_memory_block.h
     hle/kernel/k_memory_block_manager.cpp
     hle/kernel/k_memory_block_manager.h
     hle/kernel/k_memory_layout.cpp
-    hle/kernel/k_memory_layout.board.nintendo_nx.cpp
     hle/kernel/k_memory_layout.h
     hle/kernel/k_memory_manager.cpp
     hle/kernel/k_memory_manager.h
@@ -279,6 +278,7 @@ add_library(core STATIC
     hle/kernel/k_trace.h
     hle/kernel/k_transfer_memory.cpp
     hle/kernel/k_transfer_memory.h
+    hle/kernel/k_typed_address.h
     hle/kernel/k_worker_task.h
     hle/kernel/k_worker_task_manager.cpp
     hle/kernel/k_worker_task_manager.h

src/core/arm/arm_interface.cpp

@@ -44,7 +44,7 @@ void ARM_Interface::SymbolicateBacktrace(Core::System& system, std::vector<Backt
     std::map<std::string, Symbols::Symbols> symbols;
     for (const auto& module : modules) {
         symbols.insert_or_assign(
-            module.second, Symbols::GetSymbols(module.first, system.Memory(),
+            module.second, Symbols::GetSymbols(module.first, system.ApplicationMemory(),
                                                system.ApplicationProcess()->Is64BitProcess()));
     }
 
@@ -168,21 +168,21 @@ void ARM_Interface::LoadWatchpointArray(const WatchpointArray& wp) {
 }
 
 const Kernel::DebugWatchpoint* ARM_Interface::MatchingWatchpoint(
-    VAddr addr, u64 size, Kernel::DebugWatchpointType access_type) const {
+    u64 addr, u64 size, Kernel::DebugWatchpointType access_type) const {
     if (!watchpoints) {
         return nullptr;
     }
 
-    const VAddr start_address{addr};
-    const VAddr end_address{addr + size};
+    const u64 start_address{addr};
+    const u64 end_address{addr + size};
 
     for (size_t i = 0; i < Core::Hardware::NUM_WATCHPOINTS; i++) {
         const auto& watch{(*watchpoints)[i]};
 
-        if (end_address <= watch.start_address) {
+        if (end_address <= GetInteger(watch.start_address)) {
             continue;
         }
-        if (start_address >= watch.end_address) {
+        if (start_address >= GetInteger(watch.end_address)) {
             continue;
         }
         if ((access_type & watch.type) == Kernel::DebugWatchpointType::None) {

src/core/arm/arm_interface.h

@@ -78,7 +78,7 @@ public:
      * @param addr Start address of the cache range to clear
      * @param size Size of the cache range to clear, starting at addr
      */
-    virtual void InvalidateCacheRange(VAddr addr, std::size_t size) = 0;
+    virtual void InvalidateCacheRange(u64 addr, std::size_t size) = 0;
 
     /**
      * Notifies CPU emulation that the current page table has changed.
@@ -149,9 +149,9 @@ public:
      */
     virtual void SetPSTATE(u32 pstate) = 0;
 
-    virtual VAddr GetTlsAddress() const = 0;
+    virtual u64 GetTlsAddress() const = 0;
 
-    virtual void SetTlsAddress(VAddr address) = 0;
+    virtual void SetTlsAddress(u64 address) = 0;
 
     /**
      * Gets the value within the TPIDR_EL0 (read/write software thread ID) register.
@@ -214,7 +214,7 @@ protected:
 
     static void SymbolicateBacktrace(Core::System& system, std::vector<BacktraceEntry>& out);
     const Kernel::DebugWatchpoint* MatchingWatchpoint(
-        VAddr addr, u64 size, Kernel::DebugWatchpointType access_type) const;
+        u64 addr, u64 size, Kernel::DebugWatchpointType access_type) const;
 
     virtual Dynarmic::HaltReason RunJit() = 0;
     virtual Dynarmic::HaltReason StepJit() = 0;

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -28,8 +28,8 @@ using namespace Common::Literals;
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
     explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
-        : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()},
+        : parent{parent_}, memory(parent.system.ApplicationMemory()),
+          debugger_enabled{parent.system.DebuggerEnabled()},
           check_memory_access{debugger_enabled ||
                               !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 
@@ -155,7 +155,7 @@ public:
         return std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0);
     }
 
-    bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
+    bool CheckMemoryAccess(u64 addr, u64 size, Kernel::DebugWatchpointType type) {
         if (!check_memory_access) {
             return true;
         }
@@ -397,7 +397,7 @@ u64 ARM_Dynarmic_32::GetTlsAddress() const {
     return cp15->uro;
 }
 
-void ARM_Dynarmic_32::SetTlsAddress(VAddr address) {
+void ARM_Dynarmic_32::SetTlsAddress(u64 address) {
     cp15->uro = static_cast<u32>(address);
 }
 
@@ -439,7 +439,7 @@ void ARM_Dynarmic_32::ClearInstructionCache() {
     jit.load()->ClearCache();
 }
 
-void ARM_Dynarmic_32::InvalidateCacheRange(VAddr addr, std::size_t size) {
+void ARM_Dynarmic_32::InvalidateCacheRange(u64 addr, std::size_t size) {
     jit.load()->InvalidateCacheRange(static_cast<u32>(addr), size);
 }
 
@@ -468,7 +468,7 @@ void ARM_Dynarmic_32::PageTableChanged(Common::PageTable& page_table,
 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktrace(Core::System& system,
                                                                          u64 fp, u64 lr, u64 pc) {
     std::vector<BacktraceEntry> out;
-    auto& memory = system.Memory();
+    auto& memory = system.ApplicationMemory();
 
     out.push_back({"", 0, pc, 0, ""});
 

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -41,8 +41,8 @@ public:
     void SetVectorReg(int index, u128 value) override;
     u32 GetPSTATE() const override;
     void SetPSTATE(u32 pstate) override;
-    VAddr GetTlsAddress() const override;
-    void SetTlsAddress(VAddr address) override;
+    u64 GetTlsAddress() const override;
+    void SetTlsAddress(u64 address) override;
     void SetTPIDR_EL0(u64 value) override;
     u64 GetTPIDR_EL0() const override;
 
@@ -60,7 +60,7 @@ public:
     void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
-    void InvalidateCacheRange(VAddr addr, std::size_t size) override;
+    void InvalidateCacheRange(u64 addr, std::size_t size) override;
     void PageTableChanged(Common::PageTable& new_page_table,
                           std::size_t new_address_space_size_in_bits) override;
 

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -28,8 +28,8 @@ using namespace Common::Literals;
 class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
     explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_)
-        : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()},
+        : parent{parent_}, memory(parent.system.ApplicationMemory()),
+          debugger_enabled{parent.system.DebuggerEnabled()},
           check_memory_access{debugger_enabled ||
                               !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 
@@ -117,7 +117,7 @@ public:
     }
 
     void InstructionCacheOperationRaised(Dynarmic::A64::InstructionCacheOperation op,
-                                         VAddr value) override {
+                                         u64 value) override {
         switch (op) {
         case Dynarmic::A64::InstructionCacheOperation::InvalidateByVAToPoU: {
             static constexpr u64 ICACHE_LINE_SIZE = 64;
@@ -199,7 +199,7 @@ public:
         return parent.system.CoreTiming().GetClockTicks();
     }
 
-    bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
+    bool CheckMemoryAccess(u64 addr, u64 size, Kernel::DebugWatchpointType type) {
         if (!check_memory_access) {
             return true;
         }
@@ -452,7 +452,7 @@ u64 ARM_Dynarmic_64::GetTlsAddress() const {
     return cb->tpidrro_el0;
 }
 
-void ARM_Dynarmic_64::SetTlsAddress(VAddr address) {
+void ARM_Dynarmic_64::SetTlsAddress(u64 address) {
     cb->tpidrro_el0 = address;
 }
 
@@ -500,7 +500,7 @@ void ARM_Dynarmic_64::ClearInstructionCache() {
     jit.load()->ClearCache();
 }
 
-void ARM_Dynarmic_64::InvalidateCacheRange(VAddr addr, std::size_t size) {
+void ARM_Dynarmic_64::InvalidateCacheRange(u64 addr, std::size_t size) {
     jit.load()->InvalidateCacheRange(addr, size);
 }
 
@@ -529,7 +529,7 @@ void ARM_Dynarmic_64::PageTableChanged(Common::PageTable& page_table,
 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace(Core::System& system,
                                                                          u64 fp, u64 lr, u64 pc) {
     std::vector<BacktraceEntry> out;
-    auto& memory = system.Memory();
+    auto& memory = system.ApplicationMemory();
 
     out.push_back({"", 0, pc, 0, ""});
 

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -38,8 +38,8 @@ public:
     void SetVectorReg(int index, u128 value) override;
     u32 GetPSTATE() const override;
     void SetPSTATE(u32 pstate) override;
-    VAddr GetTlsAddress() const override;
-    void SetTlsAddress(VAddr address) override;
+    u64 GetTlsAddress() const override;
+    void SetTlsAddress(u64 address) override;
     void SetTPIDR_EL0(u64 value) override;
     u64 GetTPIDR_EL0() const override;
 
@@ -53,7 +53,7 @@ public:
     void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
-    void InvalidateCacheRange(VAddr addr, std::size_t size) override;
+    void InvalidateCacheRange(u64 addr, std::size_t size) override;
     void PageTableChanged(Common::PageTable& new_page_table,
                           std::size_t new_address_space_size_in_bits) override;
 

src/core/core.cpp

@@ -293,6 +293,7 @@ struct System::Impl {
         ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
                                             Kernel::KProcess::ProcessType::Userland, resource_limit)
                    .IsSuccess());
+        kernel.MakeApplicationProcess(main_process);
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
@@ -302,7 +303,6 @@ struct System::Impl {
                 static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
         }
         AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeApplicationProcess(main_process);
         kernel.InitializeCores();
 
         // Initialize cheat engine
@@ -358,7 +358,7 @@ struct System::Impl {
     void ShutdownMainProcess() {
         SetShuttingDown(true);
 
-        // Log last frame performance stats if game was loded
+        // Log last frame performance stats if game was loaded
         if (perf_stats) {
             const auto perf_results = GetAndResetPerfStats();
             constexpr auto performance = Common::Telemetry::FieldType::Performance;
@@ -434,7 +434,7 @@ struct System::Impl {
         }
 
         Service::Glue::ApplicationLaunchProperty launch{};
-        launch.title_id = process.GetProgramID();
+        launch.title_id = process.GetProgramId();
 
         FileSys::PatchManager pm{launch.title_id, fs_controller, *content_provider};
         launch.version = pm.GetGameVersion().value_or(0);
@@ -564,7 +564,7 @@ void System::InvalidateCpuInstructionCaches() {
     impl->kernel.InvalidateAllInstructionCaches();
 }
 
-void System::InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size) {
+void System::InvalidateCpuInstructionCacheRange(u64 addr, std::size_t size) {
     impl->kernel.InvalidateCpuInstructionCacheRange(addr, size);
 }
 
@@ -681,11 +681,11 @@ const ExclusiveMonitor& System::Monitor() const {
     return impl->kernel.GetExclusiveMonitor();
 }
 
-Memory::Memory& System::Memory() {
+Memory::Memory& System::ApplicationMemory() {
     return impl->memory;
 }
 
-const Core::Memory::Memory& System::Memory() const {
+const Core::Memory::Memory& System::ApplicationMemory() const {
     return impl->memory;
 }
 
@@ -762,7 +762,7 @@ const Core::SpeedLimiter& System::SpeedLimiter() const {
 }
 
 u64 System::GetApplicationProcessProgramID() const {
-    return impl->kernel.ApplicationProcess()->GetProgramID();
+    return impl->kernel.ApplicationProcess()->GetProgramId();
 }
 
 Loader::ResultStatus System::GetGameName(std::string& out) const {
@@ -794,7 +794,7 @@ FileSys::VirtualFilesystem System::GetFilesystem() const {
 }
 
 void System::RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
-                               const std::array<u8, 32>& build_id, VAddr main_region_begin,
+                               const std::array<u8, 32>& build_id, u64 main_region_begin,
                                u64 main_region_size) {
     impl->cheat_engine = std::make_unique<Memory::CheatEngine>(*this, list, build_id);
     impl->cheat_engine->SetMainMemoryParameters(main_region_begin, main_region_size);

src/core/core.h

@@ -146,7 +146,7 @@ public:
 
     /**
      * Initializes the system
-     * This function will initialize core functionaility used for system emulation
+     * This function will initialize core functionality used for system emulation
      */
     void Initialize();
 
@@ -172,7 +172,7 @@ public:
      */
     void InvalidateCpuInstructionCaches();
 
-    void InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size);
+    void InvalidateCpuInstructionCacheRange(u64 addr, std::size_t size);
 
     /// Shutdown the main emulated process.
     void ShutdownMainProcess();
@@ -256,10 +256,10 @@ public:
     [[nodiscard]] const ExclusiveMonitor& Monitor() const;
 
     /// Gets a mutable reference to the system memory instance.
-    [[nodiscard]] Core::Memory::Memory& Memory();
+    [[nodiscard]] Core::Memory::Memory& ApplicationMemory();
 
     /// Gets a constant reference to the system memory instance.
-    [[nodiscard]] const Core::Memory::Memory& Memory() const;
+    [[nodiscard]] const Core::Memory::Memory& ApplicationMemory() const;
 
     /// Gets a mutable reference to the GPU interface
     [[nodiscard]] Tegra::GPU& GPU();
@@ -353,7 +353,7 @@ public:
     [[nodiscard]] FileSys::VirtualFilesystem GetFilesystem() const;
 
     void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
-                           const std::array<u8, 0x20>& build_id, VAddr main_region_begin,
+                           const std::array<u8, 0x20>& build_id, u64 main_region_begin,
                            u64 main_region_size);
 
     void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);

src/core/core_timing.cpp

@@ -10,6 +10,10 @@
 #include "common/windows/timer_resolution.h"
 #endif
 
+#ifdef ARCHITECTURE_x86_64
+#include "common/x64/cpu_wait.h"
+#endif
+
 #include "common/microprofile.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
@@ -53,7 +57,7 @@ void CoreTiming::ThreadEntry(CoreTiming& instance) {
     static constexpr char name[] = "HostTiming";
     MicroProfileOnThreadCreate(name);
     Common::SetCurrentThreadName(name);
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
     instance.on_thread_init();
     instance.ThreadLoop();
     MicroProfileOnThreadExit();
@@ -269,7 +273,11 @@ void CoreTiming::ThreadLoop() {
                         if (wait_time >= timer_resolution_ns) {
                             Common::Windows::SleepForOneTick();
                         } else {
+#ifdef ARCHITECTURE_x86_64
+                            Common::X64::MicroSleep();
+#else
                             std::this_thread::yield();
+#endif
                         }
                     }
 

src/core/core_timing.h

@@ -150,7 +150,7 @@ private:
     // The queue is a min-heap using std::make_heap/push_heap/pop_heap.
     // We don't use std::priority_queue because we need to be able to serialize, unserialize and
     // erase arbitrary events (RemoveEvent()) regardless of the queue order. These aren't
-    // accomodated by the standard adaptor class.
+    // accommodated by the standard adaptor class.
     std::vector<Event> event_queue;
     u64 event_fifo_id = 0;
 

src/core/cpu_manager.cpp

@@ -192,7 +192,7 @@ void CpuManager::RunThread(std::stop_token token, std::size_t core) {
     }
     MicroProfileOnThreadCreate(name.c_str());
     Common::SetCurrentThreadName(name.c_str());
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
     auto& data = core_data[core];
     data.host_context = Common::Fiber::ThreadToFiber();
 

src/core/crypto/ctr_encryption_layer.h

@@ -11,7 +11,7 @@
 
 namespace Core::Crypto {
 
-// Sits on top of a VirtualFile and provides CTR-mode AES decription.
+// Sits on top of a VirtualFile and provides CTR-mode AES description.
 class CTREncryptionLayer : public EncryptionLayer {
 public:
     using IVData = std::array<u8, 16>;

src/core/crypto/key_manager.h

@@ -249,7 +249,7 @@ public:
 
     static bool KeyFileExists(bool title);
 
-    // Call before using the sd seed to attempt to derive it if it dosen't exist. Needs system
+    // Call before using the sd seed to attempt to derive it if it doesn't exist. Needs system
     // save 8*43 and the private file to exist.
     void DeriveSDSeedLazy();
 

src/core/crypto/xts_encryption_layer.h

@@ -9,7 +9,7 @@
 
 namespace Core::Crypto {
 
-// Sits on top of a VirtualFile and provides XTS-mode AES decription.
+// Sits on top of a VirtualFile and provides XTS-mode AES description.
 class XTSEncryptionLayer : public EncryptionLayer {
 public:
     XTSEncryptionLayer(FileSys::VirtualFile base, Key256 key);

src/core/debugger/gdbstub.cpp

@@ -118,14 +118,14 @@ void GDBStub::Watchpoint(Kernel::KThread* thread, const Kernel::DebugWatchpoint&
 
     switch (watch.type) {
     case Kernel::DebugWatchpointType::Read:
-        SendReply(fmt::format("{}rwatch:{:x};", status, watch.start_address));
+        SendReply(fmt::format("{}rwatch:{:x};", status, GetInteger(watch.start_address)));
         break;
     case Kernel::DebugWatchpointType::Write:
-        SendReply(fmt::format("{}watch:{:x};", status, watch.start_address));
+        SendReply(fmt::format("{}watch:{:x};", status, GetInteger(watch.start_address)));
         break;
     case Kernel::DebugWatchpointType::ReadOrWrite:
     default:
-        SendReply(fmt::format("{}awatch:{:x};", status, watch.start_address));
+        SendReply(fmt::format("{}awatch:{:x};", status, GetInteger(watch.start_address)));
         break;
     }
 }
@@ -261,9 +261,9 @@ void GDBStub::ExecuteCommand(std::string_view packet, std::vector<DebuggerAction
         const size_t addr{static_cast<size_t>(strtoll(command.data(), nullptr, 16))};
         const size_t size{static_cast<size_t>(strtoll(command.data() + sep, nullptr, 16))};
 
-        if (system.Memory().IsValidVirtualAddressRange(addr, size)) {
+        if (system.ApplicationMemory().IsValidVirtualAddressRange(addr, size)) {
             std::vector<u8> mem(size);
-            system.Memory().ReadBlock(addr, mem.data(), size);
+            system.ApplicationMemory().ReadBlock(addr, mem.data(), size);
 
             SendReply(Common::HexToString(mem));
         } else {
@@ -281,8 +281,8 @@ void GDBStub::ExecuteCommand(std::string_view packet, std::vector<DebuggerAction
         const auto mem_substr{std::string_view(command).substr(mem_sep)};
         const auto mem{Common::HexStringToVector(mem_substr, false)};
 
-        if (system.Memory().IsValidVirtualAddressRange(addr, size)) {
-            system.Memory().WriteBlock(addr, mem.data(), size);
+        if (system.ApplicationMemory().IsValidVirtualAddressRange(addr, size)) {
+            system.ApplicationMemory().WriteBlock(addr, mem.data(), size);
             system.InvalidateCpuInstructionCacheRange(addr, size);
             SendReply(GDB_STUB_REPLY_OK);
         } else {
@@ -325,7 +325,7 @@ void GDBStub::HandleBreakpointInsert(std::string_view command) {
     const size_t addr{static_cast<size_t>(strtoll(command.data() + addr_sep, nullptr, 16))};
     const size_t size{static_cast<size_t>(strtoll(command.data() + size_sep, nullptr, 16))};
 
-    if (!system.Memory().IsValidVirtualAddressRange(addr, size)) {
+    if (!system.ApplicationMemory().IsValidVirtualAddressRange(addr, size)) {
         SendReply(GDB_STUB_REPLY_ERR);
         return;
     }
@@ -334,22 +334,22 @@ void GDBStub::HandleBreakpointInsert(std::string_view command) {
 
     switch (type) {
     case BreakpointType::Software:
-        replaced_instructions[addr] = system.Memory().Read32(addr);
-        system.Memory().Write32(addr, arch->BreakpointInstruction());
+        replaced_instructions[addr] = system.ApplicationMemory().Read32(addr);
+        system.ApplicationMemory().Write32(addr, arch->BreakpointInstruction());
         system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32));
         success = true;
         break;
     case BreakpointType::WriteWatch:
-        success = system.ApplicationProcess()->InsertWatchpoint(system, addr, size,
+        success = system.ApplicationProcess()->InsertWatchpoint(addr, size,
                                                                 Kernel::DebugWatchpointType::Write);
         break;
     case BreakpointType::ReadWatch:
-        success = system.ApplicationProcess()->InsertWatchpoint(system, addr, size,
+        success = system.ApplicationProcess()->InsertWatchpoint(addr, size,
                                                                 Kernel::DebugWatchpointType::Read);
         break;
     case BreakpointType::AccessWatch:
         success = system.ApplicationProcess()->InsertWatchpoint(
-            system, addr, size, Kernel::DebugWatchpointType::ReadOrWrite);
+            addr, size, Kernel::DebugWatchpointType::ReadOrWrite);
         break;
     case BreakpointType::Hardware:
     default:
@@ -372,7 +372,7 @@ void GDBStub::HandleBreakpointRemove(std::string_view command) {
     const size_t addr{static_cast<size_t>(strtoll(command.data() + addr_sep, nullptr, 16))};
     const size_t size{static_cast<size_t>(strtoll(command.data() + size_sep, nullptr, 16))};
 
-    if (!system.Memory().IsValidVirtualAddressRange(addr, size)) {
+    if (!system.ApplicationMemory().IsValidVirtualAddressRange(addr, size)) {
         SendReply(GDB_STUB_REPLY_ERR);
         return;
     }
@@ -383,7 +383,7 @@ void GDBStub::HandleBreakpointRemove(std::string_view command) {
     case BreakpointType::Software: {
         const auto orig_insn{replaced_instructions.find(addr)};
         if (orig_insn != replaced_instructions.end()) {
-            system.Memory().Write32(addr, orig_insn->second);
+            system.ApplicationMemory().Write32(addr, orig_insn->second);
             system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32));
             replaced_instructions.erase(addr);
             success = true;
@@ -391,16 +391,16 @@ void GDBStub::HandleBreakpointRemove(std::string_view command) {
         break;
     }
     case BreakpointType::WriteWatch:
-        success = system.ApplicationProcess()->RemoveWatchpoint(system, addr, size,
+        success = system.ApplicationProcess()->RemoveWatchpoint(addr, size,
                                                                 Kernel::DebugWatchpointType::Write);
         break;
     case BreakpointType::ReadWatch:
-        success = system.ApplicationProcess()->RemoveWatchpoint(system, addr, size,
+        success = system.ApplicationProcess()->RemoveWatchpoint(addr, size,
                                                                 Kernel::DebugWatchpointType::Read);
         break;
     case BreakpointType::AccessWatch:
         success = system.ApplicationProcess()->RemoveWatchpoint(
-            system, addr, size, Kernel::DebugWatchpointType::ReadOrWrite);
+            addr, size, Kernel::DebugWatchpointType::ReadOrWrite);
         break;
     case BreakpointType::Hardware:
     default:
@@ -421,7 +421,7 @@ void GDBStub::HandleBreakpointRemove(std::string_view command) {
 static std::optional<std::string> GetNameFromThreadType32(Core::Memory::Memory& memory,
                                                           const Kernel::KThread* thread) {
     // Read thread type from TLS
-    const VAddr tls_thread_type{memory.Read32(thread->GetTLSAddress() + 0x1fc)};
+    const VAddr tls_thread_type{memory.Read32(thread->GetTlsAddress() + 0x1fc)};
     const VAddr argument_thread_type{thread->GetArgument()};
 
     if (argument_thread_type && tls_thread_type != argument_thread_type) {
@@ -452,7 +452,7 @@ static std::optional<std::string> GetNameFromThreadType32(Core::Memory::Memory&
 static std::optional<std::string> GetNameFromThreadType64(Core::Memory::Memory& memory,
                                                           const Kernel::KThread* thread) {
     // Read thread type from TLS
-    const VAddr tls_thread_type{memory.Read64(thread->GetTLSAddress() + 0x1f8)};
+    const VAddr tls_thread_type{memory.Read64(thread->GetTlsAddress() + 0x1f8)};
     const VAddr argument_thread_type{thread->GetArgument()};
 
     if (argument_thread_type && tls_thread_type != argument_thread_type) {
@@ -483,9 +483,9 @@ static std::optional<std::string> GetNameFromThreadType64(Core::Memory::Memory&
 static std::optional<std::string> GetThreadName(Core::System& system,
                                                 const Kernel::KThread* thread) {
     if (system.ApplicationProcess()->Is64BitProcess()) {
-        return GetNameFromThreadType64(system.Memory(), thread);
+        return GetNameFromThreadType64(system.ApplicationMemory(), thread);
     } else {
-        return GetNameFromThreadType32(system.Memory(), thread);
+        return GetNameFromThreadType32(system.ApplicationMemory(), thread);
     }
 }
 
@@ -554,8 +554,9 @@ void GDBStub::HandleQuery(std::string_view command) {
         if (main != modules.end()) {
             SendReply(fmt::format("TextSeg={:x}", main->first));
         } else {
-            SendReply(fmt::format("TextSeg={:x}",
-                                  system.ApplicationProcess()->PageTable().GetCodeRegionStart()));
+            SendReply(fmt::format(
+                "TextSeg={:x}",
+                GetInteger(system.ApplicationProcess()->PageTable().GetCodeRegionStart())));
         }
     } else if (command.starts_with("Xfer:libraries:read::")) {
         Loader::AppLoader::Modules modules;
@@ -576,7 +577,7 @@ void GDBStub::HandleQuery(std::string_view command) {
         const auto& threads = system.ApplicationProcess()->GetThreadList();
         std::vector<std::string> thread_ids;
         for (const auto& thread : threads) {
-            thread_ids.push_back(fmt::format("{:x}", thread->GetThreadID()));
+            thread_ids.push_back(fmt::format("{:x}", thread->GetThreadId()));
         }
         SendReply(fmt::format("m{}", fmt::join(thread_ids, ",")));
     } else if (command.starts_with("sThreadInfo")) {
@@ -591,11 +592,11 @@ void GDBStub::HandleQuery(std::string_view command) {
         for (const auto* thread : threads) {
             auto thread_name{GetThreadName(system, thread)};
             if (!thread_name) {
-                thread_name = fmt::format("Thread {:d}", thread->GetThreadID());
+                thread_name = fmt::format("Thread {:d}", thread->GetThreadId());
             }
 
             buffer += fmt::format(R"(<thread id="{:x}" core="{:d}" name="{}">{}</thread>)",
-                                  thread->GetThreadID(), thread->GetActiveCore(),
+                                  thread->GetThreadId(), thread->GetActiveCore(),
                                   EscapeXML(*thread_name), GetThreadState(thread));
         }
 
@@ -756,18 +757,21 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
 
         reply = fmt::format("Process:     {:#x} ({})\n"
                             "Program Id:  {:#018x}\n",
-                            process->GetProcessID(), process->GetName(), process->GetProgramID());
-        reply +=
-            fmt::format("Layout:\n"
-                        "  Alias: {:#012x} - {:#012x}\n"
-                        "  Heap:  {:#012x} - {:#012x}\n"
-                        "  Aslr:  {:#012x} - {:#012x}\n"
-                        "  Stack: {:#012x} - {:#012x}\n"
-                        "Modules:\n",
-                        page_table.GetAliasRegionStart(), page_table.GetAliasRegionEnd(),
-                        page_table.GetHeapRegionStart(), page_table.GetHeapRegionEnd(),
-                        page_table.GetAliasCodeRegionStart(), page_table.GetAliasCodeRegionEnd(),
-                        page_table.GetStackRegionStart(), page_table.GetStackRegionEnd());
+                            process->GetProcessId(), process->GetName(), process->GetProgramId());
+        reply += fmt::format("Layout:\n"
+                             "  Alias: {:#012x} - {:#012x}\n"
+                             "  Heap:  {:#012x} - {:#012x}\n"
+                             "  Aslr:  {:#012x} - {:#012x}\n"
+                             "  Stack: {:#012x} - {:#012x}\n"
+                             "Modules:\n",
+                             GetInteger(page_table.GetAliasRegionStart()),
+                             GetInteger(page_table.GetAliasRegionEnd()),
+                             GetInteger(page_table.GetHeapRegionStart()),
+                             GetInteger(page_table.GetHeapRegionEnd()),
+                             GetInteger(page_table.GetAliasCodeRegionStart()),
+                             GetInteger(page_table.GetAliasCodeRegionEnd()),
+                             GetInteger(page_table.GetStackRegionStart()),
+                             GetInteger(page_table.GetStackRegionEnd()));
 
         for (const auto& [vaddr, name] : modules) {
             reply += fmt::format("  {:#012x} - {:#012x} {}\n", vaddr,
@@ -819,7 +823,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
 Kernel::KThread* GDBStub::GetThreadByID(u64 thread_id) {
     const auto& threads{system.ApplicationProcess()->GetThreadList()};
     for (auto* thread : threads) {
-        if (thread->GetThreadID() == thread_id) {
+        if (thread->GetThreadId() == thread_id) {
             return thread;
         }
     }

src/core/debugger/gdbstub_arch.cpp

@@ -259,7 +259,7 @@ void GDBStubA64::WriteRegisters(Kernel::KThread* thread, std::string_view regist
 std::string GDBStubA64::ThreadStatus(const Kernel::KThread* thread, u8 signal) const {
     return fmt::format("T{:02x}{:02x}:{};{:02x}:{};{:02x}:{};thread:{:x};", signal, PC_REGISTER,
                        RegRead(thread, PC_REGISTER), SP_REGISTER, RegRead(thread, SP_REGISTER),
-                       LR_REGISTER, RegRead(thread, LR_REGISTER), thread->GetThreadID());
+                       LR_REGISTER, RegRead(thread, LR_REGISTER), thread->GetThreadId());
 }
 
 u32 GDBStubA64::BreakpointInstruction() const {
@@ -469,7 +469,7 @@ void GDBStubA32::WriteRegisters(Kernel::KThread* thread, std::string_view regist
 std::string GDBStubA32::ThreadStatus(const Kernel::KThread* thread, u8 signal) const {
     return fmt::format("T{:02x}{:02x}:{};{:02x}:{};{:02x}:{};thread:{:x};", signal, PC_REGISTER,
                        RegRead(thread, PC_REGISTER), SP_REGISTER, RegRead(thread, SP_REGISTER),
-                       LR_REGISTER, RegRead(thread, LR_REGISTER), thread->GetThreadID());
+                       LR_REGISTER, RegRead(thread, LR_REGISTER), thread->GetThreadId());
 }
 
 u32 GDBStubA32::BreakpointInstruction() const {

src/core/device_memory.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
-#include "common/common_types.h"
 #include "common/host_memory.h"
+#include "common/typed_address.h"
 
 namespace Core {
 
@@ -25,20 +25,22 @@ public:
     DeviceMemory(const DeviceMemory&) = delete;
 
     template <typename T>
-    PAddr GetPhysicalAddr(const T* ptr) const {
+    Common::PhysicalAddress GetPhysicalAddr(const T* ptr) const {
         return (reinterpret_cast<uintptr_t>(ptr) -
                 reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
                DramMemoryMap::Base;
     }
 
     template <typename T>
-    T* GetPointer(PAddr addr) {
-        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (addr - DramMemoryMap::Base));
+    T* GetPointer(Common::PhysicalAddress addr) {
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() +
+                                    (GetInteger(addr) - DramMemoryMap::Base));
     }
 
     template <typename T>
-    const T* GetPointer(PAddr addr) const {
-        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (addr - DramMemoryMap::Base));
+    const T* GetPointer(Common::PhysicalAddress addr) const {
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() +
+                                    (GetInteger(addr) - DramMemoryMap::Base));
     }
 
     Common::HostMemory buffer;

src/core/file_sys/content_archive.h

@@ -93,7 +93,7 @@ inline bool IsDirectoryLogoPartition(const VirtualDir& pfs) {
            pfs->GetFile("StartupMovie.gif") != nullptr;
 }
 
-// An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) conatiner.
+// An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) container.
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
 public:

src/core/file_sys/registered_cache.h

@@ -162,7 +162,7 @@ public:
     InstallResult InstallEntry(const NSP& nsp, bool overwrite_if_exists = false,
                                const VfsCopyFunction& copy = &VfsRawCopy);
 
-    // Due to the fact that we must use Meta-type NCAs to determine the existance of files, this
+    // Due to the fact that we must use Meta-type NCAs to determine the existence of files, this
     // poses quite a challenge. Instead of creating a new meta NCA for this file, yuzu will create a
     // dir inside the NAND called 'yuzu_meta' and store the raw CNMT there.
     // TODO(DarkLordZach): Author real meta-type NCAs and install those.

src/core/file_sys/vfs.h

@@ -45,7 +45,7 @@ public:
     // Return whether or not the user has write permission on this filesystem.
     virtual bool IsWritable() const;
 
-    // Determine if the entry at path is non-existant, a file, or a directory.
+    // Determine if the entry at path is non-existent, a file, or a directory.
     virtual VfsEntryType GetEntryType(std::string_view path) const;
 
     // Opens the file with path relative to root. If it doesn't exist, returns nullptr.
@@ -58,7 +58,7 @@ public:
     // Moves the file from old_path to new_path, returning the moved file on success and nullptr on
     // failure.
     virtual VirtualFile MoveFile(std::string_view old_path, std::string_view new_path);
-    // Deletes the file with path relative to root, returing true on success.
+    // Deletes the file with path relative to root, returning true on success.
     virtual bool DeleteFile(std::string_view path);
 
     // Opens the directory with path relative to root. If it doesn't exist, returns nullptr.
@@ -71,7 +71,7 @@ public:
     // Moves the directory from old_path to new_path, returning the moved directory on success and
     // nullptr on failure.
     virtual VirtualDir MoveDirectory(std::string_view old_path, std::string_view new_path);
-    // Deletes the directory with path relative to root, returing true on success.
+    // Deletes the directory with path relative to root, returning true on success.
     virtual bool DeleteDirectory(std::string_view path);
 
 protected:
@@ -144,7 +144,7 @@ public:
         return Read(reinterpret_cast<u8*>(data), sizeof(T), offset);
     }
 
-    // Writes exactly one byte to offset in file and retuns whether or not the byte was written
+    // Writes exactly one byte to offset in file and returns whether or not the byte was written
     // successfully.
     virtual bool WriteByte(u8 data, std::size_t offset = 0);
     // Writes a vector of bytes to offset in file and returns the number of bytes successfully
@@ -191,13 +191,13 @@ public:
     VfsDirectory() = default;
     virtual ~VfsDirectory();
 
-    // Retrives the file located at path as if the current directory was root. Returns nullptr if
+    // Retrieves the file located at path as if the current directory was root. Returns nullptr if
     // not found.
     virtual VirtualFile GetFileRelative(std::string_view path) const;
     // Calls GetFileRelative(path) on the root of the current directory.
     virtual VirtualFile GetFileAbsolute(std::string_view path) const;
 
-    // Retrives the directory located at path as if the current directory was root. Returns nullptr
+    // Retrieves the directory located at path as if the current directory was root. Returns nullptr
     // if not found.
     virtual VirtualDir GetDirectoryRelative(std::string_view path) const;
     // Calls GetDirectoryRelative(path) on the root of the current directory.
@@ -205,7 +205,7 @@ public:
 
     // Returns a vector containing all of the files in this directory.
     virtual std::vector<VirtualFile> GetFiles() const = 0;
-    // Returns the file with filename matching name. Returns nullptr if directory dosen't have a
+    // Returns the file with filename matching name. Returns nullptr if directory doesn't have a
     // file with name.
     virtual VirtualFile GetFile(std::string_view name) const;
 
@@ -214,7 +214,7 @@ public:
 
     // Returns a vector containing all of the subdirectories in this directory.
     virtual std::vector<VirtualDir> GetSubdirectories() const = 0;
-    // Returns the directory with name matching name. Returns nullptr if directory dosen't have a
+    // Returns the directory with name matching name. Returns nullptr if directory doesn't have a
     // directory with name.
     virtual VirtualDir GetSubdirectory(std::string_view name) const;
 

src/core/file_sys/vfs_real.h

@@ -38,7 +38,7 @@ private:
     boost::container::flat_map<std::string, std::weak_ptr<Common::FS::IOFile>> cache;
 };
 
-// An implmentation of VfsFile that represents a file on the user's computer.
+// An implementation of VfsFile that represents a file on the user's computer.
 class RealVfsFile : public VfsFile {
     friend class RealVfsDirectory;
     friend class RealVfsFilesystem;

src/core/frontend/applets/applet.h

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+namespace Core::Frontend {
+
+class Applet {
+public:
+    virtual ~Applet() = default;
+    virtual void Close() const = 0;
+};
+
+} // namespace Core::Frontend

src/core/frontend/applets/cabinet.cpp

@@ -10,6 +10,8 @@ namespace Core::Frontend {
 
 CabinetApplet::~CabinetApplet() = default;
 
+void DefaultCabinetApplet::Close() const {}
+
 void DefaultCabinetApplet::ShowCabinetApplet(
     const CabinetCallback& callback, const CabinetParameters& parameters,
     std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const {

src/core/frontend/applets/cabinet.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <functional>
+#include "core/frontend/applets/applet.h"
 #include "core/hle/service/nfp/nfp_types.h"
 
 namespace Service::NFP {
@@ -20,7 +21,7 @@ struct CabinetParameters {
 
 using CabinetCallback = std::function<void(bool, const std::string&)>;
 
-class CabinetApplet {
+class CabinetApplet : public Applet {
 public:
     virtual ~CabinetApplet();
     virtual void ShowCabinetApplet(const CabinetCallback& callback,
@@ -30,6 +31,7 @@ public:
 
 class DefaultCabinetApplet final : public CabinetApplet {
 public:
+    void Close() const override;
     void ShowCabinetApplet(const CabinetCallback& callback, const CabinetParameters& parameters,
                            std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const override;
 };

src/core/frontend/applets/controller.cpp

@@ -16,6 +16,8 @@ DefaultControllerApplet::DefaultControllerApplet(HID::HIDCore& hid_core_) : hid_
 
 DefaultControllerApplet::~DefaultControllerApplet() = default;
 
+void DefaultControllerApplet::Close() const {}
+
 void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callback,
                                                      const ControllerParameters& parameters) const {
     LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");
@@ -69,7 +71,7 @@ void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callbac
         }
     }
 
-    callback();
+    callback(true);
 }
 
 } // namespace Core::Frontend

src/core/frontend/applets/controller.h

@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "common/common_types.h"
+#include "core/frontend/applets/applet.h"
 
 namespace Core::HID {
 class HIDCore;
@@ -34,9 +35,9 @@ struct ControllerParameters {
     bool allow_gamecube_controller{};
 };
 
-class ControllerApplet {
+class ControllerApplet : public Applet {
 public:
-    using ReconfigureCallback = std::function<void()>;
+    using ReconfigureCallback = std::function<void(bool)>;
 
     virtual ~ControllerApplet();
 
@@ -49,6 +50,7 @@ public:
     explicit DefaultControllerApplet(HID::HIDCore& hid_core_);
     ~DefaultControllerApplet() override;
 
+    void Close() const override;
     void ReconfigureControllers(ReconfigureCallback callback,
                                 const ControllerParameters& parameters) const override;
 

src/core/frontend/applets/error.cpp

@@ -8,6 +8,8 @@ namespace Core::Frontend {
 
 ErrorApplet::~ErrorApplet() = default;
 
+void DefaultErrorApplet::Close() const {}
+
 void DefaultErrorApplet::ShowError(Result error, FinishedCallback finished) const {
     LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
                  error.module.Value(), error.description.Value(), error.raw);

src/core/frontend/applets/error.h

@@ -6,11 +6,12 @@
 #include <chrono>
 #include <functional>
 
+#include "core/frontend/applets/applet.h"
 #include "core/hle/result.h"
 
 namespace Core::Frontend {
 
-class ErrorApplet {
+class ErrorApplet : public Applet {
 public:
     using FinishedCallback = std::function<void()>;
 
@@ -28,6 +29,7 @@ public:
 
 class DefaultErrorApplet final : public ErrorApplet {
 public:
+    void Close() const override;
     void ShowError(Result error, FinishedCallback finished) const override;
     void ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
                                 FinishedCallback finished) const override;

src/core/frontend/applets/general_frontend.cpp

@@ -10,6 +10,8 @@ ParentalControlsApplet::~ParentalControlsApplet() = default;
 
 DefaultParentalControlsApplet::~DefaultParentalControlsApplet() = default;
 
+void DefaultParentalControlsApplet::Close() const {}
+
 void DefaultParentalControlsApplet::VerifyPIN(std::function<void(bool)> finished,
                                               bool suspend_future_verification_temporarily) {
     LOG_INFO(Service_AM,
@@ -39,6 +41,8 @@ PhotoViewerApplet::~PhotoViewerApplet() = default;
 
 DefaultPhotoViewerApplet::~DefaultPhotoViewerApplet() = default;
 
+void DefaultPhotoViewerApplet::Close() const {}
+
 void DefaultPhotoViewerApplet::ShowPhotosForApplication(u64 title_id,
                                                         std::function<void()> finished) const {
     LOG_INFO(Service_AM,

src/core/frontend/applets/general_frontend.h

@@ -6,9 +6,11 @@
 #include <functional>
 #include "common/common_types.h"
 
+#include "core/frontend/applets/applet.h"
+
 namespace Core::Frontend {
 
-class ParentalControlsApplet {
+class ParentalControlsApplet : public Applet {
 public:
     virtual ~ParentalControlsApplet();
 
@@ -33,6 +35,7 @@ class DefaultParentalControlsApplet final : public ParentalControlsApplet {
 public:
     ~DefaultParentalControlsApplet() override;
 
+    void Close() const override;
     void VerifyPIN(std::function<void(bool)> finished,
                    bool suspend_future_verification_temporarily) override;
     void VerifyPINForSettings(std::function<void(bool)> finished) override;
@@ -40,7 +43,7 @@ public:
     void ChangePIN(std::function<void()> finished) override;
 };
 
-class PhotoViewerApplet {
+class PhotoViewerApplet : public Applet {
 public:
     virtual ~PhotoViewerApplet();
 
@@ -52,6 +55,7 @@ class DefaultPhotoViewerApplet final : public PhotoViewerApplet {
 public:
     ~DefaultPhotoViewerApplet() override;
 
+    void Close() const override;
     void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const override;
     void ShowAllPhotos(std::function<void()> finished) const override;
 };

src/core/frontend/applets/mii_edit.cpp

@@ -8,6 +8,8 @@ namespace Core::Frontend {
 
 MiiEditApplet::~MiiEditApplet() = default;
 
+void DefaultMiiEditApplet::Close() const {}
+
 void DefaultMiiEditApplet::ShowMiiEdit(const MiiEditCallback& callback) const {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 

src/core/frontend/applets/mii_edit.h

@@ -5,9 +5,11 @@
 
 #include <functional>
 
+#include "core/frontend/applets/applet.h"
+
 namespace Core::Frontend {
 
-class MiiEditApplet {
+class MiiEditApplet : public Applet {
 public:
     using MiiEditCallback = std::function<void()>;
 
@@ -18,6 +20,7 @@ public:
 
 class DefaultMiiEditApplet final : public MiiEditApplet {
 public:
+    void Close() const override;
     void ShowMiiEdit(const MiiEditCallback& callback) const override;
 };
 

src/core/frontend/applets/profile_select.cpp

@@ -9,6 +9,8 @@ namespace Core::Frontend {
 
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
+void DefaultProfileSelectApplet::Close() const {}
+
 void DefaultProfileSelectApplet::SelectProfile(SelectProfileCallback callback) const {
     Service::Account::ProfileManager manager;
     callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::UUID{}));

src/core/frontend/applets/profile_select.h

@@ -7,9 +7,11 @@
 #include <optional>
 #include "common/uuid.h"
 
+#include "core/frontend/applets/applet.h"
+
 namespace Core::Frontend {
 
-class ProfileSelectApplet {
+class ProfileSelectApplet : public Applet {
 public:
     using SelectProfileCallback = std::function<void(std::optional<Common::UUID>)>;
 
@@ -20,6 +22,7 @@ public:
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
+    void Close() const override;
     void SelectProfile(SelectProfileCallback callback) const override;
 };
 

src/core/frontend/applets/software_keyboard.cpp

@@ -13,6 +13,8 @@ SoftwareKeyboardApplet::~SoftwareKeyboardApplet() = default;
 
 DefaultSoftwareKeyboardApplet::~DefaultSoftwareKeyboardApplet() = default;
 
+void DefaultSoftwareKeyboardApplet::Close() const {}
+
 void DefaultSoftwareKeyboardApplet::InitializeKeyboard(
     bool is_inline, KeyboardInitializeParameters initialize_parameters,
     SubmitNormalCallback submit_normal_callback_, SubmitInlineCallback submit_inline_callback_) {

src/core/frontend/applets/software_keyboard.h

@@ -7,6 +7,7 @@
 
 #include "common/common_types.h"
 
+#include "core/frontend/applets/applet.h"
 #include "core/hle/service/am/applets/applet_software_keyboard_types.h"
 
 namespace Core::Frontend {
@@ -52,7 +53,7 @@ struct InlineTextParameters {
     s32 cursor_position;
 };
 
-class SoftwareKeyboardApplet {
+class SoftwareKeyboardApplet : public Applet {
 public:
     using SubmitInlineCallback =
         std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>;
@@ -84,6 +85,8 @@ class DefaultSoftwareKeyboardApplet final : public SoftwareKeyboardApplet {
 public:
     ~DefaultSoftwareKeyboardApplet() override;
 
+    void Close() const override;
+
     void InitializeKeyboard(bool is_inline, KeyboardInitializeParameters initialize_parameters,
                             SubmitNormalCallback submit_normal_callback_,
                             SubmitInlineCallback submit_inline_callback_) override;

src/core/frontend/applets/web_browser.cpp

@@ -10,6 +10,8 @@ WebBrowserApplet::~WebBrowserApplet() = default;
 
 DefaultWebBrowserApplet::~DefaultWebBrowserApplet() = default;
 
+void DefaultWebBrowserApplet::Close() const {}
+
 void DefaultWebBrowserApplet::OpenLocalWebPage(const std::string& local_url,
                                                ExtractROMFSCallback extract_romfs_callback,
                                                OpenWebPageCallback callback) const {

src/core/frontend/applets/web_browser.h

@@ -5,11 +5,12 @@
 
 #include <functional>
 
+#include "core/frontend/applets/applet.h"
 #include "core/hle/service/am/applets/applet_web_browser_types.h"
 
 namespace Core::Frontend {
 
-class WebBrowserApplet {
+class WebBrowserApplet : public Applet {
 public:
     using ExtractROMFSCallback = std::function<void()>;
     using OpenWebPageCallback =
@@ -29,6 +30,8 @@ class DefaultWebBrowserApplet final : public WebBrowserApplet {
 public:
     ~DefaultWebBrowserApplet() override;
 
+    void Close() const override;
+
     void OpenLocalWebPage(const std::string& local_url, ExtractROMFSCallback extract_romfs_callback,
                           OpenWebPageCallback callback) const override;
 

src/core/frontend/emu_window.h

@@ -205,7 +205,7 @@ protected:
     }
 
     /**
-     * Converts a screen postion into the equivalent touchscreen position.
+     * Converts a screen position into the equivalent touchscreen position.
      */
     std::pair<f32, f32> MapToTouchScreen(u32 framebuffer_x, u32 framebuffer_y) const;
 

src/core/hid/emulated_controller.h

@@ -132,7 +132,7 @@ struct ControllerStatus {
     RingAnalogValue ring_analog_value{};
     NfcValues nfc_values{};
 
-    // Data for HID serices
+    // Data for HID services
     HomeButtonState home_button_state{};
     CaptureButtonState capture_button_state{};
     NpadButtonState npad_button_state{};
@@ -357,7 +357,7 @@ public:
 
     /**
      * Sends a small vibration to the output device
-     * @return true if SetVibration was successfull
+     * @return true if SetVibration was successful
      */
     bool IsVibrationEnabled(std::size_t device_index);
 
@@ -373,7 +373,7 @@ public:
     /**
      * Sets the desired camera format to be polled from a controller
      * @param camera_format size of each frame
-     * @return true if SetCameraFormat was successfull
+     * @return true if SetCameraFormat was successful
      */
     bool SetCameraFormat(Core::IrSensor::ImageTransferProcessorFormat camera_format);
 

src/core/hid/emulated_devices.h

@@ -53,7 +53,7 @@ struct DeviceStatus {
     MouseWheelValues mouse_wheel_values{};
     MouseStickValue mouse_stick_value{};
 
-    // Data for HID serices
+    // Data for HID services
     KeyboardKey keyboard_state{};
     KeyboardModifier keyboard_moddifier_state{};
     MouseButton mouse_button_state{};
@@ -75,7 +75,7 @@ struct InterfaceUpdateCallback {
 class EmulatedDevices {
 public:
     /**
-     * Contains all input data related to external devices that aren't necesarily a controller
+     * Contains all input data related to external devices that aren't necessarily a controller
      * This includes devices such as the keyboard or mouse
      */
     explicit EmulatedDevices();

src/core/hid/input_converter.cpp

@@ -328,7 +328,7 @@ void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value) {
     // Apply center offset
     raw_value -= properties.offset;
 
-    // Set initial values to be formated
+    // Set initial values to be formatted
     value = raw_value;
 
     // Calculate vector size
@@ -398,7 +398,7 @@ void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogS
     raw_x = properties_x.inverted ? -raw_x : raw_x;
     raw_y = properties_y.inverted ? -raw_y : raw_y;
 
-    // Set initial values to be formated
+    // Set initial values to be formatted
     x = raw_x;
     y = raw_y;
 

src/core/hid/motion_input.h

@@ -84,7 +84,7 @@ private:
     // Gyroscope vector measurement in radians/s.
     Common::Vec3f gyro;
 
-    // Vector to be substracted from gyro measurements
+    // Vector to be subtracted from gyro measurements
     Common::Vec3f gyro_bias;
 
     // Minimum gyro amplitude to detect if the device is moving

src/core/hle/kernel/board/nintendo/nx/k_memory_layout.cpp

@@ -76,22 +76,24 @@ void SetupDevicePhysicalMemoryRegions(KMemoryLayout& memory_layout) {
 
 void SetupDramPhysicalMemoryRegions(KMemoryLayout& memory_layout) {
     const size_t intended_memory_size = KSystemControl::Init::GetIntendedMemorySize();
-    const PAddr physical_memory_base_address =
+    const KPhysicalAddress physical_memory_base_address =
         KSystemControl::Init::GetKernelPhysicalBaseAddress(DramPhysicalAddress);
 
     // Insert blocks into the tree.
     ASSERT(memory_layout.GetPhysicalMemoryRegionTree().Insert(
-        physical_memory_base_address, intended_memory_size, KMemoryRegionType_Dram));
+        GetInteger(physical_memory_base_address), intended_memory_size, KMemoryRegionType_Dram));
     ASSERT(memory_layout.GetPhysicalMemoryRegionTree().Insert(
-        physical_memory_base_address, ReservedEarlyDramSize, KMemoryRegionType_DramReservedEarly));
+        GetInteger(physical_memory_base_address), ReservedEarlyDramSize,
+        KMemoryRegionType_DramReservedEarly));
 
     // Insert the KTrace block at the end of Dram, if KTrace is enabled.
     static_assert(!IsKTraceEnabled || KTraceBufferSize > 0);
     if constexpr (IsKTraceEnabled) {
-        const PAddr ktrace_buffer_phys_addr =
+        const KPhysicalAddress ktrace_buffer_phys_addr =
             physical_memory_base_address + intended_memory_size - KTraceBufferSize;
         ASSERT(memory_layout.GetPhysicalMemoryRegionTree().Insert(
-            ktrace_buffer_phys_addr, KTraceBufferSize, KMemoryRegionType_KernelTraceBuffer));
+            GetInteger(ktrace_buffer_phys_addr), KTraceBufferSize,
+            KMemoryRegionType_KernelTraceBuffer));
     }
 }
 

src/core/hle/kernel/board/nintendo/nx/k_memory_layout.h

@@ -3,10 +3,10 @@
 
 #pragma once
 
-#include "common/common_types.h"
+#include "core/hle/kernel/k_typed_address.h"
 
 namespace Kernel {
 
-constexpr inline PAddr MainMemoryAddress = 0x80000000;
+constexpr inline KPhysicalAddress MainMemoryAddress = 0x80000000;
 
 } // namespace Kernel

src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp

@@ -61,7 +61,7 @@ size_t KSystemControl::Init::GetIntendedMemorySize() {
     }
 }
 
-PAddr KSystemControl::Init::GetKernelPhysicalBaseAddress(u64 base_address) {
+KPhysicalAddress KSystemControl::Init::GetKernelPhysicalBaseAddress(KPhysicalAddress base_address) {
     const size_t real_dram_size = KSystemControl::Init::GetRealMemorySize();
     const size_t intended_dram_size = KSystemControl::Init::GetIntendedMemorySize();
     if (intended_dram_size * 2 < real_dram_size) {

src/core/hle/kernel/board/nintendo/nx/k_system_control.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include "common/common_types.h"
+#include "core/hle/kernel/k_typed_address.h"
 
 namespace Kernel::Board::Nintendo::Nx {
 
@@ -18,7 +18,7 @@ public:
         // Initialization.
         static std::size_t GetRealMemorySize();
         static std::size_t GetIntendedMemorySize();
-        static PAddr GetKernelPhysicalBaseAddress(u64 base_address);
+        static KPhysicalAddress GetKernelPhysicalBaseAddress(KPhysicalAddress base_address);
         static bool ShouldIncreaseThreadResourceLimit();
         static std::size_t GetApplicationPoolSize();
         static std::size_t GetAppletPoolSize();

src/core/hle/kernel/code_set.h

@@ -5,7 +5,7 @@
 
 #include <cstddef>
 
-#include "common/common_types.h"
+#include "core/hle/kernel/k_typed_address.h"
 #include "core/hle/kernel/physical_memory.h"
 
 namespace Kernel {
@@ -36,7 +36,7 @@ struct CodeSet final {
         std::size_t offset = 0;
 
         /// The address to map this segment to.
-        VAddr addr = 0;
+        KProcessAddress addr = 0;
 
         /// The size of this segment in bytes.
         u32 size = 0;
@@ -82,7 +82,7 @@ struct CodeSet final {
     std::array<Segment, 3> segments;
 
     /// The entry point address for this code set.
-    VAddr entrypoint = 0;
+    KProcessAddress entrypoint = 0;
 };
 
 } // namespace Kernel

src/core/hle/kernel/global_scheduler_context.cpp

@@ -12,20 +12,19 @@
 
 namespace Kernel {
 
-GlobalSchedulerContext::GlobalSchedulerContext(KernelCore& kernel_)
-    : kernel{kernel_}, scheduler_lock{kernel_} {}
+GlobalSchedulerContext::GlobalSchedulerContext(KernelCore& kernel)
+    : m_kernel{kernel}, m_scheduler_lock{kernel} {}
 
 GlobalSchedulerContext::~GlobalSchedulerContext() = default;
 
 void GlobalSchedulerContext::AddThread(KThread* thread) {
-    std::scoped_lock lock{global_list_guard};
-    thread_list.push_back(thread);
+    std::scoped_lock lock{m_global_list_guard};
+    m_thread_list.push_back(thread);
 }
 
 void GlobalSchedulerContext::RemoveThread(KThread* thread) {
-    std::scoped_lock lock{global_list_guard};
-    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
-                      thread_list.end());
+    std::scoped_lock lock{m_global_list_guard};
+    std::erase(m_thread_list, thread);
 }
 
 void GlobalSchedulerContext::PreemptThreads() {
@@ -38,37 +37,37 @@ void GlobalSchedulerContext::PreemptThreads() {
         63,
     };
 
-    ASSERT(IsLocked());
+    ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));
     for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
         const u32 priority = preemption_priorities[core_id];
-        KScheduler::RotateScheduledQueue(kernel, core_id, priority);
+        KScheduler::RotateScheduledQueue(m_kernel, core_id, priority);
     }
 }
 
 bool GlobalSchedulerContext::IsLocked() const {
-    return scheduler_lock.IsLockedByCurrentThread();
+    return m_scheduler_lock.IsLockedByCurrentThread();
 }
 
 void GlobalSchedulerContext::RegisterDummyThreadForWakeup(KThread* thread) {
-    ASSERT(IsLocked());
+    ASSERT(this->IsLocked());
 
-    woken_dummy_threads.insert(thread);
+    m_woken_dummy_threads.insert(thread);
 }
 
 void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) {
-    ASSERT(IsLocked());
+    ASSERT(this->IsLocked());
 
-    woken_dummy_threads.erase(thread);
+    m_woken_dummy_threads.erase(thread);
 }
 
 void GlobalSchedulerContext::WakeupWaitingDummyThreads() {
-    ASSERT(IsLocked());
+    ASSERT(this->IsLocked());
 
-    for (auto* thread : woken_dummy_threads) {
+    for (auto* thread : m_woken_dummy_threads) {
         thread->DummyThreadEndWait();
     }
 
-    woken_dummy_threads.clear();
+    m_woken_dummy_threads.clear();
 }
 
 } // namespace Kernel