"Merge Tagged PR 1012"

.ci/yuzu-patreon-step2.yml

@@ -10,7 +10,6 @@ stages:
   jobs:
   - job: format
     displayName: 'clang'
-    continueOnError: true
     pool:
       vmImage: ubuntu-latest
     steps:

src/audio_core/audio_renderer.cpp

@@ -73,7 +73,7 @@ private:
     EffectInStatus info{};
 };
 AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, AudioRendererParameter params,
-                             std::shared_ptr<Kernel::WritableEvent> buffer_event,
+                             Kernel::SharedPtr<Kernel::WritableEvent> buffer_event,
                              std::size_t instance_number)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
       effects(params.effect_count) {

src/audio_core/audio_renderer.h

@@ -218,7 +218,8 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size
 class AudioRenderer {
 public:
     AudioRenderer(Core::Timing::CoreTiming& core_timing, AudioRendererParameter params,
-                  std::shared_ptr<Kernel::WritableEvent> buffer_event, std::size_t instance_number);
+                  Kernel::SharedPtr<Kernel::WritableEvent> buffer_event,
+                  std::size_t instance_number);
     ~AudioRenderer();
 
     std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);
@@ -234,7 +235,7 @@ private:
     class VoiceState;
 
     AudioRendererParameter worker_params;
-    std::shared_ptr<Kernel::WritableEvent> buffer_event;
+    Kernel::SharedPtr<Kernel::WritableEvent> buffer_event;
     std::vector<VoiceState> voices;
     std::vector<EffectState> effects;
     std::unique_ptr<AudioOut> audio_out;

src/audio_core/stream.cpp

@@ -37,7 +37,7 @@ Stream::Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format fo
     : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
       sink_stream{sink_stream}, core_timing{core_timing}, name{std::move(name_)} {
 
-    release_event = Core::Timing::CreateEvent(
+    release_event = core_timing.RegisterEvent(
         name, [this](u64 userdata, s64 cycles_late) { ReleaseActiveBuffer(); });
 }
 

src/audio_core/stream.h

@@ -98,19 +98,18 @@ private:
     /// Gets the number of core cycles when the specified buffer will be released
     s64 GetBufferReleaseCycles(const Buffer& buffer) const;
 
-    u32 sample_rate;                  ///< Sample rate of the stream
-    Format format;                    ///< Format of the stream
-    float game_volume = 1.0f;         ///< The volume the game currently has set
-    ReleaseCallback release_callback; ///< Buffer release callback for the stream
-    State state{State::Stopped};      ///< Playback state of the stream
-    std::shared_ptr<Core::Timing::EventType>
-        release_event;                      ///< Core timing release event for the stream
-    BufferPtr active_buffer;                ///< Actively playing buffer in the stream
-    std::queue<BufferPtr> queued_buffers;   ///< Buffers queued to be played in the stream
-    std::queue<BufferPtr> released_buffers; ///< Buffers recently released from the stream
-    SinkStream& sink_stream;                ///< Output sink for the stream
-    Core::Timing::CoreTiming& core_timing;  ///< Core timing instance.
-    std::string name;                       ///< Name of the stream, must be unique
+    u32 sample_rate;                          ///< Sample rate of the stream
+    Format format;                            ///< Format of the stream
+    float game_volume = 1.0f;                 ///< The volume the game currently has set
+    ReleaseCallback release_callback;         ///< Buffer release callback for the stream
+    State state{State::Stopped};              ///< Playback state of the stream
+    Core::Timing::EventType* release_event{}; ///< Core timing release event for the stream
+    BufferPtr active_buffer;                  ///< Actively playing buffer in the stream
+    std::queue<BufferPtr> queued_buffers;     ///< Buffers queued to be played in the stream
+    std::queue<BufferPtr> released_buffers;   ///< Buffers recently released from the stream
+    SinkStream& sink_stream;                  ///< Output sink for the stream
+    Core::Timing::CoreTiming& core_timing;    ///< Core timing instance.
+    std::string name;                         ///< Name of the stream, must be unique
 };
 
 using StreamPtr = std::shared_ptr<Stream>;

src/common/assert.h

@@ -37,10 +37,8 @@ __declspec(noinline, noreturn)
         LOG_CRITICAL(Debug, "Assertion Failed! " __VA_ARGS__);                                     \
     }
 
-#define UNREACHABLE()                                                                              \
-    { LOG_CRITICAL(Debug, "Unreachable code!"); }
-#define UNREACHABLE_MSG(...)                                                                       \
-    { LOG_CRITICAL(Debug, "Unreachable code!\n" __VA_ARGS__); }
+#define UNREACHABLE() ASSERT_MSG(false, "Unreachable code!")
+#define UNREACHABLE_MSG(...) ASSERT_MSG(false, __VA_ARGS__)
 
 #ifdef _DEBUG
 #define DEBUG_ASSERT(_a_) ASSERT(_a_)

src/core/core.h

@@ -7,7 +7,6 @@
 #include <cstddef>
 #include <memory>
 #include <string>
-#include <vector>
 
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"

src/core/core_timing.cpp

@@ -17,15 +17,11 @@ namespace Core::Timing {
 
 constexpr int MAX_SLICE_LENGTH = 10000;
 
-std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback) {
-    return std::make_shared<EventType>(std::move(callback), std::move(name));
-}
-
 struct CoreTiming::Event {
     s64 time;
     u64 fifo_order;
     u64 userdata;
-    std::weak_ptr<EventType> type;
+    const EventType* type;
 
     // Sort by time, unless the times are the same, in which case sort by
     // the order added to the queue
@@ -58,15 +54,36 @@ void CoreTiming::Initialize() {
     event_fifo_id = 0;
 
     const auto empty_timed_callback = [](u64, s64) {};
-    ev_lost = CreateEvent("_lost_event", empty_timed_callback);
+    ev_lost = RegisterEvent("_lost_event", empty_timed_callback);
 }
 
 void CoreTiming::Shutdown() {
     ClearPendingEvents();
+    UnregisterAllEvents();
 }
 
-void CoreTiming::ScheduleEvent(s64 cycles_into_future, const std::shared_ptr<EventType>& event_type,
-                               u64 userdata) {
+EventType* CoreTiming::RegisterEvent(const std::string& name, TimedCallback callback) {
+    std::lock_guard guard{inner_mutex};
+    // check for existing type with same name.
+    // we want event type names to remain unique so that we can use them for serialization.
+    ASSERT_MSG(event_types.find(name) == event_types.end(),
+               "CoreTiming Event \"{}\" is already registered. Events should only be registered "
+               "during Init to avoid breaking save states.",
+               name.c_str());
+
+    auto info = event_types.emplace(name, EventType{callback, nullptr});
+    EventType* event_type = &info.first->second;
+    event_type->name = &info.first->first;
+    return event_type;
+}
+
+void CoreTiming::UnregisterAllEvents() {
+    ASSERT_MSG(event_queue.empty(), "Cannot unregister events with events pending");
+    event_types.clear();
+}
+
+void CoreTiming::ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
+    ASSERT(event_type != nullptr);
     std::lock_guard guard{inner_mutex};
     const s64 timeout = GetTicks() + cycles_into_future;
 
@@ -76,15 +93,13 @@ void CoreTiming::ScheduleEvent(s64 cycles_into_future, const std::shared_ptr<Eve
     }
 
     event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type});
-
     std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
 }
 
-void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata) {
+void CoreTiming::UnscheduleEvent(const EventType* event_type, u64 userdata) {
     std::lock_guard guard{inner_mutex};
-
     const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
-        return e.type.lock().get() == event_type.get() && e.userdata == userdata;
+        return e.type == event_type && e.userdata == userdata;
     });
 
     // Removing random items breaks the invariant so we have to re-establish it.
@@ -115,12 +130,10 @@ void CoreTiming::ClearPendingEvents() {
     event_queue.clear();
 }
 
-void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
+void CoreTiming::RemoveEvent(const EventType* event_type) {
     std::lock_guard guard{inner_mutex};
-
-    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
-        return e.type.lock().get() == event_type.get();
-    });
+    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(),
+                                    [&](const Event& e) { return e.type == event_type; });
 
     // Removing random items breaks the invariant so we have to re-establish it.
     if (itr != event_queue.end()) {
@@ -168,11 +181,7 @@ void CoreTiming::Advance() {
         std::pop_heap(event_queue.begin(), event_queue.end(), std::greater<>());
         event_queue.pop_back();
         inner_mutex.unlock();
-
-        if (auto event_type{evt.type.lock()}) {
-            event_type->callback(evt.userdata, global_timer - evt.time);
-        }
-
+        evt.type->callback(evt.userdata, global_timer - evt.time);
         inner_mutex.lock();
     }
 

src/core/core_timing.h

@@ -6,12 +6,11 @@
 
 #include <chrono>
 #include <functional>
-#include <memory>
 #include <mutex>
 #include <optional>
 #include <string>
+#include <unordered_map>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/threadsafe_queue.h"
 
@@ -22,13 +21,10 @@ using TimedCallback = std::function<void(u64 userdata, s64 cycles_late)>;
 
 /// Contains the characteristics of a particular event.
 struct EventType {
-    EventType(TimedCallback&& callback, std::string&& name)
-        : callback{std::move(callback)}, name{std::move(name)} {}
-
     /// The event's callback function.
     TimedCallback callback;
     /// A pointer to the name of the event.
-    const std::string name;
+    const std::string* name;
 };
 
 /**
@@ -61,17 +57,31 @@ public:
     /// Tears down all timing related functionality.
     void Shutdown();
 
+    /// Registers a core timing event with the given name and callback.
+    ///
+    /// @param name     The name of the core timing event to register.
+    /// @param callback The callback to execute for the event.
+    ///
+    /// @returns An EventType instance representing the registered event.
+    ///
+    /// @pre The name of the event being registered must be unique among all
+    ///      registered events.
+    ///
+    EventType* RegisterEvent(const std::string& name, TimedCallback callback);
+
+    /// Unregisters all registered events thus far. Note: not thread unsafe
+    void UnregisterAllEvents();
+
     /// After the first Advance, the slice lengths and the downcount will be reduced whenever an
     /// event is scheduled earlier than the current values.
     ///
     /// Scheduling from a callback will not update the downcount until the Advance() completes.
-    void ScheduleEvent(s64 cycles_into_future, const std::shared_ptr<EventType>& event_type,
-                       u64 userdata = 0);
+    void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata = 0);
 
-    void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata);
+    void UnscheduleEvent(const EventType* event_type, u64 userdata);
 
     /// We only permit one event of each type in the queue at a time.
-    void RemoveEvent(const std::shared_ptr<EventType>& event_type);
+    void RemoveEvent(const EventType* event_type);
 
     void ForceExceptionCheck(s64 cycles);
 
@@ -138,18 +148,13 @@ private:
     std::vector<Event> event_queue;
     u64 event_fifo_id = 0;
 
-    std::shared_ptr<EventType> ev_lost;
+    // Stores each element separately as a linked list node so pointers to elements
+    // remain stable regardless of rehashes/resizing.
+    std::unordered_map<std::string, EventType> event_types;
+
+    EventType* ev_lost = nullptr;
 
     std::mutex inner_mutex;
 };
 
-/// Creates a core timing event with the given name and callback.
-///
-/// @param name     The name of the core timing event to create.
-/// @param callback The callback to execute for the event.
-///
-/// @returns An EventType instance representing the created event.
-///
-std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback);
-
 } // namespace Core::Timing

src/core/file_sys/directory.h

@@ -15,7 +15,7 @@
 
 namespace FileSys {
 
-enum class EntryType : u8 {
+enum EntryType : u8 {
     Directory = 0,
     File = 1,
 };

src/core/file_sys/patch_manager.cpp

@@ -76,7 +76,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
-        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
+        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
@@ -127,7 +127,7 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
     std::vector<VirtualFile> out;
     out.reserve(patch_dirs.size());
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend())
+        if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
             continue;
 
         auto exefs_dir = subdir->GetSubdirectory("exefs");
@@ -284,17 +284,12 @@ std::vector<Memory::CheatEntry> PatchManager::CreateCheatList(
         return {};
     }
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
 
     std::vector<Memory::CheatEntry> out;
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
-            continue;
-        }
-
         auto cheats_dir = subdir->GetSubdirectory("cheats");
         if (cheats_dir != nullptr) {
             auto res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, true);
@@ -336,9 +331,8 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
     layers.reserve(patch_dirs.size() + 1);
     layers_ext.reserve(patch_dirs.size() + 1);
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
+        if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
             continue;
-        }
 
         auto romfs_dir = subdir->GetSubdirectory("romfs");
         if (romfs_dir != nullptr)
@@ -387,7 +381,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
-        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
+        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
 
     if (!update_disabled && update != nullptr) {
         const auto new_nca = std::make_shared<NCA>(update, romfs, ivfc_offset);
@@ -437,7 +431,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
     auto [nacp, discard_icon_file] = update.GetControlMetadata();
 
     const auto update_disabled =
-        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
+        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
     const auto update_label = update_disabled ? "[D] Update" : "Update";
 
     if (nacp != nullptr) {

src/core/file_sys/romfs.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <memory>
-
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/file_sys/fsmitm_romfsbuild.h"
@@ -14,7 +12,7 @@
 #include "core/file_sys/vfs_vector.h"
 
 namespace FileSys {
-namespace {
+
 constexpr u32 ROMFS_ENTRY_EMPTY = 0xFFFFFFFF;
 
 struct TableLocation {
@@ -53,7 +51,7 @@ struct FileEntry {
 static_assert(sizeof(FileEntry) == 0x20, "FileEntry has incorrect size.");
 
 template <typename Entry>
-std::pair<Entry, std::string> GetEntry(const VirtualFile& file, std::size_t offset) {
+static std::pair<Entry, std::string> GetEntry(const VirtualFile& file, std::size_t offset) {
     Entry entry{};
     if (file->ReadObject(&entry, offset) != sizeof(Entry))
         return {};
@@ -101,7 +99,6 @@ void ProcessDirectory(VirtualFile file, std::size_t dir_offset, std::size_t file
         this_dir_offset = entry.first.sibling;
     }
 }
-} // Anonymous namespace
 
 VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
     RomFSHeader header{};

src/core/file_sys/romfs.h

@@ -5,6 +5,10 @@
 #pragma once
 
 #include <array>
+#include <map>
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {

src/core/hardware_interrupt_manager.cpp

@@ -11,12 +11,13 @@
 namespace Core::Hardware {
 
 InterruptManager::InterruptManager(Core::System& system_in) : system(system_in) {
-    gpu_interrupt_event = Core::Timing::CreateEvent("GPUInterrupt", [this](u64 message, s64) {
-        auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
-        const u32 syncpt = static_cast<u32>(message >> 32);
-        const u32 value = static_cast<u32>(message);
-        nvdrv->SignalGPUInterruptSyncpt(syncpt, value);
-    });
+    gpu_interrupt_event =
+        system.CoreTiming().RegisterEvent("GPUInterrupt", [this](u64 message, s64) {
+            auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
+            const u32 syncpt = static_cast<u32>(message >> 32);
+            const u32 value = static_cast<u32>(message);
+            nvdrv->SignalGPUInterruptSyncpt(syncpt, value);
+        });
 }
 
 InterruptManager::~InterruptManager() = default;

src/core/hardware_interrupt_manager.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <memory>
-
 #include "common/common_types.h"
 
 namespace Core {
@@ -27,7 +25,7 @@ public:
 
 private:
     Core::System& system;
-    std::shared_ptr<Core::Timing::EventType> gpu_interrupt_event;
+    Core::Timing::EventType* gpu_interrupt_event{};
 };
 
 } // namespace Core::Hardware

src/core/hle/ipc_helpers.h

@@ -203,10 +203,10 @@ public:
     void PushRaw(const T& value);
 
     template <typename... O>
-    void PushMoveObjects(std::shared_ptr<O>... pointers);
+    void PushMoveObjects(Kernel::SharedPtr<O>... pointers);
 
     template <typename... O>
-    void PushCopyObjects(std::shared_ptr<O>... pointers);
+    void PushCopyObjects(Kernel::SharedPtr<O>... pointers);
 
 private:
     u32 normal_params_size{};
@@ -298,7 +298,7 @@ void ResponseBuilder::Push(const First& first_value, const Other&... other_value
 }
 
 template <typename... O>
-inline void ResponseBuilder::PushCopyObjects(std::shared_ptr<O>... pointers) {
+inline void ResponseBuilder::PushCopyObjects(Kernel::SharedPtr<O>... pointers) {
     auto objects = {pointers...};
     for (auto& object : objects) {
         context->AddCopyObject(std::move(object));
@@ -306,7 +306,7 @@ inline void ResponseBuilder::PushCopyObjects(std::shared_ptr<O>... pointers) {
 }
 
 template <typename... O>
-inline void ResponseBuilder::PushMoveObjects(std::shared_ptr<O>... pointers) {
+inline void ResponseBuilder::PushMoveObjects(Kernel::SharedPtr<O>... pointers) {
     auto objects = {pointers...};
     for (auto& object : objects) {
         context->AddMoveObject(std::move(object));
@@ -357,10 +357,10 @@ public:
     T PopRaw();
 
     template <typename T>
-    std::shared_ptr<T> GetMoveObject(std::size_t index);
+    Kernel::SharedPtr<T> GetMoveObject(std::size_t index);
 
     template <typename T>
-    std::shared_ptr<T> GetCopyObject(std::size_t index);
+    Kernel::SharedPtr<T> GetCopyObject(std::size_t index);
 
     template <class T>
     std::shared_ptr<T> PopIpcInterface() {
@@ -465,12 +465,12 @@ void RequestParser::Pop(First& first_value, Other&... other_values) {
 }
 
 template <typename T>
-std::shared_ptr<T> RequestParser::GetMoveObject(std::size_t index) {
+Kernel::SharedPtr<T> RequestParser::GetMoveObject(std::size_t index) {
     return context->GetMoveObject<T>(index);
 }
 
 template <typename T>
-std::shared_ptr<T> RequestParser::GetCopyObject(std::size_t index) {
+Kernel::SharedPtr<T> RequestParser::GetCopyObject(std::size_t index) {
     return context->GetCopyObject<T>(index);
 }
 

src/core/hle/kernel/address_arbiter.cpp

@@ -21,7 +21,7 @@
 namespace Kernel {
 namespace {
 // Wake up num_to_wake (or all) threads in a vector.
-void WakeThreads(const std::vector<std::shared_ptr<Thread>>& waiting_threads, s32 num_to_wake) {
+void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
     auto& system = Core::System::GetInstance();
     // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
     // them all.
@@ -59,8 +59,7 @@ ResultCode AddressArbiter::SignalToAddress(VAddr address, SignalType type, s32 v
 }
 
 ResultCode AddressArbiter::SignalToAddressOnly(VAddr address, s32 num_to_wake) {
-    const std::vector<std::shared_ptr<Thread>> waiting_threads =
-        GetThreadsWaitingOnAddress(address);
+    const std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
     WakeThreads(waiting_threads, num_to_wake);
     return RESULT_SUCCESS;
 }
@@ -88,8 +87,7 @@ ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr a
     }
 
     // Get threads waiting on the address.
-    const std::vector<std::shared_ptr<Thread>> waiting_threads =
-        GetThreadsWaitingOnAddress(address);
+    const std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
 
     // Determine the modified value depending on the waiting count.
     s32 updated_value;
@@ -174,21 +172,21 @@ ResultCode AddressArbiter::WaitForAddressIfEqual(VAddr address, s32 value, s64 t
 }
 
 ResultCode AddressArbiter::WaitForAddressImpl(VAddr address, s64 timeout) {
-    Thread* current_thread = system.CurrentScheduler().GetCurrentThread();
+    SharedPtr<Thread> current_thread = system.CurrentScheduler().GetCurrentThread();
     current_thread->SetArbiterWaitAddress(address);
     current_thread->SetStatus(ThreadStatus::WaitArb);
     current_thread->InvalidateWakeupCallback();
+
     current_thread->WakeAfterDelay(timeout);
 
     system.PrepareReschedule(current_thread->GetProcessorID());
     return RESULT_TIMEOUT;
 }
 
-std::vector<std::shared_ptr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(
-    VAddr address) const {
+std::vector<SharedPtr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) const {
 
     // Retrieve all threads that are waiting for this address.
-    std::vector<std::shared_ptr<Thread>> threads;
+    std::vector<SharedPtr<Thread>> threads;
     const auto& scheduler = system.GlobalScheduler();
     const auto& thread_list = scheduler.GetThreadList();
 
@@ -200,7 +198,7 @@ std::vector<std::shared_ptr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(
 
     // Sort them by priority, such that the highest priority ones come first.
     std::sort(threads.begin(), threads.end(),
-              [](const std::shared_ptr<Thread>& lhs, const std::shared_ptr<Thread>& rhs) {
+              [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
                   return lhs->GetPriority() < rhs->GetPriority();
               });
 

src/core/hle/kernel/address_arbiter.h

@@ -72,7 +72,7 @@ private:
     ResultCode WaitForAddressImpl(VAddr address, s64 timeout);
 
     // Gets the threads waiting on an address.
-    std::vector<std::shared_ptr<Thread>> GetThreadsWaitingOnAddress(VAddr address) const;
+    std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address) const;
 
     Core::System& system;
 };

src/core/hle/kernel/client_port.cpp

@@ -15,11 +15,11 @@ namespace Kernel {
 ClientPort::ClientPort(KernelCore& kernel) : Object{kernel} {}
 ClientPort::~ClientPort() = default;
 
-std::shared_ptr<ServerPort> ClientPort::GetServerPort() const {
+SharedPtr<ServerPort> ClientPort::GetServerPort() const {
     return server_port;
 }
 
-ResultVal<std::shared_ptr<ClientSession>> ClientPort::Connect() {
+ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     // Note: Threads do not wait for the server endpoint to call
     // AcceptSession before returning from this call.
 
@@ -29,8 +29,7 @@ ResultVal<std::shared_ptr<ClientSession>> ClientPort::Connect() {
     active_sessions++;
 
     // Create a new session pair, let the created sessions inherit the parent port's HLE handler.
-    auto [server, client] =
-        ServerSession::CreateSessionPair(kernel, server_port->GetName(), SharedFrom(this));
+    auto [server, client] = ServerSession::CreateSessionPair(kernel, server_port->GetName(), this);
 
     if (server_port->HasHLEHandler()) {
         server_port->GetHLEHandler()->ClientConnected(server);

src/core/hle/kernel/client_port.h

@@ -17,9 +17,6 @@ class ServerPort;
 
 class ClientPort final : public Object {
 public:
-    explicit ClientPort(KernelCore& kernel);
-    ~ClientPort() override;
-
     friend class ServerPort;
     std::string GetTypeName() const override {
         return "ClientPort";
@@ -33,7 +30,7 @@ public:
         return HANDLE_TYPE;
     }
 
-    std::shared_ptr<ServerPort> GetServerPort() const;
+    SharedPtr<ServerPort> GetServerPort() const;
 
     /**
      * Creates a new Session pair, adds the created ServerSession to the associated ServerPort's
@@ -41,7 +38,7 @@ public:
      * waiting on it to awake.
      * @returns ClientSession The client endpoint of the created Session pair, or error code.
      */
-    ResultVal<std::shared_ptr<ClientSession>> Connect();
+    ResultVal<SharedPtr<ClientSession>> Connect();
 
     /**
      * Signifies that a previously active connection has been closed,
@@ -50,7 +47,10 @@ public:
     void ConnectionClosed();
 
 private:
-    std::shared_ptr<ServerPort> server_port; ///< ServerPort associated with this client port.
+    explicit ClientPort(KernelCore& kernel);
+    ~ClientPort() override;
+
+    SharedPtr<ServerPort> server_port; ///< ServerPort associated with this client port.
     u32 max_sessions = 0;    ///< Maximum number of simultaneous sessions the port can have
     u32 active_sessions = 0; ///< Number of currently open sessions to this port
     std::string name;        ///< Name of client port (optional)

src/core/hle/kernel/client_session.cpp

@@ -16,18 +16,25 @@ ClientSession::ClientSession(KernelCore& kernel) : Object{kernel} {}
 ClientSession::~ClientSession() {
     // This destructor will be called automatically when the last ClientSession handle is closed by
     // the emulated application.
-    if (auto server = parent->server.lock()) {
+
+    // A local reference to the ServerSession is necessary to guarantee it
+    // will be kept alive until after ClientDisconnected() returns.
+    SharedPtr<ServerSession> server = parent->server;
+    if (server) {
         server->ClientDisconnected();
     }
+
+    parent->client = nullptr;
 }
 
-ResultCode ClientSession::SendSyncRequest(Thread* thread) {
-    // Signal the server session that new data is available
-    if (auto server = parent->server.lock()) {
-        return server->HandleSyncRequest(SharedFrom(thread));
-    }
+ResultCode ClientSession::SendSyncRequest(SharedPtr<Thread> thread) {
+    // Keep ServerSession alive until we're done working with it.
+    SharedPtr<ServerSession> server = parent->server;
+    if (server == nullptr)
+        return ERR_SESSION_CLOSED_BY_REMOTE;
 
-    return ERR_SESSION_CLOSED_BY_REMOTE;
+    // Signal the server session that new data is available
+    return server->HandleSyncRequest(std::move(thread));
 }
 
 } // namespace Kernel

src/core/hle/kernel/client_session.h

@@ -19,9 +19,6 @@ class Thread;
 
 class ClientSession final : public Object {
 public:
-    explicit ClientSession(KernelCore& kernel);
-    ~ClientSession() override;
-
     friend class ServerSession;
 
     std::string GetTypeName() const override {
@@ -37,9 +34,12 @@ public:
         return HANDLE_TYPE;
     }
 
-    ResultCode SendSyncRequest(Thread* thread);
+    ResultCode SendSyncRequest(SharedPtr<Thread> thread);
 
 private:
+    explicit ClientSession(KernelCore& kernel);
+    ~ClientSession() override;
+
     /// The parent session, which links to the server endpoint.
     std::shared_ptr<Session> parent;
 

src/core/hle/kernel/handle_table.cpp

@@ -44,7 +44,7 @@ ResultCode HandleTable::SetSize(s32 handle_table_size) {
     return RESULT_SUCCESS;
 }
 
-ResultVal<Handle> HandleTable::Create(std::shared_ptr<Object> obj) {
+ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
     DEBUG_ASSERT(obj != nullptr);
 
     const u16 slot = next_free_slot;
@@ -70,7 +70,7 @@ ResultVal<Handle> HandleTable::Create(std::shared_ptr<Object> obj) {
 }
 
 ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
-    std::shared_ptr<Object> object = GetGeneric(handle);
+    SharedPtr<Object> object = GetGeneric(handle);
     if (object == nullptr) {
         LOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -99,11 +99,11 @@ bool HandleTable::IsValid(Handle handle) const {
     return slot < table_size && objects[slot] != nullptr && generations[slot] == generation;
 }
 
-std::shared_ptr<Object> HandleTable::GetGeneric(Handle handle) const {
+SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
     if (handle == CurrentThread) {
-        return SharedFrom(GetCurrentThread());
+        return GetCurrentThread();
     } else if (handle == CurrentProcess) {
-        return SharedFrom(Core::System::GetInstance().CurrentProcess());
+        return Core::System::GetInstance().CurrentProcess();
     }
 
     if (!IsValid(handle)) {

src/core/hle/kernel/handle_table.h

@@ -68,7 +68,7 @@ public:
      * @return The created Handle or one of the following errors:
      *           - `ERR_HANDLE_TABLE_FULL`: the maximum number of handles has been exceeded.
      */
-    ResultVal<Handle> Create(std::shared_ptr<Object> obj);
+    ResultVal<Handle> Create(SharedPtr<Object> obj);
 
     /**
      * Returns a new handle that points to the same object as the passed in handle.
@@ -92,7 +92,7 @@ public:
      * Looks up a handle.
      * @return Pointer to the looked-up object, or `nullptr` if the handle is not valid.
      */
-    std::shared_ptr<Object> GetGeneric(Handle handle) const;
+    SharedPtr<Object> GetGeneric(Handle handle) const;
 
     /**
      * Looks up a handle while verifying its type.
@@ -100,7 +100,7 @@ public:
      *         type differs from the requested one.
      */
     template <class T>
-    std::shared_ptr<T> Get(Handle handle) const {
+    SharedPtr<T> Get(Handle handle) const {
         return DynamicObjectCast<T>(GetGeneric(handle));
     }
 
@@ -109,7 +109,7 @@ public:
 
 private:
     /// Stores the Object referenced by the handle or null if the slot is empty.
-    std::array<std::shared_ptr<Object>, MAX_COUNT> objects;
+    std::array<SharedPtr<Object>, MAX_COUNT> objects;
 
     /**
      * The value of `next_generation` when the handle was created, used to check for validity. For

src/core/hle/kernel/hle_ipc.cpp

@@ -32,25 +32,23 @@ SessionRequestHandler::SessionRequestHandler() = default;
 
 SessionRequestHandler::~SessionRequestHandler() = default;
 
-void SessionRequestHandler::ClientConnected(std::shared_ptr<ServerSession> server_session) {
+void SessionRequestHandler::ClientConnected(SharedPtr<ServerSession> server_session) {
     server_session->SetHleHandler(shared_from_this());
     connected_sessions.push_back(std::move(server_session));
 }
 
-void SessionRequestHandler::ClientDisconnected(
-    const std::shared_ptr<ServerSession>& server_session) {
+void SessionRequestHandler::ClientDisconnected(const SharedPtr<ServerSession>& server_session) {
     server_session->SetHleHandler(nullptr);
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
-std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(
+SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
     const std::string& reason, u64 timeout, WakeupCallback&& callback,
-    std::shared_ptr<WritableEvent> writable_event) {
+    SharedPtr<WritableEvent> writable_event) {
     // Put the client thread to sleep until the wait event is signaled or the timeout expires.
-    thread->SetWakeupCallback([context = *this, callback](ThreadWakeupReason reason,
-                                                          std::shared_ptr<Thread> thread,
-                                                          std::shared_ptr<WaitObject> object,
-                                                          std::size_t index) mutable -> bool {
+    thread->SetWakeupCallback([context = *this, callback](
+                                  ThreadWakeupReason reason, SharedPtr<Thread> thread,
+                                  SharedPtr<WaitObject> object, std::size_t index) mutable -> bool {
         ASSERT(thread->GetStatus() == ThreadStatus::WaitHLEEvent);
         callback(thread, context, reason);
         context.WriteToOutgoingCommandBuffer(*thread);
@@ -77,8 +75,8 @@ std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(
     return writable_event;
 }
 
-HLERequestContext::HLERequestContext(std::shared_ptr<Kernel::ServerSession> server_session,
-                                     std::shared_ptr<Thread> thread)
+HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session,
+                                     SharedPtr<Thread> thread)
     : server_session(std::move(server_session)), thread(std::move(thread)) {
     cmd_buf[0] = 0;
 }

src/core/hle/kernel/hle_ipc.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <array>
-#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -61,20 +60,20 @@ public:
      * associated ServerSession alive for the duration of the connection.
      * @param server_session Owning pointer to the ServerSession associated with the connection.
      */
-    void ClientConnected(std::shared_ptr<ServerSession> server_session);
+    void ClientConnected(SharedPtr<ServerSession> server_session);
 
     /**
      * Signals that a client has just disconnected from this HLE handler and releases the
      * associated ServerSession.
      * @param server_session ServerSession associated with the connection.
      */
-    void ClientDisconnected(const std::shared_ptr<ServerSession>& server_session);
+    void ClientDisconnected(const SharedPtr<ServerSession>& server_session);
 
 protected:
     /// List of sessions that are connected to this handler.
     /// A ServerSession whose server endpoint is an HLE implementation is kept alive by this list
     /// for the duration of the connection.
-    std::vector<std::shared_ptr<ServerSession>> connected_sessions;
+    std::vector<SharedPtr<ServerSession>> connected_sessions;
 };
 
 /**
@@ -98,8 +97,7 @@ protected:
  */
 class HLERequestContext {
 public:
-    explicit HLERequestContext(std::shared_ptr<ServerSession> session,
-                               std::shared_ptr<Thread> thread);
+    explicit HLERequestContext(SharedPtr<ServerSession> session, SharedPtr<Thread> thread);
     ~HLERequestContext();
 
     /// Returns a pointer to the IPC command buffer for this request.
@@ -111,12 +109,12 @@ public:
      * Returns the session through which this request was made. This can be used as a map key to
      * access per-client data on services.
      */
-    const std::shared_ptr<Kernel::ServerSession>& Session() const {
+    const SharedPtr<Kernel::ServerSession>& Session() const {
         return server_session;
     }
 
-    using WakeupCallback = std::function<void(
-        std::shared_ptr<Thread> thread, HLERequestContext& context, ThreadWakeupReason reason)>;
+    using WakeupCallback = std::function<void(SharedPtr<Thread> thread, HLERequestContext& context,
+                                              ThreadWakeupReason reason)>;
 
     /**
      * Puts the specified guest thread to sleep until the returned event is signaled or until the
@@ -131,9 +129,9 @@ public:
      * created.
      * @returns Event that when signaled will resume the thread and call the callback function.
      */
-    std::shared_ptr<WritableEvent> SleepClientThread(
-        const std::string& reason, u64 timeout, WakeupCallback&& callback,
-        std::shared_ptr<WritableEvent> writable_event = nullptr);
+    SharedPtr<WritableEvent> SleepClientThread(const std::string& reason, u64 timeout,
+                                               WakeupCallback&& callback,
+                                               SharedPtr<WritableEvent> writable_event = nullptr);
 
     /// Populates this context with data from the requesting process/thread.
     ResultCode PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,
@@ -211,20 +209,20 @@ public:
     std::size_t GetWriteBufferSize(int buffer_index = 0) const;
 
     template <typename T>
-    std::shared_ptr<T> GetCopyObject(std::size_t index) {
+    SharedPtr<T> GetCopyObject(std::size_t index) {
         return DynamicObjectCast<T>(copy_objects.at(index));
     }
 
     template <typename T>
-    std::shared_ptr<T> GetMoveObject(std::size_t index) {
+    SharedPtr<T> GetMoveObject(std::size_t index) {
         return DynamicObjectCast<T>(move_objects.at(index));
     }
 
-    void AddMoveObject(std::shared_ptr<Object> object) {
+    void AddMoveObject(SharedPtr<Object> object) {
         move_objects.emplace_back(std::move(object));
     }
 
-    void AddCopyObject(std::shared_ptr<Object> object) {
+    void AddCopyObject(SharedPtr<Object> object) {
         copy_objects.emplace_back(std::move(object));
     }
 
@@ -268,11 +266,11 @@ private:
     void ParseCommandBuffer(const HandleTable& handle_table, u32_le* src_cmdbuf, bool incoming);
 
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
-    std::shared_ptr<Kernel::ServerSession> server_session;
-    std::shared_ptr<Thread> thread;
+    SharedPtr<Kernel::ServerSession> server_session;
+    SharedPtr<Thread> thread;
     // TODO(yuriks): Check common usage of this and optimize size accordingly
-    boost::container::small_vector<std::shared_ptr<Object>, 8> move_objects;
-    boost::container::small_vector<std::shared_ptr<Object>, 8> copy_objects;
+    boost::container::small_vector<SharedPtr<Object>, 8> move_objects;
+    boost::container::small_vector<SharedPtr<Object>, 8> copy_objects;
     boost::container::small_vector<std::shared_ptr<SessionRequestHandler>, 8> domain_objects;
 
     std::optional<IPC::CommandHeader> command_header;

src/core/hle/kernel/kernel.cpp

@@ -40,7 +40,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
     // Lock the global kernel mutex when we enter the kernel HLE.
     std::lock_guard lock{HLE::g_hle_lock};
 
-    std::shared_ptr<Thread> thread =
+    SharedPtr<Thread> thread =
         system.Kernel().RetrieveThreadFromWakeupCallbackHandleTable(proper_handle);
     if (thread == nullptr) {
         LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
@@ -53,7 +53,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
         thread->GetStatus() == ThreadStatus::WaitHLEEvent) {
         // Remove the thread from each of its waiting objects' waitlists
         for (const auto& object : thread->GetWaitObjects()) {
-            object->RemoveWaitingThread(thread);
+            object->RemoveWaitingThread(thread.get());
         }
         thread->ClearWaitObjects();
 
@@ -139,12 +139,12 @@ struct KernelCore::Impl {
 
     void InitializeThreads() {
         thread_wakeup_event_type =
-            Core::Timing::CreateEvent("ThreadWakeupCallback", ThreadWakeupCallback);
+            system.CoreTiming().RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
     }
 
     void InitializePreemption() {
-        preemption_event =
-            Core::Timing::CreateEvent("PreemptionCallback", [this](u64 userdata, s64 cycles_late) {
+        preemption_event = system.CoreTiming().RegisterEvent(
+            "PreemptionCallback", [this](u64 userdata, s64 cycles_late) {
                 global_scheduler.PreemptThreads();
                 s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
                 system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
@@ -160,15 +160,14 @@ struct KernelCore::Impl {
     std::atomic<u64> next_thread_id{1};
 
     // Lists all processes that exist in the current session.
-    std::vector<std::shared_ptr<Process>> process_list;
+    std::vector<SharedPtr<Process>> process_list;
     Process* current_process = nullptr;
     Kernel::GlobalScheduler global_scheduler;
 
-    std::shared_ptr<ResourceLimit> system_resource_limit;
-
-    std::shared_ptr<Core::Timing::EventType> thread_wakeup_event_type;
-    std::shared_ptr<Core::Timing::EventType> preemption_event;
+    SharedPtr<ResourceLimit> system_resource_limit;
 
+    Core::Timing::EventType* thread_wakeup_event_type = nullptr;
+    Core::Timing::EventType* preemption_event = nullptr;
     // TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future,
     // allowing us to simply use a pool index or similar.
     Kernel::HandleTable thread_wakeup_callback_handle_table;
@@ -194,16 +193,15 @@ void KernelCore::Shutdown() {
     impl->Shutdown();
 }
 
-std::shared_ptr<ResourceLimit> KernelCore::GetSystemResourceLimit() const {
+SharedPtr<ResourceLimit> KernelCore::GetSystemResourceLimit() const {
     return impl->system_resource_limit;
 }
 
-std::shared_ptr<Thread> KernelCore::RetrieveThreadFromWakeupCallbackHandleTable(
-    Handle handle) const {
+SharedPtr<Thread> KernelCore::RetrieveThreadFromWakeupCallbackHandleTable(Handle handle) const {
     return impl->thread_wakeup_callback_handle_table.Get<Thread>(handle);
 }
 
-void KernelCore::AppendNewProcess(std::shared_ptr<Process> process) {
+void KernelCore::AppendNewProcess(SharedPtr<Process> process) {
     impl->process_list.push_back(std::move(process));
 }
 
@@ -225,7 +223,7 @@ const Process* KernelCore::CurrentProcess() const {
     return impl->current_process;
 }
 
-const std::vector<std::shared_ptr<Process>>& KernelCore::GetProcessList() const {
+const std::vector<SharedPtr<Process>>& KernelCore::GetProcessList() const {
     return impl->process_list;
 }
 
@@ -237,7 +235,7 @@ const Kernel::GlobalScheduler& KernelCore::GlobalScheduler() const {
     return impl->global_scheduler;
 }
 
-void KernelCore::AddNamedPort(std::string name, std::shared_ptr<ClientPort> port) {
+void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
     impl->named_ports.emplace(std::move(name), std::move(port));
 }
 
@@ -270,7 +268,7 @@ u64 KernelCore::CreateNewUserProcessID() {
     return impl->next_user_process_id++;
 }
 
-const std::shared_ptr<Core::Timing::EventType>& KernelCore::ThreadWakeupCallbackEventType() const {
+Core::Timing::EventType* KernelCore::ThreadWakeupCallbackEventType() const {
     return impl->thread_wakeup_event_type;
 }
 

src/core/hle/kernel/kernel.h

@@ -6,7 +6,6 @@
 
 #include <string>
 #include <unordered_map>
-#include <vector>
 #include "core/hle/kernel/object.h"
 
 namespace Core {
@@ -31,7 +30,7 @@ class Thread;
 /// Represents a single instance of the kernel.
 class KernelCore {
 private:
-    using NamedPortTable = std::unordered_map<std::string, std::shared_ptr<ClientPort>>;
+    using NamedPortTable = std::unordered_map<std::string, SharedPtr<ClientPort>>;
 
 public:
     /// Constructs an instance of the kernel using the given System
@@ -57,13 +56,13 @@ public:
     void Shutdown();
 
     /// Retrieves a shared pointer to the system resource limit instance.
-    std::shared_ptr<ResourceLimit> GetSystemResourceLimit() const;
+    SharedPtr<ResourceLimit> GetSystemResourceLimit() const;
 
     /// Retrieves a shared pointer to a Thread instance within the thread wakeup handle table.
-    std::shared_ptr<Thread> RetrieveThreadFromWakeupCallbackHandleTable(Handle handle) const;
+    SharedPtr<Thread> RetrieveThreadFromWakeupCallbackHandleTable(Handle handle) const;
 
     /// Adds the given shared pointer to an internal list of active processes.
-    void AppendNewProcess(std::shared_ptr<Process> process);
+    void AppendNewProcess(SharedPtr<Process> process);
 
     /// Makes the given process the new current process.
     void MakeCurrentProcess(Process* process);
@@ -75,7 +74,7 @@ public:
     const Process* CurrentProcess() const;
 
     /// Retrieves the list of processes.
-    const std::vector<std::shared_ptr<Process>>& GetProcessList() const;
+    const std::vector<SharedPtr<Process>>& GetProcessList() const;
 
     /// Gets the sole instance of the global scheduler
     Kernel::GlobalScheduler& GlobalScheduler();
@@ -84,7 +83,7 @@ public:
     const Kernel::GlobalScheduler& GlobalScheduler() const;
 
     /// Adds a port to the named port table
-    void AddNamedPort(std::string name, std::shared_ptr<ClientPort> port);
+    void AddNamedPort(std::string name, SharedPtr<ClientPort> port);
 
     /// Finds a port within the named port table with the given name.
     NamedPortTable::iterator FindNamedPort(const std::string& name);
@@ -113,7 +112,7 @@ private:
     u64 CreateNewThreadID();
 
     /// Retrieves the event type used for thread wakeup callbacks.
-    const std::shared_ptr<Core::Timing::EventType>& ThreadWakeupCallbackEventType() const;
+    Core::Timing::EventType* ThreadWakeupCallbackEventType() const;
 
     /// Provides a reference to the thread wakeup callback handle table.
     Kernel::HandleTable& ThreadWakeupCallbackHandleTable();

src/core/hle/kernel/mutex.cpp

@@ -23,10 +23,10 @@ namespace Kernel {
 
 /// Returns the number of threads that are waiting for a mutex, and the highest priority one among
 /// those.
-static std::pair<std::shared_ptr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
-    Thread* current_thread, VAddr mutex_addr) {
+static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
+    const SharedPtr<Thread>& current_thread, VAddr mutex_addr) {
 
-    std::shared_ptr<Thread> highest_priority_thread;
+    SharedPtr<Thread> highest_priority_thread;
     u32 num_waiters = 0;
 
     for (const auto& thread : current_thread->GetMutexWaitingThreads()) {
@@ -46,7 +46,8 @@ static std::pair<std::shared_ptr<Thread>, u32> GetHighestPriorityMutexWaitingThr
 }
 
 /// Update the mutex owner field of all threads waiting on the mutex to point to the new owner.
-static void TransferMutexOwnership(VAddr mutex_addr, Thread* current_thread, Thread* new_owner) {
+static void TransferMutexOwnership(VAddr mutex_addr, SharedPtr<Thread> current_thread,
+                                   SharedPtr<Thread> new_owner) {
     const auto threads = current_thread->GetMutexWaitingThreads();
     for (const auto& thread : threads) {
         if (thread->GetMutexWaitAddress() != mutex_addr)
@@ -54,7 +55,7 @@ static void TransferMutexOwnership(VAddr mutex_addr, Thread* current_thread, Thr
 
         ASSERT(thread->GetLockOwner() == current_thread);
         current_thread->RemoveMutexWaiter(thread);
-        if (new_owner != thread.get())
+        if (new_owner != thread)
             new_owner->AddMutexWaiter(thread);
     }
 }
@@ -70,10 +71,9 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
     }
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    std::shared_ptr<Thread> current_thread =
-        SharedFrom(system.CurrentScheduler().GetCurrentThread());
-    std::shared_ptr<Thread> holding_thread = handle_table.Get<Thread>(holding_thread_handle);
-    std::shared_ptr<Thread> requesting_thread = handle_table.Get<Thread>(requesting_thread_handle);
+    Thread* const current_thread = system.CurrentScheduler().GetCurrentThread();
+    SharedPtr<Thread> holding_thread = handle_table.Get<Thread>(holding_thread_handle);
+    SharedPtr<Thread> requesting_thread = handle_table.Get<Thread>(requesting_thread_handle);
 
     // TODO(Subv): It is currently unknown if it is possible to lock a mutex in behalf of another
     // thread.
@@ -134,7 +134,7 @@ ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
     }
 
     // Transfer the ownership of the mutex from the previous owner to the new one.
-    TransferMutexOwnership(address, holding_thread, thread.get());
+    TransferMutexOwnership(address, holding_thread, thread);
 
     u32 mutex_value = thread->GetWaitHandle();
 

src/core/hle/kernel/object.h

@@ -5,9 +5,10 @@
 #pragma once
 
 #include <atomic>
-#include <memory>
 #include <string>
 
+#include <boost/smart_ptr/intrusive_ptr.hpp>
+
 #include "common/common_types.h"
 
 namespace Kernel {
@@ -31,7 +32,7 @@ enum class HandleType : u32 {
     ServerSession,
 };
 
-class Object : NonCopyable, public std::enable_shared_from_this<Object> {
+class Object : NonCopyable {
 public:
     explicit Object(KernelCore& kernel);
     virtual ~Object();
@@ -60,24 +61,35 @@ protected:
     KernelCore& kernel;
 
 private:
+    friend void intrusive_ptr_add_ref(Object*);
+    friend void intrusive_ptr_release(Object*);
+
+    std::atomic<u32> ref_count{0};
     std::atomic<u32> object_id{0};
 };
 
-template <typename T>
-std::shared_ptr<T> SharedFrom(T* raw) {
-    if (raw == nullptr)
-        return nullptr;
-    return std::static_pointer_cast<T>(raw->shared_from_this());
+// Special functions used by boost::instrusive_ptr to do automatic ref-counting
+inline void intrusive_ptr_add_ref(Object* object) {
+    object->ref_count.fetch_add(1, std::memory_order_relaxed);
 }
 
+inline void intrusive_ptr_release(Object* object) {
+    if (object->ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+        delete object;
+    }
+}
+
+template <typename T>
+using SharedPtr = boost::intrusive_ptr<T>;
+
 /**
  * Attempts to downcast the given Object pointer to a pointer to T.
  * @return Derived pointer to the object, or `nullptr` if `object` isn't of type T.
  */
 template <typename T>
-inline std::shared_ptr<T> DynamicObjectCast(std::shared_ptr<Object> object) {
+inline SharedPtr<T> DynamicObjectCast(SharedPtr<Object> object) {
     if (object != nullptr && object->GetHandleType() == T::HANDLE_TYPE) {
-        return std::static_pointer_cast<T>(object);
+        return boost::static_pointer_cast<T>(object);
     }
     return nullptr;
 }

src/core/hle/kernel/process.cpp

@@ -38,7 +38,7 @@ void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority) {
     auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0,
                                      owner_process.GetIdealCore(), stack_top, owner_process);
 
-    std::shared_ptr<Thread> thread = std::move(thread_res).Unwrap();
+    SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
     // Register 1 must be a handle to the main thread
     const Handle thread_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
@@ -100,10 +100,10 @@ private:
     std::bitset<num_slot_entries> is_slot_used;
 };
 
-std::shared_ptr<Process> Process::Create(Core::System& system, std::string name, ProcessType type) {
+SharedPtr<Process> Process::Create(Core::System& system, std::string name, ProcessType type) {
     auto& kernel = system.Kernel();
 
-    std::shared_ptr<Process> process = std::make_shared<Process>(system);
+    SharedPtr<Process> process(new Process(system));
     process->name = std::move(name);
     process->resource_limit = kernel.GetSystemResourceLimit();
     process->status = ProcessStatus::Created;
@@ -121,7 +121,7 @@ std::shared_ptr<Process> Process::Create(Core::System& system, std::string name,
     return process;
 }
 
-std::shared_ptr<ResourceLimit> Process::GetResourceLimit() const {
+SharedPtr<ResourceLimit> Process::GetResourceLimit() const {
     return resource_limit;
 }
 
@@ -142,12 +142,12 @@ u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
     return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();
 }
 
-void Process::InsertConditionVariableThread(std::shared_ptr<Thread> thread) {
+void Process::InsertConditionVariableThread(SharedPtr<Thread> thread) {
     VAddr cond_var_addr = thread->GetCondVarWaitAddress();
-    std::list<std::shared_ptr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
+    std::list<SharedPtr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
     auto it = thread_list.begin();
     while (it != thread_list.end()) {
-        const std::shared_ptr<Thread> current_thread = *it;
+        const SharedPtr<Thread> current_thread = *it;
         if (current_thread->GetPriority() > thread->GetPriority()) {
             thread_list.insert(it, thread);
             return;
@@ -157,12 +157,12 @@ void Process::InsertConditionVariableThread(std::shared_ptr<Thread> thread) {
     thread_list.push_back(thread);
 }
 
-void Process::RemoveConditionVariableThread(std::shared_ptr<Thread> thread) {
+void Process::RemoveConditionVariableThread(SharedPtr<Thread> thread) {
     VAddr cond_var_addr = thread->GetCondVarWaitAddress();
-    std::list<std::shared_ptr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
+    std::list<SharedPtr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
     auto it = thread_list.begin();
     while (it != thread_list.end()) {
-        const std::shared_ptr<Thread> current_thread = *it;
+        const SharedPtr<Thread> current_thread = *it;
         if (current_thread.get() == thread.get()) {
             thread_list.erase(it);
             return;
@@ -172,13 +172,12 @@ void Process::RemoveConditionVariableThread(std::shared_ptr<Thread> thread) {
     UNREACHABLE();
 }
 
-std::vector<std::shared_ptr<Thread>> Process::GetConditionVariableThreads(
-    const VAddr cond_var_addr) {
-    std::vector<std::shared_ptr<Thread>> result{};
-    std::list<std::shared_ptr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
+std::vector<SharedPtr<Thread>> Process::GetConditionVariableThreads(const VAddr cond_var_addr) {
+    std::vector<SharedPtr<Thread>> result{};
+    std::list<SharedPtr<Thread>>& thread_list = cond_var_threads[cond_var_addr];
     auto it = thread_list.begin();
     while (it != thread_list.end()) {
-        std::shared_ptr<Thread> current_thread = *it;
+        SharedPtr<Thread> current_thread = *it;
         result.push_back(current_thread);
         ++it;
     }
@@ -240,12 +239,12 @@ void Process::Run(s32 main_thread_priority, u64 stack_size) {
 void Process::PrepareForTermination() {
     ChangeStatus(ProcessStatus::Exiting);
 
-    const auto stop_threads = [this](const std::vector<std::shared_ptr<Thread>>& thread_list) {
+    const auto stop_threads = [this](const std::vector<SharedPtr<Thread>>& thread_list) {
         for (auto& thread : thread_list) {
             if (thread->GetOwnerProcess() != this)
                 continue;
 
-            if (thread.get() == system.CurrentScheduler().GetCurrentThread())
+            if (thread == system.CurrentScheduler().GetCurrentThread())
                 continue;
 
             // TODO(Subv): When are the other running/ready threads terminated?

src/core/hle/kernel/process.h

@@ -62,9 +62,6 @@ enum class ProcessStatus {
 
 class Process final : public WaitObject {
 public:
-    explicit Process(Core::System& system);
-    ~Process() override;
-
     enum : u64 {
         /// Lowest allowed process ID for a kernel initial process.
         InitialKIPIDMin = 1,
@@ -85,8 +82,7 @@ public:
 
     static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
 
-    static std::shared_ptr<Process> Create(Core::System& system, std::string name,
-                                           ProcessType type);
+    static SharedPtr<Process> Create(Core::System& system, std::string name, ProcessType type);
 
     std::string GetTypeName() const override {
         return "Process";
@@ -161,7 +157,7 @@ public:
     }
 
     /// Gets the resource limit descriptor for this process
-    std::shared_ptr<ResourceLimit> GetResourceLimit() const;
+    SharedPtr<ResourceLimit> GetResourceLimit() const;
 
     /// Gets the ideal CPU core ID for this process
     u8 GetIdealCore() const {
@@ -238,13 +234,13 @@ public:
     }
 
     /// Insert a thread into the condition variable wait container
-    void InsertConditionVariableThread(std::shared_ptr<Thread> thread);
+    void InsertConditionVariableThread(SharedPtr<Thread> thread);
 
     /// Remove a thread from the condition variable wait container
-    void RemoveConditionVariableThread(std::shared_ptr<Thread> thread);
+    void RemoveConditionVariableThread(SharedPtr<Thread> thread);
 
     /// Obtain all condition variable threads waiting for some address
-    std::vector<std::shared_ptr<Thread>> GetConditionVariableThreads(VAddr cond_var_addr);
+    std::vector<SharedPtr<Thread>> GetConditionVariableThreads(VAddr cond_var_addr);
 
     /// Registers a thread as being created under this process,
     /// adding it to this process' thread list.
@@ -301,6 +297,9 @@ public:
     void FreeTLSRegion(VAddr tls_address);
 
 private:
+    explicit Process(Core::System& system);
+    ~Process() override;
+
     /// Checks if the specified thread should wait until this process is available.
     bool ShouldWait(const Thread* thread) const override;
 
@@ -339,7 +338,7 @@ private:
     u32 system_resource_size = 0;
 
     /// Resource limit descriptor for this process
-    std::shared_ptr<ResourceLimit> resource_limit;
+    SharedPtr<ResourceLimit> resource_limit;
 
     /// The ideal CPU core for this process, threads are scheduled on this core by default.
     u8 ideal_core = 0;
@@ -387,7 +386,7 @@ private:
     std::list<const Thread*> thread_list;
 
     /// List of threads waiting for a condition variable
-    std::unordered_map<VAddr, std::list<std::shared_ptr<Thread>>> cond_var_threads;
+    std::unordered_map<VAddr, std::list<SharedPtr<Thread>>> cond_var_threads;
 
     /// System context
     Core::System& system;

src/core/hle/kernel/resource_limit.cpp

@@ -16,8 +16,8 @@ constexpr std::size_t ResourceTypeToIndex(ResourceType type) {
 ResourceLimit::ResourceLimit(KernelCore& kernel) : Object{kernel} {}
 ResourceLimit::~ResourceLimit() = default;
 
-std::shared_ptr<ResourceLimit> ResourceLimit::Create(KernelCore& kernel) {
-    return std::make_shared<ResourceLimit>(kernel);
+SharedPtr<ResourceLimit> ResourceLimit::Create(KernelCore& kernel) {
+    return new ResourceLimit(kernel);
 }
 
 s64 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {

src/core/hle/kernel/resource_limit.h

@@ -31,11 +31,8 @@ constexpr bool IsValidResourceType(ResourceType type) {
 
 class ResourceLimit final : public Object {
 public:
-    explicit ResourceLimit(KernelCore& kernel);
-    ~ResourceLimit() override;
-
     /// Creates a resource limit object.
-    static std::shared_ptr<ResourceLimit> Create(KernelCore& kernel);
+    static SharedPtr<ResourceLimit> Create(KernelCore& kernel);
 
     std::string GetTypeName() const override {
         return "ResourceLimit";
@@ -79,6 +76,9 @@ public:
     ResultCode SetLimitValue(ResourceType resource, s64 value);
 
 private:
+    explicit ResourceLimit(KernelCore& kernel);
+    ~ResourceLimit() override;
+
     // TODO(Subv): Increment resource limit current values in their respective Kernel::T::Create
     // functions
     //

src/core/hle/kernel/scheduler.cpp

@@ -26,11 +26,11 @@ GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {}
 
 GlobalScheduler::~GlobalScheduler() = default;
 
-void GlobalScheduler::AddThread(std::shared_ptr<Thread> thread) {
+void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
     thread_list.push_back(std::move(thread));
 }
 
-void GlobalScheduler::RemoveThread(std::shared_ptr<Thread> thread) {
+void GlobalScheduler::RemoveThread(const Thread* thread) {
     thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
                       thread_list.end());
 }
@@ -42,11 +42,11 @@ void GlobalScheduler::UnloadThread(std::size_t core) {
 
 void GlobalScheduler::SelectThread(std::size_t core) {
     const auto update_thread = [](Thread* thread, Scheduler& sched) {
-        if (thread != sched.selected_thread.get()) {
+        if (thread != sched.selected_thread) {
             if (thread == nullptr) {
                 ++sched.idle_selection_count;
             }
-            sched.selected_thread = SharedFrom(thread);
+            sched.selected_thread = thread;
         }
         sched.is_context_switch_pending = sched.selected_thread != sched.current_thread;
         std::atomic_thread_fence(std::memory_order_seq_cst);
@@ -446,7 +446,7 @@ void Scheduler::SwitchContext() {
 
         // Cancel any outstanding wakeup events for this thread
         new_thread->CancelWakeupTimer();
-        current_thread = SharedFrom(new_thread);
+        current_thread = new_thread;
         new_thread->SetStatus(ThreadStatus::Running);
         new_thread->SetIsRunning(true);
 

src/core/hle/kernel/scheduler.h

@@ -28,13 +28,13 @@ public:
     ~GlobalScheduler();
 
     /// Adds a new thread to the scheduler
-    void AddThread(std::shared_ptr<Thread> thread);
+    void AddThread(SharedPtr<Thread> thread);
 
     /// Removes a thread from the scheduler
-    void RemoveThread(std::shared_ptr<Thread> thread);
+    void RemoveThread(const Thread* thread);
 
     /// Returns a list of all threads managed by the scheduler
-    const std::vector<std::shared_ptr<Thread>>& GetThreadList() const {
+    const std::vector<SharedPtr<Thread>>& GetThreadList() const {
         return thread_list;
     }
 
@@ -157,7 +157,7 @@ private:
     std::array<u32, NUM_CPU_CORES> preemption_priorities = {59, 59, 59, 62};
 
     /// Lists all thread ids that aren't deleted/etc.
-    std::vector<std::shared_ptr<Thread>> thread_list;
+    std::vector<SharedPtr<Thread>> thread_list;
     Core::System& system;
 };
 
@@ -213,8 +213,8 @@ private:
      */
     void UpdateLastContextSwitchTime(Thread* thread, Process* process);
 
-    std::shared_ptr<Thread> current_thread = nullptr;
-    std::shared_ptr<Thread> selected_thread = nullptr;
+    SharedPtr<Thread> current_thread = nullptr;
+    SharedPtr<Thread> selected_thread = nullptr;
 
     Core::System& system;
     Core::ARM_Interface& cpu_core;

src/core/hle/kernel/server_port.cpp

@@ -16,7 +16,7 @@ namespace Kernel {
 ServerPort::ServerPort(KernelCore& kernel) : WaitObject{kernel} {}
 ServerPort::~ServerPort() = default;
 
-ResultVal<std::shared_ptr<ServerSession>> ServerPort::Accept() {
+ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {
     if (pending_sessions.empty()) {
         return ERR_NOT_FOUND;
     }
@@ -26,7 +26,7 @@ ResultVal<std::shared_ptr<ServerSession>> ServerPort::Accept() {
     return MakeResult(std::move(session));
 }
 
-void ServerPort::AppendPendingSession(std::shared_ptr<ServerSession> pending_session) {
+void ServerPort::AppendPendingSession(SharedPtr<ServerSession> pending_session) {
     pending_sessions.push_back(std::move(pending_session));
 }
 
@@ -41,8 +41,8 @@ void ServerPort::Acquire(Thread* thread) {
 
 ServerPort::PortPair ServerPort::CreatePortPair(KernelCore& kernel, u32 max_sessions,
                                                 std::string name) {
-    std::shared_ptr<ServerPort> server_port = std::make_shared<ServerPort>(kernel);
-    std::shared_ptr<ClientPort> client_port = std::make_shared<ClientPort>(kernel);
+    SharedPtr<ServerPort> server_port(new ServerPort(kernel));
+    SharedPtr<ClientPort> client_port(new ClientPort(kernel));
 
     server_port->name = name + "_Server";
     client_port->name = name + "_Client";

src/core/hle/kernel/server_port.h

@@ -22,11 +22,8 @@ class SessionRequestHandler;
 
 class ServerPort final : public WaitObject {
 public:
-    explicit ServerPort(KernelCore& kernel);
-    ~ServerPort() override;
-
     using HLEHandler = std::shared_ptr<SessionRequestHandler>;
-    using PortPair = std::pair<std::shared_ptr<ServerPort>, std::shared_ptr<ClientPort>>;
+    using PortPair = std::pair<SharedPtr<ServerPort>, SharedPtr<ClientPort>>;
 
     /**
      * Creates a pair of ServerPort and an associated ClientPort.
@@ -55,7 +52,7 @@ public:
      * Accepts a pending incoming connection on this port. If there are no pending sessions, will
      * return ERR_NO_PENDING_SESSIONS.
      */
-    ResultVal<std::shared_ptr<ServerSession>> Accept();
+    ResultVal<SharedPtr<ServerSession>> Accept();
 
     /// Whether or not this server port has an HLE handler available.
     bool HasHLEHandler() const {
@@ -77,14 +74,17 @@ public:
 
     /// Appends a ServerSession to the collection of ServerSessions
     /// waiting to be accepted by this port.
-    void AppendPendingSession(std::shared_ptr<ServerSession> pending_session);
+    void AppendPendingSession(SharedPtr<ServerSession> pending_session);
 
     bool ShouldWait(const Thread* thread) const override;
     void Acquire(Thread* thread) override;
 
 private:
+    explicit ServerPort(KernelCore& kernel);
+    ~ServerPort() override;
+
     /// ServerSessions waiting to be accepted by the port
-    std::vector<std::shared_ptr<ServerSession>> pending_sessions;
+    std::vector<SharedPtr<ServerSession>> pending_sessions;
 
     /// This session's HLE request handler template (optional)
     /// ServerSessions created from this port inherit a reference to this handler.

src/core/hle/kernel/server_session.cpp

@@ -31,11 +31,12 @@ ServerSession::~ServerSession() {
     if (parent->port) {
         parent->port->ConnectionClosed();
     }
+
+    parent->server = nullptr;
 }
 
-ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelCore& kernel,
-                                                                std::string name) {
-    std::shared_ptr<ServerSession> server_session = std::make_shared<ServerSession>(kernel);
+ResultVal<SharedPtr<ServerSession>> ServerSession::Create(KernelCore& kernel, std::string name) {
+    SharedPtr<ServerSession> server_session(new ServerSession(kernel));
 
     server_session->name = std::move(name);
     server_session->parent = nullptr;
@@ -44,13 +45,11 @@ ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelCore& kern
 }
 
 bool ServerSession::ShouldWait(const Thread* thread) const {
-    // Wait if we have no pending requests, or if we're currently handling a request.
-    if (auto client = parent->client.lock()) {
-        return pending_requesting_threads.empty() || currently_handling != nullptr;
-    }
-
     // Closed sessions should never wait, an error will be returned from svcReplyAndReceive.
-    return {};
+    if (parent->client == nullptr)
+        return false;
+    // Wait if we have no pending requests, or if we're currently handling a request.
+    return pending_requesting_threads.empty() || currently_handling != nullptr;
 }
 
 void ServerSession::Acquire(Thread* thread) {
@@ -70,7 +69,7 @@ void ServerSession::ClientDisconnected() {
     if (handler) {
         // Note that after this returns, this server session's hle_handler is
         // invalidated (set to null).
-        handler->ClientDisconnected(SharedFrom(this));
+        handler->ClientDisconnected(this);
     }
 
     // Clean up the list of client threads with pending requests, they are unneeded now that the
@@ -127,11 +126,11 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
     return RESULT_SUCCESS;
 }
 
-ResultCode ServerSession::HandleSyncRequest(std::shared_ptr<Thread> thread) {
+ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // The ServerSession received a sync request, this means that there's new data available
     // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or
     // similar.
-    Kernel::HLERequestContext context(SharedFrom(this), thread);
+    Kernel::HLERequestContext context(this, thread);
     u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
     context.PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
 
@@ -187,14 +186,14 @@ ResultCode ServerSession::HandleSyncRequest(std::shared_ptr<Thread> thread) {
 
 ServerSession::SessionPair ServerSession::CreateSessionPair(KernelCore& kernel,
                                                             const std::string& name,
-                                                            std::shared_ptr<ClientPort> port) {
+                                                            SharedPtr<ClientPort> port) {
     auto server_session = ServerSession::Create(kernel, name + "_Server").Unwrap();
-    std::shared_ptr<ClientSession> client_session = std::make_shared<ClientSession>(kernel);
+    SharedPtr<ClientSession> client_session(new ClientSession(kernel));
     client_session->name = name + "_Client";
 
-    std::shared_ptr<Session> parent = std::make_shared<Session>();
-    parent->client = client_session;
-    parent->server = server_session;
+    std::shared_ptr<Session> parent(new Session);
+    parent->client = client_session.get();
+    parent->server = server_session.get();
     parent->port = std::move(port);
 
     client_session->parent = parent;

src/core/hle/kernel/server_session.h

@@ -38,9 +38,6 @@ class Thread;
  */
 class ServerSession final : public WaitObject {
 public:
-    explicit ServerSession(KernelCore& kernel);
-    ~ServerSession() override;
-
     std::string GetTypeName() const override {
         return "ServerSession";
     }
@@ -62,7 +59,7 @@ public:
         return parent.get();
     }
 
-    using SessionPair = std::pair<std::shared_ptr<ServerSession>, std::shared_ptr<ClientSession>>;
+    using SessionPair = std::pair<SharedPtr<ServerSession>, SharedPtr<ClientSession>>;
 
     /**
      * Creates a pair of ServerSession and an associated ClientSession.
@@ -72,7 +69,7 @@ public:
      * @return The created session tuple
      */
     static SessionPair CreateSessionPair(KernelCore& kernel, const std::string& name = "Unknown",
-                                         std::shared_ptr<ClientPort> client_port = nullptr);
+                                         SharedPtr<ClientPort> client_port = nullptr);
 
     /**
      * Sets the HLE handler for the session. This handler will be called to service IPC requests
@@ -88,7 +85,7 @@ public:
      * @param thread Thread that initiated the request.
      * @returns ResultCode from the operation.
      */
-    ResultCode HandleSyncRequest(std::shared_ptr<Thread> thread);
+    ResultCode HandleSyncRequest(SharedPtr<Thread> thread);
 
     bool ShouldWait(const Thread* thread) const override;
 
@@ -121,6 +118,9 @@ public:
     }
 
 private:
+    explicit ServerSession(KernelCore& kernel);
+    ~ServerSession() override;
+
     /**
      * Creates a server session. The server session can have an optional HLE handler,
      * which will be invoked to handle the IPC requests that this session receives.
@@ -128,8 +128,8 @@ private:
      * @param name Optional name of the server session.
      * @return The created server session
      */
-    static ResultVal<std::shared_ptr<ServerSession>> Create(KernelCore& kernel,
-                                                            std::string name = "Unknown");
+    static ResultVal<SharedPtr<ServerSession>> Create(KernelCore& kernel,
+                                                      std::string name = "Unknown");
 
     /// Handles a SyncRequest to a domain, forwarding the request to the proper object or closing an
     /// object handle.
@@ -147,12 +147,12 @@ private:
     /// List of threads that are pending a response after a sync request. This list is processed in
     /// a LIFO manner, thus, the last request will be dispatched first.
     /// TODO(Subv): Verify if this is indeed processed in LIFO using a hardware test.
-    std::vector<std::shared_ptr<Thread>> pending_requesting_threads;
+    std::vector<SharedPtr<Thread>> pending_requesting_threads;
 
     /// Thread whose request is currently being handled. A request is considered "handled" when a
     /// response is sent via svcReplyAndReceive.
     /// TODO(Subv): Find a better name for this.
-    std::shared_ptr<Thread> currently_handling;
+    SharedPtr<Thread> currently_handling;
 
     /// When set to True, converts the session to a domain at the end of the command
     bool convert_to_domain{};

src/core/hle/kernel/session.h

@@ -20,8 +20,8 @@ class ServerSession;
  */
 class Session final {
 public:
-    std::weak_ptr<ClientSession> client; ///< The client endpoint of the session.
-    std::weak_ptr<ServerSession> server; ///< The server endpoint of the session.
-    std::shared_ptr<ClientPort> port; ///< The port that this session is associated with (optional).
+    ClientSession* client = nullptr; ///< The client endpoint of the session.
+    ServerSession* server = nullptr; ///< The server endpoint of the session.
+    SharedPtr<ClientPort> port;      ///< The port that this session is associated with (optional).
 };
 } // namespace Kernel

src/core/hle/kernel/shared_memory.cpp

@@ -15,12 +15,11 @@ namespace Kernel {
 SharedMemory::SharedMemory(KernelCore& kernel) : Object{kernel} {}
 SharedMemory::~SharedMemory() = default;
 
-std::shared_ptr<SharedMemory> SharedMemory::Create(KernelCore& kernel, Process* owner_process,
-                                                   u64 size, MemoryPermission permissions,
-                                                   MemoryPermission other_permissions,
-                                                   VAddr address, MemoryRegion region,
-                                                   std::string name) {
-    std::shared_ptr<SharedMemory> shared_memory = std::make_shared<SharedMemory>(kernel);
+SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, Process* owner_process, u64 size,
+                                             MemoryPermission permissions,
+                                             MemoryPermission other_permissions, VAddr address,
+                                             MemoryRegion region, std::string name) {
+    SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));
 
     shared_memory->owner_process = owner_process;
     shared_memory->name = std::move(name);
@@ -59,10 +58,10 @@ std::shared_ptr<SharedMemory> SharedMemory::Create(KernelCore& kernel, Process*
     return shared_memory;
 }
 
-std::shared_ptr<SharedMemory> SharedMemory::CreateForApplet(
+SharedPtr<SharedMemory> SharedMemory::CreateForApplet(
     KernelCore& kernel, std::shared_ptr<Kernel::PhysicalMemory> heap_block, std::size_t offset,
     u64 size, MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
-    std::shared_ptr<SharedMemory> shared_memory = std::make_shared<SharedMemory>(kernel);
+    SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));
 
     shared_memory->owner_process = nullptr;
     shared_memory->name = std::move(name);

src/core/hle/kernel/shared_memory.h

@@ -33,9 +33,6 @@ enum class MemoryPermission : u32 {
 
 class SharedMemory final : public Object {
 public:
-    explicit SharedMemory(KernelCore& kernel);
-    ~SharedMemory() override;
-
     /**
      * Creates a shared memory object.
      * @param kernel The kernel instance to create a shared memory instance under.
@@ -49,12 +46,11 @@ public:
      * linear heap.
      * @param name Optional object name, used for debugging purposes.
      */
-    static std::shared_ptr<SharedMemory> Create(KernelCore& kernel, Process* owner_process,
-                                                u64 size, MemoryPermission permissions,
-                                                MemoryPermission other_permissions,
-                                                VAddr address = 0,
-                                                MemoryRegion region = MemoryRegion::BASE,
-                                                std::string name = "Unknown");
+    static SharedPtr<SharedMemory> Create(KernelCore& kernel, Process* owner_process, u64 size,
+                                          MemoryPermission permissions,
+                                          MemoryPermission other_permissions, VAddr address = 0,
+                                          MemoryRegion region = MemoryRegion::BASE,
+                                          std::string name = "Unknown");
 
     /**
      * Creates a shared memory object from a block of memory managed by an HLE applet.
@@ -67,7 +63,7 @@ public:
      * block.
      * @param name Optional object name, used for debugging purposes.
      */
-    static std::shared_ptr<SharedMemory> CreateForApplet(
+    static SharedPtr<SharedMemory> CreateForApplet(
         KernelCore& kernel, std::shared_ptr<Kernel::PhysicalMemory> heap_block, std::size_t offset,
         u64 size, MemoryPermission permissions, MemoryPermission other_permissions,
         std::string name = "Unknown Applet");
@@ -134,6 +130,9 @@ public:
     const u8* GetPointer(std::size_t offset = 0) const;
 
 private:
+    explicit SharedMemory(KernelCore& kernel);
+    ~SharedMemory() override;
+
     /// Backing memory for this shared memory block.
     std::shared_ptr<PhysicalMemory> backing_block;
     /// Offset into the backing block for this shared memory.

src/core/hle/kernel/svc.cpp

@@ -17,7 +17,6 @@
 #include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
-#include "core/core_timing_util.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
@@ -359,7 +358,7 @@ static ResultCode ConnectToNamedPort(Core::System& system, Handle* out_handle,
 
     auto client_port = it->second;
 
-    std::shared_ptr<ClientSession> client_session;
+    SharedPtr<ClientSession> client_session;
     CASCADE_RESULT(client_session, client_port->Connect());
 
     // Return the client session
@@ -371,7 +370,7 @@ static ResultCode ConnectToNamedPort(Core::System& system, Handle* out_handle,
 /// Makes a blocking IPC call to an OS service.
 static ResultCode SendSyncRequest(Core::System& system, Handle handle) {
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    std::shared_ptr<ClientSession> session = handle_table.Get<ClientSession>(handle);
+    SharedPtr<ClientSession> session = handle_table.Get<ClientSession>(handle);
     if (!session) {
         LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -391,7 +390,7 @@ static ResultCode GetThreadId(Core::System& system, u64* thread_id, Handle threa
     LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    const std::shared_ptr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", thread_handle);
         return ERR_INVALID_HANDLE;
@@ -406,13 +405,13 @@ static ResultCode GetProcessId(Core::System& system, u64* process_id, Handle han
     LOG_DEBUG(Kernel_SVC, "called handle=0x{:08X}", handle);
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    const std::shared_ptr<Process> process = handle_table.Get<Process>(handle);
+    const SharedPtr<Process> process = handle_table.Get<Process>(handle);
     if (process) {
         *process_id = process->GetProcessID();
         return RESULT_SUCCESS;
     }
 
-    const std::shared_ptr<Thread> thread = handle_table.Get<Thread>(handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(handle);
     if (thread) {
         const Process* const owner_process = thread->GetOwnerProcess();
         if (!owner_process) {
@@ -431,8 +430,8 @@ static ResultCode GetProcessId(Core::System& system, u64* process_id, Handle han
 }
 
 /// Default thread wakeup callback for WaitSynchronization
-static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, std::shared_ptr<Thread> thread,
-                                        std::shared_ptr<WaitObject> object, std::size_t index) {
+static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
+                                        SharedPtr<WaitObject> object, std::size_t index) {
     ASSERT(thread->GetStatus() == ThreadStatus::WaitSynch);
 
     if (reason == ThreadWakeupReason::Timeout) {
@@ -512,7 +511,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
     }
 
     for (auto& object : objects) {
-        object->AddWaitingThread(SharedFrom(thread));
+        object->AddWaitingThread(thread);
     }
 
     thread->SetWaitObjects(std::move(objects));
@@ -532,7 +531,7 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
     LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    std::shared_ptr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
                   thread_handle);
@@ -942,7 +941,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
         const auto& core_timing = system.CoreTiming();
         const auto& scheduler = system.CurrentScheduler();
         const auto* const current_thread = scheduler.GetCurrentThread();
-        const bool same_thread = current_thread == thread.get();
+        const bool same_thread = current_thread == thread;
 
         const u64 prev_ctx_ticks = scheduler.GetLastContextSwitchTicks();
         u64 out_ticks = 0;
@@ -1052,7 +1051,7 @@ static ResultCode SetThreadActivity(Core::System& system, Handle handle, u32 act
     }
 
     const auto* current_process = system.Kernel().CurrentProcess();
-    const std::shared_ptr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
+    const SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -1068,7 +1067,7 @@ static ResultCode SetThreadActivity(Core::System& system, Handle handle, u32 act
         return ERR_INVALID_HANDLE;
     }
 
-    if (thread.get() == system.CurrentScheduler().GetCurrentThread()) {
+    if (thread == system.CurrentScheduler().GetCurrentThread()) {
         LOG_ERROR(Kernel_SVC, "The thread handle specified is the current running thread");
         return ERR_BUSY;
     }
@@ -1084,7 +1083,7 @@ static ResultCode GetThreadContext(Core::System& system, VAddr thread_context, H
     LOG_DEBUG(Kernel_SVC, "called, context=0x{:08X}, thread=0x{:X}", thread_context, handle);
 
     const auto* current_process = system.Kernel().CurrentProcess();
-    const std::shared_ptr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
+    const SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -1100,7 +1099,7 @@ static ResultCode GetThreadContext(Core::System& system, VAddr thread_context, H
         return ERR_INVALID_HANDLE;
     }
 
-    if (thread.get() == system.CurrentScheduler().GetCurrentThread()) {
+    if (thread == system.CurrentScheduler().GetCurrentThread()) {
         LOG_ERROR(Kernel_SVC, "The thread handle specified is the current running thread");
         return ERR_BUSY;
     }
@@ -1125,7 +1124,7 @@ static ResultCode GetThreadPriority(Core::System& system, u32* priority, Handle
     LOG_TRACE(Kernel_SVC, "called");
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    const std::shared_ptr<Thread> thread = handle_table.Get<Thread>(handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -1149,7 +1148,7 @@ static ResultCode SetThreadPriority(Core::System& system, Handle handle, u32 pri
 
     const auto* const current_process = system.Kernel().CurrentProcess();
 
-    std::shared_ptr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
+    SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -1269,7 +1268,7 @@ static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_add
                                      VAddr address) {
     LOG_TRACE(Kernel_SVC, "called process=0x{:08X} address={:X}", process_handle, address);
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    std::shared_ptr<Process> process = handle_table.Get<Process>(process_handle);
+    SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
     if (!process) {
         LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
                   process_handle);
@@ -1497,7 +1496,7 @@ static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr e
     }
 
     auto& kernel = system.Kernel();
-    CASCADE_RESULT(std::shared_ptr<Thread> thread,
+    CASCADE_RESULT(SharedPtr<Thread> thread,
                    Thread::Create(kernel, "", entry_point, priority, arg, processor_id, stack_top,
                                   *current_process));
 
@@ -1523,7 +1522,7 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
     LOG_DEBUG(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    const std::shared_ptr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
                   thread_handle);
@@ -1547,7 +1546,7 @@ static void ExitThread(Core::System& system) {
 
     auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
     current_thread->Stop();
-    system.GlobalScheduler().RemoveThread(SharedFrom(current_thread));
+    system.GlobalScheduler().RemoveThread(current_thread);
     system.PrepareReschedule();
 }
 
@@ -1619,12 +1618,13 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
 
     auto* const current_process = system.Kernel().CurrentProcess();
     const auto& handle_table = current_process->GetHandleTable();
-    std::shared_ptr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     ASSERT(thread);
 
-    Thread* current_thread = system.CurrentScheduler().GetCurrentThread();
+    SharedPtr<Thread> current_thread = system.CurrentScheduler().GetCurrentThread();
 
-    const auto release_result = current_process->GetMutex().Release(mutex_addr, current_thread);
+    const auto release_result =
+        current_process->GetMutex().Release(mutex_addr, current_thread.get());
     if (release_result.IsError()) {
         return release_result;
     }
@@ -1634,7 +1634,7 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
     current_thread->SetWaitHandle(thread_handle);
     current_thread->SetStatus(ThreadStatus::WaitCondVar);
     current_thread->InvalidateWakeupCallback();
-    current_process->InsertConditionVariableThread(SharedFrom(current_thread));
+    current_process->InsertConditionVariableThread(current_thread);
 
     current_thread->WakeAfterDelay(nano_seconds);
 
@@ -1654,7 +1654,7 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
 
     // Retrieve a list of all threads that are waiting for this condition variable.
     auto* const current_process = system.Kernel().CurrentProcess();
-    std::vector<std::shared_ptr<Thread>> waiting_threads =
+    std::vector<SharedPtr<Thread>> waiting_threads =
         current_process->GetConditionVariableThreads(condition_variable_addr);
 
     // Only process up to 'target' threads, unless 'target' is less equal 0, in which case process
@@ -1780,9 +1780,7 @@ static u64 GetSystemTick(Core::System& system) {
     LOG_TRACE(Kernel_SVC, "called");
 
     auto& core_timing = system.CoreTiming();
-
-    // Returns the value of cntpct_el0 (https://switchbrew.org/wiki/SVC#svcGetSystemTick)
-    const u64 result{Core::Timing::CpuCyclesToClockCycles(system.CoreTiming().GetTicks())};
+    const u64 result{core_timing.GetTicks()};
 
     // Advance time to defeat dumb games that busy-wait for the frame to end.
     core_timing.AddTicks(400);
@@ -1971,7 +1969,7 @@ static ResultCode GetThreadCoreMask(Core::System& system, Handle thread_handle,
     LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    const std::shared_ptr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
                   thread_handle);
@@ -2030,7 +2028,7 @@ static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle,
     }
 
     const auto& handle_table = current_process->GetHandleTable();
-    const std::shared_ptr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
                   thread_handle);

src/core/hle/kernel/thread.cpp

@@ -50,7 +50,7 @@ void Thread::Stop() {
 
     // Clean up any dangling references in objects that this thread was waiting for
     for (auto& wait_object : wait_objects) {
-        wait_object->RemoveWaitingThread(SharedFrom(this));
+        wait_object->RemoveWaitingThread(this);
     }
     wait_objects.clear();
 
@@ -147,10 +147,9 @@ static void ResetThreadContext(Core::ARM_Interface::ThreadContext& context, VAdd
     context.fpcr = 0x03C00000;
 }
 
-ResultVal<std::shared_ptr<Thread>> Thread::Create(KernelCore& kernel, std::string name,
-                                                  VAddr entry_point, u32 priority, u64 arg,
-                                                  s32 processor_id, VAddr stack_top,
-                                                  Process& owner_process) {
+ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name, VAddr entry_point,
+                                            u32 priority, u64 arg, s32 processor_id,
+                                            VAddr stack_top, Process& owner_process) {
     // Check if priority is in ranged. Lowest priority -> highest priority id.
     if (priority > THREADPRIO_LOWEST) {
         LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
@@ -169,7 +168,7 @@ ResultVal<std::shared_ptr<Thread>> Thread::Create(KernelCore& kernel, std::strin
     }
 
     auto& system = Core::System::GetInstance();
-    std::shared_ptr<Thread> thread = std::make_shared<Thread>(kernel);
+    SharedPtr<Thread> thread(new Thread(kernel));
 
     thread->thread_id = kernel.CreateNewThreadID();
     thread->status = ThreadStatus::Dormant;
@@ -198,7 +197,7 @@ ResultVal<std::shared_ptr<Thread>> Thread::Create(KernelCore& kernel, std::strin
     // to initialize the context
     ResetThreadContext(thread->context, stack_top, entry_point, arg);
 
-    return MakeResult<std::shared_ptr<Thread>>(std::move(thread));
+    return MakeResult<SharedPtr<Thread>>(std::move(thread));
 }
 
 void Thread::SetPriority(u32 priority) {
@@ -216,7 +215,7 @@ void Thread::SetWaitSynchronizationOutput(s32 output) {
     context.cpu_registers[1] = output;
 }
 
-s32 Thread::GetWaitObjectIndex(std::shared_ptr<WaitObject> object) const {
+s32 Thread::GetWaitObjectIndex(const WaitObject* object) const {
     ASSERT_MSG(!wait_objects.empty(), "Thread is not waiting for anything");
     const auto match = std::find(wait_objects.rbegin(), wait_objects.rend(), object);
     return static_cast<s32>(std::distance(match, wait_objects.rend()) - 1);
@@ -256,8 +255,8 @@ void Thread::SetStatus(ThreadStatus new_status) {
     status = new_status;
 }
 
-void Thread::AddMutexWaiter(std::shared_ptr<Thread> thread) {
-    if (thread->lock_owner.get() == this) {
+void Thread::AddMutexWaiter(SharedPtr<Thread> thread) {
+    if (thread->lock_owner == this) {
         // If the thread is already waiting for this thread to release the mutex, ensure that the
         // waiters list is consistent and return without doing anything.
         const auto iter = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
@@ -277,13 +276,13 @@ void Thread::AddMutexWaiter(std::shared_ptr<Thread> thread) {
         wait_mutex_threads.begin(), wait_mutex_threads.end(),
         [&thread](const auto& entry) { return entry->GetPriority() > thread->GetPriority(); });
     wait_mutex_threads.insert(insertion_point, thread);
-    thread->lock_owner = SharedFrom(this);
+    thread->lock_owner = this;
 
     UpdatePriority();
 }
 
-void Thread::RemoveMutexWaiter(std::shared_ptr<Thread> thread) {
-    ASSERT(thread->lock_owner.get() == this);
+void Thread::RemoveMutexWaiter(SharedPtr<Thread> thread) {
+    ASSERT(thread->lock_owner == this);
 
     // Ensure that the thread is in the list of mutex waiters
     const auto iter = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
@@ -311,13 +310,13 @@ void Thread::UpdatePriority() {
     }
 
     if (GetStatus() == ThreadStatus::WaitCondVar) {
-        owner_process->RemoveConditionVariableThread(SharedFrom(this));
+        owner_process->RemoveConditionVariableThread(this);
     }
 
     SetCurrentPriority(new_priority);
 
     if (GetStatus() == ThreadStatus::WaitCondVar) {
-        owner_process->InsertConditionVariableThread(SharedFrom(this));
+        owner_process->InsertConditionVariableThread(this);
     }
 
     if (!lock_owner) {
@@ -326,8 +325,8 @@ void Thread::UpdatePriority() {
 
     // Ensure that the thread is within the correct location in the waiting list.
     auto old_owner = lock_owner;
-    lock_owner->RemoveMutexWaiter(SharedFrom(this));
-    old_owner->AddMutexWaiter(SharedFrom(this));
+    lock_owner->RemoveMutexWaiter(this);
+    old_owner->AddMutexWaiter(this);
 
     // Recursively update the priority of the thread that depends on the priority of this one.
     lock_owner->UpdatePriority();
@@ -340,11 +339,11 @@ void Thread::ChangeCore(u32 core, u64 mask) {
 bool Thread::AllWaitObjectsReady() const {
     return std::none_of(
         wait_objects.begin(), wait_objects.end(),
-        [this](const std::shared_ptr<WaitObject>& object) { return object->ShouldWait(this); });
+        [this](const SharedPtr<WaitObject>& object) { return object->ShouldWait(this); });
 }
 
-bool Thread::InvokeWakeupCallback(ThreadWakeupReason reason, std::shared_ptr<Thread> thread,
-                                  std::shared_ptr<WaitObject> object, std::size_t index) {
+bool Thread::InvokeWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
+                                  SharedPtr<WaitObject> object, std::size_t index) {
     ASSERT(wakeup_callback);
     return wakeup_callback(reason, std::move(thread), std::move(object), index);
 }

src/core/hle/kernel/thread.h

@@ -97,18 +97,14 @@ enum class ThreadSchedMasks : u32 {
 
 class Thread final : public WaitObject {
 public:
-    explicit Thread(KernelCore& kernel);
-    ~Thread() override;
-
-    using MutexWaitingThreads = std::vector<std::shared_ptr<Thread>>;
+    using MutexWaitingThreads = std::vector<SharedPtr<Thread>>;
 
     using ThreadContext = Core::ARM_Interface::ThreadContext;
 
-    using ThreadWaitObjects = std::vector<std::shared_ptr<WaitObject>>;
+    using ThreadWaitObjects = std::vector<SharedPtr<WaitObject>>;
 
-    using WakeupCallback =
-        std::function<bool(ThreadWakeupReason reason, std::shared_ptr<Thread> thread,
-                           std::shared_ptr<WaitObject> object, std::size_t index)>;
+    using WakeupCallback = std::function<bool(ThreadWakeupReason reason, SharedPtr<Thread> thread,
+                                              SharedPtr<WaitObject> object, std::size_t index)>;
 
     /**
      * Creates and returns a new thread. The new thread is immediately scheduled
@@ -122,10 +118,10 @@ public:
      * @param owner_process The parent process for the thread
      * @return A shared pointer to the newly created thread
      */
-    static ResultVal<std::shared_ptr<Thread>> Create(KernelCore& kernel, std::string name,
-                                                     VAddr entry_point, u32 priority, u64 arg,
-                                                     s32 processor_id, VAddr stack_top,
-                                                     Process& owner_process);
+    static ResultVal<SharedPtr<Thread>> Create(KernelCore& kernel, std::string name,
+                                               VAddr entry_point, u32 priority, u64 arg,
+                                               s32 processor_id, VAddr stack_top,
+                                               Process& owner_process);
 
     std::string GetName() const override {
         return name;
@@ -170,10 +166,10 @@ public:
     void SetPriority(u32 priority);
 
     /// Adds a thread to the list of threads that are waiting for a lock held by this thread.
-    void AddMutexWaiter(std::shared_ptr<Thread> thread);
+    void AddMutexWaiter(SharedPtr<Thread> thread);
 
     /// Removes a thread from the list of threads that are waiting for a lock held by this thread.
-    void RemoveMutexWaiter(std::shared_ptr<Thread> thread);
+    void RemoveMutexWaiter(SharedPtr<Thread> thread);
 
     /// Recalculates the current priority taking into account priority inheritance.
     void UpdatePriority();
@@ -233,7 +229,7 @@ public:
      *
      * @param object Object to query the index of.
      */
-    s32 GetWaitObjectIndex(std::shared_ptr<WaitObject> object) const;
+    s32 GetWaitObjectIndex(const WaitObject* object) const;
 
     /**
      * Stops a thread, invalidating it from further use
@@ -324,7 +320,7 @@ public:
 
     void ClearWaitObjects() {
         for (const auto& waiting_object : wait_objects) {
-            waiting_object->RemoveWaitingThread(SharedFrom(this));
+            waiting_object->RemoveWaitingThread(this);
         }
         wait_objects.clear();
     }
@@ -340,7 +336,7 @@ public:
         return lock_owner.get();
     }
 
-    void SetLockOwner(std::shared_ptr<Thread> owner) {
+    void SetLockOwner(SharedPtr<Thread> owner) {
         lock_owner = std::move(owner);
     }
 
@@ -394,8 +390,8 @@ public:
      * @pre A valid wakeup callback has been set. Violating this precondition
      *      will cause an assertion to trigger.
      */
-    bool InvokeWakeupCallback(ThreadWakeupReason reason, std::shared_ptr<Thread> thread,
-                              std::shared_ptr<WaitObject> object, std::size_t index);
+    bool InvokeWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
+                              SharedPtr<WaitObject> object, std::size_t index);
 
     u32 GetIdealCore() const {
         return ideal_core;
@@ -453,6 +449,9 @@ public:
     }
 
 private:
+    explicit Thread(KernelCore& kernel);
+    ~Thread() override;
+
     void SetSchedulingStatus(ThreadSchedStatus new_status);
     void SetCurrentPriority(u32 new_priority);
     ResultCode SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask);
@@ -500,7 +499,7 @@ private:
     MutexWaitingThreads wait_mutex_threads;
 
     /// Thread that owns the lock that this thread is waiting for.
-    std::shared_ptr<Thread> lock_owner;
+    SharedPtr<Thread> lock_owner;
 
     /// If waiting on a ConditionVariable, this is the ConditionVariable address
     VAddr condvar_wait_address = 0;

src/core/hle/kernel/transfer_memory.cpp

@@ -14,9 +14,9 @@ namespace Kernel {
 TransferMemory::TransferMemory(KernelCore& kernel) : Object{kernel} {}
 TransferMemory::~TransferMemory() = default;
 
-std::shared_ptr<TransferMemory> TransferMemory::Create(KernelCore& kernel, VAddr base_address,
-                                                       u64 size, MemoryPermission permissions) {
-    std::shared_ptr<TransferMemory> transfer_memory{std::make_shared<TransferMemory>(kernel)};
+SharedPtr<TransferMemory> TransferMemory::Create(KernelCore& kernel, VAddr base_address, u64 size,
+                                                 MemoryPermission permissions) {
+    SharedPtr<TransferMemory> transfer_memory{new TransferMemory(kernel)};
 
     transfer_memory->base_address = base_address;
     transfer_memory->memory_size = size;

src/core/hle/kernel/transfer_memory.h

@@ -27,13 +27,10 @@ enum class MemoryPermission : u32;
 ///
 class TransferMemory final : public Object {
 public:
-    explicit TransferMemory(KernelCore& kernel);
-    ~TransferMemory() override;
-
     static constexpr HandleType HANDLE_TYPE = HandleType::TransferMemory;
 
-    static std::shared_ptr<TransferMemory> Create(KernelCore& kernel, VAddr base_address, u64 size,
-                                                  MemoryPermission permissions);
+    static SharedPtr<TransferMemory> Create(KernelCore& kernel, VAddr base_address, u64 size,
+                                            MemoryPermission permissions);
 
     TransferMemory(const TransferMemory&) = delete;
     TransferMemory& operator=(const TransferMemory&) = delete;
@@ -82,6 +79,9 @@ public:
     ResultCode UnmapMemory(VAddr address, u64 size);
 
 private:
+    explicit TransferMemory(KernelCore& kernel);
+    ~TransferMemory() override;
+
     /// Memory block backing this instance.
     std::shared_ptr<PhysicalMemory> backing_block;
 

src/core/hle/kernel/wait_object.cpp

@@ -18,13 +18,13 @@ namespace Kernel {
 WaitObject::WaitObject(KernelCore& kernel) : Object{kernel} {}
 WaitObject::~WaitObject() = default;
 
-void WaitObject::AddWaitingThread(std::shared_ptr<Thread> thread) {
+void WaitObject::AddWaitingThread(SharedPtr<Thread> thread) {
     auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
     if (itr == waiting_threads.end())
         waiting_threads.push_back(std::move(thread));
 }
 
-void WaitObject::RemoveWaitingThread(std::shared_ptr<Thread> thread) {
+void WaitObject::RemoveWaitingThread(Thread* thread) {
     auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
     // If a thread passed multiple handles to the same object,
     // the kernel might attempt to remove the thread from the object's
@@ -33,7 +33,7 @@ void WaitObject::RemoveWaitingThread(std::shared_ptr<Thread> thread) {
         waiting_threads.erase(itr);
 }
 
-std::shared_ptr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
+SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
     Thread* candidate = nullptr;
     u32 candidate_priority = THREADPRIO_LOWEST + 1;
 
@@ -55,10 +55,10 @@ std::shared_ptr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
         candidate_priority = thread->GetPriority();
     }
 
-    return SharedFrom(candidate);
+    return candidate;
 }
 
-void WaitObject::WakeupWaitingThread(std::shared_ptr<Thread> thread) {
+void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
     ASSERT(!ShouldWait(thread.get()));
 
     if (!thread) {
@@ -74,7 +74,7 @@ void WaitObject::WakeupWaitingThread(std::shared_ptr<Thread> thread) {
         Acquire(thread.get());
     }
 
-    const std::size_t index = thread->GetWaitObjectIndex(SharedFrom(this));
+    const std::size_t index = thread->GetWaitObjectIndex(this);
 
     thread->ClearWaitObjects();
 
@@ -82,8 +82,7 @@ void WaitObject::WakeupWaitingThread(std::shared_ptr<Thread> thread) {
 
     bool resume = true;
     if (thread->HasWakeupCallback()) {
-        resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Signal, thread, SharedFrom(this),
-                                              index);
+        resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Signal, thread, this, index);
     }
     if (resume) {
         thread->ResumeFromWait();
@@ -97,7 +96,7 @@ void WaitObject::WakeupAllWaitingThreads() {
     }
 }
 
-const std::vector<std::shared_ptr<Thread>>& WaitObject::GetWaitingThreads() const {
+const std::vector<SharedPtr<Thread>>& WaitObject::GetWaitingThreads() const {
     return waiting_threads;
 }
 

src/core/hle/kernel/wait_object.h

@@ -33,13 +33,13 @@ public:
      * Add a thread to wait on this object
      * @param thread Pointer to thread to add
      */
-    void AddWaitingThread(std::shared_ptr<Thread> thread);
+    void AddWaitingThread(SharedPtr<Thread> thread);
 
     /**
      * Removes a thread from waiting on this object (e.g. if it was resumed already)
      * @param thread Pointer to thread to remove
      */
-    void RemoveWaitingThread(std::shared_ptr<Thread> thread);
+    void RemoveWaitingThread(Thread* thread);
 
     /**
      * Wake up all threads waiting on this object that can be awoken, in priority order,
@@ -51,24 +51,24 @@ public:
      * Wakes up a single thread waiting on this object.
      * @param thread Thread that is waiting on this object to wakeup.
      */
-    void WakeupWaitingThread(std::shared_ptr<Thread> thread);
+    void WakeupWaitingThread(SharedPtr<Thread> thread);
 
     /// Obtains the highest priority thread that is ready to run from this object's waiting list.
-    std::shared_ptr<Thread> GetHighestPriorityReadyThread() const;
+    SharedPtr<Thread> GetHighestPriorityReadyThread() const;
 
     /// Get a const reference to the waiting threads list for debug use
-    const std::vector<std::shared_ptr<Thread>>& GetWaitingThreads() const;
+    const std::vector<SharedPtr<Thread>>& GetWaitingThreads() const;
 
 private:
     /// Threads waiting for this object to become available
-    std::vector<std::shared_ptr<Thread>> waiting_threads;
+    std::vector<SharedPtr<Thread>> waiting_threads;
 };
 
 // Specialization of DynamicObjectCast for WaitObjects
 template <>
-inline std::shared_ptr<WaitObject> DynamicObjectCast<WaitObject>(std::shared_ptr<Object> object) {
+inline SharedPtr<WaitObject> DynamicObjectCast<WaitObject>(SharedPtr<Object> object) {
     if (object != nullptr && object->IsWaitable()) {
-        return std::static_pointer_cast<WaitObject>(object);
+        return boost::static_pointer_cast<WaitObject>(object);
     }
     return nullptr;
 }

src/core/hle/kernel/writable_event.cpp

@@ -16,8 +16,8 @@ WritableEvent::WritableEvent(KernelCore& kernel) : Object{kernel} {}
 WritableEvent::~WritableEvent() = default;
 
 EventPair WritableEvent::CreateEventPair(KernelCore& kernel, std::string name) {
-    std::shared_ptr<WritableEvent> writable_event(new WritableEvent(kernel));
-    std::shared_ptr<ReadableEvent> readable_event(new ReadableEvent(kernel));
+    SharedPtr<WritableEvent> writable_event(new WritableEvent(kernel));
+    SharedPtr<ReadableEvent> readable_event(new ReadableEvent(kernel));
 
     writable_event->name = name + ":Writable";
     writable_event->readable = readable_event;
@@ -27,7 +27,7 @@ EventPair WritableEvent::CreateEventPair(KernelCore& kernel, std::string name) {
     return {std::move(readable_event), std::move(writable_event)};
 }
 
-std::shared_ptr<ReadableEvent> WritableEvent::GetReadableEvent() const {
+SharedPtr<ReadableEvent> WritableEvent::GetReadableEvent() const {
     return readable;
 }
 

src/core/hle/kernel/writable_event.h

@@ -13,8 +13,8 @@ class ReadableEvent;
 class WritableEvent;
 
 struct EventPair {
-    std::shared_ptr<ReadableEvent> readable;
-    std::shared_ptr<WritableEvent> writable;
+    SharedPtr<ReadableEvent> readable;
+    SharedPtr<WritableEvent> writable;
 };
 
 class WritableEvent final : public Object {
@@ -40,7 +40,7 @@ public:
         return HANDLE_TYPE;
     }
 
-    std::shared_ptr<ReadableEvent> GetReadableEvent() const;
+    SharedPtr<ReadableEvent> GetReadableEvent() const;
 
     void Signal();
     void Clear();
@@ -49,7 +49,7 @@ public:
 private:
     explicit WritableEvent(KernelCore& kernel);
 
-    std::shared_ptr<ReadableEvent> readable;
+    SharedPtr<ReadableEvent> readable;
 
     std::string name; ///< Name of event (optional)
 };

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

@@ -28,7 +28,6 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
         {104, nullptr, "GetProfileUpdateNotifier"},
         {105, nullptr, "CheckNetworkServiceAvailabilityAsync"},
-        {106, nullptr, "GetProfileSyncNotifier"},
         {110, nullptr, "StoreSaveDataThumbnail"},
         {111, nullptr, "ClearSaveDataThumbnail"},
         {112, nullptr, "LoadSaveDataThumbnail"},
@@ -45,8 +44,6 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {205, &ACC_SU::GetProfileEditor, "GetProfileEditor"},
         {206, nullptr, "CompleteUserRegistrationForcibly"},
         {210, nullptr, "CreateFloatingRegistrationRequest"},
-        {211, nullptr, "CreateProcedureToRegisterUserWithNintendoAccount"},
-        {212, nullptr, "ResumeProcedureToRegisterUserWithNintendoAccount"},
         {230, nullptr, "AuthenticateServiceAsync"},
         {250, nullptr, "GetBaasAccountAdministrator"},
         {290, nullptr, "ProxyProcedureForGuestLoginWithNintendoAccount"},

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

@@ -28,7 +28,6 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {103, nullptr, "GetProfileUpdateNotifier"},
         {104, nullptr, "CheckNetworkServiceAvailabilityAsync"},
         {105, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
-        {106, nullptr, "GetProfileSyncNotifier"},
         {110, nullptr, "StoreSaveDataThumbnail"},
         {111, nullptr, "ClearSaveDataThumbnail"},
         {112, nullptr, "LoadSaveDataThumbnail"},

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

@@ -229,15 +229,7 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework{"IDebugFunctions"} {
         {20, nullptr, "InvalidateTransitionLayer"},
         {30, nullptr, "RequestLaunchApplicationWithUserAndArgumentForDebug"},
         {40, nullptr, "GetAppletResourceUsageInfo"},
-        {100, nullptr, "SetCpuBoostModeForApplet"},
-        {110, nullptr, "PushToAppletBoundChannelForDebug"},
-        {111, nullptr, "TryPopFromAppletBoundChannelForDebug"},
-        {120, nullptr, "AlarmSettingNotificationEnableAppEventReserve"},
-        {121, nullptr, "AlarmSettingNotificationDisableAppEventReserve"},
-        {122, nullptr, "AlarmSettingNotificationPushAppEventNotify"},
-        {130, nullptr, "FriendInvitationSetApplicationParameter"},
-        {131, nullptr, "FriendInvitationClearApplicationParameter"},
-        {132, nullptr, "FriendInvitationPushApplicationParameter"},
+        {41, nullptr, "SetCpuBoostModeForApplet"},
     };
     // clang-format on
 
@@ -286,12 +278,10 @@ ISelfController::ISelfController(Core::System& system,
         {69, &ISelfController::IsAutoSleepDisabled, "IsAutoSleepDisabled"},
         {70, nullptr, "ReportMultimediaError"},
         {71, nullptr, "GetCurrentIlluminanceEx"},
-        {72, nullptr, "SetInputDetectionPolicy"},
         {80, nullptr, "SetWirelessPriorityMode"},
         {90, &ISelfController::GetAccumulatedSuspendedTickValue, "GetAccumulatedSuspendedTickValue"},
         {91, &ISelfController::GetAccumulatedSuspendedTickChangedEvent, "GetAccumulatedSuspendedTickChangedEvent"},
         {100, nullptr, "SetAlbumImageTakenNotificationEnabled"},
-        {110, nullptr, "SetApplicationAlbumUserData"},
         {1000, nullptr, "GetDebugStorageChannel"},
     };
     // clang-format on
@@ -541,11 +531,12 @@ AppletMessageQueue::AppletMessageQueue(Kernel::KernelCore& kernel) {
 
 AppletMessageQueue::~AppletMessageQueue() = default;
 
-const std::shared_ptr<Kernel::ReadableEvent>& AppletMessageQueue::GetMesssageRecieveEvent() const {
+const Kernel::SharedPtr<Kernel::ReadableEvent>& AppletMessageQueue::GetMesssageRecieveEvent()
+    const {
     return on_new_message.readable;
 }
 
-const std::shared_ptr<Kernel::ReadableEvent>& AppletMessageQueue::GetOperationModeChangedEvent()
+const Kernel::SharedPtr<Kernel::ReadableEvent>& AppletMessageQueue::GetOperationModeChangedEvent()
     const {
     return on_operation_mode_changed.readable;
 }
@@ -622,7 +613,6 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system,
         {90, nullptr, "SetPerformanceConfigurationChangedNotification"},
         {91, nullptr, "GetCurrentPerformanceConfiguration"},
         {200, nullptr, "GetOperationModeSystemInfo"},
-        {300, nullptr, "GetSettingsPlatformRegion"},
     };
     // clang-format on
 
@@ -1085,18 +1075,12 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
         {100, &IApplicationFunctions::InitializeApplicationCopyrightFrameBuffer, "InitializeApplicationCopyrightFrameBuffer"},
         {101, &IApplicationFunctions::SetApplicationCopyrightImage, "SetApplicationCopyrightImage"},
         {102, &IApplicationFunctions::SetApplicationCopyrightVisibility, "SetApplicationCopyrightVisibility"},
-        {110, &IApplicationFunctions::QueryApplicationPlayStatistics, "QueryApplicationPlayStatistics"},
+        {110, nullptr, "QueryApplicationPlayStatistics"},
         {111, &IApplicationFunctions::QueryApplicationPlayStatisticsByUid, "QueryApplicationPlayStatisticsByUid"},
         {120, nullptr, "ExecuteProgram"},
         {121, nullptr, "ClearUserChannel"},
         {122, nullptr, "UnpopToUserChannel"},
         {130, &IApplicationFunctions::GetGpuErrorDetectedSystemEvent, "GetGpuErrorDetectedSystemEvent"},
-        {140, nullptr, "GetFriendInvitationStorageChannelEvent"},
-        {141, nullptr, "TryPopFromFriendInvitationStorageChannel"},
-        {150, nullptr, "GetNotificationStorageChannelEvent"},
-        {151, nullptr, "TryPopFromNotificationStorageChannel"},
-        {160, nullptr, "GetHealthWarningDisappearedSystemEvent"},
-        {170, nullptr, "SetHdcpAuthenticationActivated"},
         {500, nullptr, "StartContinuousRecordingFlushForDebug"},
         {1000, nullptr, "CreateMovieMaker"},
         {1001, nullptr, "PrepareForJit"},
@@ -1351,16 +1335,12 @@ void IApplicationFunctions::GetPseudoDeviceId(Kernel::HLERequestContext& ctx) {
 }
 
 void IApplicationFunctions::ExtendSaveData(Kernel::HLERequestContext& ctx) {
-    struct Parameters {
-        FileSys::SaveDataType type;
-        u128 user_id;
-        u64 new_normal_size;
-        u64 new_journal_size;
-    };
-    static_assert(sizeof(Parameters) == 40);
-
     IPC::RequestParser rp{ctx};
-    const auto [type, user_id, new_normal_size, new_journal_size] = rp.PopRaw<Parameters>();
+    const auto type{rp.PopRaw<FileSys::SaveDataType>()};
+    rp.Skip(1, false);
+    const auto user_id{rp.PopRaw<u128>()};
+    const auto new_normal_size{rp.PopRaw<u64>()};
+    const auto new_journal_size{rp.PopRaw<u64>()};
 
     LOG_DEBUG(Service_AM,
               "called with type={:02X}, user_id={:016X}{:016X}, new_normal={:016X}, "
@@ -1379,14 +1359,10 @@ void IApplicationFunctions::ExtendSaveData(Kernel::HLERequestContext& ctx) {
 }
 
 void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
-    struct Parameters {
-        FileSys::SaveDataType type;
-        u128 user_id;
-    };
-    static_assert(sizeof(Parameters) == 24);
-
     IPC::RequestParser rp{ctx};
-    const auto [type, user_id] = rp.PopRaw<Parameters>();
+    const auto type{rp.PopRaw<FileSys::SaveDataType>()};
+    rp.Skip(1, false);
+    const auto user_id{rp.PopRaw<u128>()};
 
     LOG_DEBUG(Service_AM, "called with type={:02X}, user_id={:016X}{:016X}", static_cast<u8>(type),
               user_id[1], user_id[0]);
@@ -1400,12 +1376,12 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
     rb.Push(size.journal);
 }
 
-void IApplicationFunctions::QueryApplicationPlayStatistics(Kernel::HLERequestContext& ctx) {
+void IApplicationFunctions::GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0);
+    rb.PushCopyObjects(gpu_error_detected_event.readable);
 }
 
 void IApplicationFunctions::QueryApplicationPlayStatisticsByUid(Kernel::HLERequestContext& ctx) {
@@ -1416,14 +1392,6 @@ void IApplicationFunctions::QueryApplicationPlayStatisticsByUid(Kernel::HLEReque
     rb.Push<u32>(0);
 }
 
-void IApplicationFunctions::GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(gpu_error_detected_event.readable);
-}
-
 void InstallInterfaces(SM::ServiceManager& service_manager,
                        std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system) {
     auto message_queue = std::make_shared<AppletMessageQueue>(system.Kernel());
@@ -1449,8 +1417,6 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
         {30, nullptr, "GetHomeButtonWriterLockAccessor"},
         {31, nullptr, "GetWriterLockAccessorEx"},
         {100, nullptr, "PopRequestLaunchApplicationForDebug"},
-        {110, nullptr, "IsForceTerminateApplicationDisabledForDebug"},
-        {200, nullptr, "LaunchDevMenu"},
     };
     // clang-format on
 

src/core/hle/service/am/am.h

@@ -54,8 +54,8 @@ public:
     explicit AppletMessageQueue(Kernel::KernelCore& kernel);
     ~AppletMessageQueue();
 
-    const std::shared_ptr<Kernel::ReadableEvent>& GetMesssageRecieveEvent() const;
-    const std::shared_ptr<Kernel::ReadableEvent>& GetOperationModeChangedEvent() const;
+    const Kernel::SharedPtr<Kernel::ReadableEvent>& GetMesssageRecieveEvent() const;
+    const Kernel::SharedPtr<Kernel::ReadableEvent>& GetOperationModeChangedEvent() const;
     void PushMessage(AppletMessage msg);
     AppletMessage PopMessage();
     std::size_t GetMessageCount() const;
@@ -255,9 +255,8 @@ private:
     void InitializeApplicationCopyrightFrameBuffer(Kernel::HLERequestContext& ctx);
     void SetApplicationCopyrightImage(Kernel::HLERequestContext& ctx);
     void SetApplicationCopyrightVisibility(Kernel::HLERequestContext& ctx);
-    void QueryApplicationPlayStatistics(Kernel::HLERequestContext& ctx);
-    void QueryApplicationPlayStatisticsByUid(Kernel::HLERequestContext& ctx);
     void GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx);
+    void QueryApplicationPlayStatisticsByUid(Kernel::HLERequestContext& ctx);
 
     bool launch_popped_application_specific = false;
     bool launch_popped_account_preselect = false;

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

@@ -110,15 +110,15 @@ void AppletDataBroker::SignalStateChanged() const {
     state_changed_event.writable->Signal();
 }
 
-std::shared_ptr<Kernel::ReadableEvent> AppletDataBroker::GetNormalDataEvent() const {
+Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetNormalDataEvent() const {
     return pop_out_data_event.readable;
 }
 
-std::shared_ptr<Kernel::ReadableEvent> AppletDataBroker::GetInteractiveDataEvent() const {
+Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetInteractiveDataEvent() const {
     return pop_interactive_out_data_event.readable;
 }
 
-std::shared_ptr<Kernel::ReadableEvent> AppletDataBroker::GetStateChangedEvent() const {
+Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetStateChangedEvent() const {
     return state_changed_event.readable;
 }
 

src/core/hle/service/am/applets/applets.h

@@ -86,9 +86,9 @@ public:
 
     void SignalStateChanged() const;
 
-    std::shared_ptr<Kernel::ReadableEvent> GetNormalDataEvent() const;
-    std::shared_ptr<Kernel::ReadableEvent> GetInteractiveDataEvent() const;
-    std::shared_ptr<Kernel::ReadableEvent> GetStateChangedEvent() const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetNormalDataEvent() const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetInteractiveDataEvent() const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetStateChangedEvent() const;
 
 private:
     // Queues are named from applet's perspective

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

@@ -10,7 +10,7 @@ IdleSys::IdleSys() : ServiceFramework{"idle:sys"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetAutoPowerDownEvent"},
-        {1, nullptr, "IsAutoPowerDownRequested"},
+        {1, nullptr, "Unknown1"},
         {2, nullptr, "Unknown2"},
         {3, nullptr, "SetHandlingContext"},
         {4, nullptr, "LoadAndApplySettings"},

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

@@ -35,8 +35,6 @@ OMM::OMM() : ServiceFramework{"omm"} {
         {23, nullptr, "GetHdcpState"},
         {24, nullptr, "ShowCardUpdateProcessing"},
         {25, nullptr, "SetApplicationCecSettingsAndNotifyChanged"},
-        {26, nullptr, "GetOperationModeSystemInfo"},
-        {27, nullptr, "GetAppletFullAwakingSystemEvent"},
     };
     // clang-format on
 

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

@@ -61,7 +61,6 @@ AOC_U::AOC_U(Core::System& system)
         {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
         {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
         {100, nullptr, "CreateEcPurchasedEventManager"},
-        {101, nullptr, "CreatePermanentEcPurchasedEventManager"},
     };
     // clang-format on
 

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

@@ -38,7 +38,6 @@ AudCtl::AudCtl() : ServiceFramework{"audctl"} {
         {24, nullptr, "GetSystemOutputMasterVolume"},
         {25, nullptr, "GetAudioVolumeDataForPlayReport"},
         {26, nullptr, "UpdateHeadphoneSettings"},
-        {27, nullptr, "SetVolumeMappingTableForDev"},
     };
     // clang-format on
 

src/core/hle/service/bcat/backend/backend.cpp

@@ -16,7 +16,7 @@ ProgressServiceBackend::ProgressServiceBackend(Kernel::KernelCore& kernel,
         kernel, std::string("ProgressServiceBackend:UpdateEvent:").append(event_name));
 }
 
-std::shared_ptr<Kernel::ReadableEvent> ProgressServiceBackend::GetEvent() const {
+Kernel::SharedPtr<Kernel::ReadableEvent> ProgressServiceBackend::GetEvent() const {
     return event.readable;
 }
 

src/core/hle/service/bcat/backend/backend.h

@@ -98,7 +98,7 @@ public:
 private:
     explicit ProgressServiceBackend(Kernel::KernelCore& kernel, std::string_view event_name);
 
-    std::shared_ptr<Kernel::ReadableEvent> GetEvent() const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetEvent() const;
     DeliveryCacheProgressImpl& GetImpl();
 
     void SignalUpdate() const;

src/core/hle/service/bcat/module.cpp

@@ -87,7 +87,7 @@ struct DeliveryCacheDirectoryEntry {
 
 class IDeliveryCacheProgressService final : public ServiceFramework<IDeliveryCacheProgressService> {
 public:
-    IDeliveryCacheProgressService(std::shared_ptr<Kernel::ReadableEvent> event,
+    IDeliveryCacheProgressService(Kernel::SharedPtr<Kernel::ReadableEvent> event,
                                   const DeliveryCacheProgressImpl& impl)
         : ServiceFramework{"IDeliveryCacheProgressService"}, event(std::move(event)), impl(impl) {
         // clang-format off
@@ -118,7 +118,7 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    std::shared_ptr<Kernel::ReadableEvent> event;
+    Kernel::SharedPtr<Kernel::ReadableEvent> event;
     const DeliveryCacheProgressImpl& impl;
 };
 
@@ -137,20 +137,14 @@ public:
             {10200, nullptr, "CancelSyncDeliveryCacheRequest"},
             {20100, nullptr, "RequestSyncDeliveryCacheWithApplicationId"},
             {20101, nullptr, "RequestSyncDeliveryCacheWithApplicationIdAndDirectoryName"},
-            {20300, nullptr, "GetDeliveryCacheStorageUpdateNotifier"},
-            {20301, nullptr, "RequestSuspendDeliveryTask"},
-            {20400, nullptr, "RegisterSystemApplicationDeliveryTask"},
-            {20401, nullptr, "UnregisterSystemApplicationDeliveryTask"},
             {30100, &IBcatService::SetPassphrase, "SetPassphrase"},
             {30200, nullptr, "RegisterBackgroundDeliveryTask"},
             {30201, nullptr, "UnregisterBackgroundDeliveryTask"},
             {30202, nullptr, "BlockDeliveryTask"},
             {30203, nullptr, "UnblockDeliveryTask"},
-            {30300, nullptr, "RegisterSystemApplicationDeliveryTasks"},
             {90100, nullptr, "EnumerateBackgroundDeliveryTask"},
             {90200, nullptr, "GetDeliveryList"},
             {90201, &IBcatService::ClearDeliveryCacheStorage, "ClearDeliveryCacheStorage"},
-            {90202, nullptr, "ClearDeliveryTaskSubscriptionStatus"},
             {90300, nullptr, "GetPushNotificationLog"},
         };
         // clang-format on

src/core/hle/service/btdrv/btdrv.cpp

@@ -155,7 +155,6 @@ public:
             {98, nullptr, "SetLeScanParameter"},
             {256, nullptr, "GetIsManufacturingMode"},
             {257, nullptr, "EmulateBluetoothCrash"},
-            {258, nullptr, "GetBleChannelMap"},
         };
         // clang-format on
 

src/core/hle/service/erpt/erpt.cpp

@@ -24,8 +24,6 @@ public:
             {6, nullptr, "SubmitMultipleCategoryContext"},
             {7, nullptr, "UpdateApplicationLaunchTime"},
             {8, nullptr, "ClearApplicationLaunchTime"},
-            {9, nullptr, "SubmitAttachment"},
-            {10, nullptr, "CreateReportWithAttachments"},
         };
         // clang-format on
 
@@ -40,7 +38,6 @@ public:
         static const FunctionInfo functions[] = {
             {0, nullptr, "OpenReport"},
             {1, nullptr, "OpenManager"},
-            {2, nullptr, "OpenAttachment"},
         };
         // clang-format on
 

src/core/hle/service/es/es.cpp

@@ -52,8 +52,6 @@ public:
             {34, nullptr, "GetEncryptedTicketSize"},
             {35, nullptr, "GetEncryptedTicketData"},
             {36, nullptr, "DeleteAllInactiveELicenseRequiredPersonalizedTicket"},
-            {37, nullptr, "OwnTicket2"},
-            {38, nullptr, "OwnTicket3"},
             {503, nullptr, "GetTitleKey"},
         };
         // clang-format on

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

@@ -256,8 +256,8 @@ public:
 
         // TODO(DarkLordZach): Verify that this is the correct behavior.
         // Build entry index now to save time later.
-        BuildEntryIndex(entries, backend->GetFiles(), FileSys::EntryType::File);
-        BuildEntryIndex(entries, backend->GetSubdirectories(), FileSys::EntryType::Directory);
+        BuildEntryIndex(entries, backend->GetFiles(), FileSys::File);
+        BuildEntryIndex(entries, backend->GetSubdirectories(), FileSys::Directory);
     }
 
 private:
@@ -680,7 +680,6 @@ FSP_SRV::FSP_SRV(FileSystemController& fsc, const Core::Reporter& reporter)
         {33, nullptr, "DeleteCacheStorage"},
         {34, nullptr, "GetCacheStorageSize"},
         {35, nullptr, "CreateSaveDataFileSystemByHashSalt"},
-        {36, nullptr, "OpenHostFileSystemWithOption"},
         {51, &FSP_SRV::OpenSaveDataFileSystem, "OpenSaveDataFileSystem"},
         {52, nullptr, "OpenSaveDataFileSystemBySystemSaveDataId"},
         {53, &FSP_SRV::OpenReadOnlySaveDataFileSystem, "OpenReadOnlySaveDataFileSystem"},
@@ -695,14 +694,11 @@ FSP_SRV::FSP_SRV(FileSystemController& fsc, const Core::Reporter& reporter)
         {66, nullptr, "WriteSaveDataFileSystemExtraData2"},
         {67, nullptr, "FindSaveDataWithFilter"},
         {68, nullptr, "OpenSaveDataInfoReaderBySaveDataFilter"},
-        {69, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
-        {70, nullptr, "WriteSaveDataFileSystemExtraDataBySaveDataAttribute"},
         {80, nullptr, "OpenSaveDataMetaFile"},
         {81, nullptr, "OpenSaveDataTransferManager"},
         {82, nullptr, "OpenSaveDataTransferManagerVersion2"},
         {83, nullptr, "OpenSaveDataTransferProhibiterForCloudBackUp"},
         {84, nullptr, "ListApplicationAccessibleSaveDataOwnerId"},
-        {85, nullptr, "OpenSaveDataTransferManagerForSaveDataRepair"},
         {100, nullptr, "OpenImageDirectoryFileSystem"},
         {110, nullptr, "OpenContentStorageFileSystem"},
         {120, nullptr, "OpenCloudBackupWorkStorageFileSystem"},
@@ -760,8 +756,6 @@ FSP_SRV::FSP_SRV(FileSystemController& fsc, const Core::Reporter& reporter)
         {1009, nullptr, "GetAndClearMemoryReportInfo"},
         {1010, nullptr, "SetDataStorageRedirectTarget"},
         {1011, &FSP_SRV::GetAccessLogVersionInfo, "GetAccessLogVersionInfo"},
-        {1012, nullptr, "GetFsStackUsage"},
-        {1013, nullptr, "UnsetSaveDataRootPath"},
         {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
         {1110, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId2"},
         {1200, nullptr, "OpenMultiCommitManager"},

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

@@ -60,9 +60,6 @@ public:
             {20801, nullptr, "SyncUserSetting"},
             {20900, nullptr, "RequestListSummaryOverlayNotification"},
             {21000, nullptr, "GetExternalApplicationCatalog"},
-            {22000, nullptr, "GetReceivedFriendInvitationList"},
-            {22001, nullptr, "GetReceivedFriendInvitationDetailedInfo"},
-            {22010, nullptr, "GetReceivedFriendInvitationCountCache"},
             {30100, nullptr, "DropFriendNewlyFlags"},
             {30101, nullptr, "DeleteFriend"},
             {30110, nullptr, "DropFriendNewlyFlag"},
@@ -94,8 +91,6 @@ public:
             {30812, nullptr, "ChangePlayLogPermission"},
             {30820, nullptr, "IssueFriendCode"},
             {30830, nullptr, "ClearPlayLog"},
-            {30900, nullptr, "SendFriendInvitation"},
-            {30910, nullptr, "ReadFriendInvitation"},
             {49900, nullptr, "DeleteNetworkServiceAccountCache"},
         };
         // clang-format on

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

@@ -501,7 +501,8 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
     last_processed_vibration = vibrations.back();
 }
 
-std::shared_ptr<Kernel::ReadableEvent> Controller_NPad::GetStyleSetChangedEvent(u32 npad_id) const {
+Kernel::SharedPtr<Kernel::ReadableEvent> Controller_NPad::GetStyleSetChangedEvent(
+    u32 npad_id) const {
     // TODO(ogniK): Figure out the best time to signal this event. This event seems that it should
     // be signalled at least once, and signaled after a new controller is connected?
     const auto& styleset_event = styleset_changed_events[NPadIdToIndex(npad_id)];

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

@@ -109,7 +109,7 @@ public:
     void VibrateController(const std::vector<u32>& controller_ids,
                            const std::vector<Vibration>& vibrations);
 
-    std::shared_ptr<Kernel::ReadableEvent> GetStyleSetChangedEvent(u32 npad_id) const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetStyleSetChangedEvent(u32 npad_id) const;
     Vibration GetLastVibration() const;
 
     void AddNewController(NPadControllerType controller);

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

@@ -77,14 +77,15 @@ IAppletResource::IAppletResource(Core::System& system)
     GetController<Controller_Stubbed>(HidController::Unknown3).SetCommonHeaderOffset(0x5000);
 
     // Register update callbacks
+    auto& core_timing = system.CoreTiming();
     pad_update_event =
-        Core::Timing::CreateEvent("HID::UpdatePadCallback", [this](u64 userdata, s64 cycles_late) {
+        core_timing.RegisterEvent("HID::UpdatePadCallback", [this](u64 userdata, s64 cycles_late) {
             UpdateControllers(userdata, cycles_late);
         });
 
     // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
 
-    system.CoreTiming().ScheduleEvent(pad_update_ticks, pad_update_event);
+    core_timing.ScheduleEvent(pad_update_ticks, pad_update_event);
 
     ReloadInputDevices();
 }
@@ -214,8 +215,6 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {132, nullptr, "EnableUnintendedHomeButtonInputProtection"},
         {133, nullptr, "SetNpadJoyAssignmentModeSingleWithDestination"},
         {134, nullptr, "SetNpadAnalogStickUseCenterClamp"},
-        {135, nullptr, "SetNpadCaptureButtonAssignment"},
-        {136, nullptr, "ClearNpadCaptureButtonAssignment"},
         {200, &Hid::GetVibrationDeviceInfo, "GetVibrationDeviceInfo"},
         {201, &Hid::SendVibrationValue, "SendVibrationValue"},
         {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
@@ -246,8 +245,6 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {404, nullptr, "HasLeftRightBattery"},
         {405, nullptr, "GetNpadInterfaceType"},
         {406, nullptr, "GetNpadLeftRightInterfaceType"},
-        {407, nullptr, "GetNpadOfHighestBatteryLevelForJoyLeft"},
-        {408, nullptr, "GetNpadOfHighestBatteryLevelForJoyRight"},
         {500, nullptr, "GetPalmaConnectionHandle"},
         {501, nullptr, "InitializePalma"},
         {502, nullptr, "AcquirePalmaOperationCompleteEvent"},
@@ -275,13 +272,8 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {524, nullptr, "PairPalma"},
         {525, &Hid::SetPalmaBoostMode, "SetPalmaBoostMode"},
         {526, nullptr, "CancelWritePalmaWaveEntry"},
-        {527, nullptr, "EnablePalmaBoostMode"},
-        {528, nullptr, "GetPalmaBluetoothAddress"},
-        {529, nullptr, "SetDisallowedPalmaConnection"},
         {1000, nullptr, "SetNpadCommunicationMode"},
         {1001, nullptr, "GetNpadCommunicationMode"},
-        {1002, nullptr, "SetTouchScreenConfiguration"},
-        {1003, nullptr, "IsFirmwareUpdateNeededForNotification"},
     };
     // clang-format on
 
@@ -977,9 +969,6 @@ public:
             {310, nullptr, "GetMaskedSupportedNpadStyleSet"},
             {311, nullptr, "SetNpadPlayerLedBlinkingDevice"},
             {312, nullptr, "SetSupportedNpadStyleSetAll"},
-            {313, nullptr, "GetNpadCaptureButtonAssignment"},
-            {314, nullptr, "GetAppletFooterUiType"},
-            {315, nullptr, "GetAppletDetailedUiType"},
             {321, nullptr, "GetUniquePadsFromNpad"},
             {322, nullptr, "GetIrSensorState"},
             {323, nullptr, "GetXcdHandleForNpadWithIrSensor"},
@@ -995,8 +984,6 @@ public:
             {513, nullptr, "EndPermitVibrationSession"},
             {520, nullptr, "EnableHandheldHids"},
             {521, nullptr, "DisableHandheldHids"},
-            {522, nullptr, "SetJoyConRailEnabled"},
-            {523, nullptr, "IsJoyConRailEnabled"},
             {540, nullptr, "AcquirePlayReportControllerUsageUpdateEvent"},
             {541, nullptr, "GetPlayReportControllerUsages"},
             {542, nullptr, "AcquirePlayReportRegisteredDeviceUpdateEvent"},
@@ -1023,7 +1010,6 @@ public:
             {809, nullptr, "GetUniquePadSerialNumber"},
             {810, nullptr, "GetUniquePadControllerNumber"},
             {811, nullptr, "GetSixAxisSensorUserCalibrationStage"},
-            {812, nullptr, "GetConsoleUniqueSixAxisSensorHandle"},
             {821, nullptr, "StartAnalogStickManualCalibration"},
             {822, nullptr, "RetryCurrentAnalogStickManualCalibrationStage"},
             {823, nullptr, "CancelAnalogStickManualCalibration"},
@@ -1034,8 +1020,6 @@ public:
             {828, nullptr, "IsAnalogStickInReleasePosition"},
             {829, nullptr, "IsAnalogStickInCircumference"},
             {830, nullptr, "SetNotificationLedPattern"},
-            {831, nullptr, "SetNotificationLedPatternWithTimeout"},
-            {832, nullptr, "PrepareHidsForNotificationWake"},
             {850, nullptr, "IsUsbFullKeyControllerEnabled"},
             {851, nullptr, "EnableUsbFullKeyController"},
             {852, nullptr, "IsUsbConnected"},
@@ -1065,13 +1049,6 @@ public:
             {1132, nullptr, "CheckUsbFirmwareUpdateRequired"},
             {1133, nullptr, "StartUsbFirmwareUpdate"},
             {1134, nullptr, "GetUsbFirmwareUpdateState"},
-            {1150, nullptr, "SetTouchScreenMagnification"},
-            {1151, nullptr, "GetTouchScreenFirmwareVersion"},
-            {1152, nullptr, "SetTouchScreenDefaultConfiguration"},
-            {1153, nullptr, "GetTouchScreenDefaultConfiguration"},
-            {1154, nullptr, "IsFirmwareAvailableForNotification"},
-            {1155, nullptr, "SetForceHandheldStyleVibration"},
-            {1156, nullptr, "SendConnectionTriggerWithoutTimeoutEvent"},
         };
         // clang-format on
 

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

@@ -67,9 +67,9 @@ private:
     void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
     void UpdateControllers(u64 userdata, s64 cycles_late);
 
-    std::shared_ptr<Kernel::SharedMemory> shared_mem;
+    Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;
 
-    std::shared_ptr<Core::Timing::EventType> pad_update_event;
+    Core::Timing::EventType* pad_update_event;
     Core::System& system;
 
     std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>

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

@@ -37,7 +37,7 @@ private:
     void RunIrLedProcessor(Kernel::HLERequestContext& ctx);
     void StopImageProcessorAsync(Kernel::HLERequestContext& ctx);
     void ActivateIrsensorWithFunctionLevel(Kernel::HLERequestContext& ctx);
-    std::shared_ptr<Kernel::SharedMemory> shared_mem;
+    Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;
     const u32 device_handle{0xABCD};
     Core::System& system;
 };

src/core/hle/service/mii/mii.cpp

@@ -50,8 +50,6 @@ public:
             {21, &IDatabaseService::GetIndex, "GetIndex"},
             {22, &IDatabaseService::SetInterfaceVersion, "SetInterfaceVersion"},
             {23, nullptr, "Convert"},
-            {24, nullptr, "ConvertCoreDataToCharInfo"},
-            {25, nullptr, "ConvertCharInfoToCoreData"},
         };
         // clang-format on
 

src/core/hle/service/ncm/ncm.cpp

@@ -61,8 +61,7 @@ public:
             {5, nullptr, "RegisterHtmlDocumentPath"},
             {6, nullptr, "UnregisterHtmlDocumentPath"},
             {7, nullptr, "RedirectHtmlDocumentPath"},
-            {8, nullptr, "Refresh"},
-            {9, nullptr, "RefreshExcluding"},
+            {8, nullptr, ""},
         };
         // clang-format on
 
@@ -78,8 +77,6 @@ public:
             {0, nullptr, "ResolveAddOnContentPath"},
             {1, nullptr, "RegisterAddOnContentStorage"},
             {2, nullptr, "UnregisterAllAddOnContentPath"},
-            {3, nullptr, "RefreshApplicationAddOnContent"},
-            {4, nullptr, "UnregisterApplicationAddOnContent"},
         };
         // clang-format on
 
@@ -121,7 +118,6 @@ public:
             {10, nullptr, "InactivateContentStorage"},
             {11, nullptr, "ActivateContentMetaDatabase"},
             {12, nullptr, "InactivateContentMetaDatabase"},
-            {13, nullptr, "InvalidateRightsIdCache"},
         };
         // clang-format on
 

src/core/hle/service/nfc/nfc.cpp

@@ -215,7 +215,6 @@ public:
             {411, nullptr, "AttachActivateEvent"},
             {412, nullptr, "AttachDeactivateEvent"},
             {500, nullptr, "SetNfcEnabled"},
-            {510, nullptr, "OutputTestWave"},
             {1000, nullptr, "ReadMifare"},
             {1001, nullptr, "WriteMifare"},
             {1300, nullptr, "SendCommandByPassThrough"},

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

@@ -342,7 +342,7 @@ bool Module::Interface::LoadAmiibo(const std::vector<u8>& buffer) {
     return true;
 }
 
-const std::shared_ptr<Kernel::ReadableEvent>& Module::Interface::GetNFCEvent() const {
+const Kernel::SharedPtr<Kernel::ReadableEvent>& Module::Interface::GetNFCEvent() const {
     return nfc_tag_load.readable;
 }
 

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

@@ -34,7 +34,7 @@ public:
 
         void CreateUserInterface(Kernel::HLERequestContext& ctx);
         bool LoadAmiibo(const std::vector<u8>& buffer);
-        const std::shared_ptr<Kernel::ReadableEvent>& GetNFCEvent() const;
+        const Kernel::SharedPtr<Kernel::ReadableEvent>& GetNFCEvent() const;
         const AmiiboFile& GetAmiiboBuffer() const;
 
     private:

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

@@ -222,7 +222,6 @@ private:
 
 IGeneralService::IGeneralService(Core::System& system)
     : ServiceFramework("IGeneralService"), system(system) {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {1, &IGeneralService::GetClientId, "GetClientId"},
         {2, &IGeneralService::CreateScanRequest, "CreateScanRequest"},
@@ -261,14 +260,7 @@ IGeneralService::IGeneralService(Core::System& system)
         {36, nullptr, "GetCurrentAccessPoint"},
         {37, nullptr, "Shutdown"},
         {38, nullptr, "GetAllowedChannels"},
-        {39, nullptr, "NotifyApplicationSuspended"},
-        {40, nullptr, "SetAcceptableNetworkTypeFlag"},
-        {41, nullptr, "GetAcceptableNetworkTypeFlag"},
-        {42, nullptr, "NotifyConnectionStateChanged"},
-        {43, nullptr, "SetWowlDelayedWakeTime"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

src/core/hle/service/nim/nim.cpp

@@ -116,8 +116,6 @@ public:
             {500, nullptr, "RequestSyncTicket"},
             {501, nullptr, "RequestDownloadTicket"},
             {502, nullptr, "RequestDownloadTicketForPrepurchasedContents"},
-            {503, nullptr, "RequestSyncTicket"},
-            {504, nullptr, "RequestDownloadTicketForPrepurchasedContents2"},
         };
         // clang-format on
 

src/core/hle/service/npns/npns.cpp

@@ -44,10 +44,6 @@ public:
             {113, nullptr, "DestroyJid"},
             {114, nullptr, "AttachJid"},
             {115, nullptr, "DetachJid"},
-            {120, nullptr, "CreateNotificationReceiver"},
-            {151, nullptr, "GetStateWithHandover"},
-            {152, nullptr, "GetStateChangeEventWithHandover"},
-            {153, nullptr, "GetDropEventWithHandover"},
             {201, nullptr, "RequestChangeStateForceTimed"},
             {202, nullptr, "RequestChangeStateForceAsync"},
         };
@@ -78,9 +74,6 @@ public:
             {104, nullptr, "GetStatistics"},
             {111, nullptr, "GetJid"},
             {120, nullptr, "CreateNotificationReceiver"},
-            {151, nullptr, "GetStateWithHandover"},
-            {152, nullptr, "GetStateChangeEventWithHandover"},
-            {153, nullptr, "GetDropEventWithHandover"},
         };
         // clang-format on
 

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

@@ -106,7 +106,6 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {96, nullptr, "AcquireApplicationLaunchInfo"},
         {97, nullptr, "GetMainApplicationProgramIndex2"},
         {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
-        {99, nullptr, "LaunchDevMenu"},
         {100, nullptr, "ResetToFactorySettings"},
         {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
         {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
@@ -131,8 +130,6 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {404, nullptr, "InvalidateApplicationControlCache"},
         {405, nullptr, "ListApplicationControlCacheEntryInfo"},
         {406, nullptr, "GetApplicationControlProperty"},
-        {407, nullptr, "ListApplicationTitle"},
-        {408, nullptr, "ListApplicationIcon"},
         {502, nullptr, "RequestCheckGameCardRegistration"},
         {503, nullptr, "RequestGameCardRegistrationGoldPoint"},
         {504, nullptr, "RequestRegisterGameCard"},
@@ -141,7 +138,6 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {507, nullptr, "EnsureGameCardAccess"},
         {508, nullptr, "GetLastGameCardMountFailureResult"},
         {509, nullptr, "ListApplicationIdOnGameCard"},
-        {510, nullptr, "GetGameCardPlatformRegion"},
         {600, nullptr, "CountApplicationContentMeta"},
         {601, nullptr, "ListApplicationContentMetaStatus"},
         {602, nullptr, "ListAvailableAddOnContent"},
@@ -172,9 +168,6 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {910, nullptr, "HasApplicationRecord"},
         {911, nullptr, "SetPreInstalledApplication"},
         {912, nullptr, "ClearPreInstalledApplicationFlag"},
-        {913, nullptr, "ListAllApplicationRecord"},
-        {914, nullptr, "HideApplicationRecord"},
-        {915, nullptr, "ShowApplicationRecord"},
         {1000, nullptr, "RequestVerifyApplicationDeprecated"},
         {1001, nullptr, "CorruptApplicationForDebug"},
         {1002, nullptr, "RequestVerifyAddOnContentsRights"},
@@ -197,14 +190,12 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {1502, nullptr, "GetLastSdCardFormatUnexpectedResult"},
         {1504, nullptr, "InsertSdCard"},
         {1505, nullptr, "RemoveSdCard"},
-        {1506, nullptr, "GetSdCardStartupStatus"},
         {1600, nullptr, "GetSystemSeedForPseudoDeviceId"},
         {1601, nullptr, "ResetSystemSeedForPseudoDeviceId"},
         {1700, nullptr, "ListApplicationDownloadingContentMeta"},
         {1701, nullptr, "GetApplicationView"},
         {1702, nullptr, "GetApplicationDownloadTaskStatus"},
         {1703, nullptr, "GetApplicationViewDownloadErrorContext"},
-        {1704, nullptr, "GetApplicationViewWithPromotionInfo"},
         {1800, nullptr, "IsNotificationSetupCompleted"},
         {1801, nullptr, "GetLastNotificationInfoCount"},
         {1802, nullptr, "ListLastNotificationInfo"},
@@ -232,7 +223,6 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {2017, nullptr, "CreateDownloadTask"},
         {2018, nullptr, "GetApplicationDeliveryInfoHash"},
         {2050, nullptr, "GetApplicationRightsOnClient"},
-        {2051, nullptr, "InvalidateRightsIdCache"},
         {2100, nullptr, "GetApplicationTerminateResult"},
         {2101, nullptr, "GetRawApplicationTerminateResult"},
         {2150, nullptr, "CreateRightsEnvironment"},
@@ -240,8 +230,6 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {2152, nullptr, "ActivateRightsEnvironment"},
         {2153, nullptr, "DeactivateRightsEnvironment"},
         {2154, nullptr, "ForceActivateRightsContextForExit"},
-        {2155, nullptr, "UpdateRightsEnvironmentStatus"},
-        {2156, nullptr, "CreateRightsEnvironmentForPreomia"},
         {2160, nullptr, "AddTargetApplicationToRightsEnvironment"},
         {2161, nullptr, "SetUsersToRightsEnvironment"},
         {2170, nullptr, "GetRightsEnvironmentStatus"},
@@ -255,20 +243,6 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {2201, nullptr, "GetInstalledApplicationCopyIdentifier"},
         {2250, nullptr, "RequestReportActiveELicence"},
         {2300, nullptr, "ListEventLog"},
-        {2350, nullptr, "PerformAutoUpdateByApplicationId"},
-        {2351, nullptr, "RequestNoDownloadRightsErrorResolution"},
-        {2352, nullptr, "RequestResolveNoDownloadRightsError"},
-        {2400, nullptr, "GetPromotionInfo"},
-        {2401, nullptr, "CountPromotionInfo"},
-        {2402, nullptr, "ListPromotionInfo"},
-        {2403, nullptr, "ImportPromotionJsonForDebug"},
-        {2404, nullptr, "ClearPromotionInfoForDebug"},
-        {2500, nullptr, "ConfirmAvailableTime"},
-        {2510, nullptr, "CreateApplicationResource"},
-        {2511, nullptr, "GetApplicationResource"},
-        {2513, nullptr, "LaunchPreomia"},
-        {2514, nullptr, "ClearTaskOfAsyncTaskManager"},
-        {2800, nullptr, "GetApplicationIdOfPreomia"},
     };
     // clang-format on
 
@@ -489,7 +463,6 @@ IECommerceInterface::IECommerceInterface() : ServiceFramework{"IECommerceInterfa
         {3, nullptr, "RequestSyncRights"},
         {4, nullptr, "RequestUnlinkDevice"},
         {5, nullptr, "RequestRevokeAllELicense"},
-        {6, nullptr, "RequestSyncRightsBasedOnAssignedELicenses"},
     };
     // clang-format on
 

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

@@ -141,7 +141,7 @@ struct PL_U::Impl {
     }
 
     /// Handle to shared memory region designated for a shared font
-    std::shared_ptr<Kernel::SharedMemory> shared_font_mem;
+    Kernel::SharedPtr<Kernel::SharedMemory> shared_font_mem;
 
     /// Backing memory for the shared font data
     std::shared_ptr<Kernel::PhysicalMemory> shared_font;
@@ -152,7 +152,7 @@ struct PL_U::Impl {
 
 PL_U::PL_U(Core::System& system)
     : ServiceFramework("pl:u"), impl{std::make_unique<Impl>()}, system(system) {
-    // clang-format off
+
     static const FunctionInfo functions[] = {
         {0, &PL_U::RequestLoad, "RequestLoad"},
         {1, &PL_U::GetLoadState, "GetLoadState"},
@@ -160,13 +160,7 @@ PL_U::PL_U(Core::System& system)
         {3, &PL_U::GetSharedMemoryAddressOffset, "GetSharedMemoryAddressOffset"},
         {4, &PL_U::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"},
         {5, &PL_U::GetSharedFontInOrderOfPriority, "GetSharedFontInOrderOfPriority"},
-        {6, nullptr, "GetSharedFontInOrderOfPriorityForSystem"},
-        {100, nullptr, "RequestApplicationFunctionAuthorization"},
-        {101, nullptr, "RequestApplicationFunctionAuthorizationForSystem"},
-        {1000, nullptr, "LoadNgWordDataForPlatformRegionChina"},
-        {1001, nullptr, "GetNgWordDataSizeForPlatformRegionChina"},
     };
-    // clang-format on
     RegisterHandlers(functions);
 
     auto& fsc = system.GetFileSystemController();

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

@@ -61,7 +61,7 @@ void NVDRV::IoctlBase(Kernel::HLERequestContext& ctx, IoctlVersion version) {
     if (ctrl.must_delay) {
         ctrl.fresh_call = false;
         ctx.SleepClientThread("NVServices::DelayedResponse", ctrl.timeout,
-                              [=](std::shared_ptr<Kernel::Thread> thread,
+                              [=](Kernel::SharedPtr<Kernel::Thread> thread,
                                   Kernel::HLERequestContext& ctx,
                                   Kernel::ThreadWakeupReason reason) {
                                   IoctlCtrl ctrl2{ctrl};

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

@@ -100,11 +100,11 @@ void Module::SignalSyncpt(const u32 syncpoint_id, const u32 value) {
     }
 }
 
-std::shared_ptr<Kernel::ReadableEvent> Module::GetEvent(const u32 event_id) const {
+Kernel::SharedPtr<Kernel::ReadableEvent> Module::GetEvent(const u32 event_id) const {
     return events_interface.events[event_id].readable;
 }
 
-std::shared_ptr<Kernel::WritableEvent> Module::GetEventWriteable(const u32 event_id) const {
+Kernel::SharedPtr<Kernel::WritableEvent> Module::GetEventWriteable(const u32 event_id) const {
     return events_interface.events[event_id].writable;
 }
 

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

@@ -114,9 +114,9 @@ public:
 
     void SignalSyncpt(const u32 syncpoint_id, const u32 value);
 
-    std::shared_ptr<Kernel::ReadableEvent> GetEvent(u32 event_id) const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetEvent(u32 event_id) const;
 
-    std::shared_ptr<Kernel::WritableEvent> GetEventWriteable(u32 event_id) const;
+    Kernel::SharedPtr<Kernel::WritableEvent> GetEventWriteable(u32 event_id) const;
 
 private:
     /// Id to use for the next open file descriptor.

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -117,11 +117,11 @@ u32 BufferQueue::Query(QueryType type) {
     return 0;
 }
 
-std::shared_ptr<Kernel::WritableEvent> BufferQueue::GetWritableBufferWaitEvent() const {
+Kernel::SharedPtr<Kernel::WritableEvent> BufferQueue::GetWritableBufferWaitEvent() const {
     return buffer_wait_event.writable;
 }
 
-std::shared_ptr<Kernel::ReadableEvent> BufferQueue::GetBufferWaitEvent() const {
+Kernel::SharedPtr<Kernel::ReadableEvent> BufferQueue::GetBufferWaitEvent() const {
     return buffer_wait_event.readable;
 }
 

src/core/hle/service/nvflinger/buffer_queue.h

@@ -93,9 +93,9 @@ public:
         return id;
     }
 
-    std::shared_ptr<Kernel::WritableEvent> GetWritableBufferWaitEvent() const;
+    Kernel::SharedPtr<Kernel::WritableEvent> GetWritableBufferWaitEvent() const;
 
-    std::shared_ptr<Kernel::ReadableEvent> GetBufferWaitEvent() const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetBufferWaitEvent() const;
 
 private:
     u32 id;

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -37,8 +37,8 @@ NVFlinger::NVFlinger(Core::System& system) : system(system) {
     displays.emplace_back(4, "Null", system);
 
     // Schedule the screen composition events
-    composition_event =
-        Core::Timing::CreateEvent("ScreenComposition", [this](u64 userdata, s64 cycles_late) {
+    composition_event = system.CoreTiming().RegisterEvent(
+        "ScreenComposition", [this](u64 userdata, s64 cycles_late) {
             Compose();
             const auto ticks =
                 Settings::values.force_30fps_mode ? frame_ticks_30fps : GetNextTicks();
@@ -98,7 +98,7 @@ std::optional<u32> NVFlinger::FindBufferQueueId(u64 display_id, u64 layer_id) co
     return layer->GetBufferQueue().GetId();
 }
 
-std::shared_ptr<Kernel::ReadableEvent> NVFlinger::FindVsyncEvent(u64 display_id) const {
+Kernel::SharedPtr<Kernel::ReadableEvent> NVFlinger::FindVsyncEvent(u64 display_id) const {
     auto* const display = FindDisplay(display_id);
 
     if (display == nullptr) {

src/core/hle/service/nvflinger/nvflinger.h

@@ -62,7 +62,7 @@ public:
     /// Gets the vsync event for the specified display.
     ///
     /// If an invalid display ID is provided, then nullptr is returned.
-    std::shared_ptr<Kernel::ReadableEvent> FindVsyncEvent(u64 display_id) const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> FindVsyncEvent(u64 display_id) const;
 
     /// Obtains a buffer queue identified by the ID.
     BufferQueue& FindBufferQueue(u32 id);
@@ -103,7 +103,7 @@ private:
     u32 swap_interval = 1;
 
     /// Event that handles screen composition.
-    std::shared_ptr<Core::Timing::EventType> composition_event;
+    Core::Timing::EventType* composition_event;
 
     Core::System& system;
 };

src/core/hle/service/pm/pm.cpp

@@ -16,9 +16,9 @@ constexpr ResultCode ERROR_PROCESS_NOT_FOUND{ErrorModule::PM, 1};
 
 constexpr u64 NO_PROCESS_FOUND_PID{0};
 
-std::optional<std::shared_ptr<Kernel::Process>> SearchProcessList(
-    const std::vector<std::shared_ptr<Kernel::Process>>& process_list,
-    std::function<bool(const std::shared_ptr<Kernel::Process>&)> predicate) {
+std::optional<Kernel::SharedPtr<Kernel::Process>> SearchProcessList(
+    const std::vector<Kernel::SharedPtr<Kernel::Process>>& process_list,
+    std::function<bool(const Kernel::SharedPtr<Kernel::Process>&)> predicate) {
     const auto iter = std::find_if(process_list.begin(), process_list.end(), predicate);
 
     if (iter == process_list.end()) {
@@ -29,7 +29,7 @@ std::optional<std::shared_ptr<Kernel::Process>> SearchProcessList(
 }
 
 void GetApplicationPidGeneric(Kernel::HLERequestContext& ctx,
-                              const std::vector<std::shared_ptr<Kernel::Process>>& process_list) {
+                              const std::vector<Kernel::SharedPtr<Kernel::Process>>& process_list) {
     const auto process = SearchProcessList(process_list, [](const auto& process) {
         return process->GetProcessID() == Kernel::Process::ProcessIDMin;
     });
@@ -124,7 +124,7 @@ private:
 
 class Info final : public ServiceFramework<Info> {
 public:
-    explicit Info(const std::vector<std::shared_ptr<Kernel::Process>>& process_list)
+    explicit Info(const std::vector<Kernel::SharedPtr<Kernel::Process>>& process_list)
         : ServiceFramework{"pm:info"}, process_list(process_list) {
         static const FunctionInfo functions[] = {
             {0, &Info::GetTitleId, "GetTitleId"},
@@ -154,7 +154,7 @@ private:
         rb.Push((*process)->GetTitleID());
     }
 
-    const std::vector<std::shared_ptr<Kernel::Process>>& process_list;
+    const std::vector<Kernel::SharedPtr<Kernel::Process>>& process_list;
 };
 
 class Shell final : public ServiceFramework<Shell> {
@@ -172,7 +172,7 @@ public:
             {6, &Shell::GetApplicationPid, "GetApplicationPid"},
             {7, nullptr, "BoostSystemMemoryResourceLimit"},
             {8, nullptr, "EnableAdditionalSystemThreads"},
-            {9, nullptr, "GetBootFinishedEventHandle"},
+            {9, nullptr, "GetUnimplementedEventHandle"},
         };
         // clang-format on
 

src/core/hle/service/prepo/prepo.cpp

@@ -25,7 +25,6 @@ public:
             {10103, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::New>, "SaveReportWithUser"},
             {10200, nullptr, "RequestImmediateTransmission"},
             {10300, nullptr, "GetTransmissionStatus"},
-            {10400, nullptr, "GetSystemSessionId"},
             {20100, &PlayReport::SaveSystemReport, "SaveSystemReport"},
             {20101, &PlayReport::SaveSystemReportWithUser, "SaveSystemReportWithUser"},
             {20200, nullptr, "SetOperationMode"},

src/core/hle/service/service.cpp

@@ -116,7 +116,7 @@ void ServiceFrameworkBase::InstallAsNamedPort() {
     port_installed = true;
 }
 
-std::shared_ptr<Kernel::ClientPort> ServiceFrameworkBase::CreatePort() {
+Kernel::SharedPtr<Kernel::ClientPort> ServiceFrameworkBase::CreatePort() {
     ASSERT(!port_installed);
 
     auto& kernel = Core::System::GetInstance().Kernel();

src/core/hle/service/service.h

@@ -65,7 +65,7 @@ public:
     /// Creates a port pair and registers it on the kernel's global port registry.
     void InstallAsNamedPort();
     /// Creates and returns an unregistered port for the service.
-    std::shared_ptr<Kernel::ClientPort> CreatePort();
+    Kernel::SharedPtr<Kernel::ClientPort> CreatePort();
 
     void InvokeRequest(Kernel::HLERequestContext& ctx);
 

src/core/hle/service/set/set.cpp

@@ -124,7 +124,6 @@ SET::SET() : ServiceFramework("set") {
         {7, nullptr, "GetKeyCodeMap"},
         {8, &SET::GetQuestFlag, "GetQuestFlag"},
         {9, nullptr, "GetKeyCodeMap2"},
-        {10, nullptr, "GetFirmwareVersionForDebug"},
     };
     // clang-format on
 

src/core/hle/service/set/set_cal.cpp

@@ -7,7 +7,6 @@
 namespace Service::Set {
 
 SET_CAL::SET_CAL() : ServiceFramework("set:cal") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetBluetoothBdAddress"},
         {1, nullptr, "GetConfigurationId1"},
@@ -41,18 +40,8 @@ SET_CAL::SET_CAL() : ServiceFramework("set:cal") {
         {30, nullptr, "GetAmiiboEcqvBlsCertificate"},
         {31, nullptr, "GetAmiiboEcqvBlsRootCertificate"},
         {32, nullptr, "GetUsbTypeCPowerSourceCircuitVersion"},
-        {33, nullptr, "GetAnalogStickModuleTypeL"},
-        {34, nullptr, "GetAnalogStickModelParameterL"},
-        {35, nullptr, "GetAnalogStickFactoryCalibrationL"},
-        {36, nullptr, "GetAnalogStickModuleTypeR"},
-        {37, nullptr, "GetAnalogStickModelParameterR"},
-        {38, nullptr, "GetAnalogStickFactoryCalibrationR"},
-        {39, nullptr, "GetConsoleSixAxisSensorModuleType"},
-        {40, nullptr, "GetConsoleSixAxisSensorHorizontalOffset"},
         {41, nullptr, "GetBatteryVersion"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

src/core/hle/service/set/set_fd.cpp

@@ -7,7 +7,6 @@
 namespace Service::Set {
 
 SET_FD::SET_FD() : ServiceFramework("set:fd") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {2, nullptr, "SetSettingsItemValue"},
         {3, nullptr, "ResetSettingsItemValue"},
@@ -17,10 +16,7 @@ SET_FD::SET_FD() : ServiceFramework("set:fd") {
         {20, nullptr, "SetWebInspectorFlag"},
         {21, nullptr, "SetAllowedSslHosts"},
         {22, nullptr, "SetHostFsMountPoint"},
-        {23, nullptr, "SetMemoryUsageRateFlag"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

src/core/hle/service/set/set_sys.cpp

@@ -273,21 +273,10 @@ SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
         {171, nullptr, "SetChineseTraditionalInputMethod"},
         {172, nullptr, "GetPtmCycleCountReliability"},
         {173, nullptr, "SetPtmCycleCountReliability"},
-        {174, nullptr, "GetHomeMenuScheme"},
         {175, nullptr, "GetThemeSettings"},
         {176, nullptr, "SetThemeSettings"},
         {177, nullptr, "GetThemeKey"},
         {178, nullptr, "SetThemeKey"},
-        {179, nullptr, "GetZoomFlag"},
-        {180, nullptr, "SetZoomFlag"},
-        {181, nullptr, "GetT"},
-        {182, nullptr, "SetT"},
-        {183, nullptr, "GetPlatformRegion"},
-        {184, nullptr, "SetPlatformRegion"},
-        {185, nullptr, "GetHomeMenuSchemeModel"},
-        {186, nullptr, "GetMemoryUsageRateFlag"},
-        {187, nullptr, "GetTouchScreenMode"},
-        {188, nullptr, "SetTouchScreenMode"},
     };
     // clang-format on