201 files changed, 8690 insertions, 2779 deletions

diff --git a/src/audio_core/renderer/adsp/audio_renderer.cpp b/src/audio_core/renderer/adsp/audio_renderer.cpp
index d982ef630..78c15629b 100644
--- a/src/audio_core/renderer/adsp/audio_renderer.cpp
+++ b/src/audio_core/renderer/adsp/audio_renderer.cpp
@@ -132,7 +132,7 @@ void AudioRenderer::CreateSinkStreams() {
 }
 
 void AudioRenderer::ThreadFunc() {
-    constexpr char name[]{"AudioRenderer"};
+    static constexpr char name[]{"AudioRenderer"};
     MicroProfileOnThreadCreate(name);
     Common::SetCurrentThreadName(name);
     Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
diff --git a/src/audio_core/renderer/command/command_buffer.cpp b/src/audio_core/renderer/command/command_buffer.cpp
index 8c6fe97e7..0bd418306 100644
--- a/src/audio_core/renderer/command/command_buffer.cpp
+++ b/src/audio_core/renderer/command/command_buffer.cpp
@@ -251,8 +251,8 @@ void CommandBuffer::GenerateBiquadFilterCommand(const s32 node_id, EffectInfoBas
 
     const auto& parameter{
         *reinterpret_cast<BiquadFilterInfo::ParameterVersion1*>(effect_info.GetParameter())};
-    const auto state{
-        reinterpret_cast<VoiceState::BiquadFilterState*>(effect_info.GetStateBuffer())};
+    const auto state{reinterpret_cast<VoiceState::BiquadFilterState*>(
+        effect_info.GetStateBuffer() + channel * sizeof(VoiceState::BiquadFilterState))};
 
     cmd.input = buffer_offset + parameter.inputs[channel];
     cmd.output = buffer_offset + parameter.outputs[channel];
diff --git a/src/audio_core/renderer/command/command_generator.cpp b/src/audio_core/renderer/command/command_generator.cpp
index 2ea50d128..fba84c7bd 100644
--- a/src/audio_core/renderer/command/command_generator.cpp
+++ b/src/audio_core/renderer/command/command_generator.cpp
@@ -46,7 +46,7 @@ void CommandGenerator::GenerateDataSourceCommand(VoiceInfo& voice_info,
             while (destination != nullptr) {
                 if (destination->IsConfigured()) {
                     auto mix_id{destination->GetMixId()};
-                    if (mix_id < mix_context.GetCount()) {
+                    if (mix_id < mix_context.GetCount() && mix_id != UnusedSplitterId) {
                         auto mix_info{mix_context.GetInfo(mix_id)};
                         command_buffer.GenerateDepopPrepareCommand(
                             voice_info.node_id, voice_state, render_context.depop_buffer,
diff --git a/src/audio_core/renderer/command/effect/aux_.cpp b/src/audio_core/renderer/command/effect/aux_.cpp
index e76db893f..c5650effa 100644
--- a/src/audio_core/renderer/command/effect/aux_.cpp
+++ b/src/audio_core/renderer/command/effect/aux_.cpp
@@ -4,6 +4,7 @@
 #include "audio_core/renderer/adsp/command_list_processor.h"
 #include "audio_core/renderer/command/effect/aux_.h"
 #include "audio_core/renderer/effect/aux_.h"
+#include "core/core.h"
 #include "core/memory.h"
 
 namespace AudioCore::AudioRenderer {
@@ -19,10 +20,24 @@ static void ResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_in
         return;
     }
 
-    auto info{reinterpret_cast<AuxInfo::AuxInfoDsp*>(memory.GetPointer(aux_info))};
-    info->read_offset = 0;
-    info->write_offset = 0;
-    info->total_sample_count = 0;
+    AuxInfo::AuxInfoDsp info{};
+    auto info_ptr{&info};
+    bool host_safe{(aux_info & Core::Memory::YUZU_PAGEMASK) <=
+                   (Core::Memory::YUZU_PAGESIZE - sizeof(AuxInfo::AuxInfoDsp))};
+
+    if (host_safe) [[likely]] {
+        info_ptr = memory.GetPointer<AuxInfo::AuxInfoDsp>(aux_info);
+    } else {
+        memory.ReadBlockUnsafe(aux_info, info_ptr, sizeof(AuxInfo::AuxInfoDsp));
+    }
+
+    info_ptr->read_offset = 0;
+    info_ptr->write_offset = 0;
+    info_ptr->total_sample_count = 0;
+
+    if (!host_safe) [[unlikely]] {
+        memory.WriteBlockUnsafe(aux_info, info_ptr, sizeof(AuxInfo::AuxInfoDsp));
+    }
 }
 
 /**
@@ -40,11 +55,10 @@ static void ResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_in
  * @param update_count - If non-zero, send_info_ will be updated.
  * @return Number of samples written.
  */
-static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_info_,
-                             [[maybe_unused]] u32 sample_count, const CpuAddr send_buffer,
-                             const u32 count_max, std::span<const s32> input,
-                             const u32 write_count_, const u32 write_offset,
-                             const u32 update_count) {
+static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr send_info_,
+                             [[maybe_unused]] u32 sample_count, CpuAddr send_buffer, u32 count_max,
+                             std::span<const s32> input, u32 write_count_, u32 write_offset,
+                             u32 update_count) {
     if (write_count_ > count_max) {
         LOG_ERROR(Service_Audio,
                   "write_count must be smaller than count_max! write_count {}, count_max {}",
@@ -52,6 +66,11 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_in
         return 0;
     }
 
+    if (send_info_ == 0) {
+        LOG_ERROR(Service_Audio, "send_info_ is 0!");
+        return 0;
+    }
+
     if (input.empty()) {
         LOG_ERROR(Service_Audio, "input buffer is empty!");
         return 0;
@@ -67,33 +86,47 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_in
     }
 
     AuxInfo::AuxInfoDsp send_info{};
-    memory.ReadBlockUnsafe(send_info_, &send_info, sizeof(AuxInfo::AuxInfoDsp));
+    auto send_ptr = &send_info;
+    bool host_safe = (send_info_ & Core::Memory::YUZU_PAGEMASK) <=
+                     (Core::Memory::YUZU_PAGESIZE - sizeof(AuxInfo::AuxInfoDsp));
 
-    u32 target_write_offset{send_info.write_offset + write_offset};
-    if (target_write_offset > count_max || write_count_ == 0) {
+    if (host_safe) [[likely]] {
+        send_ptr = memory.GetPointer<AuxInfo::AuxInfoDsp>(send_info_);
+    } else {
+        memory.ReadBlockUnsafe(send_info_, send_ptr, sizeof(AuxInfo::AuxInfoDsp));
+    }
+
+    u32 target_write_offset{send_ptr->write_offset + write_offset};
+    if (target_write_offset > count_max) {
         return 0;
     }
 
     u32 write_count{write_count_};
-    u32 write_pos{0};
+    u32 read_pos{0};
     while (write_count > 0) {
         u32 to_write{std::min(count_max - target_write_offset, write_count)};
-
-        if (to_write > 0) {
+        const auto write_addr = send_buffer + target_write_offset * sizeof(s32);
+        bool write_safe{(write_addr & Core::Memory::YUZU_PAGEMASK) <=
+                        (Core::Memory::YUZU_PAGESIZE - (write_addr + to_write * sizeof(s32)))};
+        if (write_safe) [[likely]] {
+            auto ptr = memory.GetPointer(write_addr);
+            std::memcpy(ptr, &input[read_pos], to_write * sizeof(s32));
+        } else {
             memory.WriteBlockUnsafe(send_buffer + target_write_offset * sizeof(s32),
-                                    &input[write_pos], to_write * sizeof(s32));
+                                    &input[read_pos], to_write * sizeof(s32));
         }
-
         target_write_offset = (target_write_offset + to_write) % count_max;
         write_count -= to_write;
-        write_pos += to_write;
+        read_pos += to_write;
     }
 
     if (update_count) {
-        send_info.write_offset = (send_info.write_offset + update_count) % count_max;
+        send_ptr->write_offset = (send_ptr->write_offset + update_count) % count_max;
     }
 
-    memory.WriteBlockUnsafe(send_info_, &send_info, sizeof(AuxInfo::AuxInfoDsp));
+    if (!host_safe) [[unlikely]] {
+        memory.WriteBlockUnsafe(send_info_, send_ptr, sizeof(AuxInfo::AuxInfoDsp));
+    }
 
     return write_count_;
 }
@@ -102,7 +135,7 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_in
  * Read the given memory at return_buffer into the output mix buffer, and update return_info_ if
  * update_count is set, to notify the game that an update happened.
  *
- * @param memory        - Core memory for writing.
+ * @param memory        - Core memory for reading.
  * @param return_info_  - Meta information for where to read the mix buffer.
  * @param return_buffer - Memory address to read the samples from.
  * @param count_max     - Maximum number of samples in the receiving buffer.
@@ -112,16 +145,21 @@ static u32 WriteAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr send_in
  * @param update_count  - If non-zero, send_info_ will be updated.
  * @return Number of samples read.
  */
-static u32 ReadAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr return_info_,
-                            const CpuAddr return_buffer, const u32 count_max, std::span<s32> output,
-                            const u32 count_, const u32 read_offset, const u32 update_count) {
+static u32 ReadAuxBufferDsp(Core::Memory::Memory& memory, CpuAddr return_info_,
+                            CpuAddr return_buffer, u32 count_max, std::span<s32> output,
+                            u32 read_count_, u32 read_offset, u32 update_count) {
     if (count_max == 0) {
         return 0;
     }
 
-    if (count_ > count_max) {
+    if (read_count_ > count_max) {
         LOG_ERROR(Service_Audio, "count must be smaller than count_max! count {}, count_max {}",
-                  count_, count_max);
+                  read_count_, count_max);
+        return 0;
+    }
+
+    if (return_info_ == 0) {
+        LOG_ERROR(Service_Audio, "return_info_ is 0!");
         return 0;
     }
 
@@ -136,35 +174,49 @@ static u32 ReadAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr return_i
     }
 
     AuxInfo::AuxInfoDsp return_info{};
-    memory.ReadBlockUnsafe(return_info_, &return_info, sizeof(AuxInfo::AuxInfoDsp));
+    auto return_ptr = &return_info;
+    bool host_safe = (return_info_ & Core::Memory::YUZU_PAGEMASK) <=
+                     (Core::Memory::YUZU_PAGESIZE - sizeof(AuxInfo::AuxInfoDsp));
+
+    if (host_safe) [[likely]] {
+        return_ptr = memory.GetPointer<AuxInfo::AuxInfoDsp>(return_info_);
+    } else {
+        memory.ReadBlockUnsafe(return_info_, return_ptr, sizeof(AuxInfo::AuxInfoDsp));
+    }
 
-    u32 target_read_offset{return_info.read_offset + read_offset};
+    u32 target_read_offset{return_ptr->read_offset + read_offset};
     if (target_read_offset > count_max) {
         return 0;
     }
 
-    u32 read_count{count_};
-    u32 read_pos{0};
+    u32 read_count{read_count_};
+    u32 write_pos{0};
     while (read_count > 0) {
         u32 to_read{std::min(count_max - target_read_offset, read_count)};
-
-        if (to_read > 0) {
+        const auto read_addr = return_buffer + target_read_offset * sizeof(s32);
+        bool read_safe{(read_addr & Core::Memory::YUZU_PAGEMASK) <=
+                       (Core::Memory::YUZU_PAGESIZE - (read_addr + to_read * sizeof(s32)))};
+        if (read_safe) [[likely]] {
+            auto ptr = memory.GetPointer(read_addr);
+            std::memcpy(&output[write_pos], ptr, to_read * sizeof(s32));
+        } else {
             memory.ReadBlockUnsafe(return_buffer + target_read_offset * sizeof(s32),
-                                   &output[read_pos], to_read * sizeof(s32));
+                                   &output[write_pos], to_read * sizeof(s32));
         }
-
         target_read_offset = (target_read_offset + to_read) % count_max;
         read_count -= to_read;
-        read_pos += to_read;
+        write_pos += to_read;
     }
 
     if (update_count) {
-        return_info.read_offset = (return_info.read_offset + update_count) % count_max;
+        return_ptr->read_offset = (return_ptr->read_offset + update_count) % count_max;
     }
 
-    memory.WriteBlockUnsafe(return_info_, &return_info, sizeof(AuxInfo::AuxInfoDsp));
+    if (!host_safe) [[unlikely]] {
+        memory.WriteBlockUnsafe(return_info_, return_ptr, sizeof(AuxInfo::AuxInfoDsp));
+    }
 
-    return count_;
+    return read_count_;
 }
 
 void AuxCommand::Dump([[maybe_unused]] const ADSP::CommandListProcessor& processor,
@@ -189,7 +241,7 @@ void AuxCommand::Process(const ADSP::CommandListProcessor& processor) {
                                    update_count)};
 
         if (read != processor.sample_count) {
-            std::memset(&output_buffer[read], 0, processor.sample_count - read);
+            std::memset(&output_buffer[read], 0, (processor.sample_count - read) * sizeof(s32));
         }
     } else {
         ResetAuxBufferDsp(*processor.memory, send_buffer_info);
diff --git a/src/audio_core/renderer/command/effect/biquad_filter.cpp b/src/audio_core/renderer/command/effect/biquad_filter.cpp
index edb30ce72..dea6423dc 100644
--- a/src/audio_core/renderer/command/effect/biquad_filter.cpp
+++ b/src/audio_core/renderer/command/effect/biquad_filter.cpp
@@ -4,6 +4,7 @@
 #include "audio_core/renderer/adsp/command_list_processor.h"
 #include "audio_core/renderer/command/effect/biquad_filter.h"
 #include "audio_core/renderer/voice/voice_state.h"
+#include "common/bit_cast.h"
 
 namespace AudioCore::AudioRenderer {
 /**
@@ -19,21 +20,21 @@ namespace AudioCore::AudioRenderer {
 void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
                             std::array<s16, 3>& b_, std::array<s16, 2>& a_,
                             VoiceState::BiquadFilterState& state, const u32 sample_count) {
-    constexpr s64 min{std::numeric_limits<s32>::min()};
-    constexpr s64 max{std::numeric_limits<s32>::max()};
+    constexpr f64 min{std::numeric_limits<s32>::min()};
+    constexpr f64 max{std::numeric_limits<s32>::max()};
     std::array<f64, 3> b{Common::FixedPoint<50, 14>::from_base(b_[0]).to_double(),
                          Common::FixedPoint<50, 14>::from_base(b_[1]).to_double(),
                          Common::FixedPoint<50, 14>::from_base(b_[2]).to_double()};
     std::array<f64, 2> a{Common::FixedPoint<50, 14>::from_base(a_[0]).to_double(),
                          Common::FixedPoint<50, 14>::from_base(a_[1]).to_double()};
-    std::array<f64, 4> s{state.s0.to_double(), state.s1.to_double(), state.s2.to_double(),
-                         state.s3.to_double()};
+    std::array<f64, 4> s{Common::BitCast<f64>(state.s0), Common::BitCast<f64>(state.s1),
+                         Common::BitCast<f64>(state.s2), Common::BitCast<f64>(state.s3)};
 
     for (u32 i = 0; i < sample_count; i++) {
         f64 in_sample{static_cast<f64>(input[i])};
         auto sample{in_sample * b[0] + s[0] * b[1] + s[1] * b[2] + s[2] * a[0] + s[3] * a[1]};
 
-        output[i] = static_cast<s32>(std::clamp(static_cast<s64>(sample), min, max));
+        output[i] = static_cast<s32>(std::clamp(sample, min, max));
 
         s[1] = s[0];
         s[0] = in_sample;
@@ -41,10 +42,10 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
         s[2] = sample;
     }
 
-    state.s0 = s[0];
-    state.s1 = s[1];
-    state.s2 = s[2];
-    state.s3 = s[3];
+    state.s0 = Common::BitCast<s64>(s[0]);
+    state.s1 = Common::BitCast<s64>(s[1]);
+    state.s2 = Common::BitCast<s64>(s[2]);
+    state.s3 = Common::BitCast<s64>(s[3]);
 }
 
 /**
@@ -58,29 +59,20 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
  * @param sample_count - Number of samples to process.
  */
 static void ApplyBiquadFilterInt(std::span<s32> output, std::span<const s32> input,
-                                 std::array<s16, 3>& b_, std::array<s16, 2>& a_,
+                                 std::array<s16, 3>& b, std::array<s16, 2>& a,
                                  VoiceState::BiquadFilterState& state, const u32 sample_count) {
     constexpr s64 min{std::numeric_limits<s32>::min()};
     constexpr s64 max{std::numeric_limits<s32>::max()};
-    std::array<Common::FixedPoint<50, 14>, 3> b{
-        Common::FixedPoint<50, 14>::from_base(b_[0]),
-        Common::FixedPoint<50, 14>::from_base(b_[1]),
-        Common::FixedPoint<50, 14>::from_base(b_[2]),
-    };
-    std::array<Common::FixedPoint<50, 14>, 3> a{
-        Common::FixedPoint<50, 14>::from_base(a_[0]),
-        Common::FixedPoint<50, 14>::from_base(a_[1]),
-    };
 
     for (u32 i = 0; i < sample_count; i++) {
-        s64 in_sample{input[i]};
-        auto sample{in_sample * b[0] + state.s0};
-        const auto out_sample{std::clamp(sample.to_long(), min, max)};
+        const s64 in_sample{input[i]};
+        const s64 sample{in_sample * b[0] + state.s0};
+        const s64 out_sample{std::clamp<s64>((sample + (1 << 13)) >> 14, min, max)};
 
         output[i] = static_cast<s32>(out_sample);
 
         state.s0 = state.s1 + b[1] * in_sample + a[0] * out_sample;
-        state.s1 = 0 + b[2] * in_sample + a[1] * out_sample;
+        state.s1 = b[2] * in_sample + a[1] * out_sample;
     }
 }
 
diff --git a/src/audio_core/renderer/command/effect/i3dl2_reverb.cpp b/src/audio_core/renderer/command/effect/i3dl2_reverb.cpp
index 2187d8a65..27d8b9844 100644
--- a/src/audio_core/renderer/command/effect/i3dl2_reverb.cpp
+++ b/src/audio_core/renderer/command/effect/i3dl2_reverb.cpp
@@ -244,16 +244,16 @@ template <size_t NumChannels>
 static void ApplyI3dl2ReverbEffect(I3dl2ReverbInfo::State& state,
                                    std::span<std::span<const s32>> inputs,
                                    std::span<std::span<s32>> outputs, const u32 sample_count) {
-    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
+    static constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     };
-    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
+    static constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
         0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
     };
-    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
+    static constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
         0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 3, 3, 3,
     };
-    constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
+    static constexpr std::array<u8, I3dl2ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
         2, 0, 0, 1, 1, 1, 1, 4, 4, 4, 1, 1, 1, 0, 0, 0, 0, 5, 5, 5,
     };
 
diff --git a/src/audio_core/renderer/command/effect/reverb.cpp b/src/audio_core/renderer/command/effect/reverb.cpp
index 427489214..6fe844ff0 100644
--- a/src/audio_core/renderer/command/effect/reverb.cpp
+++ b/src/audio_core/renderer/command/effect/reverb.cpp
@@ -252,16 +252,16 @@ template <size_t NumChannels>
 static void ApplyReverbEffect(const ReverbInfo::ParameterVersion2& params, ReverbInfo::State& state,
                               std::vector<std::span<const s32>>& inputs,
                               std::vector<std::span<s32>>& outputs, const u32 sample_count) {
-    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
+    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes1Ch{
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     };
-    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
+    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes2Ch{
         0, 0, 1, 1, 0, 1, 0, 0, 1, 1,
     };
-    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
+    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes4Ch{
         0, 0, 1, 1, 0, 1, 2, 2, 3, 3,
     };
-    constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
+    static constexpr std::array<u8, ReverbInfo::MaxDelayTaps> OutTapIndexes6Ch{
         0, 0, 1, 1, 2, 2, 4, 4, 5, 5,
     };
 
diff --git a/src/audio_core/renderer/command/resample/upsample.cpp b/src/audio_core/renderer/command/resample/upsample.cpp
index 5f7db12ca..86ddee1a4 100644
--- a/src/audio_core/renderer/command/resample/upsample.cpp
+++ b/src/audio_core/renderer/command/resample/upsample.cpp
@@ -19,24 +19,24 @@ namespace AudioCore::AudioRenderer {
 static void SrcProcessFrame(std::span<s32> output, std::span<const s32> input,
                             const u32 target_sample_count, const u32 source_sample_count,
                             UpsamplerState* state) {
-    constexpr u32 WindowSize = 10;
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc1{
+    static constexpr u32 WindowSize = 10;
+    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc1{
         0.95376587f,   -0.12872314f, 0.060028076f,  -0.032470703f, 0.017669678f,
         -0.009124756f, 0.004272461f, -0.001739502f, 0.000579834f,  -0.000091552734f,
     };
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc2{
+    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc2{
         0.8230896f,    -0.19161987f,  0.093444824f,  -0.05090332f,   0.027557373f,
         -0.014038086f, 0.0064697266f, -0.002532959f, 0.00079345703f, -0.00012207031f,
     };
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc3{
+    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc3{
         0.6298828f,    -0.19274902f, 0.09725952f,    -0.05319214f,  0.028625488f,
         -0.014373779f, 0.006500244f, -0.0024719238f, 0.0007324219f, -0.000091552734f,
     };
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc4{
+    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc4{
         0.4057312f,    -0.1468811f,  0.07601929f,    -0.041656494f,  0.022216797f,
         -0.011016846f, 0.004852295f, -0.0017700195f, 0.00048828125f, -0.000030517578f,
     };
-    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc5{
+    static constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc5{
         0.1854248f,    -0.075164795f, 0.03967285f,    -0.021728516f,  0.011474609f,
         -0.005584717f, 0.0024108887f, -0.0008239746f, 0.00021362305f, 0.0f,
     };
diff --git a/src/audio_core/renderer/system.cpp b/src/audio_core/renderer/system.cpp
index 4fac30c7c..31cbee282 100644
--- a/src/audio_core/renderer/system.cpp
+++ b/src/audio_core/renderer/system.cpp
@@ -127,7 +127,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
     render_device = params.rendering_device;
     execution_mode = params.execution_mode;
 
-    core.Memory().ZeroBlock(*core.Kernel().CurrentProcess(), transfer_memory->GetSourceAddress(),
+    core.Memory().ZeroBlock(*core.ApplicationProcess(), transfer_memory->GetSourceAddress(),
                             transfer_memory_size);
 
     // Note: We're not actually using the transfer memory because it's a pain to code for.
diff --git a/src/audio_core/renderer/system_manager.cpp b/src/audio_core/renderer/system_manager.cpp
index f66b2b890..ce631f810 100644
--- a/src/audio_core/renderer/system_manager.cpp
+++ b/src/audio_core/renderer/system_manager.cpp
@@ -94,7 +94,7 @@ bool SystemManager::Remove(System& system_) {
 }
 
 void SystemManager::ThreadFunc() {
-    constexpr char name[]{"AudioRenderSystemManager"};
+    static constexpr char name[]{"AudioRenderSystemManager"};
     MicroProfileOnThreadCreate(name);
     Common::SetCurrentThreadName(name);
     Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
diff --git a/src/audio_core/renderer/voice/voice_state.h b/src/audio_core/renderer/voice/voice_state.h
index d5497e2fb..ce947233f 100644
--- a/src/audio_core/renderer/voice/voice_state.h
+++ b/src/audio_core/renderer/voice/voice_state.h
@@ -19,10 +19,10 @@ struct VoiceState {
      * State of the voice's biquad filter.
      */
     struct BiquadFilterState {
-        Common::FixedPoint<50, 14> s0;
-        Common::FixedPoint<50, 14> s1;
-        Common::FixedPoint<50, 14> s2;
-        Common::FixedPoint<50, 14> s3;
+        s64 s0;
+        s64 s1;
+        s64 s2;
+        s64 s3;
     };
 
     /**
diff --git a/src/audio_core/sink/cubeb_sink.cpp b/src/audio_core/sink/cubeb_sink.cpp
index 32c1b1cb3..9133f5388 100644
--- a/src/audio_core/sink/cubeb_sink.cpp
+++ b/src/audio_core/sink/cubeb_sink.cpp
@@ -302,11 +302,21 @@ std::vector<std::string> ListCubebSinkDevices(bool capture) {
     std::vector<std::string> device_list;
     cubeb* ctx;
 
+#ifdef _WIN32
+    auto com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+#endif
+
     if (cubeb_init(&ctx, "yuzu Device Enumerator", nullptr) != CUBEB_OK) {
         LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
         return {};
     }
 
+#ifdef _WIN32
+    if (SUCCEEDED(com_init_result)) {
+        CoUninitialize();
+    }
+#endif
+
     auto type{capture ? CUBEB_DEVICE_TYPE_INPUT : CUBEB_DEVICE_TYPE_OUTPUT};
     cubeb_device_collection collection;
     if (cubeb_enumerate_devices(ctx, type, &collection) != CUBEB_OK) {
@@ -329,12 +339,22 @@ std::vector<std::string> ListCubebSinkDevices(bool capture) {
 u32 GetCubebLatency() {
     cubeb* ctx;
 
+#ifdef _WIN32
+    auto com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+#endif
+
     if (cubeb_init(&ctx, "yuzu Latency Getter", nullptr) != CUBEB_OK) {
         LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
         // Return a large latency so we choose SDL instead.
         return 10000u;
     }
 
+#ifdef _WIN32
+    if (SUCCEEDED(com_init_result)) {
+        CoUninitialize();
+    }
+#endif
+
     cubeb_stream_params params{};
     params.rate = TargetSampleRate;
     params.channels = 2;
diff --git a/src/audio_core/sink/sink_stream.cpp b/src/audio_core/sink/sink_stream.cpp
index 06c2a876e..39a21b0f0 100644
--- a/src/audio_core/sink/sink_stream.cpp
+++ b/src/audio_core/sink/sink_stream.cpp
@@ -35,7 +35,7 @@ void SinkStream::AppendBuffer(SinkBuffer& buffer, std::vector<s16>& samples) {
 
     if (system_channels == 6 && device_channels == 2) {
         // We're given 6 channels, but our device only outputs 2, so downmix.
-        constexpr std::array<f32, 4> down_mix_coeff{1.0f, 0.707f, 0.251f, 0.707f};
+        static constexpr std::array<f32, 4> down_mix_coeff{1.0f, 0.707f, 0.251f, 0.707f};
 
         for (u32 read_index = 0, write_index = 0; read_index < samples.size();
              read_index += system_channels, write_index += device_channels) {
@@ -202,7 +202,7 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
     // If we're paused or going to shut down, we don't want to consume buffers as coretiming is
     // paused and we'll desync, so just play silence.
     if (system.IsPaused() || system.IsShuttingDown()) {
-        constexpr std::array<s16, 6> silence{};
+        static constexpr std::array<s16, 6> silence{};
         for (size_t i = frames_written; i < num_frames; i++) {
             std::memcpy(&output_buffer[i * frame_size], &silence[0], frame_size_bytes);
         }
@@ -270,7 +270,7 @@ void SinkStream::Stall() {
     if (stalled_lock) {
         return;
     }
-    stalled_lock = system.StallProcesses();
+    stalled_lock = system.StallApplication();
 }
 
 void SinkStream::Unstall() {
@@ -278,7 +278,7 @@ void SinkStream::Unstall() {
     if (!stalled_lock) {
         return;
     }
-    system.UnstallProcesses();
+    system.UnstallApplication();
     stalled_lock.unlock();
 }
 
diff --git a/src/common/settings.cpp b/src/common/settings.cpp
index b1a2aa8b2..49b41c158 100644
--- a/src/common/settings.cpp
+++ b/src/common/settings.cpp
@@ -199,7 +199,11 @@ void RestoreGlobalState(bool is_powered_on) {
     values.renderer_backend.SetGlobal(true);
     values.renderer_force_max_clock.SetGlobal(true);
     values.vulkan_device.SetGlobal(true);
+    values.fullscreen_mode.SetGlobal(true);
     values.aspect_ratio.SetGlobal(true);
+    values.resolution_setup.SetGlobal(true);
+    values.scaling_filter.SetGlobal(true);
+    values.anti_aliasing.SetGlobal(true);
     values.max_anisotropy.SetGlobal(true);
     values.use_speed_limit.SetGlobal(true);
     values.speed_limit.SetGlobal(true);
diff --git a/src/common/settings.h b/src/common/settings.h
index 64db66f37..6d27dd5ee 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -488,6 +488,7 @@ struct Values {
     Setting<bool> enable_raw_input{false, "enable_raw_input"};
     Setting<bool> controller_navigation{true, "controller_navigation"};
     Setting<bool> enable_joycon_driver{true, "enable_joycon_driver"};
+    Setting<bool> enable_procon_driver{false, "enable_procon_driver"};
 
     SwitchableSetting<bool> vibration_enabled{true, "vibration_enabled"};
     SwitchableSetting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index f16072e6c..ff5502d87 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -225,6 +225,8 @@ add_library(core STATIC
     hle/kernel/k_memory_manager.h
     hle/kernel/k_memory_region.h
     hle/kernel/k_memory_region_type.h
+    hle/kernel/k_object_name.cpp
+    hle/kernel/k_object_name.h
     hle/kernel/k_page_bitmap.h
     hle/kernel/k_page_buffer.cpp
     hle/kernel/k_page_buffer.h
@@ -310,6 +312,7 @@ add_library(core STATIC
     hle/kernel/svc/svc_event.cpp
     hle/kernel/svc/svc_exception.cpp
     hle/kernel/svc/svc_info.cpp
+    hle/kernel/svc/svc_insecure_memory.cpp
     hle/kernel/svc/svc_interrupt_event.cpp
     hle/kernel/svc/svc_io_pool.cpp
     hle/kernel/svc/svc_ipc.cpp
@@ -383,8 +386,6 @@ add_library(core STATIC
     hle/service/am/omm.h
     hle/service/am/spsm.cpp
     hle/service/am/spsm.h
-    hle/service/am/tcap.cpp
-    hle/service/am/tcap.h
     hle/service/aoc/aoc_u.cpp
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
@@ -395,28 +396,18 @@ add_library(core STATIC
     hle/service/apm/apm_interface.h
     hle/service/audio/audctl.cpp
     hle/service/audio/audctl.h
-    hle/service/audio/auddbg.cpp
-    hle/service/audio/auddbg.h
-    hle/service/audio/audin_a.cpp
-    hle/service/audio/audin_a.h
     hle/service/audio/audin_u.cpp
     hle/service/audio/audin_u.h
     hle/service/audio/audio.cpp
     hle/service/audio/audio.h
-    hle/service/audio/audout_a.cpp
-    hle/service/audio/audout_a.h
     hle/service/audio/audout_u.cpp
     hle/service/audio/audout_u.h
     hle/service/audio/audrec_a.cpp
     hle/service/audio/audrec_a.h
     hle/service/audio/audrec_u.cpp
     hle/service/audio/audrec_u.h
-    hle/service/audio/audren_a.cpp
-    hle/service/audio/audren_a.h
     hle/service/audio/audren_u.cpp
     hle/service/audio/audren_u.h
-    hle/service/audio/codecctl.cpp
-    hle/service/audio/codecctl.h
     hle/service/audio/errors.h
     hle/service/audio/hwopus.cpp
     hle/service/audio/hwopus.h
@@ -711,8 +702,6 @@ add_library(core STATIC
     hle/service/sm/sm_controller.h
     hle/service/sockets/bsd.cpp
     hle/service/sockets/bsd.h
-    hle/service/sockets/ethc.cpp
-    hle/service/sockets/ethc.h
     hle/service/sockets/nsd.cpp
     hle/service/sockets/nsd.h
     hle/service/sockets/sfdnsres.cpp
@@ -779,8 +768,6 @@ add_library(core STATIC
     hle/service/vi/vi_s.h
     hle/service/vi/vi_u.cpp
     hle/service/vi/vi_u.h
-    hle/service/wlan/wlan.cpp
-    hle/service/wlan/wlan.h
     internal_network/network.cpp
     internal_network/network.h
     internal_network/network_interface.cpp
diff --git a/src/core/arm/arm_interface.cpp b/src/core/arm/arm_interface.cpp
index 8aa7b9641..4a331d4c1 100644
--- a/src/core/arm/arm_interface.cpp
+++ b/src/core/arm/arm_interface.cpp
@@ -43,9 +43,9 @@ void ARM_Interface::SymbolicateBacktrace(Core::System& system, std::vector<Backt
 
     std::map<std::string, Symbols::Symbols> symbols;
     for (const auto& module : modules) {
-        symbols.insert_or_assign(module.second,
-                                 Symbols::GetSymbols(module.first, system.Memory(),
-                                                     system.CurrentProcess()->Is64BitProcess()));
+        symbols.insert_or_assign(
+            module.second, Symbols::GetSymbols(module.first, system.Memory(),
+                                               system.ApplicationProcess()->Is64BitProcess()));
     }
 
     for (auto& entry : out) {
diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h
index 7d62d030e..c40771c97 100644
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -5,6 +5,7 @@
 
 #include <array>
 #include <span>
+#include <string>
 #include <vector>
 
 #include <dynarmic/interface/halt_reason.h>
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 47292cd78..fb9b25d12 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -186,7 +186,7 @@ struct System::Impl {
     void Run() {
         std::unique_lock<std::mutex> lk(suspend_guard);
 
-        kernel.Suspend(false);
+        kernel.SuspendApplication(false);
         core_timing.SyncPause(false);
         is_paused.store(false, std::memory_order_relaxed);
     }
@@ -195,7 +195,7 @@ struct System::Impl {
         std::unique_lock<std::mutex> lk(suspend_guard);
 
         core_timing.SyncPause(true);
-        kernel.Suspend(true);
+        kernel.SuspendApplication(true);
         is_paused.store(true, std::memory_order_relaxed);
     }
 
@@ -203,17 +203,17 @@ struct System::Impl {
         return is_paused.load(std::memory_order_relaxed);
     }
 
-    std::unique_lock<std::mutex> StallProcesses() {
+    std::unique_lock<std::mutex> StallApplication() {
         std::unique_lock<std::mutex> lk(suspend_guard);
-        kernel.Suspend(true);
+        kernel.SuspendApplication(true);
         core_timing.SyncPause(true);
         return lk;
     }
 
-    void UnstallProcesses() {
+    void UnstallApplication() {
         if (!IsPaused()) {
             core_timing.SyncPause(false);
-            kernel.Suspend(false);
+            kernel.SuspendApplication(false);
         }
     }
 
@@ -221,7 +221,7 @@ struct System::Impl {
         debugger = std::make_unique<Debugger>(system, port);
     }
 
-    SystemResultStatus SetupForMainProcess(System& system, Frontend::EmuWindow& emu_window) {
+    SystemResultStatus SetupForApplicationProcess(System& system, Frontend::EmuWindow& emu_window) {
         LOG_DEBUG(Core, "initialized OK");
 
         // Setting changes may require a full system reinitialization (e.g., disabling multicore).
@@ -273,7 +273,7 @@ struct System::Impl {
             return SystemResultStatus::ErrorGetLoader;
         }
 
-        SystemResultStatus init_result{SetupForMainProcess(system, emu_window)};
+        SystemResultStatus init_result{SetupForApplicationProcess(system, emu_window)};
         if (init_result != SystemResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                          static_cast<int>(init_result));
@@ -302,7 +302,7 @@ struct System::Impl {
                 static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
         }
         AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process);
+        kernel.MakeApplicationProcess(main_process);
         kernel.InitializeCores();
 
         // Initialize cheat engine
@@ -585,12 +585,12 @@ void System::DetachDebugger() {
     }
 }
 
-std::unique_lock<std::mutex> System::StallProcesses() {
-    return impl->StallProcesses();
+std::unique_lock<std::mutex> System::StallApplication() {
+    return impl->StallApplication();
 }
 
-void System::UnstallProcesses() {
-    impl->UnstallProcesses();
+void System::UnstallApplication() {
+    impl->UnstallApplication();
 }
 
 void System::InitializeDebugger() {
@@ -648,8 +648,8 @@ const Kernel::GlobalSchedulerContext& System::GlobalSchedulerContext() const {
     return impl->kernel.GlobalSchedulerContext();
 }
 
-Kernel::KProcess* System::CurrentProcess() {
-    return impl->kernel.CurrentProcess();
+Kernel::KProcess* System::ApplicationProcess() {
+    return impl->kernel.ApplicationProcess();
 }
 
 Core::DeviceMemory& System::DeviceMemory() {
@@ -660,8 +660,8 @@ const Core::DeviceMemory& System::DeviceMemory() const {
     return *impl->device_memory;
 }
 
-const Kernel::KProcess* System::CurrentProcess() const {
-    return impl->kernel.CurrentProcess();
+const Kernel::KProcess* System::ApplicationProcess() const {
+    return impl->kernel.ApplicationProcess();
 }
 
 ARM_Interface& System::ArmInterface(std::size_t core_index) {
@@ -760,8 +760,8 @@ const Core::SpeedLimiter& System::SpeedLimiter() const {
     return impl->speed_limiter;
 }
 
-u64 System::GetCurrentProcessProgramID() const {
-    return impl->kernel.CurrentProcess()->GetProgramID();
+u64 System::GetApplicationProcessProgramID() const {
+    return impl->kernel.ApplicationProcess()->GetProgramID();
 }
 
 Loader::ResultStatus System::GetGameName(std::string& out) const {
@@ -880,11 +880,11 @@ bool System::GetExitLock() const {
     return impl->exit_lock;
 }
 
-void System::SetCurrentProcessBuildID(const CurrentBuildProcessID& id) {
+void System::SetApplicationProcessBuildID(const CurrentBuildProcessID& id) {
     impl->build_id = id;
 }
 
-const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
+const System::CurrentBuildProcessID& System::GetApplicationProcessBuildID() const {
     return impl->build_id;
 }
 
diff --git a/src/core/core.h b/src/core/core.h
index fb5cda2f5..0042ac170 100644
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -184,8 +184,8 @@ public:
     /// Forcibly detach the debugger if it is running.
     void DetachDebugger();
 
-    std::unique_lock<std::mutex> StallProcesses();
-    void UnstallProcesses();
+    std::unique_lock<std::mutex> StallApplication();
+    void UnstallApplication();
 
     /**
      * Initialize the debugger.
@@ -295,11 +295,11 @@ public:
     /// Gets the manager for the guest device memory
     [[nodiscard]] const Core::DeviceMemory& DeviceMemory() const;
 
-    /// Provides a pointer to the current process
-    [[nodiscard]] Kernel::KProcess* CurrentProcess();
+    /// Provides a pointer to the application process
+    [[nodiscard]] Kernel::KProcess* ApplicationProcess();
 
-    /// Provides a constant pointer to the current process.
-    [[nodiscard]] const Kernel::KProcess* CurrentProcess() const;
+    /// Provides a constant pointer to the application process.
+    [[nodiscard]] const Kernel::KProcess* ApplicationProcess() const;
 
     /// Provides a reference to the core timing instance.
     [[nodiscard]] Timing::CoreTiming& CoreTiming();
@@ -331,7 +331,7 @@ public:
     /// Provides a constant reference to the speed limiter
     [[nodiscard]] const Core::SpeedLimiter& SpeedLimiter() const;
 
-    [[nodiscard]] u64 GetCurrentProcessProgramID() const;
+    [[nodiscard]] u64 GetApplicationProcessProgramID() const;
 
     /// Gets the name of the current game
     [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
@@ -396,8 +396,8 @@ public:
     void SetExitLock(bool locked);
     [[nodiscard]] bool GetExitLock() const;
 
-    void SetCurrentProcessBuildID(const CurrentBuildProcessID& id);
-    [[nodiscard]] const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
+    void SetApplicationProcessBuildID(const CurrentBuildProcessID& id);
+    [[nodiscard]] const CurrentBuildProcessID& GetApplicationProcessBuildID() const;
 
     /// Register a host thread as an emulated CPU Core.
     void RegisterCoreThread(std::size_t id);
diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cpp
index 6bac6722f..3a63b52e3 100644
--- a/src/core/core_timing.cpp
+++ b/src/core/core_timing.cpp
@@ -45,7 +45,7 @@ CoreTiming::~CoreTiming() {
 }
 
 void CoreTiming::ThreadEntry(CoreTiming& instance) {
-    constexpr char name[] = "HostTiming";
+    static constexpr char name[] = "HostTiming";
     MicroProfileOnThreadCreate(name);
     Common::SetCurrentThreadName(name);
     Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
diff --git a/src/core/debugger/gdbstub.cpp b/src/core/debugger/gdbstub.cpp
index 9c02b7b31..945ec528e 100644
--- a/src/core/debugger/gdbstub.cpp
+++ b/src/core/debugger/gdbstub.cpp
@@ -96,7 +96,7 @@ static std::string EscapeXML(std::string_view data) {
 
 GDBStub::GDBStub(DebuggerBackend& backend_, Core::System& system_)
     : DebuggerFrontend(backend_), system{system_} {
-    if (system.CurrentProcess()->Is64BitProcess()) {
+    if (system.ApplicationProcess()->Is64BitProcess()) {
         arch = std::make_unique<GDBStubA64>();
     } else {
         arch = std::make_unique<GDBStubA32>();
@@ -340,15 +340,15 @@ void GDBStub::HandleBreakpointInsert(std::string_view command) {
         success = true;
         break;
     case BreakpointType::WriteWatch:
-        success = system.CurrentProcess()->InsertWatchpoint(system, addr, size,
-                                                            Kernel::DebugWatchpointType::Write);
+        success = system.ApplicationProcess()->InsertWatchpoint(system, addr, size,
+                                                                Kernel::DebugWatchpointType::Write);
         break;
     case BreakpointType::ReadWatch:
-        success = system.CurrentProcess()->InsertWatchpoint(system, addr, size,
-                                                            Kernel::DebugWatchpointType::Read);
+        success = system.ApplicationProcess()->InsertWatchpoint(system, addr, size,
+                                                                Kernel::DebugWatchpointType::Read);
         break;
     case BreakpointType::AccessWatch:
-        success = system.CurrentProcess()->InsertWatchpoint(
+        success = system.ApplicationProcess()->InsertWatchpoint(
             system, addr, size, Kernel::DebugWatchpointType::ReadOrWrite);
         break;
     case BreakpointType::Hardware:
@@ -391,15 +391,15 @@ void GDBStub::HandleBreakpointRemove(std::string_view command) {
         break;
     }
     case BreakpointType::WriteWatch:
-        success = system.CurrentProcess()->RemoveWatchpoint(system, addr, size,
-                                                            Kernel::DebugWatchpointType::Write);
+        success = system.ApplicationProcess()->RemoveWatchpoint(system, addr, size,
+                                                                Kernel::DebugWatchpointType::Write);
         break;
     case BreakpointType::ReadWatch:
-        success = system.CurrentProcess()->RemoveWatchpoint(system, addr, size,
-                                                            Kernel::DebugWatchpointType::Read);
+        success = system.ApplicationProcess()->RemoveWatchpoint(system, addr, size,
+                                                                Kernel::DebugWatchpointType::Read);
         break;
     case BreakpointType::AccessWatch:
-        success = system.CurrentProcess()->RemoveWatchpoint(
+        success = system.ApplicationProcess()->RemoveWatchpoint(
             system, addr, size, Kernel::DebugWatchpointType::ReadOrWrite);
         break;
     case BreakpointType::Hardware:
@@ -482,7 +482,7 @@ static std::optional<std::string> GetNameFromThreadType64(Core::Memory::Memory&
 
 static std::optional<std::string> GetThreadName(Core::System& system,
                                                 const Kernel::KThread* thread) {
-    if (system.CurrentProcess()->Is64BitProcess()) {
+    if (system.ApplicationProcess()->Is64BitProcess()) {
         return GetNameFromThreadType64(system.Memory(), thread);
     } else {
         return GetNameFromThreadType32(system.Memory(), thread);
@@ -555,7 +555,7 @@ void GDBStub::HandleQuery(std::string_view command) {
             SendReply(fmt::format("TextSeg={:x}", main->first));
         } else {
             SendReply(fmt::format("TextSeg={:x}",
-                                  system.CurrentProcess()->PageTable().GetCodeRegionStart()));
+                                  system.ApplicationProcess()->PageTable().GetCodeRegionStart()));
         }
     } else if (command.starts_with("Xfer:libraries:read::")) {
         Loader::AppLoader::Modules modules;
@@ -729,7 +729,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
     std::string_view command_str{reinterpret_cast<const char*>(&command[0]), command.size()};
     std::string reply;
 
-    auto* process = system.CurrentProcess();
+    auto* process = system.ApplicationProcess();
     auto& page_table = process->PageTable();
 
     const char* commands = "Commands:\n"
diff --git a/src/core/debugger/gdbstub_arch.cpp b/src/core/debugger/gdbstub_arch.cpp
index 4bef09bd7..831c48513 100644
--- a/src/core/debugger/gdbstub_arch.cpp
+++ b/src/core/debugger/gdbstub_arch.cpp
@@ -41,9 +41,8 @@ static void PutSIMDRegister(std::array<u32, 64>& simd_regs, size_t offset, const
 
 // For sample XML files see the GDB source /gdb/features
 // This XML defines what the registers are for this specific ARM device
-std::string GDBStubA64::GetTargetXML() const {
-    constexpr const char* target_xml =
-        R"(<?xml version="1.0"?>
+std::string_view GDBStubA64::GetTargetXML() const {
+    return R"(<?xml version="1.0"?>
 <!DOCTYPE target SYSTEM "gdb-target.dtd">
 <target version="1.0">
   <architecture>aarch64</architecture>
@@ -178,8 +177,6 @@ std::string GDBStubA64::GetTargetXML() const {
     <reg name="fpcr" bitsize="32"/>
   </feature>
 </target>)";
-
-    return target_xml;
 }
 
 std::string GDBStubA64::RegRead(const Kernel::KThread* thread, size_t id) const {
@@ -270,9 +267,8 @@ u32 GDBStubA64::BreakpointInstruction() const {
     return 0xd4200000;
 }
 
-std::string GDBStubA32::GetTargetXML() const {
-    constexpr const char* target_xml =
-        R"(<?xml version="1.0"?>
+std::string_view GDBStubA32::GetTargetXML() const {
+    return R"(<?xml version="1.0"?>
 <!DOCTYPE target SYSTEM "gdb-target.dtd">
 <target version="1.0">
   <architecture>arm</architecture>
@@ -378,8 +374,6 @@ std::string GDBStubA32::GetTargetXML() const {
     <reg name="fpscr" bitsize="32" type="int" group="float" regnum="80"/>
   </feature>
 </target>)";
-
-    return target_xml;
 }
 
 std::string GDBStubA32::RegRead(const Kernel::KThread* thread, size_t id) const {
diff --git a/src/core/debugger/gdbstub_arch.h b/src/core/debugger/gdbstub_arch.h
index 2540d6456..34530c788 100644
--- a/src/core/debugger/gdbstub_arch.h
+++ b/src/core/debugger/gdbstub_arch.h
@@ -16,7 +16,7 @@ namespace Core {
 class GDBStubArch {
 public:
     virtual ~GDBStubArch() = default;
-    virtual std::string GetTargetXML() const = 0;
+    virtual std::string_view GetTargetXML() const = 0;
     virtual std::string RegRead(const Kernel::KThread* thread, size_t id) const = 0;
     virtual void RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const = 0;
     virtual std::string ReadRegisters(const Kernel::KThread* thread) const = 0;
@@ -27,7 +27,7 @@ public:
 
 class GDBStubA64 final : public GDBStubArch {
 public:
-    std::string GetTargetXML() const override;
+    std::string_view GetTargetXML() const override;
     std::string RegRead(const Kernel::KThread* thread, size_t id) const override;
     void RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const override;
     std::string ReadRegisters(const Kernel::KThread* thread) const override;
@@ -47,7 +47,7 @@ private:
 
 class GDBStubA32 final : public GDBStubArch {
 public:
-    std::string GetTargetXML() const override;
+    std::string_view GetTargetXML() const override;
     std::string RegRead(const Kernel::KThread* thread, size_t id) const override;
     void RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const override;
     std::string ReadRegisters(const Kernel::KThread* thread) const override;
diff --git a/src/core/file_sys/ips_layer.cpp b/src/core/file_sys/ips_layer.cpp
index 5aab428bb..efdf18cee 100644
--- a/src/core/file_sys/ips_layer.cpp
+++ b/src/core/file_sys/ips_layer.cpp
@@ -41,12 +41,12 @@ static IPSFileType IdentifyMagic(const std::vector<u8>& magic) {
         return IPSFileType::Error;
     }
 
-    constexpr std::array<u8, 5> patch_magic{{'P', 'A', 'T', 'C', 'H'}};
+    static constexpr std::array<u8, 5> patch_magic{{'P', 'A', 'T', 'C', 'H'}};
     if (std::equal(magic.begin(), magic.end(), patch_magic.begin())) {
         return IPSFileType::IPS;
     }
 
-    constexpr std::array<u8, 5> ips32_magic{{'I', 'P', 'S', '3', '2'}};
+    static constexpr std::array<u8, 5> ips32_magic{{'I', 'P', 'S', '3', '2'}};
     if (std::equal(magic.begin(), magic.end(), ips32_magic.begin())) {
         return IPSFileType::IPS32;
     }
@@ -55,12 +55,12 @@ static IPSFileType IdentifyMagic(const std::vector<u8>& magic) {
 }
 
 static bool IsEOF(IPSFileType type, const std::vector<u8>& data) {
-    constexpr std::array<u8, 3> eof{{'E', 'O', 'F'}};
+    static constexpr std::array<u8, 3> eof{{'E', 'O', 'F'}};
     if (type == IPSFileType::IPS && std::equal(data.begin(), data.end(), eof.begin())) {
         return true;
     }
 
-    constexpr std::array<u8, 4> eeof{{'E', 'E', 'O', 'F'}};
+    static constexpr std::array<u8, 4> eeof{{'E', 'E', 'O', 'F'}};
     return type == IPSFileType::IPS32 && std::equal(data.begin(), data.end(), eeof.begin());
 }
 
diff --git a/src/core/file_sys/registered_cache.cpp b/src/core/file_sys/registered_cache.cpp
index 878d832c2..a6960170c 100644
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -71,7 +71,7 @@ static std::string GetRelativePathFromNcaID(const std::array<u8, 16>& nca_id, bo
 }
 
 static std::string GetCNMTName(TitleType type, u64 title_id) {
-    constexpr std::array<const char*, 9> TITLE_TYPE_NAMES{
+    static constexpr std::array<const char*, 9> TITLE_TYPE_NAMES{
         "SystemProgram",
         "SystemData",
         "SystemUpdate",
diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp
index 1567da231..769065b6f 100644
--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -172,7 +172,7 @@ std::string SaveDataFactory::GetFullPath(Core::System& system, VirtualDir dir,
     // be interpreted as the title id of the current process.
     if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
         if (title_id == 0) {
-            title_id = system.GetCurrentProcessProgramID();
+            title_id = system.GetApplicationProcessProgramID();
         }
     }
 
diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp
index 1c91bbe40..17d663379 100644
--- a/src/core/hid/emulated_console.cpp
+++ b/src/core/hid/emulated_console.cpp
@@ -23,7 +23,8 @@ void EmulatedConsole::SetTouchParams() {
 
     // We can't use mouse as touch if native mouse is enabled
     if (!Settings::values.mouse_enabled) {
-        touch_params[index++] = Common::ParamPackage{"engine:mouse,axis_x:10,axis_y:11,button:0"};
+        touch_params[index++] =
+            Common::ParamPackage{"engine:mouse,axis_x:0,axis_y:1,button:0,port:2"};
     }
 
     touch_params[index++] =
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 631aa6ad2..6d5a3dead 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -957,7 +957,7 @@ void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback
         raw_status.gyro.y.value,
         raw_status.gyro.z.value,
     });
-    emulated.SetGyroThreshold(raw_status.gyro.x.properties.threshold);
+    emulated.SetUserGyroThreshold(raw_status.gyro.x.properties.threshold);
     emulated.UpdateRotation(raw_status.delta_timestamp);
     emulated.UpdateOrientation(raw_status.delta_timestamp);
     force_update_motion = raw_status.force_update;
@@ -1284,6 +1284,26 @@ void EmulatedController::SetLedPattern() {
     }
 }
 
+void EmulatedController::SetGyroscopeZeroDriftMode(GyroscopeZeroDriftMode mode) {
+    for (auto& motion : controller.motion_values) {
+        switch (mode) {
+        case GyroscopeZeroDriftMode::Loose:
+            motion_sensitivity = motion.emulated.IsAtRestLoose;
+            motion.emulated.SetGyroThreshold(motion.emulated.ThresholdLoose);
+            break;
+        case GyroscopeZeroDriftMode::Tight:
+            motion_sensitivity = motion.emulated.IsAtRestThight;
+            motion.emulated.SetGyroThreshold(motion.emulated.ThresholdThight);
+            break;
+        case GyroscopeZeroDriftMode::Standard:
+        default:
+            motion_sensitivity = motion.emulated.IsAtRestStandard;
+            motion.emulated.SetGyroThreshold(motion.emulated.ThresholdStandard);
+            break;
+        }
+    }
+}
+
 void EmulatedController::SetSupportedNpadStyleTag(NpadStyleTag supported_styles) {
     supported_style_tag = supported_styles;
     if (!is_connected) {
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index b02bf35c4..a9da465a2 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -398,6 +398,9 @@ public:
     /// Asks the output device to change the player led pattern
     void SetLedPattern();
 
+    /// Changes sensitivity of the motion sensor
+    void SetGyroscopeZeroDriftMode(GyroscopeZeroDriftMode mode);
+
     /**
      * Adds a callback to the list of events
      * @param update_callback A ConsoleUpdateCallback that will be triggered
@@ -523,7 +526,7 @@ private:
     bool is_connected{false};
     bool is_configuring{false};
     bool system_buttons_enabled{true};
-    f32 motion_sensitivity{0.01f};
+    f32 motion_sensitivity{Core::HID::MotionInput::IsAtRestStandard};
     bool force_update_motion{false};
     u32 turbo_button_state{0};
 
diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index 836f32c0f..578a6ff61 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -34,9 +34,12 @@ void EmulatedDevices::ReloadInput() {
     // First two axis are reserved for mouse position
     key_index = 2;
     for (auto& mouse_device : mouse_analog_devices) {
+        // Mouse axis are only mapped on port 1, pad 0
         Common::ParamPackage mouse_params;
         mouse_params.Set("engine", "mouse");
         mouse_params.Set("axis", static_cast<int>(key_index));
+        mouse_params.Set("port", 1);
+        mouse_params.Set("pad", 0);
         mouse_device = Common::Input::CreateInputDevice(mouse_params);
         key_index++;
     }
diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h
index e3b1cfbc6..6b35f448c 100644
--- a/src/core/hid/hid_types.h
+++ b/src/core/hid/hid_types.h
@@ -282,6 +282,13 @@ enum class VibrationGcErmCommand : u64 {
     StopHard = 2,
 };
 
+// This is nn::hid::GyroscopeZeroDriftMode
+enum class GyroscopeZeroDriftMode : u32 {
+    Loose = 0,
+    Standard = 1,
+    Tight = 2,
+};
+
 // This is nn::hid::NpadStyleTag
 struct NpadStyleTag {
     union {
diff --git a/src/core/hid/motion_input.cpp b/src/core/hid/motion_input.cpp
index b1f658e62..eef6edf4b 100644
--- a/src/core/hid/motion_input.cpp
+++ b/src/core/hid/motion_input.cpp
@@ -9,7 +9,7 @@ namespace Core::HID {
 MotionInput::MotionInput() {
     // Initialize PID constants with default values
     SetPID(0.3f, 0.005f, 0.0f);
-    SetGyroThreshold(0.007f);
+    SetGyroThreshold(ThresholdStandard);
 }
 
 void MotionInput::SetPID(f32 new_kp, f32 new_ki, f32 new_kd) {
@@ -26,11 +26,11 @@ void MotionInput::SetGyroscope(const Common::Vec3f& gyroscope) {
     gyro = gyroscope - gyro_bias;
 
     // Auto adjust drift to minimize drift
-    if (!IsMoving(0.1f)) {
+    if (!IsMoving(IsAtRestRelaxed)) {
         gyro_bias = (gyro_bias * 0.9999f) + (gyroscope * 0.0001f);
     }
 
-    if (gyro.Length() < gyro_threshold) {
+    if (gyro.Length() < gyro_threshold * user_gyro_threshold) {
         gyro = {};
     } else {
         only_accelerometer = false;
@@ -49,6 +49,10 @@ void MotionInput::SetGyroThreshold(f32 threshold) {
     gyro_threshold = threshold;
 }
 
+void MotionInput::SetUserGyroThreshold(f32 threshold) {
+    user_gyro_threshold = threshold / ThresholdStandard;
+}
+
 void MotionInput::EnableReset(bool reset) {
     reset_enabled = reset;
 }
@@ -208,7 +212,7 @@ void MotionInput::ResetOrientation() {
     if (!reset_enabled || only_accelerometer) {
         return;
     }
-    if (!IsMoving(0.5f) && accel.z <= -0.9f) {
+    if (!IsMoving(IsAtRestRelaxed) && accel.z <= -0.9f) {
         ++reset_counter;
         if (reset_counter > 900) {
             quat.w = 0;
diff --git a/src/core/hid/motion_input.h b/src/core/hid/motion_input.h
index f5fd90db5..9180bb9aa 100644
--- a/src/core/hid/motion_input.h
+++ b/src/core/hid/motion_input.h
@@ -11,6 +11,15 @@ namespace Core::HID {
 
 class MotionInput {
 public:
+    static constexpr float ThresholdLoose = 0.01f;
+    static constexpr float ThresholdStandard = 0.007f;
+    static constexpr float ThresholdThight = 0.002f;
+
+    static constexpr float IsAtRestRelaxed = 0.05f;
+    static constexpr float IsAtRestLoose = 0.02f;
+    static constexpr float IsAtRestStandard = 0.01f;
+    static constexpr float IsAtRestThight = 0.005f;
+
     explicit MotionInput();
 
     MotionInput(const MotionInput&) = default;
@@ -26,6 +35,9 @@ public:
     void SetGyroBias(const Common::Vec3f& bias);
     void SetGyroThreshold(f32 threshold);
 
+    /// Applies a modifier on top of the normal gyro threshold
+    void SetUserGyroThreshold(f32 threshold);
+
     void EnableReset(bool reset);
     void ResetRotations();
 
@@ -74,6 +86,9 @@ private:
     // Minimum gyro amplitude to detect if the device is moving
     f32 gyro_threshold = 0.0f;
 
+    // Multiplies gyro_threshold by this value
+    f32 user_gyro_threshold = 0.0f;
+
     // Number of invalid sequential data
     u32 reset_counter = 0;
 
diff --git a/src/core/hle/ipc_helpers.h b/src/core/hle/ipc_helpers.h
index a86bec252..38d6cfaff 100644
--- a/src/core/hle/ipc_helpers.h
+++ b/src/core/hle/ipc_helpers.h
@@ -148,7 +148,7 @@ public:
         if (context->GetManager()->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
-            kernel.CurrentProcess()->GetResourceLimit()->Reserve(
+            kernel.ApplicationProcess()->GetResourceLimit()->Reserve(
                 Kernel::LimitableResource::SessionCountMax, 1);
 
             auto* session = Kernel::KSession::Create(kernel);
diff --git a/src/core/hle/kernel/init/init_slab_setup.cpp b/src/core/hle/kernel/init/init_slab_setup.cpp
index 571acf4b2..abdb5639f 100644
--- a/src/core/hle/kernel/init/init_slab_setup.cpp
+++ b/src/core/hle/kernel/init/init_slab_setup.cpp
@@ -16,6 +16,7 @@
 #include "core/hle/kernel/k_event_info.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
+#include "core/hle/kernel/k_object_name.h"
 #include "core/hle/kernel/k_page_buffer.h"
 #include "core/hle/kernel/k_port.h"
 #include "core/hle/kernel/k_process.h"
@@ -49,6 +50,7 @@ namespace Kernel::Init {
     HANDLER(KThreadLocalPage,                                                                      \
             (SLAB_COUNT(KProcess) + (SLAB_COUNT(KProcess) + SLAB_COUNT(KThread)) / 8),             \
             ##__VA_ARGS__)                                                                         \
+    HANDLER(KObjectName, (SLAB_COUNT(KObjectName)), ##__VA_ARGS__)                                 \
     HANDLER(KResourceLimit, (SLAB_COUNT(KResourceLimit)), ##__VA_ARGS__)                           \
     HANDLER(KEventInfo, (SLAB_COUNT(KThread) + SLAB_COUNT(KDebug)), ##__VA_ARGS__)                 \
     HANDLER(KDebug, (SLAB_COUNT(KDebug)), ##__VA_ARGS__)                                           \
diff --git a/src/core/hle/kernel/k_client_port.cpp b/src/core/hle/kernel/k_client_port.cpp
index 2ec623a58..c72a91a76 100644
--- a/src/core/hle/kernel/k_client_port.cpp
+++ b/src/core/hle/kernel/k_client_port.cpp
@@ -60,7 +60,8 @@ bool KClientPort::IsSignaled() const {
 
 Result KClientPort::CreateSession(KClientSession** out) {
     // Reserve a new session from the resource limit.
-    KScopedResourceReservation session_reservation(kernel.CurrentProcess()->GetResourceLimit(),
+    //! FIXME: we are reserving this from the wrong resource limit!
+    KScopedResourceReservation session_reservation(kernel.ApplicationProcess()->GetResourceLimit(),
                                                    LimitableResource::SessionCountMax);
     R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);
 
diff --git a/src/core/hle/kernel/k_code_memory.cpp b/src/core/hle/kernel/k_code_memory.cpp
index 884eba001..6c44a9e99 100644
--- a/src/core/hle/kernel/k_code_memory.cpp
+++ b/src/core/hle/kernel/k_code_memory.cpp
@@ -21,7 +21,7 @@ KCodeMemory::KCodeMemory(KernelCore& kernel_)
 
 Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, size_t size) {
     // Set members.
-    m_owner = kernel.CurrentProcess();
+    m_owner = GetCurrentProcessPointer(kernel);
 
     // Get the owner page table.
     auto& page_table = m_owner->PageTable();
@@ -74,7 +74,7 @@ Result KCodeMemory::Map(VAddr address, size_t size) {
     R_UNLESS(!m_is_mapped, ResultInvalidState);
 
     // Map the memory.
-    R_TRY(kernel.CurrentProcess()->PageTable().MapPageGroup(
+    R_TRY(GetCurrentProcess(kernel).PageTable().MapPageGroup(
         address, *m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));
 
     // Mark ourselves as mapped.
@@ -91,8 +91,8 @@ Result KCodeMemory::Unmap(VAddr address, size_t size) {
     KScopedLightLock lk(m_lock);
 
     // Unmap the memory.
-    R_TRY(kernel.CurrentProcess()->PageTable().UnmapPageGroup(address, *m_page_group,
-                                                              KMemoryState::CodeOut));
+    R_TRY(GetCurrentProcess(kernel).PageTable().UnmapPageGroup(address, *m_page_group,
+                                                               KMemoryState::CodeOut));
 
     // Mark ourselves as unmapped.
     m_is_mapped = false;
diff --git a/src/core/hle/kernel/k_condition_variable.cpp b/src/core/hle/kernel/k_condition_variable.cpp
index 0c6b20db3..3f0be1c3f 100644
--- a/src/core/hle/kernel/k_condition_variable.cpp
+++ b/src/core/hle/kernel/k_condition_variable.cpp
@@ -164,8 +164,8 @@ Result KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 value)
         R_SUCCEED_IF(test_tag != (handle | Svc::HandleWaitMask));
 
         // Get the lock owner thread.
-        owner_thread = kernel.CurrentProcess()
-                           ->GetHandleTable()
+        owner_thread = GetCurrentProcess(kernel)
+                           .GetHandleTable()
                            .GetObjectWithoutPseudoHandle<KThread>(handle)
                            .ReleasePointerUnsafe();
         R_UNLESS(owner_thread != nullptr, ResultInvalidHandle);
@@ -213,8 +213,8 @@ void KConditionVariable::SignalImpl(KThread* thread) {
             thread->EndWait(ResultSuccess);
         } else {
             // Get the previous owner.
-            KThread* owner_thread = kernel.CurrentProcess()
-                                        ->GetHandleTable()
+            KThread* owner_thread = GetCurrentProcess(kernel)
+                                        .GetHandleTable()
                                         .GetObjectWithoutPseudoHandle<KThread>(
                                             static_cast<Handle>(prev_tag & ~Svc::HandleWaitMask))
                                         .ReleasePointerUnsafe();
diff --git a/src/core/hle/kernel/k_handle_table.h b/src/core/hle/kernel/k_handle_table.h
index 37a24e7d9..d7660630c 100644
--- a/src/core/hle/kernel/k_handle_table.h
+++ b/src/core/hle/kernel/k_handle_table.h
@@ -90,7 +90,8 @@ public:
         // Handle pseudo-handles.
         if constexpr (std::derived_from<KProcess, T>) {
             if (handle == Svc::PseudoHandle::CurrentProcess) {
-                auto* const cur_process = m_kernel.CurrentProcess();
+                //! FIXME: this is the wrong process!
+                auto* const cur_process = m_kernel.ApplicationProcess();
                 ASSERT(cur_process != nullptr);
                 return cur_process;
             }
diff --git a/src/core/hle/kernel/k_interrupt_manager.cpp b/src/core/hle/kernel/k_interrupt_manager.cpp
index 4a6b60d26..fe6a20168 100644
--- a/src/core/hle/kernel/k_interrupt_manager.cpp
+++ b/src/core/hle/kernel/k_interrupt_manager.cpp
@@ -16,7 +16,7 @@ void HandleInterrupt(KernelCore& kernel, s32 core_id) {
 
     auto& current_thread = GetCurrentThread(kernel);
 
-    if (auto* process = kernel.CurrentProcess(); process) {
+    if (auto* process = GetCurrentProcessPointer(kernel); process) {
         // If the user disable count is set, we may need to pin the current thread.
         if (current_thread.GetUserDisableCount() && !process->GetPinnedThread(core_id)) {
             KScopedSchedulerLock sl{kernel};
diff --git a/src/core/hle/kernel/k_object_name.cpp b/src/core/hle/kernel/k_object_name.cpp
new file mode 100644
index 000000000..df3a1c4c5
--- /dev/null
+++ b/src/core/hle/kernel/k_object_name.cpp
@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/kernel/k_object_name.h"
+
+namespace Kernel {
+
+KObjectNameGlobalData::KObjectNameGlobalData(KernelCore& kernel) : m_object_list_lock{kernel} {}
+KObjectNameGlobalData::~KObjectNameGlobalData() = default;
+
+void KObjectName::Initialize(KAutoObject* obj, const char* name) {
+    // Set member variables.
+    m_object = obj;
+    std::strncpy(m_name.data(), name, sizeof(m_name) - 1);
+    m_name[sizeof(m_name) - 1] = '\x00';
+
+    // Open a reference to the object we hold.
+    m_object->Open();
+}
+
+bool KObjectName::MatchesName(const char* name) const {
+    return std::strncmp(m_name.data(), name, sizeof(m_name)) == 0;
+}
+
+Result KObjectName::NewFromName(KernelCore& kernel, KAutoObject* obj, const char* name) {
+    // Create a new object name.
+    KObjectName* new_name = KObjectName::Allocate(kernel);
+    R_UNLESS(new_name != nullptr, ResultOutOfResource);
+
+    // Initialize the new name.
+    new_name->Initialize(obj, name);
+
+    // Check if there's an existing name.
+    {
+        // Get the global data.
+        KObjectNameGlobalData& gd{kernel.ObjectNameGlobalData()};
+
+        // Ensure we have exclusive access to the global list.
+        KScopedLightLock lk{gd.GetObjectListLock()};
+
+        // If the object doesn't exist, put it into the list.
+        KScopedAutoObject existing_object = FindImpl(kernel, name);
+        if (existing_object.IsNull()) {
+            gd.GetObjectList().push_back(*new_name);
+            R_SUCCEED();
+        }
+    }
+
+    // The object already exists, which is an error condition. Perform cleanup.
+    obj->Close();
+    KObjectName::Free(kernel, new_name);
+    R_THROW(ResultInvalidState);
+}
+
+Result KObjectName::Delete(KernelCore& kernel, KAutoObject* obj, const char* compare_name) {
+    // Get the global data.
+    KObjectNameGlobalData& gd{kernel.ObjectNameGlobalData()};
+
+    // Ensure we have exclusive access to the global list.
+    KScopedLightLock lk{gd.GetObjectListLock()};
+
+    // Find a matching entry in the list, and delete it.
+    for (auto& name : gd.GetObjectList()) {
+        if (name.MatchesName(compare_name) && obj == name.GetObject()) {
+            // We found a match, clean up its resources.
+            obj->Close();
+            gd.GetObjectList().erase(gd.GetObjectList().iterator_to(name));
+            KObjectName::Free(kernel, std::addressof(name));
+            R_SUCCEED();
+        }
+    }
+
+    // We didn't find the object in the list.
+    R_THROW(ResultNotFound);
+}
+
+KScopedAutoObject<KAutoObject> KObjectName::Find(KernelCore& kernel, const char* name) {
+    // Get the global data.
+    KObjectNameGlobalData& gd{kernel.ObjectNameGlobalData()};
+
+    // Ensure we have exclusive access to the global list.
+    KScopedLightLock lk{gd.GetObjectListLock()};
+
+    return FindImpl(kernel, name);
+}
+
+KScopedAutoObject<KAutoObject> KObjectName::FindImpl(KernelCore& kernel, const char* compare_name) {
+    // Get the global data.
+    KObjectNameGlobalData& gd{kernel.ObjectNameGlobalData()};
+
+    // Try to find a matching object in the global list.
+    for (const auto& name : gd.GetObjectList()) {
+        if (name.MatchesName(compare_name)) {
+            return name.GetObject();
+        }
+    }
+
+    // There's no matching entry in the list.
+    return nullptr;
+}
+
+} // namespace Kernel
diff --git a/src/core/hle/kernel/k_object_name.h b/src/core/hle/kernel/k_object_name.h
new file mode 100644
index 000000000..b7f943134
--- /dev/null
+++ b/src/core/hle/kernel/k_object_name.h
@@ -0,0 +1,86 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <boost/intrusive/list.hpp>
+
+#include "core/hle/kernel/k_light_lock.h"
+#include "core/hle/kernel/slab_helpers.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel {
+
+class KObjectNameGlobalData;
+
+class KObjectName : public KSlabAllocated<KObjectName>, public boost::intrusive::list_base_hook<> {
+public:
+    explicit KObjectName(KernelCore&) {}
+    virtual ~KObjectName() = default;
+
+    static constexpr size_t NameLengthMax = 12;
+    using List = boost::intrusive::list<KObjectName>;
+
+    static Result NewFromName(KernelCore& kernel, KAutoObject* obj, const char* name);
+    static Result Delete(KernelCore& kernel, KAutoObject* obj, const char* name);
+
+    static KScopedAutoObject<KAutoObject> Find(KernelCore& kernel, const char* name);
+
+    template <typename Derived>
+    static Result Delete(KernelCore& kernel, const char* name) {
+        // Find the object.
+        KScopedAutoObject obj = Find(kernel, name);
+        R_UNLESS(obj.IsNotNull(), ResultNotFound);
+
+        // Cast the object to the desired type.
+        Derived* derived = obj->DynamicCast<Derived*>();
+        R_UNLESS(derived != nullptr, ResultNotFound);
+
+        // Check that the object is closed.
+        R_UNLESS(derived->IsServerClosed(), ResultInvalidState);
+
+        return Delete(kernel, obj.GetPointerUnsafe(), name);
+    }
+
+    template <typename Derived>
+        requires(std::derived_from<Derived, KAutoObject>)
+    static KScopedAutoObject<Derived> Find(KernelCore& kernel, const char* name) {
+        return Find(kernel, name);
+    }
+
+private:
+    static KScopedAutoObject<KAutoObject> FindImpl(KernelCore& kernel, const char* name);
+
+    void Initialize(KAutoObject* obj, const char* name);
+
+    bool MatchesName(const char* name) const;
+    KAutoObject* GetObject() const {
+        return m_object;
+    }
+
+private:
+    std::array<char, NameLengthMax> m_name{};
+    KAutoObject* m_object{};
+};
+
+class KObjectNameGlobalData {
+public:
+    explicit KObjectNameGlobalData(KernelCore& kernel);
+    ~KObjectNameGlobalData();
+
+    KLightLock& GetObjectListLock() {
+        return m_object_list_lock;
+    }
+
+    KObjectName::List& GetObjectList() {
+        return m_object_list;
+    }
+
+private:
+    KLightLock m_object_list_lock;
+    KObjectName::List m_object_list;
+};
+
+} // namespace Kernel
diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cpp
index e201bb0cd..0e4283a0c 100644
--- a/src/core/hle/kernel/k_process.cpp
+++ b/src/core/hle/kernel/k_process.cpp
@@ -370,7 +370,7 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:
     // Initialize proces address space
     if (const Result result{page_table.InitializeForProcess(
             metadata.GetAddressSpaceType(), false, false, false, KMemoryManager::Pool::Application,
-            0x8000000, code_size, &kernel.GetSystemSystemResource(), resource_limit)};
+            0x8000000, code_size, &kernel.GetAppSystemResource(), resource_limit)};
         result.IsError()) {
         R_RETURN(result);
     }
diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cpp
index d6676904b..d6c214237 100644
--- a/src/core/hle/kernel/k_scheduler.cpp
+++ b/src/core/hle/kernel/k_scheduler.cpp
@@ -328,7 +328,7 @@ u64 KScheduler::UpdateHighestPriorityThreadsImpl(KernelCore& kernel) {
 }
 
 void KScheduler::SwitchThread(KThread* next_thread) {
-    KProcess* const cur_process = kernel.CurrentProcess();
+    KProcess* const cur_process = GetCurrentProcessPointer(kernel);
     KThread* const cur_thread = GetCurrentThreadPointer(kernel);
 
     // We never want to schedule a null thread, so use the idle thread if we don't have a next.
@@ -689,11 +689,11 @@ void KScheduler::RotateScheduledQueue(KernelCore& kernel, s32 core_id, s32 prior
 void KScheduler::YieldWithoutCoreMigration(KernelCore& kernel) {
     // Validate preconditions.
     ASSERT(CanSchedule(kernel));
-    ASSERT(kernel.CurrentProcess() != nullptr);
+    ASSERT(GetCurrentProcessPointer(kernel) != nullptr);
 
     // Get the current thread and process.
     KThread& cur_thread = GetCurrentThread(kernel);
-    KProcess& cur_process = *kernel.CurrentProcess();
+    KProcess& cur_process = GetCurrentProcess(kernel);
 
     // If the thread's yield count matches, there's nothing for us to do.
     if (cur_thread.GetYieldScheduleCount() == cur_process.GetScheduledCount()) {
@@ -728,11 +728,11 @@ void KScheduler::YieldWithoutCoreMigration(KernelCore& kernel) {
 void KScheduler::YieldWithCoreMigration(KernelCore& kernel) {
     // Validate preconditions.
     ASSERT(CanSchedule(kernel));
-    ASSERT(kernel.CurrentProcess() != nullptr);
+    ASSERT(GetCurrentProcessPointer(kernel) != nullptr);
 
     // Get the current thread and process.
     KThread& cur_thread = GetCurrentThread(kernel);
-    KProcess& cur_process = *kernel.CurrentProcess();
+    KProcess& cur_process = GetCurrentProcess(kernel);
 
     // If the thread's yield count matches, there's nothing for us to do.
     if (cur_thread.GetYieldScheduleCount() == cur_process.GetScheduledCount()) {
@@ -816,11 +816,11 @@ void KScheduler::YieldWithCoreMigration(KernelCore& kernel) {
 void KScheduler::YieldToAnyThread(KernelCore& kernel) {
     // Validate preconditions.
     ASSERT(CanSchedule(kernel));
-    ASSERT(kernel.CurrentProcess() != nullptr);
+    ASSERT(GetCurrentProcessPointer(kernel) != nullptr);
 
     // Get the current thread and process.
     KThread& cur_thread = GetCurrentThread(kernel);
-    KProcess& cur_process = *kernel.CurrentProcess();
+    KProcess& cur_process = GetCurrentProcess(kernel);
 
     // If the thread's yield count matches, there's nothing for us to do.
     if (cur_thread.GetYieldScheduleCount() == cur_process.GetScheduledCount()) {
diff --git a/src/core/hle/kernel/k_session.cpp b/src/core/hle/kernel/k_session.cpp
index b6f6fe9d9..7e677c028 100644
--- a/src/core/hle/kernel/k_session.cpp
+++ b/src/core/hle/kernel/k_session.cpp
@@ -33,7 +33,8 @@ void KSession::Initialize(KClientPort* port_, const std::string& name_) {
     name = name_;
 
     // Set our owner process.
-    process = kernel.CurrentProcess();
+    //! FIXME: this is the wrong process!
+    process = kernel.ApplicationProcess();
     process->Open();
 
     // Set our port.
diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cpp
index 84ff3c64b..2d3da9d66 100644
--- a/src/core/hle/kernel/k_thread.cpp
+++ b/src/core/hle/kernel/k_thread.cpp
@@ -1266,6 +1266,14 @@ KThread& GetCurrentThread(KernelCore& kernel) {
     return *GetCurrentThreadPointer(kernel);
 }
 
+KProcess* GetCurrentProcessPointer(KernelCore& kernel) {
+    return GetCurrentThread(kernel).GetOwnerProcess();
+}
+
+KProcess& GetCurrentProcess(KernelCore& kernel) {
+    return *GetCurrentProcessPointer(kernel);
+}
+
 s32 GetCurrentCoreId(KernelCore& kernel) {
     return GetCurrentThread(kernel).GetCurrentCore();
 }
diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h
index 8b8dc51be..ca82ce3b6 100644
--- a/src/core/hle/kernel/k_thread.h
+++ b/src/core/hle/kernel/k_thread.h
@@ -110,6 +110,8 @@ enum class StepState : u32 {
 void SetCurrentThread(KernelCore& kernel, KThread* thread);
 [[nodiscard]] KThread* GetCurrentThreadPointer(KernelCore& kernel);
 [[nodiscard]] KThread& GetCurrentThread(KernelCore& kernel);
+[[nodiscard]] KProcess* GetCurrentProcessPointer(KernelCore& kernel);
+[[nodiscard]] KProcess& GetCurrentProcess(KernelCore& kernel);
 [[nodiscard]] s32 GetCurrentCoreId(KernelCore& kernel);
 
 class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KWorkerTask>,
diff --git a/src/core/hle/kernel/k_transfer_memory.cpp b/src/core/hle/kernel/k_transfer_memory.cpp
index 9f34c2d46..faa5c73b5 100644
--- a/src/core/hle/kernel/k_transfer_memory.cpp
+++ b/src/core/hle/kernel/k_transfer_memory.cpp
@@ -16,7 +16,7 @@ KTransferMemory::~KTransferMemory() = default;
 Result KTransferMemory::Initialize(VAddr address_, std::size_t size_,
                                    Svc::MemoryPermission owner_perm_) {
     // Set members.
-    owner = kernel.CurrentProcess();
+    owner = GetCurrentProcessPointer(kernel);
 
     // TODO(bunnei): Lock for transfer memory
 
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index ece20a643..2ff253183 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -29,6 +29,7 @@
 #include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
+#include "core/hle/kernel/k_object_name.h"
 #include "core/hle/kernel/k_page_buffer.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_resource_limit.h"
@@ -84,6 +85,7 @@ struct KernelCore::Impl {
         InitializeShutdownThreads();
         InitializePhysicalCores();
         InitializePreemption(kernel);
+        InitializeGlobalData(kernel);
 
         // Initialize the Dynamic Slab Heaps.
         {
@@ -102,13 +104,13 @@ struct KernelCore::Impl {
 
     void InitializeCores() {
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            cores[core_id]->Initialize((*current_process).Is64BitProcess());
-            system.Memory().SetCurrentPageTable(*current_process, core_id);
+            cores[core_id]->Initialize((*application_process).Is64BitProcess());
+            system.Memory().SetCurrentPageTable(*application_process, core_id);
         }
     }
 
-    void CloseCurrentProcess() {
-        KProcess* old_process = current_process.exchange(nullptr);
+    void CloseApplicationProcess() {
+        KProcess* old_process = application_process.exchange(nullptr);
         if (old_process == nullptr) {
             return;
         }
@@ -182,7 +184,7 @@ struct KernelCore::Impl {
             }
         }
 
-        CloseCurrentProcess();
+        CloseApplicationProcess();
 
         // Track kernel objects that were not freed on shutdown
         {
@@ -194,6 +196,8 @@ struct KernelCore::Impl {
             }
         }
 
+        object_name_global_data.reset();
+
         // Ensure that the object list container is finalized and properly shutdown.
         global_object_list_container->Finalize();
         global_object_list_container.reset();
@@ -363,8 +367,12 @@ struct KernelCore::Impl {
         }
     }
 
-    void MakeCurrentProcess(KProcess* process) {
-        current_process = process;
+    void InitializeGlobalData(KernelCore& kernel) {
+        object_name_global_data = std::make_unique<KObjectNameGlobalData>(kernel);
+    }
+
+    void MakeApplicationProcess(KProcess* process) {
+        application_process = process;
     }
 
     static inline thread_local u8 host_thread_id = UINT8_MAX;
@@ -812,7 +820,7 @@ struct KernelCore::Impl {
 
     // Lists all processes that exist in the current session.
     std::vector<KProcess*> process_list;
-    std::atomic<KProcess*> current_process{};
+    std::atomic<KProcess*> application_process{};
     std::unique_ptr<Kernel::GlobalSchedulerContext> global_scheduler_context;
     std::unique_ptr<Kernel::KHardwareTimer> hardware_timer;
 
@@ -829,6 +837,8 @@ struct KernelCore::Impl {
 
     std::unique_ptr<KAutoObjectWithListContainer> global_object_list_container;
 
+    std::unique_ptr<KObjectNameGlobalData> object_name_global_data;
+
     /// Map of named ports managed by the kernel, which can be retrieved using
     /// the ConnectToPort SVC.
     std::unordered_map<std::string, ServiceInterfaceFactory> service_interface_factory;
@@ -932,20 +942,20 @@ void KernelCore::AppendNewProcess(KProcess* process) {
     impl->process_list.push_back(process);
 }
 
-void KernelCore::MakeCurrentProcess(KProcess* process) {
-    impl->MakeCurrentProcess(process);
+void KernelCore::MakeApplicationProcess(KProcess* process) {
+    impl->MakeApplicationProcess(process);
 }
 
-KProcess* KernelCore::CurrentProcess() {
-    return impl->current_process;
+KProcess* KernelCore::ApplicationProcess() {
+    return impl->application_process;
 }
 
-const KProcess* KernelCore::CurrentProcess() const {
-    return impl->current_process;
+const KProcess* KernelCore::ApplicationProcess() const {
+    return impl->application_process;
 }
 
-void KernelCore::CloseCurrentProcess() {
-    impl->CloseCurrentProcess();
+void KernelCore::CloseApplicationProcess() {
+    impl->CloseApplicationProcess();
 }
 
 const std::vector<KProcess*>& KernelCore::GetProcessList() const {
@@ -1129,6 +1139,10 @@ void KernelCore::SetCurrentEmuThread(KThread* thread) {
     impl->SetCurrentEmuThread(thread);
 }
 
+KObjectNameGlobalData& KernelCore::ObjectNameGlobalData() {
+    return *impl->object_name_global_data;
+}
+
 KMemoryManager& KernelCore::MemoryManager() {
     return *impl->memory_manager;
 }
@@ -1137,6 +1151,14 @@ const KMemoryManager& KernelCore::MemoryManager() const {
     return *impl->memory_manager;
 }
 
+KSystemResource& KernelCore::GetAppSystemResource() {
+    return *impl->app_system_resource;
+}
+
+const KSystemResource& KernelCore::GetAppSystemResource() const {
+    return *impl->app_system_resource;
+}
+
 KSystemResource& KernelCore::GetSystemSystemResource() {
     return *impl->sys_system_resource;
 }
@@ -1185,12 +1207,12 @@ const Kernel::KSharedMemory& KernelCore::GetHidBusSharedMem() const {
     return *impl->hidbus_shared_mem;
 }
 
-void KernelCore::Suspend(bool suspended) {
+void KernelCore::SuspendApplication(bool suspended) {
     const bool should_suspend{exception_exited || suspended};
     const auto activity = should_suspend ? ProcessActivity::Paused : ProcessActivity::Runnable;
 
-    //! This refers to the application process, not the current process.
-    KScopedAutoObject<KProcess> process = CurrentProcess();
+    // Get the application process.
+    KScopedAutoObject<KProcess> process = ApplicationProcess();
     if (process.IsNull()) {
         return;
     }
@@ -1201,8 +1223,8 @@ void KernelCore::Suspend(bool suspended) {
     // Wait for process execution to stop.
     bool must_wait{should_suspend};
 
-    // KernelCore::Suspend must be called from locked context, or we
-    // could race another call to SetActivity, interfering with waiting.
+    // KernelCore::SuspendApplication must be called from locked context,
+    // or we could race another call to SetActivity, interfering with waiting.
     while (must_wait) {
         KScopedSchedulerLock sl{*this};
 
@@ -1236,9 +1258,9 @@ bool KernelCore::IsShuttingDown() const {
     return impl->IsShuttingDown();
 }
 
-void KernelCore::ExceptionalExit() {
+void KernelCore::ExceptionalExitApplication() {
     exception_exited = true;
-    Suspend(true);
+    SuspendApplication(true);
 }
 
 void KernelCore::EnterSVCProfile() {
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 5f52e1e95..6e0668f7f 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -44,6 +44,8 @@ class KHardwareTimer;
 class KLinkedListNode;
 class KMemoryLayout;
 class KMemoryManager;
+class KObjectName;
+class KObjectNameGlobalData;
 class KPageBuffer;
 class KPageBufferSlabHeap;
 class KPort;
@@ -131,17 +133,17 @@ public:
     /// Adds the given shared pointer to an internal list of active processes.
     void AppendNewProcess(KProcess* process);
 
-    /// Makes the given process the new current process.
-    void MakeCurrentProcess(KProcess* process);
+    /// Makes the given process the new application process.
+    void MakeApplicationProcess(KProcess* process);
 
-    /// Retrieves a pointer to the current process.
-    KProcess* CurrentProcess();
+    /// Retrieves a pointer to the application process.
+    KProcess* ApplicationProcess();
 
-    /// Retrieves a const pointer to the current process.
-    const KProcess* CurrentProcess() const;
+    /// Retrieves a const pointer to the application process.
+    const KProcess* ApplicationProcess() const;
 
-    /// Closes the current process.
-    void CloseCurrentProcess();
+    /// Closes the application process.
+    void CloseApplicationProcess();
 
     /// Retrieves the list of processes.
     const std::vector<KProcess*>& GetProcessList() const;
@@ -240,12 +242,21 @@ public:
     /// Register the current thread as a non CPU core thread.
     void RegisterHostThread(KThread* existing_thread = nullptr);
 
+    /// Gets global data for KObjectName.
+    KObjectNameGlobalData& ObjectNameGlobalData();
+
     /// Gets the virtual memory manager for the kernel.
     KMemoryManager& MemoryManager();
 
     /// Gets the virtual memory manager for the kernel.
     const KMemoryManager& MemoryManager() const;
 
+    /// Gets the application resource manager.
+    KSystemResource& GetAppSystemResource();
+
+    /// Gets the application resource manager.
+    const KSystemResource& GetAppSystemResource() const;
+
     /// Gets the system resource manager.
     KSystemResource& GetSystemSystemResource();
 
@@ -282,11 +293,11 @@ public:
     /// Gets the shared memory object for HIDBus services.
     const Kernel::KSharedMemory& GetHidBusSharedMem() const;
 
-    /// Suspend/unsuspend all processes.
-    void Suspend(bool suspend);
+    /// Suspend/unsuspend application process.
+    void SuspendApplication(bool suspend);
 
-    /// Exceptional exit all processes.
-    void ExceptionalExit();
+    /// Exceptional exit application process.
+    void ExceptionalExitApplication();
 
     /// Notify emulated CPU cores to shut down.
     void ShutdownCores();
@@ -366,6 +377,8 @@ public:
             return slab_heap_container->page_buffer;
         } else if constexpr (std::is_same_v<T, KThreadLocalPage>) {
             return slab_heap_container->thread_local_page;
+        } else if constexpr (std::is_same_v<T, KObjectName>) {
+            return slab_heap_container->object_name;
         } else if constexpr (std::is_same_v<T, KSessionRequest>) {
             return slab_heap_container->session_request;
         } else if constexpr (std::is_same_v<T, KSecureSystemResource>) {
@@ -437,6 +450,7 @@ private:
         KSlabHeap<KDeviceAddressSpace> device_address_space;
         KSlabHeap<KPageBuffer> page_buffer;
         KSlabHeap<KThreadLocalPage> thread_local_page;
+        KSlabHeap<KObjectName> object_name;
         KSlabHeap<KSessionRequest> session_request;
         KSlabHeap<KSecureSystemResource> secure_system_resource;
         KSlabHeap<KEventInfo> event_info;
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 4cb6f40a0..1072da8cc 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -1,449 +1,4435 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/common_types.h"
+// This file is automatically generated using svc_generator.py.
+
+#include <type_traits>
+
+#include "core/arm/arm_interface.h"
+#include "core/core.h"
 #include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/svc.h"
-#include "core/hle/kernel/svc_wrap.h"
-#include "core/hle/result.h"
 
 namespace Kernel::Svc {
-namespace {
-
-struct FunctionDef {
-    using Func = void(Core::System&);
-
-    u32 id;
-    Func* func;
-    const char* name;
-};
-
-} // namespace
-
-static const FunctionDef SVC_Table_32[] = {
-    {0x00, nullptr, "Unknown0"},
-    {0x01, SvcWrap32<SetHeapSize32>, "SetHeapSize32"},
-    {0x02, nullptr, "SetMemoryPermission32"},
-    {0x03, SvcWrap32<SetMemoryAttribute32>, "SetMemoryAttribute32"},
-    {0x04, SvcWrap32<MapMemory32>, "MapMemory32"},
-    {0x05, SvcWrap32<UnmapMemory32>, "UnmapMemory32"},
-    {0x06, SvcWrap32<QueryMemory32>, "QueryMemory32"},
-    {0x07, SvcWrap32<ExitProcess32>, "ExitProcess32"},
-    {0x08, SvcWrap32<CreateThread32>, "CreateThread32"},
-    {0x09, SvcWrap32<StartThread32>, "StartThread32"},
-    {0x0a, SvcWrap32<ExitThread32>, "ExitThread32"},
-    {0x0b, SvcWrap32<SleepThread32>, "SleepThread32"},
-    {0x0c, SvcWrap32<GetThreadPriority32>, "GetThreadPriority32"},
-    {0x0d, SvcWrap32<SetThreadPriority32>, "SetThreadPriority32"},
-    {0x0e, SvcWrap32<GetThreadCoreMask32>, "GetThreadCoreMask32"},
-    {0x0f, SvcWrap32<SetThreadCoreMask32>, "SetThreadCoreMask32"},
-    {0x10, SvcWrap32<GetCurrentProcessorNumber32>, "GetCurrentProcessorNumber32"},
-    {0x11, SvcWrap32<SignalEvent32>, "SignalEvent32"},
-    {0x12, SvcWrap32<ClearEvent32>, "ClearEvent32"},
-    {0x13, SvcWrap32<MapSharedMemory32>, "MapSharedMemory32"},
-    {0x14, SvcWrap32<UnmapSharedMemory32>, "UnmapSharedMemory32"},
-    {0x15, SvcWrap32<CreateTransferMemory32>, "CreateTransferMemory32"},
-    {0x16, SvcWrap32<CloseHandle32>, "CloseHandle32"},
-    {0x17, SvcWrap32<ResetSignal32>, "ResetSignal32"},
-    {0x18, SvcWrap32<WaitSynchronization32>, "WaitSynchronization32"},
-    {0x19, SvcWrap32<CancelSynchronization32>, "CancelSynchronization32"},
-    {0x1a, SvcWrap32<ArbitrateLock32>, "ArbitrateLock32"},
-    {0x1b, SvcWrap32<ArbitrateUnlock32>, "ArbitrateUnlock32"},
-    {0x1c, SvcWrap32<WaitProcessWideKeyAtomic32>, "WaitProcessWideKeyAtomic32"},
-    {0x1d, SvcWrap32<SignalProcessWideKey32>, "SignalProcessWideKey32"},
-    {0x1e, SvcWrap32<GetSystemTick32>, "GetSystemTick32"},
-    {0x1f, SvcWrap32<ConnectToNamedPort32>, "ConnectToNamedPort32"},
-    {0x20, nullptr, "SendSyncRequestLight32"},
-    {0x21, SvcWrap32<SendSyncRequest32>, "SendSyncRequest32"},
-    {0x22, nullptr, "SendSyncRequestWithUserBuffer32"},
-    {0x23, nullptr, "SendAsyncRequestWithUserBuffer32"},
-    {0x24, SvcWrap32<GetProcessId32>, "GetProcessId32"},
-    {0x25, SvcWrap32<GetThreadId32>, "GetThreadId32"},
-    {0x26, SvcWrap32<Break32>, "Break32"},
-    {0x27, SvcWrap32<OutputDebugString32>, "OutputDebugString32"},
-    {0x28, nullptr, "ReturnFromException32"},
-    {0x29, SvcWrap32<GetInfo32>, "GetInfo32"},
-    {0x2a, nullptr, "FlushEntireDataCache32"},
-    {0x2b, nullptr, "FlushDataCache32"},
-    {0x2c, SvcWrap32<MapPhysicalMemory32>, "MapPhysicalMemory32"},
-    {0x2d, SvcWrap32<UnmapPhysicalMemory32>, "UnmapPhysicalMemory32"},
-    {0x2e, nullptr, "GetDebugFutureThreadInfo32"},
-    {0x2f, nullptr, "GetLastThreadInfo32"},
-    {0x30, nullptr, "GetResourceLimitLimitValue32"},
-    {0x31, nullptr, "GetResourceLimitCurrentValue32"},
-    {0x32, SvcWrap32<SetThreadActivity32>, "SetThreadActivity32"},
-    {0x33, SvcWrap32<GetThreadContext32>, "GetThreadContext32"},
-    {0x34, SvcWrap32<WaitForAddress32>, "WaitForAddress32"},
-    {0x35, SvcWrap32<SignalToAddress32>, "SignalToAddress32"},
-    {0x36, SvcWrap32<SynchronizePreemptionState>, "SynchronizePreemptionState32"},
-    {0x37, nullptr, "GetResourceLimitPeakValue32"},
-    {0x38, nullptr, "Unknown38"},
-    {0x39, nullptr, "CreateIoPool32"},
-    {0x3a, nullptr, "CreateIoRegion32"},
-    {0x3b, nullptr, "Unknown3b"},
-    {0x3c, nullptr, "KernelDebug32"},
-    {0x3d, nullptr, "ChangeKernelTraceState32"},
-    {0x3e, nullptr, "Unknown3e"},
-    {0x3f, nullptr, "Unknown3f"},
-    {0x40, nullptr, "CreateSession32"},
-    {0x41, nullptr, "AcceptSession32"},
-    {0x42, nullptr, "ReplyAndReceiveLight32"},
-    {0x43, nullptr, "ReplyAndReceive32"},
-    {0x44, nullptr, "ReplyAndReceiveWithUserBuffer32"},
-    {0x45, SvcWrap32<CreateEvent32>, "CreateEvent32"},
-    {0x46, nullptr, "MapIoRegion32"},
-    {0x47, nullptr, "UnmapIoRegion32"},
-    {0x48, nullptr, "MapPhysicalMemoryUnsafe32"},
-    {0x49, nullptr, "UnmapPhysicalMemoryUnsafe32"},
-    {0x4a, nullptr, "SetUnsafeLimit32"},
-    {0x4b, SvcWrap32<CreateCodeMemory32>, "CreateCodeMemory32"},
-    {0x4c, SvcWrap32<ControlCodeMemory32>, "ControlCodeMemory32"},
-    {0x4d, nullptr, "SleepSystem32"},
-    {0x4e, nullptr, "ReadWriteRegister32"},
-    {0x4f, nullptr, "SetProcessActivity32"},
-    {0x50, nullptr, "CreateSharedMemory32"},
-    {0x51, nullptr, "MapTransferMemory32"},
-    {0x52, nullptr, "UnmapTransferMemory32"},
-    {0x53, nullptr, "CreateInterruptEvent32"},
-    {0x54, nullptr, "QueryPhysicalAddress32"},
-    {0x55, nullptr, "QueryIoMapping32"},
-    {0x56, nullptr, "CreateDeviceAddressSpace32"},
-    {0x57, nullptr, "AttachDeviceAddressSpace32"},
-    {0x58, nullptr, "DetachDeviceAddressSpace32"},
-    {0x59, nullptr, "MapDeviceAddressSpaceByForce32"},
-    {0x5a, nullptr, "MapDeviceAddressSpaceAligned32"},
-    {0x5b, nullptr, "MapDeviceAddressSpace32"},
-    {0x5c, nullptr, "UnmapDeviceAddressSpace32"},
-    {0x5d, nullptr, "InvalidateProcessDataCache32"},
-    {0x5e, nullptr, "StoreProcessDataCache32"},
-    {0x5F, SvcWrap32<FlushProcessDataCache32>, "FlushProcessDataCache32"},
-    {0x60, nullptr, "StoreProcessDataCache32"},
-    {0x61, nullptr, "BreakDebugProcess32"},
-    {0x62, nullptr, "TerminateDebugProcess32"},
-    {0x63, nullptr, "GetDebugEvent32"},
-    {0x64, nullptr, "ContinueDebugEvent32"},
-    {0x65, nullptr, "GetProcessList32"},
-    {0x66, nullptr, "GetThreadList"},
-    {0x67, nullptr, "GetDebugThreadContext32"},
-    {0x68, nullptr, "SetDebugThreadContext32"},
-    {0x69, nullptr, "QueryDebugProcessMemory32"},
-    {0x6A, nullptr, "ReadDebugProcessMemory32"},
-    {0x6B, nullptr, "WriteDebugProcessMemory32"},
-    {0x6C, nullptr, "SetHardwareBreakPoint32"},
-    {0x6D, nullptr, "GetDebugThreadParam32"},
-    {0x6E, nullptr, "Unknown6E"},
-    {0x6f, nullptr, "GetSystemInfo32"},
-    {0x70, nullptr, "CreatePort32"},
-    {0x71, nullptr, "ManageNamedPort32"},
-    {0x72, nullptr, "ConnectToPort32"},
-    {0x73, nullptr, "SetProcessMemoryPermission32"},
-    {0x74, nullptr, "MapProcessMemory32"},
-    {0x75, nullptr, "UnmapProcessMemory32"},
-    {0x76, nullptr, "QueryProcessMemory32"},
-    {0x77, nullptr, "MapProcessCodeMemory32"},
-    {0x78, nullptr, "UnmapProcessCodeMemory32"},
-    {0x79, nullptr, "CreateProcess32"},
-    {0x7A, nullptr, "StartProcess32"},
-    {0x7B, nullptr, "TerminateProcess32"},
-    {0x7C, nullptr, "GetProcessInfo32"},
-    {0x7D, nullptr, "CreateResourceLimit32"},
-    {0x7E, nullptr, "SetResourceLimitLimitValue32"},
-    {0x7F, nullptr, "CallSecureMonitor32"},
-    {0x80, nullptr, "Unknown"},
-    {0x81, nullptr, "Unknown"},
-    {0x82, nullptr, "Unknown"},
-    {0x83, nullptr, "Unknown"},
-    {0x84, nullptr, "Unknown"},
-    {0x85, nullptr, "Unknown"},
-    {0x86, nullptr, "Unknown"},
-    {0x87, nullptr, "Unknown"},
-    {0x88, nullptr, "Unknown"},
-    {0x89, nullptr, "Unknown"},
-    {0x8A, nullptr, "Unknown"},
-    {0x8B, nullptr, "Unknown"},
-    {0x8C, nullptr, "Unknown"},
-    {0x8D, nullptr, "Unknown"},
-    {0x8E, nullptr, "Unknown"},
-    {0x8F, nullptr, "Unknown"},
-    {0x90, nullptr, "Unknown"},
-    {0x91, nullptr, "Unknown"},
-    {0x92, nullptr, "Unknown"},
-    {0x93, nullptr, "Unknown"},
-    {0x94, nullptr, "Unknown"},
-    {0x95, nullptr, "Unknown"},
-    {0x96, nullptr, "Unknown"},
-    {0x97, nullptr, "Unknown"},
-    {0x98, nullptr, "Unknown"},
-    {0x99, nullptr, "Unknown"},
-    {0x9A, nullptr, "Unknown"},
-    {0x9B, nullptr, "Unknown"},
-    {0x9C, nullptr, "Unknown"},
-    {0x9D, nullptr, "Unknown"},
-    {0x9E, nullptr, "Unknown"},
-    {0x9F, nullptr, "Unknown"},
-    {0xA0, nullptr, "Unknown"},
-    {0xA1, nullptr, "Unknown"},
-    {0xA2, nullptr, "Unknown"},
-    {0xA3, nullptr, "Unknown"},
-    {0xA4, nullptr, "Unknown"},
-    {0xA5, nullptr, "Unknown"},
-    {0xA6, nullptr, "Unknown"},
-    {0xA7, nullptr, "Unknown"},
-    {0xA8, nullptr, "Unknown"},
-    {0xA9, nullptr, "Unknown"},
-    {0xAA, nullptr, "Unknown"},
-    {0xAB, nullptr, "Unknown"},
-    {0xAC, nullptr, "Unknown"},
-    {0xAD, nullptr, "Unknown"},
-    {0xAE, nullptr, "Unknown"},
-    {0xAF, nullptr, "Unknown"},
-    {0xB0, nullptr, "Unknown"},
-    {0xB1, nullptr, "Unknown"},
-    {0xB2, nullptr, "Unknown"},
-    {0xB3, nullptr, "Unknown"},
-    {0xB4, nullptr, "Unknown"},
-    {0xB5, nullptr, "Unknown"},
-    {0xB6, nullptr, "Unknown"},
-    {0xB7, nullptr, "Unknown"},
-    {0xB8, nullptr, "Unknown"},
-    {0xB9, nullptr, "Unknown"},
-    {0xBA, nullptr, "Unknown"},
-    {0xBB, nullptr, "Unknown"},
-    {0xBC, nullptr, "Unknown"},
-    {0xBD, nullptr, "Unknown"},
-    {0xBE, nullptr, "Unknown"},
-    {0xBF, nullptr, "Unknown"},
-};
-
-static const FunctionDef SVC_Table_64[] = {
-    {0x00, nullptr, "Unknown0"},
-    {0x01, SvcWrap64<SetHeapSize>, "SetHeapSize"},
-    {0x02, SvcWrap64<SetMemoryPermission>, "SetMemoryPermission"},
-    {0x03, SvcWrap64<SetMemoryAttribute>, "SetMemoryAttribute"},
-    {0x04, SvcWrap64<MapMemory>, "MapMemory"},
-    {0x05, SvcWrap64<UnmapMemory>, "UnmapMemory"},
-    {0x06, SvcWrap64<QueryMemory>, "QueryMemory"},
-    {0x07, SvcWrap64<ExitProcess>, "ExitProcess"},
-    {0x08, SvcWrap64<CreateThread>, "CreateThread"},
-    {0x09, SvcWrap64<StartThread>, "StartThread"},
-    {0x0A, SvcWrap64<ExitThread>, "ExitThread"},
-    {0x0B, SvcWrap64<SleepThread>, "SleepThread"},
-    {0x0C, SvcWrap64<GetThreadPriority>, "GetThreadPriority"},
-    {0x0D, SvcWrap64<SetThreadPriority>, "SetThreadPriority"},
-    {0x0E, SvcWrap64<GetThreadCoreMask>, "GetThreadCoreMask"},
-    {0x0F, SvcWrap64<SetThreadCoreMask>, "SetThreadCoreMask"},
-    {0x10, SvcWrap64<GetCurrentProcessorNumber>, "GetCurrentProcessorNumber"},
-    {0x11, SvcWrap64<SignalEvent>, "SignalEvent"},
-    {0x12, SvcWrap64<ClearEvent>, "ClearEvent"},
-    {0x13, SvcWrap64<MapSharedMemory>, "MapSharedMemory"},
-    {0x14, SvcWrap64<UnmapSharedMemory>, "UnmapSharedMemory"},
-    {0x15, SvcWrap64<CreateTransferMemory>, "CreateTransferMemory"},
-    {0x16, SvcWrap64<CloseHandle>, "CloseHandle"},
-    {0x17, SvcWrap64<ResetSignal>, "ResetSignal"},
-    {0x18, SvcWrap64<WaitSynchronization>, "WaitSynchronization"},
-    {0x19, SvcWrap64<CancelSynchronization>, "CancelSynchronization"},
-    {0x1A, SvcWrap64<ArbitrateLock>, "ArbitrateLock"},
-    {0x1B, SvcWrap64<ArbitrateUnlock>, "ArbitrateUnlock"},
-    {0x1C, SvcWrap64<WaitProcessWideKeyAtomic>, "WaitProcessWideKeyAtomic"},
-    {0x1D, SvcWrap64<SignalProcessWideKey>, "SignalProcessWideKey"},
-    {0x1E, SvcWrap64<GetSystemTick>, "GetSystemTick"},
-    {0x1F, SvcWrap64<ConnectToNamedPort>, "ConnectToNamedPort"},
-    {0x20, nullptr, "SendSyncRequestLight"},
-    {0x21, SvcWrap64<SendSyncRequest>, "SendSyncRequest"},
-    {0x22, nullptr, "SendSyncRequestWithUserBuffer"},
-    {0x23, nullptr, "SendAsyncRequestWithUserBuffer"},
-    {0x24, SvcWrap64<GetProcessId>, "GetProcessId"},
-    {0x25, SvcWrap64<GetThreadId>, "GetThreadId"},
-    {0x26, SvcWrap64<Break>, "Break"},
-    {0x27, SvcWrap64<OutputDebugString>, "OutputDebugString"},
-    {0x28, nullptr, "ReturnFromException"},
-    {0x29, SvcWrap64<GetInfo>, "GetInfo"},
-    {0x2A, nullptr, "FlushEntireDataCache"},
-    {0x2B, nullptr, "FlushDataCache"},
-    {0x2C, SvcWrap64<MapPhysicalMemory>, "MapPhysicalMemory"},
-    {0x2D, SvcWrap64<UnmapPhysicalMemory>, "UnmapPhysicalMemory"},
-    {0x2E, nullptr, "GetFutureThreadInfo"},
-    {0x2F, nullptr, "GetLastThreadInfo"},
-    {0x30, SvcWrap64<GetResourceLimitLimitValue>, "GetResourceLimitLimitValue"},
-    {0x31, SvcWrap64<GetResourceLimitCurrentValue>, "GetResourceLimitCurrentValue"},
-    {0x32, SvcWrap64<SetThreadActivity>, "SetThreadActivity"},
-    {0x33, SvcWrap64<GetThreadContext>, "GetThreadContext"},
-    {0x34, SvcWrap64<WaitForAddress>, "WaitForAddress"},
-    {0x35, SvcWrap64<SignalToAddress>, "SignalToAddress"},
-    {0x36, SvcWrap64<SynchronizePreemptionState>, "SynchronizePreemptionState"},
-    {0x37, nullptr, "GetResourceLimitPeakValue"},
-    {0x38, nullptr, "Unknown38"},
-    {0x39, nullptr, "CreateIoPool"},
-    {0x3A, nullptr, "CreateIoRegion"},
-    {0x3B, nullptr, "Unknown3B"},
-    {0x3C, SvcWrap64<KernelDebug>, "KernelDebug"},
-    {0x3D, SvcWrap64<ChangeKernelTraceState>, "ChangeKernelTraceState"},
-    {0x3E, nullptr, "Unknown3e"},
-    {0x3F, nullptr, "Unknown3f"},
-    {0x40, SvcWrap64<CreateSession>, "CreateSession"},
-    {0x41, nullptr, "AcceptSession"},
-    {0x42, nullptr, "ReplyAndReceiveLight"},
-    {0x43, SvcWrap64<ReplyAndReceive>, "ReplyAndReceive"},
-    {0x44, nullptr, "ReplyAndReceiveWithUserBuffer"},
-    {0x45, SvcWrap64<CreateEvent>, "CreateEvent"},
-    {0x46, nullptr, "MapIoRegion"},
-    {0x47, nullptr, "UnmapIoRegion"},
-    {0x48, nullptr, "MapPhysicalMemoryUnsafe"},
-    {0x49, nullptr, "UnmapPhysicalMemoryUnsafe"},
-    {0x4A, nullptr, "SetUnsafeLimit"},
-    {0x4B, SvcWrap64<CreateCodeMemory>, "CreateCodeMemory"},
-    {0x4C, SvcWrap64<ControlCodeMemory>, "ControlCodeMemory"},
-    {0x4D, nullptr, "SleepSystem"},
-    {0x4E, nullptr, "ReadWriteRegister"},
-    {0x4F, nullptr, "SetProcessActivity"},
-    {0x50, nullptr, "CreateSharedMemory"},
-    {0x51, nullptr, "MapTransferMemory"},
-    {0x52, nullptr, "UnmapTransferMemory"},
-    {0x53, nullptr, "CreateInterruptEvent"},
-    {0x54, nullptr, "QueryPhysicalAddress"},
-    {0x55, nullptr, "QueryIoMapping"},
-    {0x56, nullptr, "CreateDeviceAddressSpace"},
-    {0x57, nullptr, "AttachDeviceAddressSpace"},
-    {0x58, nullptr, "DetachDeviceAddressSpace"},
-    {0x59, nullptr, "MapDeviceAddressSpaceByForce"},
-    {0x5A, nullptr, "MapDeviceAddressSpaceAligned"},
-    {0x5B, nullptr, "MapDeviceAddressSpace"},
-    {0x5C, nullptr, "UnmapDeviceAddressSpace"},
-    {0x5D, nullptr, "InvalidateProcessDataCache"},
-    {0x5E, nullptr, "StoreProcessDataCache"},
-    {0x5F, nullptr, "FlushProcessDataCache"},
-    {0x60, nullptr, "DebugActiveProcess"},
-    {0x61, nullptr, "BreakDebugProcess"},
-    {0x62, nullptr, "TerminateDebugProcess"},
-    {0x63, nullptr, "GetDebugEvent"},
-    {0x64, nullptr, "ContinueDebugEvent"},
-    {0x65, SvcWrap64<GetProcessList>, "GetProcessList"},
-    {0x66, SvcWrap64<GetThreadList>, "GetThreadList"},
-    {0x67, nullptr, "GetDebugThreadContext"},
-    {0x68, nullptr, "SetDebugThreadContext"},
-    {0x69, nullptr, "QueryDebugProcessMemory"},
-    {0x6A, nullptr, "ReadDebugProcessMemory"},
-    {0x6B, nullptr, "WriteDebugProcessMemory"},
-    {0x6C, nullptr, "SetHardwareBreakPoint"},
-    {0x6D, nullptr, "GetDebugThreadParam"},
-    {0x6E, nullptr, "Unknown6E"},
-    {0x6F, nullptr, "GetSystemInfo"},
-    {0x70, nullptr, "CreatePort"},
-    {0x71, nullptr, "ManageNamedPort"},
-    {0x72, nullptr, "ConnectToPort"},
-    {0x73, SvcWrap64<SetProcessMemoryPermission>, "SetProcessMemoryPermission"},
-    {0x74, SvcWrap64<MapProcessMemory>, "MapProcessMemory"},
-    {0x75, SvcWrap64<UnmapProcessMemory>, "UnmapProcessMemory"},
-    {0x76, SvcWrap64<QueryProcessMemory>, "QueryProcessMemory"},
-    {0x77, SvcWrap64<MapProcessCodeMemory>, "MapProcessCodeMemory"},
-    {0x78, SvcWrap64<UnmapProcessCodeMemory>, "UnmapProcessCodeMemory"},
-    {0x79, nullptr, "CreateProcess"},
-    {0x7A, nullptr, "StartProcess"},
-    {0x7B, nullptr, "TerminateProcess"},
-    {0x7C, SvcWrap64<GetProcessInfo>, "GetProcessInfo"},
-    {0x7D, SvcWrap64<CreateResourceLimit>, "CreateResourceLimit"},
-    {0x7E, SvcWrap64<SetResourceLimitLimitValue>, "SetResourceLimitLimitValue"},
-    {0x7F, nullptr, "CallSecureMonitor"},
-    {0x80, nullptr, "Unknown"},
-    {0x81, nullptr, "Unknown"},
-    {0x82, nullptr, "Unknown"},
-    {0x83, nullptr, "Unknown"},
-    {0x84, nullptr, "Unknown"},
-    {0x85, nullptr, "Unknown"},
-    {0x86, nullptr, "Unknown"},
-    {0x87, nullptr, "Unknown"},
-    {0x88, nullptr, "Unknown"},
-    {0x89, nullptr, "Unknown"},
-    {0x8A, nullptr, "Unknown"},
-    {0x8B, nullptr, "Unknown"},
-    {0x8C, nullptr, "Unknown"},
-    {0x8D, nullptr, "Unknown"},
-    {0x8E, nullptr, "Unknown"},
-    {0x8F, nullptr, "Unknown"},
-    {0x90, nullptr, "Unknown"},
-    {0x91, nullptr, "Unknown"},
-    {0x92, nullptr, "Unknown"},
-    {0x93, nullptr, "Unknown"},
-    {0x94, nullptr, "Unknown"},
-    {0x95, nullptr, "Unknown"},
-    {0x96, nullptr, "Unknown"},
-    {0x97, nullptr, "Unknown"},
-    {0x98, nullptr, "Unknown"},
-    {0x99, nullptr, "Unknown"},
-    {0x9A, nullptr, "Unknown"},
-    {0x9B, nullptr, "Unknown"},
-    {0x9C, nullptr, "Unknown"},
-    {0x9D, nullptr, "Unknown"},
-    {0x9E, nullptr, "Unknown"},
-    {0x9F, nullptr, "Unknown"},
-    {0xA0, nullptr, "Unknown"},
-    {0xA1, nullptr, "Unknown"},
-    {0xA2, nullptr, "Unknown"},
-    {0xA3, nullptr, "Unknown"},
-    {0xA4, nullptr, "Unknown"},
-    {0xA5, nullptr, "Unknown"},
-    {0xA6, nullptr, "Unknown"},
-    {0xA7, nullptr, "Unknown"},
-    {0xA8, nullptr, "Unknown"},
-    {0xA9, nullptr, "Unknown"},
-    {0xAA, nullptr, "Unknown"},
-    {0xAB, nullptr, "Unknown"},
-    {0xAC, nullptr, "Unknown"},
-    {0xAD, nullptr, "Unknown"},
-    {0xAE, nullptr, "Unknown"},
-    {0xAF, nullptr, "Unknown"},
-    {0xB0, nullptr, "Unknown"},
-    {0xB1, nullptr, "Unknown"},
-    {0xB2, nullptr, "Unknown"},
-    {0xB3, nullptr, "Unknown"},
-    {0xB4, nullptr, "Unknown"},
-    {0xB5, nullptr, "Unknown"},
-    {0xB6, nullptr, "Unknown"},
-    {0xB7, nullptr, "Unknown"},
-    {0xB8, nullptr, "Unknown"},
-    {0xB9, nullptr, "Unknown"},
-    {0xBA, nullptr, "Unknown"},
-    {0xBB, nullptr, "Unknown"},
-    {0xBC, nullptr, "Unknown"},
-    {0xBD, nullptr, "Unknown"},
-    {0xBE, nullptr, "Unknown"},
-    {0xBF, nullptr, "Unknown"},
-};
-
-static const FunctionDef* GetSVCInfo32(u32 func_num) {
-    if (func_num >= std::size(SVC_Table_32)) {
-        LOG_ERROR(Kernel_SVC, "Unknown svc=0x{:02X}", func_num);
-        return nullptr;
+
+static uint32_t GetReg32(Core::System& system, int n) {
+    return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n));
+}
+
+static void SetReg32(Core::System& system, int n, uint32_t result) {
+    system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result));
+}
+
+static uint64_t GetReg64(Core::System& system, int n) {
+    return system.CurrentArmInterface().GetReg(n);
+}
+
+static void SetReg64(Core::System& system, int n, uint64_t result) {
+    system.CurrentArmInterface().SetReg(n, result);
+}
+
+// Like bit_cast, but handles the case when the source and dest
+// are differently-sized.
+template <typename To, typename From>
+    requires(std::is_trivial_v<To> && std::is_trivially_copyable_v<From>)
+static To Convert(const From& from) {
+    To to{};
+
+    if constexpr (sizeof(To) >= sizeof(From)) {
+        std::memcpy(&to, &from, sizeof(From));
+    } else {
+        std::memcpy(&to, &from, sizeof(To));
+    }
+
+    return to;
+}
+
+// clang-format off
+static_assert(sizeof(ArbitrationType) == 4);
+static_assert(sizeof(BreakReason) == 4);
+static_assert(sizeof(CodeMemoryOperation) == 4);
+static_assert(sizeof(DebugThreadParam) == 4);
+static_assert(sizeof(DeviceName) == 4);
+static_assert(sizeof(HardwareBreakPointRegisterName) == 4);
+static_assert(sizeof(Handle) == 4);
+static_assert(sizeof(InfoType) == 4);
+static_assert(sizeof(InterruptType) == 4);
+static_assert(sizeof(IoPoolType) == 4);
+static_assert(sizeof(KernelDebugType) == 4);
+static_assert(sizeof(KernelTraceState) == 4);
+static_assert(sizeof(LimitableResource) == 4);
+static_assert(sizeof(MemoryMapping) == 4);
+static_assert(sizeof(MemoryPermission) == 4);
+static_assert(sizeof(PageInfo) == 4);
+static_assert(sizeof(ProcessActivity) == 4);
+static_assert(sizeof(ProcessInfoType) == 4);
+static_assert(sizeof(Result) == 4);
+static_assert(sizeof(SignalType) == 4);
+static_assert(sizeof(SystemInfoType) == 4);
+static_assert(sizeof(ThreadActivity) == 4);
+static_assert(sizeof(ilp32::LastThreadContext) == 16);
+static_assert(sizeof(ilp32::PhysicalMemoryInfo) == 16);
+static_assert(sizeof(ilp32::SecureMonitorArguments) == 32);
+static_assert(sizeof(lp64::LastThreadContext) == 32);
+static_assert(sizeof(lp64::PhysicalMemoryInfo) == 24);
+static_assert(sizeof(lp64::SecureMonitorArguments) == 64);
+static_assert(sizeof(bool) == 1);
+static_assert(sizeof(int32_t) == 4);
+static_assert(sizeof(int64_t) == 8);
+static_assert(sizeof(uint32_t) == 4);
+static_assert(sizeof(uint64_t) == 8);
+
+static void SvcWrap_SetHeapSize64From32(Core::System& system) {
+    Result ret{};
+
+    uintptr_t out_address{};
+    uint32_t size{};
+
+    size = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = SetHeapSize64From32(system, &out_address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_address));
+}
+
+static void SvcWrap_SetMemoryPermission64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+    MemoryPermission perm{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+    perm = Convert<MemoryPermission>(GetReg32(system, 2));
+
+    ret = SetMemoryPermission64From32(system, address, size, perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SetMemoryAttribute64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+    uint32_t mask{};
+    uint32_t attr{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+    mask = Convert<uint32_t>(GetReg32(system, 2));
+    attr = Convert<uint32_t>(GetReg32(system, 3));
+
+    ret = SetMemoryAttribute64From32(system, address, size, mask, attr);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_MapMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t dst_address{};
+    uint32_t src_address{};
+    uint32_t size{};
+
+    dst_address = Convert<uint32_t>(GetReg32(system, 0));
+    src_address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+
+    ret = MapMemory64From32(system, dst_address, src_address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t dst_address{};
+    uint32_t src_address{};
+    uint32_t size{};
+
+    dst_address = Convert<uint32_t>(GetReg32(system, 0));
+    src_address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+
+    ret = UnmapMemory64From32(system, dst_address, src_address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_QueryMemory64From32(Core::System& system) {
+    Result ret{};
+
+    PageInfo out_page_info{};
+    uint32_t out_memory_info{};
+    uint32_t address{};
+
+    out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetReg32(system, 2));
+
+    ret = QueryMemory64From32(system, out_memory_info, &out_page_info, address);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_page_info));
+}
+
+static void SvcWrap_ExitProcess64From32(Core::System& system) {
+    ExitProcess64From32(system);
+}
+
+static void SvcWrap_CreateThread64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint32_t func{};
+    uint32_t arg{};
+    uint32_t stack_bottom{};
+    int32_t priority{};
+    int32_t core_id{};
+
+    func = Convert<uint32_t>(GetReg32(system, 1));
+    arg = Convert<uint32_t>(GetReg32(system, 2));
+    stack_bottom = Convert<uint32_t>(GetReg32(system, 3));
+    priority = Convert<int32_t>(GetReg32(system, 0));
+    core_id = Convert<int32_t>(GetReg32(system, 4));
+
+    ret = CreateThread64From32(system, &out_handle, func, arg, stack_bottom, priority, core_id);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_StartThread64From32(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+
+    thread_handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = StartThread64From32(system, thread_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_ExitThread64From32(Core::System& system) {
+    ExitThread64From32(system);
+}
+
+static void SvcWrap_SleepThread64From32(Core::System& system) {
+    int64_t ns{};
+
+    std::array<uint32_t, 2> ns_gather{};
+    ns_gather[0] = GetReg32(system, 0);
+    ns_gather[1] = GetReg32(system, 1);
+    ns = Convert<int64_t>(ns_gather);
+
+    SleepThread64From32(system, ns);
+}
+
+static void SvcWrap_GetThreadPriority64From32(Core::System& system) {
+    Result ret{};
+
+    int32_t out_priority{};
+    Handle thread_handle{};
+
+    thread_handle = Convert<Handle>(GetReg32(system, 1));
+
+    ret = GetThreadPriority64From32(system, &out_priority, thread_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_priority));
+}
+
+static void SvcWrap_SetThreadPriority64From32(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+    int32_t priority{};
+
+    thread_handle = Convert<Handle>(GetReg32(system, 0));
+    priority = Convert<int32_t>(GetReg32(system, 1));
+
+    ret = SetThreadPriority64From32(system, thread_handle, priority);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_GetThreadCoreMask64From32(Core::System& system) {
+    Result ret{};
+
+    int32_t out_core_id{};
+    uint64_t out_affinity_mask{};
+    Handle thread_handle{};
+
+    thread_handle = Convert<Handle>(GetReg32(system, 2));
+
+    ret = GetThreadCoreMask64From32(system, &out_core_id, &out_affinity_mask, thread_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_core_id));
+    auto out_affinity_mask_scatter = Convert<std::array<uint32_t, 2>>(out_affinity_mask);
+    SetReg32(system, 2, out_affinity_mask_scatter[0]);
+    SetReg32(system, 3, out_affinity_mask_scatter[1]);
+}
+
+static void SvcWrap_SetThreadCoreMask64From32(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+    int32_t core_id{};
+    uint64_t affinity_mask{};
+
+    thread_handle = Convert<Handle>(GetReg32(system, 0));
+    core_id = Convert<int32_t>(GetReg32(system, 1));
+    std::array<uint32_t, 2> affinity_mask_gather{};
+    affinity_mask_gather[0] = GetReg32(system, 2);
+    affinity_mask_gather[1] = GetReg32(system, 3);
+    affinity_mask = Convert<uint64_t>(affinity_mask_gather);
+
+    ret = SetThreadCoreMask64From32(system, thread_handle, core_id, affinity_mask);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system) {
+    int32_t ret{};
+
+    ret = GetCurrentProcessorNumber64From32(system);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SignalEvent64From32(Core::System& system) {
+    Result ret{};
+
+    Handle event_handle{};
+
+    event_handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = SignalEvent64From32(system, event_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_ClearEvent64From32(Core::System& system) {
+    Result ret{};
+
+    Handle event_handle{};
+
+    event_handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = ClearEvent64From32(system, event_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_MapSharedMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle shmem_handle{};
+    uint32_t address{};
+    uint32_t size{};
+    MemoryPermission map_perm{};
+
+    shmem_handle = Convert<Handle>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+    map_perm = Convert<MemoryPermission>(GetReg32(system, 3));
+
+    ret = MapSharedMemory64From32(system, shmem_handle, address, size, map_perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapSharedMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle shmem_handle{};
+    uint32_t address{};
+    uint32_t size{};
+
+    shmem_handle = Convert<Handle>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+
+    ret = UnmapSharedMemory64From32(system, shmem_handle, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_CreateTransferMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint32_t address{};
+    uint32_t size{};
+    MemoryPermission map_perm{};
+
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+    map_perm = Convert<MemoryPermission>(GetReg32(system, 3));
+
+    ret = CreateTransferMemory64From32(system, &out_handle, address, size, map_perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_CloseHandle64From32(Core::System& system) {
+    Result ret{};
+
+    Handle handle{};
+
+    handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = CloseHandle64From32(system, handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_ResetSignal64From32(Core::System& system) {
+    Result ret{};
+
+    Handle handle{};
+
+    handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = ResetSignal64From32(system, handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_WaitSynchronization64From32(Core::System& system) {
+    Result ret{};
+
+    int32_t out_index{};
+    uint32_t handles{};
+    int32_t num_handles{};
+    int64_t timeout_ns{};
+
+    handles = Convert<uint32_t>(GetReg32(system, 1));
+    num_handles = Convert<int32_t>(GetReg32(system, 2));
+    std::array<uint32_t, 2> timeout_ns_gather{};
+    timeout_ns_gather[0] = GetReg32(system, 0);
+    timeout_ns_gather[1] = GetReg32(system, 3);
+    timeout_ns = Convert<int64_t>(timeout_ns_gather);
+
+    ret = WaitSynchronization64From32(system, &out_index, handles, num_handles, timeout_ns);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_index));
+}
+
+static void SvcWrap_CancelSynchronization64From32(Core::System& system) {
+    Result ret{};
+
+    Handle handle{};
+
+    handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = CancelSynchronization64From32(system, handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_ArbitrateLock64From32(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+    uint32_t address{};
+    uint32_t tag{};
+
+    thread_handle = Convert<Handle>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    tag = Convert<uint32_t>(GetReg32(system, 2));
+
+    ret = ArbitrateLock64From32(system, thread_handle, address, tag);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_ArbitrateUnlock64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+
+    ret = ArbitrateUnlock64From32(system, address);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t cv_key{};
+    uint32_t tag{};
+    int64_t timeout_ns{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    cv_key = Convert<uint32_t>(GetReg32(system, 1));
+    tag = Convert<uint32_t>(GetReg32(system, 2));
+    std::array<uint32_t, 2> timeout_ns_gather{};
+    timeout_ns_gather[0] = GetReg32(system, 3);
+    timeout_ns_gather[1] = GetReg32(system, 4);
+    timeout_ns = Convert<int64_t>(timeout_ns_gather);
+
+    ret = WaitProcessWideKeyAtomic64From32(system, address, cv_key, tag, timeout_ns);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SignalProcessWideKey64From32(Core::System& system) {
+    uint32_t cv_key{};
+    int32_t count{};
+
+    cv_key = Convert<uint32_t>(GetReg32(system, 0));
+    count = Convert<int32_t>(GetReg32(system, 1));
+
+    SignalProcessWideKey64From32(system, cv_key, count);
+}
+
+static void SvcWrap_GetSystemTick64From32(Core::System& system) {
+    int64_t ret{};
+
+    ret = GetSystemTick64From32(system);
+
+    auto ret_scatter = Convert<std::array<uint32_t, 2>>(ret);
+    SetReg32(system, 0, ret_scatter[0]);
+    SetReg32(system, 1, ret_scatter[1]);
+}
+
+static void SvcWrap_ConnectToNamedPort64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint32_t name{};
+
+    name = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = ConnectToNamedPort64From32(system, &out_handle, name);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_SendSyncRequest64From32(Core::System& system) {
+    Result ret{};
+
+    Handle session_handle{};
+
+    session_handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = SendSyncRequest64From32(system, session_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t message_buffer{};
+    uint32_t message_buffer_size{};
+    Handle session_handle{};
+
+    message_buffer = Convert<uint32_t>(GetReg32(system, 0));
+    message_buffer_size = Convert<uint32_t>(GetReg32(system, 1));
+    session_handle = Convert<Handle>(GetReg32(system, 2));
+
+    ret = SendSyncRequestWithUserBuffer64From32(system, message_buffer, message_buffer_size, session_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_event_handle{};
+    uint32_t message_buffer{};
+    uint32_t message_buffer_size{};
+    Handle session_handle{};
+
+    message_buffer = Convert<uint32_t>(GetReg32(system, 1));
+    message_buffer_size = Convert<uint32_t>(GetReg32(system, 2));
+    session_handle = Convert<Handle>(GetReg32(system, 3));
+
+    ret = SendAsyncRequestWithUserBuffer64From32(system, &out_event_handle, message_buffer, message_buffer_size, session_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_event_handle));
+}
+
+static void SvcWrap_GetProcessId64From32(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_process_id{};
+    Handle process_handle{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 1));
+
+    ret = GetProcessId64From32(system, &out_process_id, process_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_process_id_scatter = Convert<std::array<uint32_t, 2>>(out_process_id);
+    SetReg32(system, 1, out_process_id_scatter[0]);
+    SetReg32(system, 2, out_process_id_scatter[1]);
+}
+
+static void SvcWrap_GetThreadId64From32(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_thread_id{};
+    Handle thread_handle{};
+
+    thread_handle = Convert<Handle>(GetReg32(system, 1));
+
+    ret = GetThreadId64From32(system, &out_thread_id, thread_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id);
+    SetReg32(system, 1, out_thread_id_scatter[0]);
+    SetReg32(system, 2, out_thread_id_scatter[1]);
+}
+
+static void SvcWrap_Break64From32(Core::System& system) {
+    BreakReason break_reason{};
+    uint32_t arg{};
+    uint32_t size{};
+
+    break_reason = Convert<BreakReason>(GetReg32(system, 0));
+    arg = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+
+    Break64From32(system, break_reason, arg, size);
+}
+
+static void SvcWrap_OutputDebugString64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t debug_str{};
+    uint32_t len{};
+
+    debug_str = Convert<uint32_t>(GetReg32(system, 0));
+    len = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = OutputDebugString64From32(system, debug_str, len);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_ReturnFromException64From32(Core::System& system) {
+    Result result{};
+
+    result = Convert<Result>(GetReg32(system, 0));
+
+    ReturnFromException64From32(system, result);
+}
+
+static void SvcWrap_GetInfo64From32(Core::System& system) {
+    Result ret{};
+
+    uint64_t out{};
+    InfoType info_type{};
+    Handle handle{};
+    uint64_t info_subtype{};
+
+    info_type = Convert<InfoType>(GetReg32(system, 1));
+    handle = Convert<Handle>(GetReg32(system, 2));
+    std::array<uint32_t, 2> info_subtype_gather{};
+    info_subtype_gather[0] = GetReg32(system, 0);
+    info_subtype_gather[1] = GetReg32(system, 3);
+    info_subtype = Convert<uint64_t>(info_subtype_gather);
+
+    ret = GetInfo64From32(system, &out, info_type, handle, info_subtype);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_scatter = Convert<std::array<uint32_t, 2>>(out);
+    SetReg32(system, 1, out_scatter[0]);
+    SetReg32(system, 2, out_scatter[1]);
+}
+
+static void SvcWrap_FlushEntireDataCache64From32(Core::System& system) {
+    FlushEntireDataCache64From32(system);
+}
+
+static void SvcWrap_FlushDataCache64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = FlushDataCache64From32(system, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_MapPhysicalMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = MapPhysicalMemory64From32(system, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = UnmapPhysicalMemory64From32(system, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) {
+    Result ret{};
+
+    ilp32::LastThreadContext out_context{};
+    uint64_t out_thread_id{};
+    Handle debug_handle{};
+    int64_t ns{};
+
+    debug_handle = Convert<Handle>(GetReg32(system, 2));
+    std::array<uint32_t, 2> ns_gather{};
+    ns_gather[0] = GetReg32(system, 0);
+    ns_gather[1] = GetReg32(system, 1);
+    ns = Convert<int64_t>(ns_gather);
+
+    ret = GetDebugFutureThreadInfo64From32(system, &out_context, &out_thread_id, debug_handle, ns);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context);
+    SetReg32(system, 1, out_context_scatter[0]);
+    SetReg32(system, 2, out_context_scatter[1]);
+    SetReg32(system, 3, out_context_scatter[2]);
+    SetReg32(system, 4, out_context_scatter[3]);
+    auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id);
+    SetReg32(system, 5, out_thread_id_scatter[0]);
+    SetReg32(system, 6, out_thread_id_scatter[1]);
+}
+
+static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) {
+    Result ret{};
+
+    ilp32::LastThreadContext out_context{};
+    uintptr_t out_tls_address{};
+    uint32_t out_flags{};
+
+    ret = GetLastThreadInfo64From32(system, &out_context, &out_tls_address, &out_flags);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context);
+    SetReg32(system, 1, out_context_scatter[0]);
+    SetReg32(system, 2, out_context_scatter[1]);
+    SetReg32(system, 3, out_context_scatter[2]);
+    SetReg32(system, 4, out_context_scatter[3]);
+    SetReg32(system, 5, Convert<uint32_t>(out_tls_address));
+    SetReg32(system, 6, Convert<uint32_t>(out_flags));
+}
+
+static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system) {
+    Result ret{};
+
+    int64_t out_limit_value{};
+    Handle resource_limit_handle{};
+    LimitableResource which{};
+
+    resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
+    which = Convert<LimitableResource>(GetReg32(system, 2));
+
+    ret = GetResourceLimitLimitValue64From32(system, &out_limit_value, resource_limit_handle, which);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_limit_value_scatter = Convert<std::array<uint32_t, 2>>(out_limit_value);
+    SetReg32(system, 1, out_limit_value_scatter[0]);
+    SetReg32(system, 2, out_limit_value_scatter[1]);
+}
+
+static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system) {
+    Result ret{};
+
+    int64_t out_current_value{};
+    Handle resource_limit_handle{};
+    LimitableResource which{};
+
+    resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
+    which = Convert<LimitableResource>(GetReg32(system, 2));
+
+    ret = GetResourceLimitCurrentValue64From32(system, &out_current_value, resource_limit_handle, which);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_current_value_scatter = Convert<std::array<uint32_t, 2>>(out_current_value);
+    SetReg32(system, 1, out_current_value_scatter[0]);
+    SetReg32(system, 2, out_current_value_scatter[1]);
+}
+
+static void SvcWrap_SetThreadActivity64From32(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+    ThreadActivity thread_activity{};
+
+    thread_handle = Convert<Handle>(GetReg32(system, 0));
+    thread_activity = Convert<ThreadActivity>(GetReg32(system, 1));
+
+    ret = SetThreadActivity64From32(system, thread_handle, thread_activity);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_GetThreadContext364From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t out_context{};
+    Handle thread_handle{};
+
+    out_context = Convert<uint32_t>(GetReg32(system, 0));
+    thread_handle = Convert<Handle>(GetReg32(system, 1));
+
+    ret = GetThreadContext364From32(system, out_context, thread_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_WaitForAddress64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    ArbitrationType arb_type{};
+    int32_t value{};
+    int64_t timeout_ns{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    arb_type = Convert<ArbitrationType>(GetReg32(system, 1));
+    value = Convert<int32_t>(GetReg32(system, 2));
+    std::array<uint32_t, 2> timeout_ns_gather{};
+    timeout_ns_gather[0] = GetReg32(system, 3);
+    timeout_ns_gather[1] = GetReg32(system, 4);
+    timeout_ns = Convert<int64_t>(timeout_ns_gather);
+
+    ret = WaitForAddress64From32(system, address, arb_type, value, timeout_ns);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SignalToAddress64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    SignalType signal_type{};
+    int32_t value{};
+    int32_t count{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    signal_type = Convert<SignalType>(GetReg32(system, 1));
+    value = Convert<int32_t>(GetReg32(system, 2));
+    count = Convert<int32_t>(GetReg32(system, 3));
+
+    ret = SignalToAddress64From32(system, address, signal_type, value, count);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system) {
+    SynchronizePreemptionState64From32(system);
+}
+
+static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system) {
+    Result ret{};
+
+    int64_t out_peak_value{};
+    Handle resource_limit_handle{};
+    LimitableResource which{};
+
+    resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
+    which = Convert<LimitableResource>(GetReg32(system, 2));
+
+    ret = GetResourceLimitPeakValue64From32(system, &out_peak_value, resource_limit_handle, which);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_peak_value_scatter = Convert<std::array<uint32_t, 2>>(out_peak_value);
+    SetReg32(system, 1, out_peak_value_scatter[0]);
+    SetReg32(system, 2, out_peak_value_scatter[1]);
+}
+
+static void SvcWrap_CreateIoPool64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    IoPoolType which{};
+
+    which = Convert<IoPoolType>(GetReg32(system, 1));
+
+    ret = CreateIoPool64From32(system, &out_handle, which);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_CreateIoRegion64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    Handle io_pool{};
+    uint64_t physical_address{};
+    uint32_t size{};
+    MemoryMapping mapping{};
+    MemoryPermission perm{};
+
+    io_pool = Convert<Handle>(GetReg32(system, 1));
+    std::array<uint32_t, 2> physical_address_gather{};
+    physical_address_gather[0] = GetReg32(system, 2);
+    physical_address_gather[1] = GetReg32(system, 3);
+    physical_address = Convert<uint64_t>(physical_address_gather);
+    size = Convert<uint32_t>(GetReg32(system, 0));
+    mapping = Convert<MemoryMapping>(GetReg32(system, 4));
+    perm = Convert<MemoryPermission>(GetReg32(system, 5));
+
+    ret = CreateIoRegion64From32(system, &out_handle, io_pool, physical_address, size, mapping, perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_KernelDebug64From32(Core::System& system) {
+    KernelDebugType kern_debug_type{};
+    uint64_t arg0{};
+    uint64_t arg1{};
+    uint64_t arg2{};
+
+    kern_debug_type = Convert<KernelDebugType>(GetReg32(system, 0));
+    std::array<uint32_t, 2> arg0_gather{};
+    arg0_gather[0] = GetReg32(system, 2);
+    arg0_gather[1] = GetReg32(system, 3);
+    arg0 = Convert<uint64_t>(arg0_gather);
+    std::array<uint32_t, 2> arg1_gather{};
+    arg1_gather[0] = GetReg32(system, 1);
+    arg1_gather[1] = GetReg32(system, 4);
+    arg1 = Convert<uint64_t>(arg1_gather);
+    std::array<uint32_t, 2> arg2_gather{};
+    arg2_gather[0] = GetReg32(system, 5);
+    arg2_gather[1] = GetReg32(system, 6);
+    arg2 = Convert<uint64_t>(arg2_gather);
+
+    KernelDebug64From32(system, kern_debug_type, arg0, arg1, arg2);
+}
+
+static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system) {
+    KernelTraceState kern_trace_state{};
+
+    kern_trace_state = Convert<KernelTraceState>(GetReg32(system, 0));
+
+    ChangeKernelTraceState64From32(system, kern_trace_state);
+}
+
+static void SvcWrap_CreateSession64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_server_session_handle{};
+    Handle out_client_session_handle{};
+    bool is_light{};
+    uint32_t name{};
+
+    is_light = Convert<bool>(GetReg32(system, 2));
+    name = Convert<uint32_t>(GetReg32(system, 3));
+
+    ret = CreateSession64From32(system, &out_server_session_handle, &out_client_session_handle, is_light, name);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_server_session_handle));
+    SetReg32(system, 2, Convert<uint32_t>(out_client_session_handle));
+}
+
+static void SvcWrap_AcceptSession64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    Handle port{};
+
+    port = Convert<Handle>(GetReg32(system, 1));
+
+    ret = AcceptSession64From32(system, &out_handle, port);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_ReplyAndReceive64From32(Core::System& system) {
+    Result ret{};
+
+    int32_t out_index{};
+    uint32_t handles{};
+    int32_t num_handles{};
+    Handle reply_target{};
+    int64_t timeout_ns{};
+
+    handles = Convert<uint32_t>(GetReg32(system, 1));
+    num_handles = Convert<int32_t>(GetReg32(system, 2));
+    reply_target = Convert<Handle>(GetReg32(system, 3));
+    std::array<uint32_t, 2> timeout_ns_gather{};
+    timeout_ns_gather[0] = GetReg32(system, 0);
+    timeout_ns_gather[1] = GetReg32(system, 4);
+    timeout_ns = Convert<int64_t>(timeout_ns_gather);
+
+    ret = ReplyAndReceive64From32(system, &out_index, handles, num_handles, reply_target, timeout_ns);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_index));
+}
+
+static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system) {
+    Result ret{};
+
+    int32_t out_index{};
+    uint32_t message_buffer{};
+    uint32_t message_buffer_size{};
+    uint32_t handles{};
+    int32_t num_handles{};
+    Handle reply_target{};
+    int64_t timeout_ns{};
+
+    message_buffer = Convert<uint32_t>(GetReg32(system, 1));
+    message_buffer_size = Convert<uint32_t>(GetReg32(system, 2));
+    handles = Convert<uint32_t>(GetReg32(system, 3));
+    num_handles = Convert<int32_t>(GetReg32(system, 0));
+    reply_target = Convert<Handle>(GetReg32(system, 4));
+    std::array<uint32_t, 2> timeout_ns_gather{};
+    timeout_ns_gather[0] = GetReg32(system, 5);
+    timeout_ns_gather[1] = GetReg32(system, 6);
+    timeout_ns = Convert<int64_t>(timeout_ns_gather);
+
+    ret = ReplyAndReceiveWithUserBuffer64From32(system, &out_index, message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_index));
+}
+
+static void SvcWrap_CreateEvent64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_write_handle{};
+    Handle out_read_handle{};
+
+    ret = CreateEvent64From32(system, &out_write_handle, &out_read_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_write_handle));
+    SetReg32(system, 2, Convert<uint32_t>(out_read_handle));
+}
+
+static void SvcWrap_MapIoRegion64From32(Core::System& system) {
+    Result ret{};
+
+    Handle io_region{};
+    uint32_t address{};
+    uint32_t size{};
+    MemoryPermission perm{};
+
+    io_region = Convert<Handle>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+    perm = Convert<MemoryPermission>(GetReg32(system, 3));
+
+    ret = MapIoRegion64From32(system, io_region, address, size, perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapIoRegion64From32(Core::System& system) {
+    Result ret{};
+
+    Handle io_region{};
+    uint32_t address{};
+    uint32_t size{};
+
+    io_region = Convert<Handle>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+
+    ret = UnmapIoRegion64From32(system, io_region, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = MapPhysicalMemoryUnsafe64From32(system, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = UnmapPhysicalMemoryUnsafe64From32(system, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SetUnsafeLimit64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t limit{};
+
+    limit = Convert<uint32_t>(GetReg32(system, 0));
+
+    ret = SetUnsafeLimit64From32(system, limit);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_CreateCodeMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint32_t address{};
+    uint32_t size{};
+
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+
+    ret = CreateCodeMemory64From32(system, &out_handle, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_ControlCodeMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle code_memory_handle{};
+    CodeMemoryOperation operation{};
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission perm{};
+
+    code_memory_handle = Convert<Handle>(GetReg32(system, 0));
+    operation = Convert<CodeMemoryOperation>(GetReg32(system, 1));
+    std::array<uint32_t, 2> address_gather{};
+    address_gather[0] = GetReg32(system, 2);
+    address_gather[1] = GetReg32(system, 3);
+    address = Convert<uint64_t>(address_gather);
+    std::array<uint32_t, 2> size_gather{};
+    size_gather[0] = GetReg32(system, 4);
+    size_gather[1] = GetReg32(system, 5);
+    size = Convert<uint64_t>(size_gather);
+    perm = Convert<MemoryPermission>(GetReg32(system, 6));
+
+    ret = ControlCodeMemory64From32(system, code_memory_handle, operation, address, size, perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SleepSystem64From32(Core::System& system) {
+    SleepSystem64From32(system);
+}
+
+static void SvcWrap_ReadWriteRegister64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t out_value{};
+    uint64_t address{};
+    uint32_t mask{};
+    uint32_t value{};
+
+    std::array<uint32_t, 2> address_gather{};
+    address_gather[0] = GetReg32(system, 2);
+    address_gather[1] = GetReg32(system, 3);
+    address = Convert<uint64_t>(address_gather);
+    mask = Convert<uint32_t>(GetReg32(system, 0));
+    value = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = ReadWriteRegister64From32(system, &out_value, address, mask, value);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_value));
+}
+
+static void SvcWrap_SetProcessActivity64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    ProcessActivity process_activity{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+    process_activity = Convert<ProcessActivity>(GetReg32(system, 1));
+
+    ret = SetProcessActivity64From32(system, process_handle, process_activity);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_CreateSharedMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint32_t size{};
+    MemoryPermission owner_perm{};
+    MemoryPermission remote_perm{};
+
+    size = Convert<uint32_t>(GetReg32(system, 1));
+    owner_perm = Convert<MemoryPermission>(GetReg32(system, 2));
+    remote_perm = Convert<MemoryPermission>(GetReg32(system, 3));
+
+    ret = CreateSharedMemory64From32(system, &out_handle, size, owner_perm, remote_perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_MapTransferMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle trmem_handle{};
+    uint32_t address{};
+    uint32_t size{};
+    MemoryPermission owner_perm{};
+
+    trmem_handle = Convert<Handle>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+    owner_perm = Convert<MemoryPermission>(GetReg32(system, 3));
+
+    ret = MapTransferMemory64From32(system, trmem_handle, address, size, owner_perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapTransferMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle trmem_handle{};
+    uint32_t address{};
+    uint32_t size{};
+
+    trmem_handle = Convert<Handle>(GetReg32(system, 0));
+    address = Convert<uint32_t>(GetReg32(system, 1));
+    size = Convert<uint32_t>(GetReg32(system, 2));
+
+    ret = UnmapTransferMemory64From32(system, trmem_handle, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_CreateInterruptEvent64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_read_handle{};
+    int32_t interrupt_id{};
+    InterruptType interrupt_type{};
+
+    interrupt_id = Convert<int32_t>(GetReg32(system, 1));
+    interrupt_type = Convert<InterruptType>(GetReg32(system, 2));
+
+    ret = CreateInterruptEvent64From32(system, &out_read_handle, interrupt_id, interrupt_type);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_read_handle));
+}
+
+static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system) {
+    Result ret{};
+
+    ilp32::PhysicalMemoryInfo out_info{};
+    uint32_t address{};
+
+    address = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = QueryPhysicalAddress64From32(system, &out_info, address);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_info_scatter = Convert<std::array<uint32_t, 4>>(out_info);
+    SetReg32(system, 1, out_info_scatter[0]);
+    SetReg32(system, 2, out_info_scatter[1]);
+    SetReg32(system, 3, out_info_scatter[2]);
+    SetReg32(system, 4, out_info_scatter[3]);
+}
+
+static void SvcWrap_QueryIoMapping64From32(Core::System& system) {
+    Result ret{};
+
+    uintptr_t out_address{};
+    uintptr_t out_size{};
+    uint64_t physical_address{};
+    uint32_t size{};
+
+    std::array<uint32_t, 2> physical_address_gather{};
+    physical_address_gather[0] = GetReg32(system, 2);
+    physical_address_gather[1] = GetReg32(system, 3);
+    physical_address = Convert<uint64_t>(physical_address_gather);
+    size = Convert<uint32_t>(GetReg32(system, 0));
+
+    ret = QueryIoMapping64From32(system, &out_address, &out_size, physical_address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_address));
+    SetReg32(system, 2, Convert<uint32_t>(out_size));
+}
+
+static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t das_address{};
+    uint64_t das_size{};
+
+    std::array<uint32_t, 2> das_address_gather{};
+    das_address_gather[0] = GetReg32(system, 2);
+    das_address_gather[1] = GetReg32(system, 3);
+    das_address = Convert<uint64_t>(das_address_gather);
+    std::array<uint32_t, 2> das_size_gather{};
+    das_size_gather[0] = GetReg32(system, 0);
+    das_size_gather[1] = GetReg32(system, 1);
+    das_size = Convert<uint64_t>(das_size_gather);
+
+    ret = CreateDeviceAddressSpace64From32(system, &out_handle, das_address, das_size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system) {
+    Result ret{};
+
+    DeviceName device_name{};
+    Handle das_handle{};
+
+    device_name = Convert<DeviceName>(GetReg32(system, 0));
+    das_handle = Convert<Handle>(GetReg32(system, 1));
+
+    ret = AttachDeviceAddressSpace64From32(system, device_name, das_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system) {
+    Result ret{};
+
+    DeviceName device_name{};
+    Handle das_handle{};
+
+    device_name = Convert<DeviceName>(GetReg32(system, 0));
+    das_handle = Convert<Handle>(GetReg32(system, 1));
+
+    ret = DetachDeviceAddressSpace64From32(system, device_name, das_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system) {
+    Result ret{};
+
+    Handle das_handle{};
+    Handle process_handle{};
+    uint64_t process_address{};
+    uint32_t size{};
+    uint64_t device_address{};
+    uint32_t option{};
+
+    das_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetReg32(system, 1));
+    std::array<uint32_t, 2> process_address_gather{};
+    process_address_gather[0] = GetReg32(system, 2);
+    process_address_gather[1] = GetReg32(system, 3);
+    process_address = Convert<uint64_t>(process_address_gather);
+    size = Convert<uint32_t>(GetReg32(system, 4));
+    std::array<uint32_t, 2> device_address_gather{};
+    device_address_gather[0] = GetReg32(system, 5);
+    device_address_gather[1] = GetReg32(system, 6);
+    device_address = Convert<uint64_t>(device_address_gather);
+    option = Convert<uint32_t>(GetReg32(system, 7));
+
+    ret = MapDeviceAddressSpaceByForce64From32(system, das_handle, process_handle, process_address, size, device_address, option);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system) {
+    Result ret{};
+
+    Handle das_handle{};
+    Handle process_handle{};
+    uint64_t process_address{};
+    uint32_t size{};
+    uint64_t device_address{};
+    uint32_t option{};
+
+    das_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetReg32(system, 1));
+    std::array<uint32_t, 2> process_address_gather{};
+    process_address_gather[0] = GetReg32(system, 2);
+    process_address_gather[1] = GetReg32(system, 3);
+    process_address = Convert<uint64_t>(process_address_gather);
+    size = Convert<uint32_t>(GetReg32(system, 4));
+    std::array<uint32_t, 2> device_address_gather{};
+    device_address_gather[0] = GetReg32(system, 5);
+    device_address_gather[1] = GetReg32(system, 6);
+    device_address = Convert<uint64_t>(device_address_gather);
+    option = Convert<uint32_t>(GetReg32(system, 7));
+
+    ret = MapDeviceAddressSpaceAligned64From32(system, das_handle, process_handle, process_address, size, device_address, option);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system) {
+    Result ret{};
+
+    Handle das_handle{};
+    Handle process_handle{};
+    uint64_t process_address{};
+    uint32_t size{};
+    uint64_t device_address{};
+
+    das_handle = Convert<Handle>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetReg32(system, 1));
+    std::array<uint32_t, 2> process_address_gather{};
+    process_address_gather[0] = GetReg32(system, 2);
+    process_address_gather[1] = GetReg32(system, 3);
+    process_address = Convert<uint64_t>(process_address_gather);
+    size = Convert<uint32_t>(GetReg32(system, 4));
+    std::array<uint32_t, 2> device_address_gather{};
+    device_address_gather[0] = GetReg32(system, 5);
+    device_address_gather[1] = GetReg32(system, 6);
+    device_address = Convert<uint64_t>(device_address_gather);
+
+    ret = UnmapDeviceAddressSpace64From32(system, das_handle, process_handle, process_address, size, device_address);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+    std::array<uint32_t, 2> address_gather{};
+    address_gather[0] = GetReg32(system, 2);
+    address_gather[1] = GetReg32(system, 3);
+    address = Convert<uint64_t>(address_gather);
+    std::array<uint32_t, 2> size_gather{};
+    size_gather[0] = GetReg32(system, 1);
+    size_gather[1] = GetReg32(system, 4);
+    size = Convert<uint64_t>(size_gather);
+
+    ret = InvalidateProcessDataCache64From32(system, process_handle, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_StoreProcessDataCache64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+    std::array<uint32_t, 2> address_gather{};
+    address_gather[0] = GetReg32(system, 2);
+    address_gather[1] = GetReg32(system, 3);
+    address = Convert<uint64_t>(address_gather);
+    std::array<uint32_t, 2> size_gather{};
+    size_gather[0] = GetReg32(system, 1);
+    size_gather[1] = GetReg32(system, 4);
+    size = Convert<uint64_t>(size_gather);
+
+    ret = StoreProcessDataCache64From32(system, process_handle, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_FlushProcessDataCache64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+    std::array<uint32_t, 2> address_gather{};
+    address_gather[0] = GetReg32(system, 2);
+    address_gather[1] = GetReg32(system, 3);
+    address = Convert<uint64_t>(address_gather);
+    std::array<uint32_t, 2> size_gather{};
+    size_gather[0] = GetReg32(system, 1);
+    size_gather[1] = GetReg32(system, 4);
+    size = Convert<uint64_t>(size_gather);
+
+    ret = FlushProcessDataCache64From32(system, process_handle, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_DebugActiveProcess64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t process_id{};
+
+    std::array<uint32_t, 2> process_id_gather{};
+    process_id_gather[0] = GetReg32(system, 2);
+    process_id_gather[1] = GetReg32(system, 3);
+    process_id = Convert<uint64_t>(process_id_gather);
+
+    ret = DebugActiveProcess64From32(system, &out_handle, process_id);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_BreakDebugProcess64From32(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+
+    debug_handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = BreakDebugProcess64From32(system, debug_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_TerminateDebugProcess64From32(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+
+    debug_handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = TerminateDebugProcess64From32(system, debug_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_GetDebugEvent64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t out_info{};
+    Handle debug_handle{};
+
+    out_info = Convert<uint32_t>(GetReg32(system, 0));
+    debug_handle = Convert<Handle>(GetReg32(system, 1));
+
+    ret = GetDebugEvent64From32(system, out_info, debug_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_ContinueDebugEvent64From32(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+    uint32_t flags{};
+    uint32_t thread_ids{};
+    int32_t num_thread_ids{};
+
+    debug_handle = Convert<Handle>(GetReg32(system, 0));
+    flags = Convert<uint32_t>(GetReg32(system, 1));
+    thread_ids = Convert<uint32_t>(GetReg32(system, 2));
+    num_thread_ids = Convert<int32_t>(GetReg32(system, 3));
+
+    ret = ContinueDebugEvent64From32(system, debug_handle, flags, thread_ids, num_thread_ids);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_GetProcessList64From32(Core::System& system) {
+    Result ret{};
+
+    int32_t out_num_processes{};
+    uint32_t out_process_ids{};
+    int32_t max_out_count{};
+
+    out_process_ids = Convert<uint32_t>(GetReg32(system, 1));
+    max_out_count = Convert<int32_t>(GetReg32(system, 2));
+
+    ret = GetProcessList64From32(system, &out_num_processes, out_process_ids, max_out_count);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_num_processes));
+}
+
+static void SvcWrap_GetThreadList64From32(Core::System& system) {
+    Result ret{};
+
+    int32_t out_num_threads{};
+    uint32_t out_thread_ids{};
+    int32_t max_out_count{};
+    Handle debug_handle{};
+
+    out_thread_ids = Convert<uint32_t>(GetReg32(system, 1));
+    max_out_count = Convert<int32_t>(GetReg32(system, 2));
+    debug_handle = Convert<Handle>(GetReg32(system, 3));
+
+    ret = GetThreadList64From32(system, &out_num_threads, out_thread_ids, max_out_count, debug_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_num_threads));
+}
+
+static void SvcWrap_GetDebugThreadContext64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t out_context{};
+    Handle debug_handle{};
+    uint64_t thread_id{};
+    uint32_t context_flags{};
+
+    out_context = Convert<uint32_t>(GetReg32(system, 0));
+    debug_handle = Convert<Handle>(GetReg32(system, 1));
+    std::array<uint32_t, 2> thread_id_gather{};
+    thread_id_gather[0] = GetReg32(system, 2);
+    thread_id_gather[1] = GetReg32(system, 3);
+    thread_id = Convert<uint64_t>(thread_id_gather);
+    context_flags = Convert<uint32_t>(GetReg32(system, 4));
+
+    ret = GetDebugThreadContext64From32(system, out_context, debug_handle, thread_id, context_flags);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SetDebugThreadContext64From32(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+    uint64_t thread_id{};
+    uint32_t context{};
+    uint32_t context_flags{};
+
+    debug_handle = Convert<Handle>(GetReg32(system, 0));
+    std::array<uint32_t, 2> thread_id_gather{};
+    thread_id_gather[0] = GetReg32(system, 2);
+    thread_id_gather[1] = GetReg32(system, 3);
+    thread_id = Convert<uint64_t>(thread_id_gather);
+    context = Convert<uint32_t>(GetReg32(system, 1));
+    context_flags = Convert<uint32_t>(GetReg32(system, 4));
+
+    ret = SetDebugThreadContext64From32(system, debug_handle, thread_id, context, context_flags);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) {
+    Result ret{};
+
+    PageInfo out_page_info{};
+    uint32_t out_memory_info{};
+    Handle process_handle{};
+    uint32_t address{};
+
+    out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetReg32(system, 2));
+    address = Convert<uint32_t>(GetReg32(system, 3));
+
+    ret = QueryDebugProcessMemory64From32(system, out_memory_info, &out_page_info, process_handle, address);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_page_info));
+}
+
+static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t buffer{};
+    Handle debug_handle{};
+    uint32_t address{};
+    uint32_t size{};
+
+    buffer = Convert<uint32_t>(GetReg32(system, 0));
+    debug_handle = Convert<Handle>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetReg32(system, 2));
+    size = Convert<uint32_t>(GetReg32(system, 3));
+
+    ret = ReadDebugProcessMemory64From32(system, buffer, debug_handle, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+    uint32_t buffer{};
+    uint32_t address{};
+    uint32_t size{};
+
+    debug_handle = Convert<Handle>(GetReg32(system, 0));
+    buffer = Convert<uint32_t>(GetReg32(system, 1));
+    address = Convert<uint32_t>(GetReg32(system, 2));
+    size = Convert<uint32_t>(GetReg32(system, 3));
+
+    ret = WriteDebugProcessMemory64From32(system, debug_handle, buffer, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system) {
+    Result ret{};
+
+    HardwareBreakPointRegisterName name{};
+    uint64_t flags{};
+    uint64_t value{};
+
+    name = Convert<HardwareBreakPointRegisterName>(GetReg32(system, 0));
+    std::array<uint32_t, 2> flags_gather{};
+    flags_gather[0] = GetReg32(system, 2);
+    flags_gather[1] = GetReg32(system, 3);
+    flags = Convert<uint64_t>(flags_gather);
+    std::array<uint32_t, 2> value_gather{};
+    value_gather[0] = GetReg32(system, 1);
+    value_gather[1] = GetReg32(system, 4);
+    value = Convert<uint64_t>(value_gather);
+
+    ret = SetHardwareBreakPoint64From32(system, name, flags, value);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_64{};
+    uint32_t out_32{};
+    Handle debug_handle{};
+    uint64_t thread_id{};
+    DebugThreadParam param{};
+
+    debug_handle = Convert<Handle>(GetReg32(system, 2));
+    std::array<uint32_t, 2> thread_id_gather{};
+    thread_id_gather[0] = GetReg32(system, 0);
+    thread_id_gather[1] = GetReg32(system, 1);
+    thread_id = Convert<uint64_t>(thread_id_gather);
+    param = Convert<DebugThreadParam>(GetReg32(system, 3));
+
+    ret = GetDebugThreadParam64From32(system, &out_64, &out_32, debug_handle, thread_id, param);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_64_scatter = Convert<std::array<uint32_t, 2>>(out_64);
+    SetReg32(system, 1, out_64_scatter[0]);
+    SetReg32(system, 2, out_64_scatter[1]);
+    SetReg32(system, 3, Convert<uint32_t>(out_32));
+}
+
+static void SvcWrap_GetSystemInfo64From32(Core::System& system) {
+    Result ret{};
+
+    uint64_t out{};
+    SystemInfoType info_type{};
+    Handle handle{};
+    uint64_t info_subtype{};
+
+    info_type = Convert<SystemInfoType>(GetReg32(system, 1));
+    handle = Convert<Handle>(GetReg32(system, 2));
+    std::array<uint32_t, 2> info_subtype_gather{};
+    info_subtype_gather[0] = GetReg32(system, 0);
+    info_subtype_gather[1] = GetReg32(system, 3);
+    info_subtype = Convert<uint64_t>(info_subtype_gather);
+
+    ret = GetSystemInfo64From32(system, &out, info_type, handle, info_subtype);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_scatter = Convert<std::array<uint32_t, 2>>(out);
+    SetReg32(system, 1, out_scatter[0]);
+    SetReg32(system, 2, out_scatter[1]);
+}
+
+static void SvcWrap_CreatePort64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_server_handle{};
+    Handle out_client_handle{};
+    int32_t max_sessions{};
+    bool is_light{};
+    uint32_t name{};
+
+    max_sessions = Convert<int32_t>(GetReg32(system, 2));
+    is_light = Convert<bool>(GetReg32(system, 3));
+    name = Convert<uint32_t>(GetReg32(system, 0));
+
+    ret = CreatePort64From32(system, &out_server_handle, &out_client_handle, max_sessions, is_light, name);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_server_handle));
+    SetReg32(system, 2, Convert<uint32_t>(out_client_handle));
+}
+
+static void SvcWrap_ManageNamedPort64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_server_handle{};
+    uint32_t name{};
+    int32_t max_sessions{};
+
+    name = Convert<uint32_t>(GetReg32(system, 1));
+    max_sessions = Convert<int32_t>(GetReg32(system, 2));
+
+    ret = ManageNamedPort64From32(system, &out_server_handle, name, max_sessions);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_server_handle));
+}
+
+static void SvcWrap_ConnectToPort64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    Handle port{};
+
+    port = Convert<Handle>(GetReg32(system, 1));
+
+    ret = ConnectToPort64From32(system, &out_handle, port);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission perm{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+    std::array<uint32_t, 2> address_gather{};
+    address_gather[0] = GetReg32(system, 2);
+    address_gather[1] = GetReg32(system, 3);
+    address = Convert<uint64_t>(address_gather);
+    std::array<uint32_t, 2> size_gather{};
+    size_gather[0] = GetReg32(system, 1);
+    size_gather[1] = GetReg32(system, 4);
+    size = Convert<uint64_t>(size_gather);
+    perm = Convert<MemoryPermission>(GetReg32(system, 5));
+
+    ret = SetProcessMemoryPermission64From32(system, process_handle, address, size, perm);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_MapProcessMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t dst_address{};
+    Handle process_handle{};
+    uint64_t src_address{};
+    uint32_t size{};
+
+    dst_address = Convert<uint32_t>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetReg32(system, 1));
+    std::array<uint32_t, 2> src_address_gather{};
+    src_address_gather[0] = GetReg32(system, 2);
+    src_address_gather[1] = GetReg32(system, 3);
+    src_address = Convert<uint64_t>(src_address_gather);
+    size = Convert<uint32_t>(GetReg32(system, 4));
+
+    ret = MapProcessMemory64From32(system, dst_address, process_handle, src_address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapProcessMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t dst_address{};
+    Handle process_handle{};
+    uint64_t src_address{};
+    uint32_t size{};
+
+    dst_address = Convert<uint32_t>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetReg32(system, 1));
+    std::array<uint32_t, 2> src_address_gather{};
+    src_address_gather[0] = GetReg32(system, 2);
+    src_address_gather[1] = GetReg32(system, 3);
+    src_address = Convert<uint64_t>(src_address_gather);
+    size = Convert<uint32_t>(GetReg32(system, 4));
+
+    ret = UnmapProcessMemory64From32(system, dst_address, process_handle, src_address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_QueryProcessMemory64From32(Core::System& system) {
+    Result ret{};
+
+    PageInfo out_page_info{};
+    uint32_t out_memory_info{};
+    Handle process_handle{};
+    uint64_t address{};
+
+    out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
+    process_handle = Convert<Handle>(GetReg32(system, 2));
+    std::array<uint32_t, 2> address_gather{};
+    address_gather[0] = GetReg32(system, 1);
+    address_gather[1] = GetReg32(system, 3);
+    address = Convert<uint64_t>(address_gather);
+
+    ret = QueryProcessMemory64From32(system, out_memory_info, &out_page_info, process_handle, address);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_page_info));
+}
+
+static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t dst_address{};
+    uint64_t src_address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+    std::array<uint32_t, 2> dst_address_gather{};
+    dst_address_gather[0] = GetReg32(system, 2);
+    dst_address_gather[1] = GetReg32(system, 3);
+    dst_address = Convert<uint64_t>(dst_address_gather);
+    std::array<uint32_t, 2> src_address_gather{};
+    src_address_gather[0] = GetReg32(system, 1);
+    src_address_gather[1] = GetReg32(system, 4);
+    src_address = Convert<uint64_t>(src_address_gather);
+    std::array<uint32_t, 2> size_gather{};
+    size_gather[0] = GetReg32(system, 5);
+    size_gather[1] = GetReg32(system, 6);
+    size = Convert<uint64_t>(size_gather);
+
+    ret = MapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t dst_address{};
+    uint64_t src_address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+    std::array<uint32_t, 2> dst_address_gather{};
+    dst_address_gather[0] = GetReg32(system, 2);
+    dst_address_gather[1] = GetReg32(system, 3);
+    dst_address = Convert<uint64_t>(dst_address_gather);
+    std::array<uint32_t, 2> src_address_gather{};
+    src_address_gather[0] = GetReg32(system, 1);
+    src_address_gather[1] = GetReg32(system, 4);
+    src_address = Convert<uint64_t>(src_address_gather);
+    std::array<uint32_t, 2> size_gather{};
+    size_gather[0] = GetReg32(system, 5);
+    size_gather[1] = GetReg32(system, 6);
+    size = Convert<uint64_t>(size_gather);
+
+    ret = UnmapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_CreateProcess64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint32_t parameters{};
+    uint32_t caps{};
+    int32_t num_caps{};
+
+    parameters = Convert<uint32_t>(GetReg32(system, 1));
+    caps = Convert<uint32_t>(GetReg32(system, 2));
+    num_caps = Convert<int32_t>(GetReg32(system, 3));
+
+    ret = CreateProcess64From32(system, &out_handle, parameters, caps, num_caps);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_StartProcess64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    int32_t priority{};
+    int32_t core_id{};
+    uint64_t main_thread_stack_size{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+    priority = Convert<int32_t>(GetReg32(system, 1));
+    core_id = Convert<int32_t>(GetReg32(system, 2));
+    std::array<uint32_t, 2> main_thread_stack_size_gather{};
+    main_thread_stack_size_gather[0] = GetReg32(system, 3);
+    main_thread_stack_size_gather[1] = GetReg32(system, 4);
+    main_thread_stack_size = Convert<uint64_t>(main_thread_stack_size_gather);
+
+    ret = StartProcess64From32(system, process_handle, priority, core_id, main_thread_stack_size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_TerminateProcess64From32(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 0));
+
+    ret = TerminateProcess64From32(system, process_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_GetProcessInfo64From32(Core::System& system) {
+    Result ret{};
+
+    int64_t out_info{};
+    Handle process_handle{};
+    ProcessInfoType info_type{};
+
+    process_handle = Convert<Handle>(GetReg32(system, 1));
+    info_type = Convert<ProcessInfoType>(GetReg32(system, 2));
+
+    ret = GetProcessInfo64From32(system, &out_info, process_handle, info_type);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    auto out_info_scatter = Convert<std::array<uint32_t, 2>>(out_info);
+    SetReg32(system, 1, out_info_scatter[0]);
+    SetReg32(system, 2, out_info_scatter[1]);
+}
+
+static void SvcWrap_CreateResourceLimit64From32(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+
+    ret = CreateResourceLimit64From32(system, &out_handle);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+    SetReg32(system, 1, Convert<uint32_t>(out_handle));
+}
+
+static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system) {
+    Result ret{};
+
+    Handle resource_limit_handle{};
+    LimitableResource which{};
+    int64_t limit_value{};
+
+    resource_limit_handle = Convert<Handle>(GetReg32(system, 0));
+    which = Convert<LimitableResource>(GetReg32(system, 1));
+    std::array<uint32_t, 2> limit_value_gather{};
+    limit_value_gather[0] = GetReg32(system, 2);
+    limit_value_gather[1] = GetReg32(system, 3);
+    limit_value = Convert<int64_t>(limit_value_gather);
+
+    ret = SetResourceLimitLimitValue64From32(system, resource_limit_handle, which, limit_value);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_MapInsecureMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = MapInsecureMemory64From32(system, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system) {
+    Result ret{};
+
+    uint32_t address{};
+    uint32_t size{};
+
+    address = Convert<uint32_t>(GetReg32(system, 0));
+    size = Convert<uint32_t>(GetReg32(system, 1));
+
+    ret = UnmapInsecureMemory64From32(system, address, size);
+
+    SetReg32(system, 0, Convert<uint32_t>(ret));
+}
+
+static void SvcWrap_SetHeapSize64(Core::System& system) {
+    Result ret{};
+
+    uintptr_t out_address{};
+    uint64_t size{};
+
+    size = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = SetHeapSize64(system, &out_address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_address));
+}
+
+static void SvcWrap_SetMemoryPermission64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission perm{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+    perm = Convert<MemoryPermission>(GetReg64(system, 2));
+
+    ret = SetMemoryPermission64(system, address, size, perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SetMemoryAttribute64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+    uint32_t mask{};
+    uint32_t attr{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+    mask = Convert<uint32_t>(GetReg64(system, 2));
+    attr = Convert<uint32_t>(GetReg64(system, 3));
+
+    ret = SetMemoryAttribute64(system, address, size, mask, attr);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_MapMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t dst_address{};
+    uint64_t src_address{};
+    uint64_t size{};
+
+    dst_address = Convert<uint64_t>(GetReg64(system, 0));
+    src_address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = MapMemory64(system, dst_address, src_address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t dst_address{};
+    uint64_t src_address{};
+    uint64_t size{};
+
+    dst_address = Convert<uint64_t>(GetReg64(system, 0));
+    src_address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = UnmapMemory64(system, dst_address, src_address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_QueryMemory64(Core::System& system) {
+    Result ret{};
+
+    PageInfo out_page_info{};
+    uint64_t out_memory_info{};
+    uint64_t address{};
+
+    out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = QueryMemory64(system, out_memory_info, &out_page_info, address);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_page_info));
+}
+
+static void SvcWrap_ExitProcess64(Core::System& system) {
+    ExitProcess64(system);
+}
+
+static void SvcWrap_CreateThread64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t func{};
+    uint64_t arg{};
+    uint64_t stack_bottom{};
+    int32_t priority{};
+    int32_t core_id{};
+
+    func = Convert<uint64_t>(GetReg64(system, 1));
+    arg = Convert<uint64_t>(GetReg64(system, 2));
+    stack_bottom = Convert<uint64_t>(GetReg64(system, 3));
+    priority = Convert<int32_t>(GetReg64(system, 4));
+    core_id = Convert<int32_t>(GetReg64(system, 5));
+
+    ret = CreateThread64(system, &out_handle, func, arg, stack_bottom, priority, core_id);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_StartThread64(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+
+    thread_handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = StartThread64(system, thread_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_ExitThread64(Core::System& system) {
+    ExitThread64(system);
+}
+
+static void SvcWrap_SleepThread64(Core::System& system) {
+    int64_t ns{};
+
+    ns = Convert<int64_t>(GetReg64(system, 0));
+
+    SleepThread64(system, ns);
+}
+
+static void SvcWrap_GetThreadPriority64(Core::System& system) {
+    Result ret{};
+
+    int32_t out_priority{};
+    Handle thread_handle{};
+
+    thread_handle = Convert<Handle>(GetReg64(system, 1));
+
+    ret = GetThreadPriority64(system, &out_priority, thread_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_priority));
+}
+
+static void SvcWrap_SetThreadPriority64(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+    int32_t priority{};
+
+    thread_handle = Convert<Handle>(GetReg64(system, 0));
+    priority = Convert<int32_t>(GetReg64(system, 1));
+
+    ret = SetThreadPriority64(system, thread_handle, priority);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_GetThreadCoreMask64(Core::System& system) {
+    Result ret{};
+
+    int32_t out_core_id{};
+    uint64_t out_affinity_mask{};
+    Handle thread_handle{};
+
+    thread_handle = Convert<Handle>(GetReg64(system, 2));
+
+    ret = GetThreadCoreMask64(system, &out_core_id, &out_affinity_mask, thread_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_core_id));
+    SetReg64(system, 2, Convert<uint64_t>(out_affinity_mask));
+}
+
+static void SvcWrap_SetThreadCoreMask64(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+    int32_t core_id{};
+    uint64_t affinity_mask{};
+
+    thread_handle = Convert<Handle>(GetReg64(system, 0));
+    core_id = Convert<int32_t>(GetReg64(system, 1));
+    affinity_mask = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = SetThreadCoreMask64(system, thread_handle, core_id, affinity_mask);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system) {
+    int32_t ret{};
+
+    ret = GetCurrentProcessorNumber64(system);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SignalEvent64(Core::System& system) {
+    Result ret{};
+
+    Handle event_handle{};
+
+    event_handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = SignalEvent64(system, event_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_ClearEvent64(Core::System& system) {
+    Result ret{};
+
+    Handle event_handle{};
+
+    event_handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = ClearEvent64(system, event_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_MapSharedMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle shmem_handle{};
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission map_perm{};
+
+    shmem_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+    map_perm = Convert<MemoryPermission>(GetReg64(system, 3));
+
+    ret = MapSharedMemory64(system, shmem_handle, address, size, map_perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapSharedMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle shmem_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    shmem_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = UnmapSharedMemory64(system, shmem_handle, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_CreateTransferMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission map_perm{};
+
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+    map_perm = Convert<MemoryPermission>(GetReg64(system, 3));
+
+    ret = CreateTransferMemory64(system, &out_handle, address, size, map_perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_CloseHandle64(Core::System& system) {
+    Result ret{};
+
+    Handle handle{};
+
+    handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = CloseHandle64(system, handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_ResetSignal64(Core::System& system) {
+    Result ret{};
+
+    Handle handle{};
+
+    handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = ResetSignal64(system, handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_WaitSynchronization64(Core::System& system) {
+    Result ret{};
+
+    int32_t out_index{};
+    uint64_t handles{};
+    int32_t num_handles{};
+    int64_t timeout_ns{};
+
+    handles = Convert<uint64_t>(GetReg64(system, 1));
+    num_handles = Convert<int32_t>(GetReg64(system, 2));
+    timeout_ns = Convert<int64_t>(GetReg64(system, 3));
+
+    ret = WaitSynchronization64(system, &out_index, handles, num_handles, timeout_ns);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_index));
+}
+
+static void SvcWrap_CancelSynchronization64(Core::System& system) {
+    Result ret{};
+
+    Handle handle{};
+
+    handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = CancelSynchronization64(system, handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_ArbitrateLock64(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+    uint64_t address{};
+    uint32_t tag{};
+
+    thread_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    tag = Convert<uint32_t>(GetReg64(system, 2));
+
+    ret = ArbitrateLock64(system, thread_handle, address, tag);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_ArbitrateUnlock64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+
+    ret = ArbitrateUnlock64(system, address);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t cv_key{};
+    uint32_t tag{};
+    int64_t timeout_ns{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    cv_key = Convert<uint64_t>(GetReg64(system, 1));
+    tag = Convert<uint32_t>(GetReg64(system, 2));
+    timeout_ns = Convert<int64_t>(GetReg64(system, 3));
+
+    ret = WaitProcessWideKeyAtomic64(system, address, cv_key, tag, timeout_ns);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SignalProcessWideKey64(Core::System& system) {
+    uint64_t cv_key{};
+    int32_t count{};
+
+    cv_key = Convert<uint64_t>(GetReg64(system, 0));
+    count = Convert<int32_t>(GetReg64(system, 1));
+
+    SignalProcessWideKey64(system, cv_key, count);
+}
+
+static void SvcWrap_GetSystemTick64(Core::System& system) {
+    int64_t ret{};
+
+    ret = GetSystemTick64(system);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_ConnectToNamedPort64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t name{};
+
+    name = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = ConnectToNamedPort64(system, &out_handle, name);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_SendSyncRequest64(Core::System& system) {
+    Result ret{};
+
+    Handle session_handle{};
+
+    session_handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = SendSyncRequest64(system, session_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system) {
+    Result ret{};
+
+    uint64_t message_buffer{};
+    uint64_t message_buffer_size{};
+    Handle session_handle{};
+
+    message_buffer = Convert<uint64_t>(GetReg64(system, 0));
+    message_buffer_size = Convert<uint64_t>(GetReg64(system, 1));
+    session_handle = Convert<Handle>(GetReg64(system, 2));
+
+    ret = SendSyncRequestWithUserBuffer64(system, message_buffer, message_buffer_size, session_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) {
+    Result ret{};
+
+    Handle out_event_handle{};
+    uint64_t message_buffer{};
+    uint64_t message_buffer_size{};
+    Handle session_handle{};
+
+    message_buffer = Convert<uint64_t>(GetReg64(system, 1));
+    message_buffer_size = Convert<uint64_t>(GetReg64(system, 2));
+    session_handle = Convert<Handle>(GetReg64(system, 3));
+
+    ret = SendAsyncRequestWithUserBuffer64(system, &out_event_handle, message_buffer, message_buffer_size, session_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_event_handle));
+}
+
+static void SvcWrap_GetProcessId64(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_process_id{};
+    Handle process_handle{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 1));
+
+    ret = GetProcessId64(system, &out_process_id, process_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_process_id));
+}
+
+static void SvcWrap_GetThreadId64(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_thread_id{};
+    Handle thread_handle{};
+
+    thread_handle = Convert<Handle>(GetReg64(system, 1));
+
+    ret = GetThreadId64(system, &out_thread_id, thread_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_thread_id));
+}
+
+static void SvcWrap_Break64(Core::System& system) {
+    BreakReason break_reason{};
+    uint64_t arg{};
+    uint64_t size{};
+
+    break_reason = Convert<BreakReason>(GetReg64(system, 0));
+    arg = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    Break64(system, break_reason, arg, size);
+}
+
+static void SvcWrap_OutputDebugString64(Core::System& system) {
+    Result ret{};
+
+    uint64_t debug_str{};
+    uint64_t len{};
+
+    debug_str = Convert<uint64_t>(GetReg64(system, 0));
+    len = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = OutputDebugString64(system, debug_str, len);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_ReturnFromException64(Core::System& system) {
+    Result result{};
+
+    result = Convert<Result>(GetReg64(system, 0));
+
+    ReturnFromException64(system, result);
+}
+
+static void SvcWrap_GetInfo64(Core::System& system) {
+    Result ret{};
+
+    uint64_t out{};
+    InfoType info_type{};
+    Handle handle{};
+    uint64_t info_subtype{};
+
+    info_type = Convert<InfoType>(GetReg64(system, 1));
+    handle = Convert<Handle>(GetReg64(system, 2));
+    info_subtype = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = GetInfo64(system, &out, info_type, handle, info_subtype);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out));
+}
+
+static void SvcWrap_FlushEntireDataCache64(Core::System& system) {
+    FlushEntireDataCache64(system);
+}
+
+static void SvcWrap_FlushDataCache64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = FlushDataCache64(system, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_MapPhysicalMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = MapPhysicalMemory64(system, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapPhysicalMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = UnmapPhysicalMemory64(system, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) {
+    Result ret{};
+
+    lp64::LastThreadContext out_context{};
+    uint64_t out_thread_id{};
+    Handle debug_handle{};
+    int64_t ns{};
+
+    debug_handle = Convert<Handle>(GetReg64(system, 2));
+    ns = Convert<int64_t>(GetReg64(system, 3));
+
+    ret = GetDebugFutureThreadInfo64(system, &out_context, &out_thread_id, debug_handle, ns);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context);
+    SetReg64(system, 1, out_context_scatter[0]);
+    SetReg64(system, 2, out_context_scatter[1]);
+    SetReg64(system, 3, out_context_scatter[2]);
+    SetReg64(system, 4, out_context_scatter[3]);
+    SetReg64(system, 5, Convert<uint64_t>(out_thread_id));
+}
+
+static void SvcWrap_GetLastThreadInfo64(Core::System& system) {
+    Result ret{};
+
+    lp64::LastThreadContext out_context{};
+    uintptr_t out_tls_address{};
+    uint32_t out_flags{};
+
+    ret = GetLastThreadInfo64(system, &out_context, &out_tls_address, &out_flags);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context);
+    SetReg64(system, 1, out_context_scatter[0]);
+    SetReg64(system, 2, out_context_scatter[1]);
+    SetReg64(system, 3, out_context_scatter[2]);
+    SetReg64(system, 4, out_context_scatter[3]);
+    SetReg64(system, 5, Convert<uint64_t>(out_tls_address));
+    SetReg64(system, 6, Convert<uint64_t>(out_flags));
+}
+
+static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system) {
+    Result ret{};
+
+    int64_t out_limit_value{};
+    Handle resource_limit_handle{};
+    LimitableResource which{};
+
+    resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
+    which = Convert<LimitableResource>(GetReg64(system, 2));
+
+    ret = GetResourceLimitLimitValue64(system, &out_limit_value, resource_limit_handle, which);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_limit_value));
+}
+
+static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system) {
+    Result ret{};
+
+    int64_t out_current_value{};
+    Handle resource_limit_handle{};
+    LimitableResource which{};
+
+    resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
+    which = Convert<LimitableResource>(GetReg64(system, 2));
+
+    ret = GetResourceLimitCurrentValue64(system, &out_current_value, resource_limit_handle, which);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_current_value));
+}
+
+static void SvcWrap_SetThreadActivity64(Core::System& system) {
+    Result ret{};
+
+    Handle thread_handle{};
+    ThreadActivity thread_activity{};
+
+    thread_handle = Convert<Handle>(GetReg64(system, 0));
+    thread_activity = Convert<ThreadActivity>(GetReg64(system, 1));
+
+    ret = SetThreadActivity64(system, thread_handle, thread_activity);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_GetThreadContext364(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_context{};
+    Handle thread_handle{};
+
+    out_context = Convert<uint64_t>(GetReg64(system, 0));
+    thread_handle = Convert<Handle>(GetReg64(system, 1));
+
+    ret = GetThreadContext364(system, out_context, thread_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_WaitForAddress64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    ArbitrationType arb_type{};
+    int32_t value{};
+    int64_t timeout_ns{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    arb_type = Convert<ArbitrationType>(GetReg64(system, 1));
+    value = Convert<int32_t>(GetReg64(system, 2));
+    timeout_ns = Convert<int64_t>(GetReg64(system, 3));
+
+    ret = WaitForAddress64(system, address, arb_type, value, timeout_ns);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SignalToAddress64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    SignalType signal_type{};
+    int32_t value{};
+    int32_t count{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    signal_type = Convert<SignalType>(GetReg64(system, 1));
+    value = Convert<int32_t>(GetReg64(system, 2));
+    count = Convert<int32_t>(GetReg64(system, 3));
+
+    ret = SignalToAddress64(system, address, signal_type, value, count);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SynchronizePreemptionState64(Core::System& system) {
+    SynchronizePreemptionState64(system);
+}
+
+static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system) {
+    Result ret{};
+
+    int64_t out_peak_value{};
+    Handle resource_limit_handle{};
+    LimitableResource which{};
+
+    resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
+    which = Convert<LimitableResource>(GetReg64(system, 2));
+
+    ret = GetResourceLimitPeakValue64(system, &out_peak_value, resource_limit_handle, which);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_peak_value));
+}
+
+static void SvcWrap_CreateIoPool64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    IoPoolType which{};
+
+    which = Convert<IoPoolType>(GetReg64(system, 1));
+
+    ret = CreateIoPool64(system, &out_handle, which);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_CreateIoRegion64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    Handle io_pool{};
+    uint64_t physical_address{};
+    uint64_t size{};
+    MemoryMapping mapping{};
+    MemoryPermission perm{};
+
+    io_pool = Convert<Handle>(GetReg64(system, 1));
+    physical_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+    mapping = Convert<MemoryMapping>(GetReg64(system, 4));
+    perm = Convert<MemoryPermission>(GetReg64(system, 5));
+
+    ret = CreateIoRegion64(system, &out_handle, io_pool, physical_address, size, mapping, perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_KernelDebug64(Core::System& system) {
+    KernelDebugType kern_debug_type{};
+    uint64_t arg0{};
+    uint64_t arg1{};
+    uint64_t arg2{};
+
+    kern_debug_type = Convert<KernelDebugType>(GetReg64(system, 0));
+    arg0 = Convert<uint64_t>(GetReg64(system, 1));
+    arg1 = Convert<uint64_t>(GetReg64(system, 2));
+    arg2 = Convert<uint64_t>(GetReg64(system, 3));
+
+    KernelDebug64(system, kern_debug_type, arg0, arg1, arg2);
+}
+
+static void SvcWrap_ChangeKernelTraceState64(Core::System& system) {
+    KernelTraceState kern_trace_state{};
+
+    kern_trace_state = Convert<KernelTraceState>(GetReg64(system, 0));
+
+    ChangeKernelTraceState64(system, kern_trace_state);
+}
+
+static void SvcWrap_CreateSession64(Core::System& system) {
+    Result ret{};
+
+    Handle out_server_session_handle{};
+    Handle out_client_session_handle{};
+    bool is_light{};
+    uint64_t name{};
+
+    is_light = Convert<bool>(GetReg64(system, 2));
+    name = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = CreateSession64(system, &out_server_session_handle, &out_client_session_handle, is_light, name);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_server_session_handle));
+    SetReg64(system, 2, Convert<uint64_t>(out_client_session_handle));
+}
+
+static void SvcWrap_AcceptSession64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    Handle port{};
+
+    port = Convert<Handle>(GetReg64(system, 1));
+
+    ret = AcceptSession64(system, &out_handle, port);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_ReplyAndReceive64(Core::System& system) {
+    Result ret{};
+
+    int32_t out_index{};
+    uint64_t handles{};
+    int32_t num_handles{};
+    Handle reply_target{};
+    int64_t timeout_ns{};
+
+    handles = Convert<uint64_t>(GetReg64(system, 1));
+    num_handles = Convert<int32_t>(GetReg64(system, 2));
+    reply_target = Convert<Handle>(GetReg64(system, 3));
+    timeout_ns = Convert<int64_t>(GetReg64(system, 4));
+
+    ret = ReplyAndReceive64(system, &out_index, handles, num_handles, reply_target, timeout_ns);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_index));
+}
+
+static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) {
+    Result ret{};
+
+    int32_t out_index{};
+    uint64_t message_buffer{};
+    uint64_t message_buffer_size{};
+    uint64_t handles{};
+    int32_t num_handles{};
+    Handle reply_target{};
+    int64_t timeout_ns{};
+
+    message_buffer = Convert<uint64_t>(GetReg64(system, 1));
+    message_buffer_size = Convert<uint64_t>(GetReg64(system, 2));
+    handles = Convert<uint64_t>(GetReg64(system, 3));
+    num_handles = Convert<int32_t>(GetReg64(system, 4));
+    reply_target = Convert<Handle>(GetReg64(system, 5));
+    timeout_ns = Convert<int64_t>(GetReg64(system, 6));
+
+    ret = ReplyAndReceiveWithUserBuffer64(system, &out_index, message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_index));
+}
+
+static void SvcWrap_CreateEvent64(Core::System& system) {
+    Result ret{};
+
+    Handle out_write_handle{};
+    Handle out_read_handle{};
+
+    ret = CreateEvent64(system, &out_write_handle, &out_read_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_write_handle));
+    SetReg64(system, 2, Convert<uint64_t>(out_read_handle));
+}
+
+static void SvcWrap_MapIoRegion64(Core::System& system) {
+    Result ret{};
+
+    Handle io_region{};
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission perm{};
+
+    io_region = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+    perm = Convert<MemoryPermission>(GetReg64(system, 3));
+
+    ret = MapIoRegion64(system, io_region, address, size, perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapIoRegion64(Core::System& system) {
+    Result ret{};
+
+    Handle io_region{};
+    uint64_t address{};
+    uint64_t size{};
+
+    io_region = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = UnmapIoRegion64(system, io_region, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = MapPhysicalMemoryUnsafe64(system, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = UnmapPhysicalMemoryUnsafe64(system, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SetUnsafeLimit64(Core::System& system) {
+    Result ret{};
+
+    uint64_t limit{};
+
+    limit = Convert<uint64_t>(GetReg64(system, 0));
+
+    ret = SetUnsafeLimit64(system, limit);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_CreateCodeMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = CreateCodeMemory64(system, &out_handle, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_ControlCodeMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle code_memory_handle{};
+    CodeMemoryOperation operation{};
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission perm{};
+
+    code_memory_handle = Convert<Handle>(GetReg64(system, 0));
+    operation = Convert<CodeMemoryOperation>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+    perm = Convert<MemoryPermission>(GetReg64(system, 4));
+
+    ret = ControlCodeMemory64(system, code_memory_handle, operation, address, size, perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SleepSystem64(Core::System& system) {
+    SleepSystem64(system);
+}
+
+static void SvcWrap_ReadWriteRegister64(Core::System& system) {
+    Result ret{};
+
+    uint32_t out_value{};
+    uint64_t address{};
+    uint32_t mask{};
+    uint32_t value{};
+
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    mask = Convert<uint32_t>(GetReg64(system, 2));
+    value = Convert<uint32_t>(GetReg64(system, 3));
+
+    ret = ReadWriteRegister64(system, &out_value, address, mask, value);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_value));
+}
+
+static void SvcWrap_SetProcessActivity64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    ProcessActivity process_activity{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+    process_activity = Convert<ProcessActivity>(GetReg64(system, 1));
+
+    ret = SetProcessActivity64(system, process_handle, process_activity);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_CreateSharedMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t size{};
+    MemoryPermission owner_perm{};
+    MemoryPermission remote_perm{};
+
+    size = Convert<uint64_t>(GetReg64(system, 1));
+    owner_perm = Convert<MemoryPermission>(GetReg64(system, 2));
+    remote_perm = Convert<MemoryPermission>(GetReg64(system, 3));
+
+    ret = CreateSharedMemory64(system, &out_handle, size, owner_perm, remote_perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_MapTransferMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle trmem_handle{};
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission owner_perm{};
+
+    trmem_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+    owner_perm = Convert<MemoryPermission>(GetReg64(system, 3));
+
+    ret = MapTransferMemory64(system, trmem_handle, address, size, owner_perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapTransferMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle trmem_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    trmem_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = UnmapTransferMemory64(system, trmem_handle, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_CreateInterruptEvent64(Core::System& system) {
+    Result ret{};
+
+    Handle out_read_handle{};
+    int32_t interrupt_id{};
+    InterruptType interrupt_type{};
+
+    interrupt_id = Convert<int32_t>(GetReg64(system, 1));
+    interrupt_type = Convert<InterruptType>(GetReg64(system, 2));
+
+    ret = CreateInterruptEvent64(system, &out_read_handle, interrupt_id, interrupt_type);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_read_handle));
+}
+
+static void SvcWrap_QueryPhysicalAddress64(Core::System& system) {
+    Result ret{};
+
+    lp64::PhysicalMemoryInfo out_info{};
+    uint64_t address{};
+
+    address = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = QueryPhysicalAddress64(system, &out_info, address);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    auto out_info_scatter = Convert<std::array<uint64_t, 3>>(out_info);
+    SetReg64(system, 1, out_info_scatter[0]);
+    SetReg64(system, 2, out_info_scatter[1]);
+    SetReg64(system, 3, out_info_scatter[2]);
+}
+
+static void SvcWrap_QueryIoMapping64(Core::System& system) {
+    Result ret{};
+
+    uintptr_t out_address{};
+    uintptr_t out_size{};
+    uint64_t physical_address{};
+    uint64_t size{};
+
+    physical_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = QueryIoMapping64(system, &out_address, &out_size, physical_address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_address));
+    SetReg64(system, 2, Convert<uint64_t>(out_size));
+}
+
+static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t das_address{};
+    uint64_t das_size{};
+
+    das_address = Convert<uint64_t>(GetReg64(system, 1));
+    das_size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = CreateDeviceAddressSpace64(system, &out_handle, das_address, das_size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system) {
+    Result ret{};
+
+    DeviceName device_name{};
+    Handle das_handle{};
+
+    device_name = Convert<DeviceName>(GetReg64(system, 0));
+    das_handle = Convert<Handle>(GetReg64(system, 1));
+
+    ret = AttachDeviceAddressSpace64(system, device_name, das_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system) {
+    Result ret{};
+
+    DeviceName device_name{};
+    Handle das_handle{};
+
+    device_name = Convert<DeviceName>(GetReg64(system, 0));
+    das_handle = Convert<Handle>(GetReg64(system, 1));
+
+    ret = DetachDeviceAddressSpace64(system, device_name, das_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system) {
+    Result ret{};
+
+    Handle das_handle{};
+    Handle process_handle{};
+    uint64_t process_address{};
+    uint64_t size{};
+    uint64_t device_address{};
+    uint32_t option{};
+
+    das_handle = Convert<Handle>(GetReg64(system, 0));
+    process_handle = Convert<Handle>(GetReg64(system, 1));
+    process_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+    device_address = Convert<uint64_t>(GetReg64(system, 4));
+    option = Convert<uint32_t>(GetReg64(system, 5));
+
+    ret = MapDeviceAddressSpaceByForce64(system, das_handle, process_handle, process_address, size, device_address, option);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system) {
+    Result ret{};
+
+    Handle das_handle{};
+    Handle process_handle{};
+    uint64_t process_address{};
+    uint64_t size{};
+    uint64_t device_address{};
+    uint32_t option{};
+
+    das_handle = Convert<Handle>(GetReg64(system, 0));
+    process_handle = Convert<Handle>(GetReg64(system, 1));
+    process_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+    device_address = Convert<uint64_t>(GetReg64(system, 4));
+    option = Convert<uint32_t>(GetReg64(system, 5));
+
+    ret = MapDeviceAddressSpaceAligned64(system, das_handle, process_handle, process_address, size, device_address, option);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system) {
+    Result ret{};
+
+    Handle das_handle{};
+    Handle process_handle{};
+    uint64_t process_address{};
+    uint64_t size{};
+    uint64_t device_address{};
+
+    das_handle = Convert<Handle>(GetReg64(system, 0));
+    process_handle = Convert<Handle>(GetReg64(system, 1));
+    process_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+    device_address = Convert<uint64_t>(GetReg64(system, 4));
+
+    ret = UnmapDeviceAddressSpace64(system, das_handle, process_handle, process_address, size, device_address);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_InvalidateProcessDataCache64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = InvalidateProcessDataCache64(system, process_handle, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_StoreProcessDataCache64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = StoreProcessDataCache64(system, process_handle, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_FlushProcessDataCache64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = FlushProcessDataCache64(system, process_handle, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_DebugActiveProcess64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t process_id{};
+
+    process_id = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = DebugActiveProcess64(system, &out_handle, process_id);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_BreakDebugProcess64(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+
+    debug_handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = BreakDebugProcess64(system, debug_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_TerminateDebugProcess64(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+
+    debug_handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = TerminateDebugProcess64(system, debug_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_GetDebugEvent64(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_info{};
+    Handle debug_handle{};
+
+    out_info = Convert<uint64_t>(GetReg64(system, 0));
+    debug_handle = Convert<Handle>(GetReg64(system, 1));
+
+    ret = GetDebugEvent64(system, out_info, debug_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_ContinueDebugEvent64(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+    uint32_t flags{};
+    uint64_t thread_ids{};
+    int32_t num_thread_ids{};
+
+    debug_handle = Convert<Handle>(GetReg64(system, 0));
+    flags = Convert<uint32_t>(GetReg64(system, 1));
+    thread_ids = Convert<uint64_t>(GetReg64(system, 2));
+    num_thread_ids = Convert<int32_t>(GetReg64(system, 3));
+
+    ret = ContinueDebugEvent64(system, debug_handle, flags, thread_ids, num_thread_ids);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_GetProcessList64(Core::System& system) {
+    Result ret{};
+
+    int32_t out_num_processes{};
+    uint64_t out_process_ids{};
+    int32_t max_out_count{};
+
+    out_process_ids = Convert<uint64_t>(GetReg64(system, 1));
+    max_out_count = Convert<int32_t>(GetReg64(system, 2));
+
+    ret = GetProcessList64(system, &out_num_processes, out_process_ids, max_out_count);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_num_processes));
+}
+
+static void SvcWrap_GetThreadList64(Core::System& system) {
+    Result ret{};
+
+    int32_t out_num_threads{};
+    uint64_t out_thread_ids{};
+    int32_t max_out_count{};
+    Handle debug_handle{};
+
+    out_thread_ids = Convert<uint64_t>(GetReg64(system, 1));
+    max_out_count = Convert<int32_t>(GetReg64(system, 2));
+    debug_handle = Convert<Handle>(GetReg64(system, 3));
+
+    ret = GetThreadList64(system, &out_num_threads, out_thread_ids, max_out_count, debug_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_num_threads));
+}
+
+static void SvcWrap_GetDebugThreadContext64(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_context{};
+    Handle debug_handle{};
+    uint64_t thread_id{};
+    uint32_t context_flags{};
+
+    out_context = Convert<uint64_t>(GetReg64(system, 0));
+    debug_handle = Convert<Handle>(GetReg64(system, 1));
+    thread_id = Convert<uint64_t>(GetReg64(system, 2));
+    context_flags = Convert<uint32_t>(GetReg64(system, 3));
+
+    ret = GetDebugThreadContext64(system, out_context, debug_handle, thread_id, context_flags);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SetDebugThreadContext64(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+    uint64_t thread_id{};
+    uint64_t context{};
+    uint32_t context_flags{};
+
+    debug_handle = Convert<Handle>(GetReg64(system, 0));
+    thread_id = Convert<uint64_t>(GetReg64(system, 1));
+    context = Convert<uint64_t>(GetReg64(system, 2));
+    context_flags = Convert<uint32_t>(GetReg64(system, 3));
+
+    ret = SetDebugThreadContext64(system, debug_handle, thread_id, context, context_flags);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) {
+    Result ret{};
+
+    PageInfo out_page_info{};
+    uint64_t out_memory_info{};
+    Handle process_handle{};
+    uint64_t address{};
+
+    out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
+    process_handle = Convert<Handle>(GetReg64(system, 2));
+    address = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = QueryDebugProcessMemory64(system, out_memory_info, &out_page_info, process_handle, address);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_page_info));
+}
+
+static void SvcWrap_ReadDebugProcessMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t buffer{};
+    Handle debug_handle{};
+    uint64_t address{};
+    uint64_t size{};
+
+    buffer = Convert<uint64_t>(GetReg64(system, 0));
+    debug_handle = Convert<Handle>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = ReadDebugProcessMemory64(system, buffer, debug_handle, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_WriteDebugProcessMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle debug_handle{};
+    uint64_t buffer{};
+    uint64_t address{};
+    uint64_t size{};
+
+    debug_handle = Convert<Handle>(GetReg64(system, 0));
+    buffer = Convert<uint64_t>(GetReg64(system, 1));
+    address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = WriteDebugProcessMemory64(system, debug_handle, buffer, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_SetHardwareBreakPoint64(Core::System& system) {
+    Result ret{};
+
+    HardwareBreakPointRegisterName name{};
+    uint64_t flags{};
+    uint64_t value{};
+
+    name = Convert<HardwareBreakPointRegisterName>(GetReg64(system, 0));
+    flags = Convert<uint64_t>(GetReg64(system, 1));
+    value = Convert<uint64_t>(GetReg64(system, 2));
+
+    ret = SetHardwareBreakPoint64(system, name, flags, value);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_GetDebugThreadParam64(Core::System& system) {
+    Result ret{};
+
+    uint64_t out_64{};
+    uint32_t out_32{};
+    Handle debug_handle{};
+    uint64_t thread_id{};
+    DebugThreadParam param{};
+
+    debug_handle = Convert<Handle>(GetReg64(system, 2));
+    thread_id = Convert<uint64_t>(GetReg64(system, 3));
+    param = Convert<DebugThreadParam>(GetReg64(system, 4));
+
+    ret = GetDebugThreadParam64(system, &out_64, &out_32, debug_handle, thread_id, param);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_64));
+    SetReg64(system, 2, Convert<uint64_t>(out_32));
+}
+
+static void SvcWrap_GetSystemInfo64(Core::System& system) {
+    Result ret{};
+
+    uint64_t out{};
+    SystemInfoType info_type{};
+    Handle handle{};
+    uint64_t info_subtype{};
+
+    info_type = Convert<SystemInfoType>(GetReg64(system, 1));
+    handle = Convert<Handle>(GetReg64(system, 2));
+    info_subtype = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = GetSystemInfo64(system, &out, info_type, handle, info_subtype);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out));
+}
+
+static void SvcWrap_CreatePort64(Core::System& system) {
+    Result ret{};
+
+    Handle out_server_handle{};
+    Handle out_client_handle{};
+    int32_t max_sessions{};
+    bool is_light{};
+    uint64_t name{};
+
+    max_sessions = Convert<int32_t>(GetReg64(system, 2));
+    is_light = Convert<bool>(GetReg64(system, 3));
+    name = Convert<uint64_t>(GetReg64(system, 4));
+
+    ret = CreatePort64(system, &out_server_handle, &out_client_handle, max_sessions, is_light, name);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_server_handle));
+    SetReg64(system, 2, Convert<uint64_t>(out_client_handle));
+}
+
+static void SvcWrap_ManageNamedPort64(Core::System& system) {
+    Result ret{};
+
+    Handle out_server_handle{};
+    uint64_t name{};
+    int32_t max_sessions{};
+
+    name = Convert<uint64_t>(GetReg64(system, 1));
+    max_sessions = Convert<int32_t>(GetReg64(system, 2));
+
+    ret = ManageNamedPort64(system, &out_server_handle, name, max_sessions);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_server_handle));
+}
+
+static void SvcWrap_ConnectToPort64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    Handle port{};
+
+    port = Convert<Handle>(GetReg64(system, 1));
+
+    ret = ConnectToPort64(system, &out_handle, port);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_SetProcessMemoryPermission64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t address{};
+    uint64_t size{};
+    MemoryPermission perm{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+    address = Convert<uint64_t>(GetReg64(system, 1));
+    size = Convert<uint64_t>(GetReg64(system, 2));
+    perm = Convert<MemoryPermission>(GetReg64(system, 3));
+
+    ret = SetProcessMemoryPermission64(system, process_handle, address, size, perm);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_MapProcessMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t dst_address{};
+    Handle process_handle{};
+    uint64_t src_address{};
+    uint64_t size{};
+
+    dst_address = Convert<uint64_t>(GetReg64(system, 0));
+    process_handle = Convert<Handle>(GetReg64(system, 1));
+    src_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = MapProcessMemory64(system, dst_address, process_handle, src_address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapProcessMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t dst_address{};
+    Handle process_handle{};
+    uint64_t src_address{};
+    uint64_t size{};
+
+    dst_address = Convert<uint64_t>(GetReg64(system, 0));
+    process_handle = Convert<Handle>(GetReg64(system, 1));
+    src_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = UnmapProcessMemory64(system, dst_address, process_handle, src_address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_QueryProcessMemory64(Core::System& system) {
+    Result ret{};
+
+    PageInfo out_page_info{};
+    uint64_t out_memory_info{};
+    Handle process_handle{};
+    uint64_t address{};
+
+    out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
+    process_handle = Convert<Handle>(GetReg64(system, 2));
+    address = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = QueryProcessMemory64(system, out_memory_info, &out_page_info, process_handle, address);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_page_info));
+}
+
+static void SvcWrap_MapProcessCodeMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t dst_address{};
+    uint64_t src_address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+    dst_address = Convert<uint64_t>(GetReg64(system, 1));
+    src_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = MapProcessCodeMemory64(system, process_handle, dst_address, src_address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    uint64_t dst_address{};
+    uint64_t src_address{};
+    uint64_t size{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+    dst_address = Convert<uint64_t>(GetReg64(system, 1));
+    src_address = Convert<uint64_t>(GetReg64(system, 2));
+    size = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = UnmapProcessCodeMemory64(system, process_handle, dst_address, src_address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_CreateProcess64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+    uint64_t parameters{};
+    uint64_t caps{};
+    int32_t num_caps{};
+
+    parameters = Convert<uint64_t>(GetReg64(system, 1));
+    caps = Convert<uint64_t>(GetReg64(system, 2));
+    num_caps = Convert<int32_t>(GetReg64(system, 3));
+
+    ret = CreateProcess64(system, &out_handle, parameters, caps, num_caps);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_StartProcess64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+    int32_t priority{};
+    int32_t core_id{};
+    uint64_t main_thread_stack_size{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+    priority = Convert<int32_t>(GetReg64(system, 1));
+    core_id = Convert<int32_t>(GetReg64(system, 2));
+    main_thread_stack_size = Convert<uint64_t>(GetReg64(system, 3));
+
+    ret = StartProcess64(system, process_handle, priority, core_id, main_thread_stack_size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_TerminateProcess64(Core::System& system) {
+    Result ret{};
+
+    Handle process_handle{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 0));
+
+    ret = TerminateProcess64(system, process_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_GetProcessInfo64(Core::System& system) {
+    Result ret{};
+
+    int64_t out_info{};
+    Handle process_handle{};
+    ProcessInfoType info_type{};
+
+    process_handle = Convert<Handle>(GetReg64(system, 1));
+    info_type = Convert<ProcessInfoType>(GetReg64(system, 2));
+
+    ret = GetProcessInfo64(system, &out_info, process_handle, info_type);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_info));
+}
+
+static void SvcWrap_CreateResourceLimit64(Core::System& system) {
+    Result ret{};
+
+    Handle out_handle{};
+
+    ret = CreateResourceLimit64(system, &out_handle);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+    SetReg64(system, 1, Convert<uint64_t>(out_handle));
+}
+
+static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system) {
+    Result ret{};
+
+    Handle resource_limit_handle{};
+    LimitableResource which{};
+    int64_t limit_value{};
+
+    resource_limit_handle = Convert<Handle>(GetReg64(system, 0));
+    which = Convert<LimitableResource>(GetReg64(system, 1));
+    limit_value = Convert<int64_t>(GetReg64(system, 2));
+
+    ret = SetResourceLimitLimitValue64(system, resource_limit_handle, which, limit_value);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_MapInsecureMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = MapInsecureMemory64(system, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void SvcWrap_UnmapInsecureMemory64(Core::System& system) {
+    Result ret{};
+
+    uint64_t address{};
+    uint64_t size{};
+
+    address = Convert<uint64_t>(GetReg64(system, 0));
+    size = Convert<uint64_t>(GetReg64(system, 1));
+
+    ret = UnmapInsecureMemory64(system, address, size);
+
+    SetReg64(system, 0, Convert<uint64_t>(ret));
+}
+
+static void Call32(Core::System& system, u32 imm) {
+    switch (static_cast<SvcId>(imm)) {
+    case SvcId::SetHeapSize:
+        return SvcWrap_SetHeapSize64From32(system);
+    case SvcId::SetMemoryPermission:
+        return SvcWrap_SetMemoryPermission64From32(system);
+    case SvcId::SetMemoryAttribute:
+        return SvcWrap_SetMemoryAttribute64From32(system);
+    case SvcId::MapMemory:
+        return SvcWrap_MapMemory64From32(system);
+    case SvcId::UnmapMemory:
+        return SvcWrap_UnmapMemory64From32(system);
+    case SvcId::QueryMemory:
+        return SvcWrap_QueryMemory64From32(system);
+    case SvcId::ExitProcess:
+        return SvcWrap_ExitProcess64From32(system);
+    case SvcId::CreateThread:
+        return SvcWrap_CreateThread64From32(system);
+    case SvcId::StartThread:
+        return SvcWrap_StartThread64From32(system);
+    case SvcId::ExitThread:
+        return SvcWrap_ExitThread64From32(system);
+    case SvcId::SleepThread:
+        return SvcWrap_SleepThread64From32(system);
+    case SvcId::GetThreadPriority:
+        return SvcWrap_GetThreadPriority64From32(system);
+    case SvcId::SetThreadPriority:
+        return SvcWrap_SetThreadPriority64From32(system);
+    case SvcId::GetThreadCoreMask:
+        return SvcWrap_GetThreadCoreMask64From32(system);
+    case SvcId::SetThreadCoreMask:
+        return SvcWrap_SetThreadCoreMask64From32(system);
+    case SvcId::GetCurrentProcessorNumber:
+        return SvcWrap_GetCurrentProcessorNumber64From32(system);
+    case SvcId::SignalEvent:
+        return SvcWrap_SignalEvent64From32(system);
+    case SvcId::ClearEvent:
+        return SvcWrap_ClearEvent64From32(system);
+    case SvcId::MapSharedMemory:
+        return SvcWrap_MapSharedMemory64From32(system);
+    case SvcId::UnmapSharedMemory:
+        return SvcWrap_UnmapSharedMemory64From32(system);
+    case SvcId::CreateTransferMemory:
+        return SvcWrap_CreateTransferMemory64From32(system);
+    case SvcId::CloseHandle:
+        return SvcWrap_CloseHandle64From32(system);
+    case SvcId::ResetSignal:
+        return SvcWrap_ResetSignal64From32(system);
+    case SvcId::WaitSynchronization:
+        return SvcWrap_WaitSynchronization64From32(system);
+    case SvcId::CancelSynchronization:
+        return SvcWrap_CancelSynchronization64From32(system);
+    case SvcId::ArbitrateLock:
+        return SvcWrap_ArbitrateLock64From32(system);
+    case SvcId::ArbitrateUnlock:
+        return SvcWrap_ArbitrateUnlock64From32(system);
+    case SvcId::WaitProcessWideKeyAtomic:
+        return SvcWrap_WaitProcessWideKeyAtomic64From32(system);
+    case SvcId::SignalProcessWideKey:
+        return SvcWrap_SignalProcessWideKey64From32(system);
+    case SvcId::GetSystemTick:
+        return SvcWrap_GetSystemTick64From32(system);
+    case SvcId::ConnectToNamedPort:
+        return SvcWrap_ConnectToNamedPort64From32(system);
+    case SvcId::SendSyncRequestLight:
+        return SvcWrap_SendSyncRequestLight64From32(system);
+    case SvcId::SendSyncRequest:
+        return SvcWrap_SendSyncRequest64From32(system);
+    case SvcId::SendSyncRequestWithUserBuffer:
+        return SvcWrap_SendSyncRequestWithUserBuffer64From32(system);
+    case SvcId::SendAsyncRequestWithUserBuffer:
+        return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system);
+    case SvcId::GetProcessId:
+        return SvcWrap_GetProcessId64From32(system);
+    case SvcId::GetThreadId:
+        return SvcWrap_GetThreadId64From32(system);
+    case SvcId::Break:
+        return SvcWrap_Break64From32(system);
+    case SvcId::OutputDebugString:
+        return SvcWrap_OutputDebugString64From32(system);
+    case SvcId::ReturnFromException:
+        return SvcWrap_ReturnFromException64From32(system);
+    case SvcId::GetInfo:
+        return SvcWrap_GetInfo64From32(system);
+    case SvcId::FlushEntireDataCache:
+        return SvcWrap_FlushEntireDataCache64From32(system);
+    case SvcId::FlushDataCache:
+        return SvcWrap_FlushDataCache64From32(system);
+    case SvcId::MapPhysicalMemory:
+        return SvcWrap_MapPhysicalMemory64From32(system);
+    case SvcId::UnmapPhysicalMemory:
+        return SvcWrap_UnmapPhysicalMemory64From32(system);
+    case SvcId::GetDebugFutureThreadInfo:
+        return SvcWrap_GetDebugFutureThreadInfo64From32(system);
+    case SvcId::GetLastThreadInfo:
+        return SvcWrap_GetLastThreadInfo64From32(system);
+    case SvcId::GetResourceLimitLimitValue:
+        return SvcWrap_GetResourceLimitLimitValue64From32(system);
+    case SvcId::GetResourceLimitCurrentValue:
+        return SvcWrap_GetResourceLimitCurrentValue64From32(system);
+    case SvcId::SetThreadActivity:
+        return SvcWrap_SetThreadActivity64From32(system);
+    case SvcId::GetThreadContext3:
+        return SvcWrap_GetThreadContext364From32(system);
+    case SvcId::WaitForAddress:
+        return SvcWrap_WaitForAddress64From32(system);
+    case SvcId::SignalToAddress:
+        return SvcWrap_SignalToAddress64From32(system);
+    case SvcId::SynchronizePreemptionState:
+        return SvcWrap_SynchronizePreemptionState64From32(system);
+    case SvcId::GetResourceLimitPeakValue:
+        return SvcWrap_GetResourceLimitPeakValue64From32(system);
+    case SvcId::CreateIoPool:
+        return SvcWrap_CreateIoPool64From32(system);
+    case SvcId::CreateIoRegion:
+        return SvcWrap_CreateIoRegion64From32(system);
+    case SvcId::KernelDebug:
+        return SvcWrap_KernelDebug64From32(system);
+    case SvcId::ChangeKernelTraceState:
+        return SvcWrap_ChangeKernelTraceState64From32(system);
+    case SvcId::CreateSession:
+        return SvcWrap_CreateSession64From32(system);
+    case SvcId::AcceptSession:
+        return SvcWrap_AcceptSession64From32(system);
+    case SvcId::ReplyAndReceiveLight:
+        return SvcWrap_ReplyAndReceiveLight64From32(system);
+    case SvcId::ReplyAndReceive:
+        return SvcWrap_ReplyAndReceive64From32(system);
+    case SvcId::ReplyAndReceiveWithUserBuffer:
+        return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system);
+    case SvcId::CreateEvent:
+        return SvcWrap_CreateEvent64From32(system);
+    case SvcId::MapIoRegion:
+        return SvcWrap_MapIoRegion64From32(system);
+    case SvcId::UnmapIoRegion:
+        return SvcWrap_UnmapIoRegion64From32(system);
+    case SvcId::MapPhysicalMemoryUnsafe:
+        return SvcWrap_MapPhysicalMemoryUnsafe64From32(system);
+    case SvcId::UnmapPhysicalMemoryUnsafe:
+        return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system);
+    case SvcId::SetUnsafeLimit:
+        return SvcWrap_SetUnsafeLimit64From32(system);
+    case SvcId::CreateCodeMemory:
+        return SvcWrap_CreateCodeMemory64From32(system);
+    case SvcId::ControlCodeMemory:
+        return SvcWrap_ControlCodeMemory64From32(system);
+    case SvcId::SleepSystem:
+        return SvcWrap_SleepSystem64From32(system);
+    case SvcId::ReadWriteRegister:
+        return SvcWrap_ReadWriteRegister64From32(system);
+    case SvcId::SetProcessActivity:
+        return SvcWrap_SetProcessActivity64From32(system);
+    case SvcId::CreateSharedMemory:
+        return SvcWrap_CreateSharedMemory64From32(system);
+    case SvcId::MapTransferMemory:
+        return SvcWrap_MapTransferMemory64From32(system);
+    case SvcId::UnmapTransferMemory:
+        return SvcWrap_UnmapTransferMemory64From32(system);
+    case SvcId::CreateInterruptEvent:
+        return SvcWrap_CreateInterruptEvent64From32(system);
+    case SvcId::QueryPhysicalAddress:
+        return SvcWrap_QueryPhysicalAddress64From32(system);
+    case SvcId::QueryIoMapping:
+        return SvcWrap_QueryIoMapping64From32(system);
+    case SvcId::CreateDeviceAddressSpace:
+        return SvcWrap_CreateDeviceAddressSpace64From32(system);
+    case SvcId::AttachDeviceAddressSpace:
+        return SvcWrap_AttachDeviceAddressSpace64From32(system);
+    case SvcId::DetachDeviceAddressSpace:
+        return SvcWrap_DetachDeviceAddressSpace64From32(system);
+    case SvcId::MapDeviceAddressSpaceByForce:
+        return SvcWrap_MapDeviceAddressSpaceByForce64From32(system);
+    case SvcId::MapDeviceAddressSpaceAligned:
+        return SvcWrap_MapDeviceAddressSpaceAligned64From32(system);
+    case SvcId::UnmapDeviceAddressSpace:
+        return SvcWrap_UnmapDeviceAddressSpace64From32(system);
+    case SvcId::InvalidateProcessDataCache:
+        return SvcWrap_InvalidateProcessDataCache64From32(system);
+    case SvcId::StoreProcessDataCache:
+        return SvcWrap_StoreProcessDataCache64From32(system);
+    case SvcId::FlushProcessDataCache:
+        return SvcWrap_FlushProcessDataCache64From32(system);
+    case SvcId::DebugActiveProcess:
+        return SvcWrap_DebugActiveProcess64From32(system);
+    case SvcId::BreakDebugProcess:
+        return SvcWrap_BreakDebugProcess64From32(system);
+    case SvcId::TerminateDebugProcess:
+        return SvcWrap_TerminateDebugProcess64From32(system);
+    case SvcId::GetDebugEvent:
+        return SvcWrap_GetDebugEvent64From32(system);
+    case SvcId::ContinueDebugEvent:
+        return SvcWrap_ContinueDebugEvent64From32(system);
+    case SvcId::GetProcessList:
+        return SvcWrap_GetProcessList64From32(system);
+    case SvcId::GetThreadList:
+        return SvcWrap_GetThreadList64From32(system);
+    case SvcId::GetDebugThreadContext:
+        return SvcWrap_GetDebugThreadContext64From32(system);
+    case SvcId::SetDebugThreadContext:
+        return SvcWrap_SetDebugThreadContext64From32(system);
+    case SvcId::QueryDebugProcessMemory:
+        return SvcWrap_QueryDebugProcessMemory64From32(system);
+    case SvcId::ReadDebugProcessMemory:
+        return SvcWrap_ReadDebugProcessMemory64From32(system);
+    case SvcId::WriteDebugProcessMemory:
+        return SvcWrap_WriteDebugProcessMemory64From32(system);
+    case SvcId::SetHardwareBreakPoint:
+        return SvcWrap_SetHardwareBreakPoint64From32(system);
+    case SvcId::GetDebugThreadParam:
+        return SvcWrap_GetDebugThreadParam64From32(system);
+    case SvcId::GetSystemInfo:
+        return SvcWrap_GetSystemInfo64From32(system);
+    case SvcId::CreatePort:
+        return SvcWrap_CreatePort64From32(system);
+    case SvcId::ManageNamedPort:
+        return SvcWrap_ManageNamedPort64From32(system);
+    case SvcId::ConnectToPort:
+        return SvcWrap_ConnectToPort64From32(system);
+    case SvcId::SetProcessMemoryPermission:
+        return SvcWrap_SetProcessMemoryPermission64From32(system);
+    case SvcId::MapProcessMemory:
+        return SvcWrap_MapProcessMemory64From32(system);
+    case SvcId::UnmapProcessMemory:
+        return SvcWrap_UnmapProcessMemory64From32(system);
+    case SvcId::QueryProcessMemory:
+        return SvcWrap_QueryProcessMemory64From32(system);
+    case SvcId::MapProcessCodeMemory:
+        return SvcWrap_MapProcessCodeMemory64From32(system);
+    case SvcId::UnmapProcessCodeMemory:
+        return SvcWrap_UnmapProcessCodeMemory64From32(system);
+    case SvcId::CreateProcess:
+        return SvcWrap_CreateProcess64From32(system);
+    case SvcId::StartProcess:
+        return SvcWrap_StartProcess64From32(system);
+    case SvcId::TerminateProcess:
+        return SvcWrap_TerminateProcess64From32(system);
+    case SvcId::GetProcessInfo:
+        return SvcWrap_GetProcessInfo64From32(system);
+    case SvcId::CreateResourceLimit:
+        return SvcWrap_CreateResourceLimit64From32(system);
+    case SvcId::SetResourceLimitLimitValue:
+        return SvcWrap_SetResourceLimitLimitValue64From32(system);
+    case SvcId::CallSecureMonitor:
+        return SvcWrap_CallSecureMonitor64From32(system);
+    case SvcId::MapInsecureMemory:
+        return SvcWrap_MapInsecureMemory64From32(system);
+    case SvcId::UnmapInsecureMemory:
+        return SvcWrap_UnmapInsecureMemory64From32(system);
+    default:
+        LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm);
+        break;
     }
-    return &SVC_Table_32[func_num];
 }
 
-static const FunctionDef* GetSVCInfo64(u32 func_num) {
-    if (func_num >= std::size(SVC_Table_64)) {
-        LOG_ERROR(Kernel_SVC, "Unknown svc=0x{:02X}", func_num);
-        return nullptr;
+static void Call64(Core::System& system, u32 imm) {
+    switch (static_cast<SvcId>(imm)) {
+    case SvcId::SetHeapSize:
+        return SvcWrap_SetHeapSize64(system);
+    case SvcId::SetMemoryPermission:
+        return SvcWrap_SetMemoryPermission64(system);
+    case SvcId::SetMemoryAttribute:
+        return SvcWrap_SetMemoryAttribute64(system);
+    case SvcId::MapMemory:
+        return SvcWrap_MapMemory64(system);
+    case SvcId::UnmapMemory:
+        return SvcWrap_UnmapMemory64(system);
+    case SvcId::QueryMemory:
+        return SvcWrap_QueryMemory64(system);
+    case SvcId::ExitProcess:
+        return SvcWrap_ExitProcess64(system);
+    case SvcId::CreateThread:
+        return SvcWrap_CreateThread64(system);
+    case SvcId::StartThread:
+        return SvcWrap_StartThread64(system);
+    case SvcId::ExitThread:
+        return SvcWrap_ExitThread64(system);
+    case SvcId::SleepThread:
+        return SvcWrap_SleepThread64(system);
+    case SvcId::GetThreadPriority:
+        return SvcWrap_GetThreadPriority64(system);
+    case SvcId::SetThreadPriority:
+        return SvcWrap_SetThreadPriority64(system);
+    case SvcId::GetThreadCoreMask:
+        return SvcWrap_GetThreadCoreMask64(system);
+    case SvcId::SetThreadCoreMask:
+        return SvcWrap_SetThreadCoreMask64(system);
+    case SvcId::GetCurrentProcessorNumber:
+        return SvcWrap_GetCurrentProcessorNumber64(system);
+    case SvcId::SignalEvent:
+        return SvcWrap_SignalEvent64(system);
+    case SvcId::ClearEvent:
+        return SvcWrap_ClearEvent64(system);
+    case SvcId::MapSharedMemory:
+        return SvcWrap_MapSharedMemory64(system);
+    case SvcId::UnmapSharedMemory:
+        return SvcWrap_UnmapSharedMemory64(system);
+    case SvcId::CreateTransferMemory:
+        return SvcWrap_CreateTransferMemory64(system);
+    case SvcId::CloseHandle:
+        return SvcWrap_CloseHandle64(system);
+    case SvcId::ResetSignal:
+        return SvcWrap_ResetSignal64(system);
+    case SvcId::WaitSynchronization:
+        return SvcWrap_WaitSynchronization64(system);
+    case SvcId::CancelSynchronization:
+        return SvcWrap_CancelSynchronization64(system);
+    case SvcId::ArbitrateLock:
+        return SvcWrap_ArbitrateLock64(system);
+    case SvcId::ArbitrateUnlock:
+        return SvcWrap_ArbitrateUnlock64(system);
+    case SvcId::WaitProcessWideKeyAtomic:
+        return SvcWrap_WaitProcessWideKeyAtomic64(system);
+    case SvcId::SignalProcessWideKey:
+        return SvcWrap_SignalProcessWideKey64(system);
+    case SvcId::GetSystemTick:
+        return SvcWrap_GetSystemTick64(system);
+    case SvcId::ConnectToNamedPort:
+        return SvcWrap_ConnectToNamedPort64(system);
+    case SvcId::SendSyncRequestLight:
+        return SvcWrap_SendSyncRequestLight64(system);
+    case SvcId::SendSyncRequest:
+        return SvcWrap_SendSyncRequest64(system);
+    case SvcId::SendSyncRequestWithUserBuffer:
+        return SvcWrap_SendSyncRequestWithUserBuffer64(system);
+    case SvcId::SendAsyncRequestWithUserBuffer:
+        return SvcWrap_SendAsyncRequestWithUserBuffer64(system);
+    case SvcId::GetProcessId:
+        return SvcWrap_GetProcessId64(system);
+    case SvcId::GetThreadId:
+        return SvcWrap_GetThreadId64(system);
+    case SvcId::Break:
+        return SvcWrap_Break64(system);
+    case SvcId::OutputDebugString:
+        return SvcWrap_OutputDebugString64(system);
+    case SvcId::ReturnFromException:
+        return SvcWrap_ReturnFromException64(system);
+    case SvcId::GetInfo:
+        return SvcWrap_GetInfo64(system);
+    case SvcId::FlushEntireDataCache:
+        return SvcWrap_FlushEntireDataCache64(system);
+    case SvcId::FlushDataCache:
+        return SvcWrap_FlushDataCache64(system);
+    case SvcId::MapPhysicalMemory:
+        return SvcWrap_MapPhysicalMemory64(system);
+    case SvcId::UnmapPhysicalMemory:
+        return SvcWrap_UnmapPhysicalMemory64(system);
+    case SvcId::GetDebugFutureThreadInfo:
+        return SvcWrap_GetDebugFutureThreadInfo64(system);
+    case SvcId::GetLastThreadInfo:
+        return SvcWrap_GetLastThreadInfo64(system);
+    case SvcId::GetResourceLimitLimitValue:
+        return SvcWrap_GetResourceLimitLimitValue64(system);
+    case SvcId::GetResourceLimitCurrentValue:
+        return SvcWrap_GetResourceLimitCurrentValue64(system);
+    case SvcId::SetThreadActivity:
+        return SvcWrap_SetThreadActivity64(system);
+    case SvcId::GetThreadContext3:
+        return SvcWrap_GetThreadContext364(system);
+    case SvcId::WaitForAddress:
+        return SvcWrap_WaitForAddress64(system);
+    case SvcId::SignalToAddress:
+        return SvcWrap_SignalToAddress64(system);
+    case SvcId::SynchronizePreemptionState:
+        return SvcWrap_SynchronizePreemptionState64(system);
+    case SvcId::GetResourceLimitPeakValue:
+        return SvcWrap_GetResourceLimitPeakValue64(system);
+    case SvcId::CreateIoPool:
+        return SvcWrap_CreateIoPool64(system);
+    case SvcId::CreateIoRegion:
+        return SvcWrap_CreateIoRegion64(system);
+    case SvcId::KernelDebug:
+        return SvcWrap_KernelDebug64(system);
+    case SvcId::ChangeKernelTraceState:
+        return SvcWrap_ChangeKernelTraceState64(system);
+    case SvcId::CreateSession:
+        return SvcWrap_CreateSession64(system);
+    case SvcId::AcceptSession:
+        return SvcWrap_AcceptSession64(system);
+    case SvcId::ReplyAndReceiveLight:
+        return SvcWrap_ReplyAndReceiveLight64(system);
+    case SvcId::ReplyAndReceive:
+        return SvcWrap_ReplyAndReceive64(system);
+    case SvcId::ReplyAndReceiveWithUserBuffer:
+        return SvcWrap_ReplyAndReceiveWithUserBuffer64(system);
+    case SvcId::CreateEvent:
+        return SvcWrap_CreateEvent64(system);
+    case SvcId::MapIoRegion:
+        return SvcWrap_MapIoRegion64(system);
+    case SvcId::UnmapIoRegion:
+        return SvcWrap_UnmapIoRegion64(system);
+    case SvcId::MapPhysicalMemoryUnsafe:
+        return SvcWrap_MapPhysicalMemoryUnsafe64(system);
+    case SvcId::UnmapPhysicalMemoryUnsafe:
+        return SvcWrap_UnmapPhysicalMemoryUnsafe64(system);
+    case SvcId::SetUnsafeLimit:
+        return SvcWrap_SetUnsafeLimit64(system);
+    case SvcId::CreateCodeMemory:
+        return SvcWrap_CreateCodeMemory64(system);
+    case SvcId::ControlCodeMemory:
+        return SvcWrap_ControlCodeMemory64(system);
+    case SvcId::SleepSystem:
+        return SvcWrap_SleepSystem64(system);
+    case SvcId::ReadWriteRegister:
+        return SvcWrap_ReadWriteRegister64(system);
+    case SvcId::SetProcessActivity:
+        return SvcWrap_SetProcessActivity64(system);
+    case SvcId::CreateSharedMemory:
+        return SvcWrap_CreateSharedMemory64(system);
+    case SvcId::MapTransferMemory:
+        return SvcWrap_MapTransferMemory64(system);
+    case SvcId::UnmapTransferMemory:
+        return SvcWrap_UnmapTransferMemory64(system);
+    case SvcId::CreateInterruptEvent:
+        return SvcWrap_CreateInterruptEvent64(system);
+    case SvcId::QueryPhysicalAddress:
+        return SvcWrap_QueryPhysicalAddress64(system);
+    case SvcId::QueryIoMapping:
+        return SvcWrap_QueryIoMapping64(system);
+    case SvcId::CreateDeviceAddressSpace:
+        return SvcWrap_CreateDeviceAddressSpace64(system);
+    case SvcId::AttachDeviceAddressSpace:
+        return SvcWrap_AttachDeviceAddressSpace64(system);
+    case SvcId::DetachDeviceAddressSpace:
+        return SvcWrap_DetachDeviceAddressSpace64(system);
+    case SvcId::MapDeviceAddressSpaceByForce:
+        return SvcWrap_MapDeviceAddressSpaceByForce64(system);
+    case SvcId::MapDeviceAddressSpaceAligned:
+        return SvcWrap_MapDeviceAddressSpaceAligned64(system);
+    case SvcId::UnmapDeviceAddressSpace:
+        return SvcWrap_UnmapDeviceAddressSpace64(system);
+    case SvcId::InvalidateProcessDataCache:
+        return SvcWrap_InvalidateProcessDataCache64(system);
+    case SvcId::StoreProcessDataCache:
+        return SvcWrap_StoreProcessDataCache64(system);
+    case SvcId::FlushProcessDataCache:
+        return SvcWrap_FlushProcessDataCache64(system);
+    case SvcId::DebugActiveProcess:
+        return SvcWrap_DebugActiveProcess64(system);
+    case SvcId::BreakDebugProcess:
+        return SvcWrap_BreakDebugProcess64(system);
+    case SvcId::TerminateDebugProcess:
+        return SvcWrap_TerminateDebugProcess64(system);
+    case SvcId::GetDebugEvent:
+        return SvcWrap_GetDebugEvent64(system);
+    case SvcId::ContinueDebugEvent:
+        return SvcWrap_ContinueDebugEvent64(system);
+    case SvcId::GetProcessList:
+        return SvcWrap_GetProcessList64(system);
+    case SvcId::GetThreadList:
+        return SvcWrap_GetThreadList64(system);
+    case SvcId::GetDebugThreadContext:
+        return SvcWrap_GetDebugThreadContext64(system);
+    case SvcId::SetDebugThreadContext:
+        return SvcWrap_SetDebugThreadContext64(system);
+    case SvcId::QueryDebugProcessMemory:
+        return SvcWrap_QueryDebugProcessMemory64(system);
+    case SvcId::ReadDebugProcessMemory:
+        return SvcWrap_ReadDebugProcessMemory64(system);
+    case SvcId::WriteDebugProcessMemory:
+        return SvcWrap_WriteDebugProcessMemory64(system);
+    case SvcId::SetHardwareBreakPoint:
+        return SvcWrap_SetHardwareBreakPoint64(system);
+    case SvcId::GetDebugThreadParam:
+        return SvcWrap_GetDebugThreadParam64(system);
+    case SvcId::GetSystemInfo:
+        return SvcWrap_GetSystemInfo64(system);
+    case SvcId::CreatePort:
+        return SvcWrap_CreatePort64(system);
+    case SvcId::ManageNamedPort:
+        return SvcWrap_ManageNamedPort64(system);
+    case SvcId::ConnectToPort:
+        return SvcWrap_ConnectToPort64(system);
+    case SvcId::SetProcessMemoryPermission:
+        return SvcWrap_SetProcessMemoryPermission64(system);
+    case SvcId::MapProcessMemory:
+        return SvcWrap_MapProcessMemory64(system);
+    case SvcId::UnmapProcessMemory:
+        return SvcWrap_UnmapProcessMemory64(system);
+    case SvcId::QueryProcessMemory:
+        return SvcWrap_QueryProcessMemory64(system);
+    case SvcId::MapProcessCodeMemory:
+        return SvcWrap_MapProcessCodeMemory64(system);
+    case SvcId::UnmapProcessCodeMemory:
+        return SvcWrap_UnmapProcessCodeMemory64(system);
+    case SvcId::CreateProcess:
+        return SvcWrap_CreateProcess64(system);
+    case SvcId::StartProcess:
+        return SvcWrap_StartProcess64(system);
+    case SvcId::TerminateProcess:
+        return SvcWrap_TerminateProcess64(system);
+    case SvcId::GetProcessInfo:
+        return SvcWrap_GetProcessInfo64(system);
+    case SvcId::CreateResourceLimit:
+        return SvcWrap_CreateResourceLimit64(system);
+    case SvcId::SetResourceLimitLimitValue:
+        return SvcWrap_SetResourceLimitLimitValue64(system);
+    case SvcId::CallSecureMonitor:
+        return SvcWrap_CallSecureMonitor64(system);
+    case SvcId::MapInsecureMemory:
+        return SvcWrap_MapInsecureMemory64(system);
+    case SvcId::UnmapInsecureMemory:
+        return SvcWrap_UnmapInsecureMemory64(system);
+    default:
+        LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm);
+        break;
     }
-    return &SVC_Table_64[func_num];
 }
+// clang-format on
 
-void Call(Core::System& system, u32 immediate) {
+void Call(Core::System& system, u32 imm) {
     auto& kernel = system.Kernel();
     kernel.EnterSVCProfile();
 
-    auto* thread = GetCurrentThreadPointer(kernel);
-    thread->SetIsCallingSvc();
-
-    const FunctionDef* info = system.CurrentProcess()->Is64BitProcess() ? GetSVCInfo64(immediate)
-                                                                        : GetSVCInfo32(immediate);
-    if (info) {
-        if (info->func) {
-            info->func(system);
-        } else {
-            LOG_CRITICAL(Kernel_SVC, "Unimplemented SVC function {}(..)", info->name);
-        }
+    if (GetCurrentProcess(system.Kernel()).Is64BitProcess()) {
+        Call64(system, imm);
     } else {
-        LOG_CRITICAL(Kernel_SVC, "Unknown SVC function 0x{:X}", immediate);
+        Call32(system, imm);
     }
 
     kernel.ExitSVCProfile();
diff --git a/src/core/hle/kernel/svc.h b/src/core/hle/kernel/svc.h
index b599f9a3d..36e619959 100644
--- a/src/core/hle/kernel/svc.h
+++ b/src/core/hle/kernel/svc.h
@@ -1,172 +1,536 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#pragma once
+// This file is automatically generated using svc_generator.py.
 
-#include "common/common_types.h"
-#include "core/hle/kernel/svc_types.h"
-#include "core/hle/result.h"
+#pragma once
 
 namespace Core {
 class System;
 }
 
-namespace Kernel::Svc {
+#include "common/common_types.h"
+#include "core/hle/kernel/svc_types.h"
+#include "core/hle/result.h"
 
-void Call(Core::System& system, u32 immediate);
+namespace Kernel::Svc {
 
-Result SetHeapSize(Core::System& system, VAddr* out_address, u64 size);
-Result SetMemoryPermission(Core::System& system, VAddr address, u64 size, MemoryPermission perm);
-Result SetMemoryAttribute(Core::System& system, VAddr address, u64 size, u32 mask, u32 attr);
-Result MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size);
-Result UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size);
-Result QueryMemory(Core::System& system, VAddr memory_info_address, VAddr page_info_address,
-                   VAddr query_address);
+// clang-format off
+Result SetHeapSize(Core::System& system, uintptr_t* out_address, uint64_t size);
+Result SetMemoryPermission(Core::System& system, uint64_t address, uint64_t size, MemoryPermission perm);
+Result SetMemoryAttribute(Core::System& system, uint64_t address, uint64_t size, uint32_t mask, uint32_t attr);
+Result MapMemory(Core::System& system, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result UnmapMemory(Core::System& system, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result QueryMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, uint64_t address);
 void ExitProcess(Core::System& system);
-Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point, u64 arg,
-                    VAddr stack_bottom, u32 priority, s32 core_id);
+Result CreateThread(Core::System& system, Handle* out_handle, uint64_t func, uint64_t arg, uint64_t stack_bottom, int32_t priority, int32_t core_id);
 Result StartThread(Core::System& system, Handle thread_handle);
 void ExitThread(Core::System& system);
-void SleepThread(Core::System& system, s64 nanoseconds);
-Result GetThreadPriority(Core::System& system, u32* out_priority, Handle handle);
-Result SetThreadPriority(Core::System& system, Handle thread_handle, u32 priority);
-Result GetThreadCoreMask(Core::System& system, Handle thread_handle, s32* out_core_id,
-                         u64* out_affinity_mask);
-Result SetThreadCoreMask(Core::System& system, Handle thread_handle, s32 core_id,
-                         u64 affinity_mask);
-u32 GetCurrentProcessorNumber(Core::System& system);
+void SleepThread(Core::System& system, int64_t ns);
+Result GetThreadPriority(Core::System& system, int32_t* out_priority, Handle thread_handle);
+Result SetThreadPriority(Core::System& system, Handle thread_handle, int32_t priority);
+Result GetThreadCoreMask(Core::System& system, int32_t* out_core_id, uint64_t* out_affinity_mask, Handle thread_handle);
+Result SetThreadCoreMask(Core::System& system, Handle thread_handle, int32_t core_id, uint64_t affinity_mask);
+int32_t GetCurrentProcessorNumber(Core::System& system);
 Result SignalEvent(Core::System& system, Handle event_handle);
 Result ClearEvent(Core::System& system, Handle event_handle);
-Result MapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address, u64 size,
-                       MemoryPermission map_perm);
-Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address, u64 size);
-Result CreateTransferMemory(Core::System& system, Handle* out, VAddr address, u64 size,
-                            MemoryPermission map_perm);
+Result MapSharedMemory(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size, MemoryPermission map_perm);
+Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size);
+Result CreateTransferMemory(Core::System& system, Handle* out_handle, uint64_t address, uint64_t size, MemoryPermission map_perm);
 Result CloseHandle(Core::System& system, Handle handle);
 Result ResetSignal(Core::System& system, Handle handle);
-Result WaitSynchronization(Core::System& system, s32* index, VAddr handles_address, s32 num_handles,
-                           s64 nano_seconds);
+Result WaitSynchronization(Core::System& system, int32_t* out_index, uint64_t handles, int32_t num_handles, int64_t timeout_ns);
 Result CancelSynchronization(Core::System& system, Handle handle);
-Result ArbitrateLock(Core::System& system, Handle thread_handle, VAddr address, u32 tag);
-Result ArbitrateUnlock(Core::System& system, VAddr address);
-Result WaitProcessWideKeyAtomic(Core::System& system, VAddr address, VAddr cv_key, u32 tag,
-                                s64 timeout_ns);
-void SignalProcessWideKey(Core::System& system, VAddr cv_key, s32 count);
-u64 GetSystemTick(Core::System& system);
-Result ConnectToNamedPort(Core::System& system, Handle* out, VAddr port_name_address);
-Result SendSyncRequest(Core::System& system, Handle handle);
-Result GetProcessId(Core::System& system, u64* out_process_id, Handle handle);
-Result GetThreadId(Core::System& system, u64* out_thread_id, Handle thread_handle);
-void Break(Core::System& system, u32 reason, u64 info1, u64 info2);
-void OutputDebugString(Core::System& system, VAddr address, u64 len);
-Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle, u64 info_sub_id);
-Result MapPhysicalMemory(Core::System& system, VAddr addr, u64 size);
-Result UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size);
-Result GetResourceLimitLimitValue(Core::System& system, u64* out_limit_value,
-                                  Handle resource_limit_handle, LimitableResource which);
-Result GetResourceLimitCurrentValue(Core::System& system, u64* out_current_value,
-                                    Handle resource_limit_handle, LimitableResource which);
-Result SetThreadActivity(Core::System& system, Handle thread_handle,
-                         ThreadActivity thread_activity);
-Result GetThreadContext(Core::System& system, VAddr out_context, Handle thread_handle);
-Result WaitForAddress(Core::System& system, VAddr address, ArbitrationType arb_type, s32 value,
-                      s64 timeout_ns);
-Result SignalToAddress(Core::System& system, VAddr address, SignalType signal_type, s32 value,
-                       s32 count);
+Result ArbitrateLock(Core::System& system, Handle thread_handle, uint64_t address, uint32_t tag);
+Result ArbitrateUnlock(Core::System& system, uint64_t address);
+Result WaitProcessWideKeyAtomic(Core::System& system, uint64_t address, uint64_t cv_key, uint32_t tag, int64_t timeout_ns);
+void SignalProcessWideKey(Core::System& system, uint64_t cv_key, int32_t count);
+int64_t GetSystemTick(Core::System& system);
+Result ConnectToNamedPort(Core::System& system, Handle* out_handle, uint64_t name);
+Result SendSyncRequest(Core::System& system, Handle session_handle);
+Result SendSyncRequestWithUserBuffer(Core::System& system, uint64_t message_buffer, uint64_t message_buffer_size, Handle session_handle);
+Result SendAsyncRequestWithUserBuffer(Core::System& system, Handle* out_event_handle, uint64_t message_buffer, uint64_t message_buffer_size, Handle session_handle);
+Result GetProcessId(Core::System& system, uint64_t* out_process_id, Handle process_handle);
+Result GetThreadId(Core::System& system, uint64_t* out_thread_id, Handle thread_handle);
+void Break(Core::System& system, BreakReason break_reason, uint64_t arg, uint64_t size);
+Result OutputDebugString(Core::System& system, uint64_t debug_str, uint64_t len);
+void ReturnFromException(Core::System& system, Result result);
+Result GetInfo(Core::System& system, uint64_t* out, InfoType info_type, Handle handle, uint64_t info_subtype);
+void FlushEntireDataCache(Core::System& system);
+Result FlushDataCache(Core::System& system, uint64_t address, uint64_t size);
+Result MapPhysicalMemory(Core::System& system, uint64_t address, uint64_t size);
+Result UnmapPhysicalMemory(Core::System& system, uint64_t address, uint64_t size);
+Result GetDebugFutureThreadInfo(Core::System& system, lp64::LastThreadContext* out_context, uint64_t* out_thread_id, Handle debug_handle, int64_t ns);
+Result GetLastThreadInfo(Core::System& system, lp64::LastThreadContext* out_context, uintptr_t* out_tls_address, uint32_t* out_flags);
+Result GetResourceLimitLimitValue(Core::System& system, int64_t* out_limit_value, Handle resource_limit_handle, LimitableResource which);
+Result GetResourceLimitCurrentValue(Core::System& system, int64_t* out_current_value, Handle resource_limit_handle, LimitableResource which);
+Result SetThreadActivity(Core::System& system, Handle thread_handle, ThreadActivity thread_activity);
+Result GetThreadContext3(Core::System& system, uint64_t out_context, Handle thread_handle);
+Result WaitForAddress(Core::System& system, uint64_t address, ArbitrationType arb_type, int32_t value, int64_t timeout_ns);
+Result SignalToAddress(Core::System& system, uint64_t address, SignalType signal_type, int32_t value, int32_t count);
 void SynchronizePreemptionState(Core::System& system);
-void KernelDebug(Core::System& system, u32 kernel_debug_type, u64 param1, u64 param2, u64 param3);
-void ChangeKernelTraceState(Core::System& system, u32 trace_state);
-Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, u32 is_light,
-                     u64 name);
-Result ReplyAndReceive(Core::System& system, s32* out_index, Handle* handles, s32 num_handles,
-                       Handle reply_target, s64 timeout_ns);
-Result CreateEvent(Core::System& system, Handle* out_write, Handle* out_read);
-Result CreateCodeMemory(Core::System& system, Handle* out, VAddr address, size_t size);
-Result ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 operation,
-                         VAddr address, size_t size, MemoryPermission perm);
-Result GetProcessList(Core::System& system, u32* out_num_processes, VAddr out_process_ids,
-                      u32 out_process_ids_size);
-Result GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_thread_ids,
-                     u32 out_thread_ids_size, Handle debug_handle);
-Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, VAddr address,
-                                  u64 size, MemoryPermission perm);
-Result MapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
-                        VAddr src_address, u64 size);
-Result UnmapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
-                          VAddr src_address, u64 size);
-Result QueryProcessMemory(Core::System& system, VAddr memory_info_address, VAddr page_info_address,
-                          Handle process_handle, VAddr address);
-Result MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst_address,
-                            u64 src_address, u64 size);
-Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst_address,
-                              u64 src_address, u64 size);
-Result GetProcessInfo(Core::System& system, u64* out, Handle process_handle, u32 type);
+Result GetResourceLimitPeakValue(Core::System& system, int64_t* out_peak_value, Handle resource_limit_handle, LimitableResource which);
+Result CreateIoPool(Core::System& system, Handle* out_handle, IoPoolType which);
+Result CreateIoRegion(Core::System& system, Handle* out_handle, Handle io_pool, uint64_t physical_address, uint64_t size, MemoryMapping mapping, MemoryPermission perm);
+void KernelDebug(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2);
+void ChangeKernelTraceState(Core::System& system, KernelTraceState kern_trace_state);
+Result CreateSession(Core::System& system, Handle* out_server_session_handle, Handle* out_client_session_handle, bool is_light, uint64_t name);
+Result AcceptSession(Core::System& system, Handle* out_handle, Handle port);
+Result ReplyAndReceive(Core::System& system, int32_t* out_index, uint64_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
+Result ReplyAndReceiveWithUserBuffer(Core::System& system, int32_t* out_index, uint64_t message_buffer, uint64_t message_buffer_size, uint64_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
+Result CreateEvent(Core::System& system, Handle* out_write_handle, Handle* out_read_handle);
+Result MapIoRegion(Core::System& system, Handle io_region, uint64_t address, uint64_t size, MemoryPermission perm);
+Result UnmapIoRegion(Core::System& system, Handle io_region, uint64_t address, uint64_t size);
+Result MapPhysicalMemoryUnsafe(Core::System& system, uint64_t address, uint64_t size);
+Result UnmapPhysicalMemoryUnsafe(Core::System& system, uint64_t address, uint64_t size);
+Result SetUnsafeLimit(Core::System& system, uint64_t limit);
+Result CreateCodeMemory(Core::System& system, Handle* out_handle, uint64_t address, uint64_t size);
+Result ControlCodeMemory(Core::System& system, Handle code_memory_handle, CodeMemoryOperation operation, uint64_t address, uint64_t size, MemoryPermission perm);
+void SleepSystem(Core::System& system);
+Result ReadWriteRegister(Core::System& system, uint32_t* out_value, uint64_t address, uint32_t mask, uint32_t value);
+Result SetProcessActivity(Core::System& system, Handle process_handle, ProcessActivity process_activity);
+Result CreateSharedMemory(Core::System& system, Handle* out_handle, uint64_t size, MemoryPermission owner_perm, MemoryPermission remote_perm);
+Result MapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size, MemoryPermission owner_perm);
+Result UnmapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size);
+Result CreateInterruptEvent(Core::System& system, Handle* out_read_handle, int32_t interrupt_id, InterruptType interrupt_type);
+Result QueryPhysicalAddress(Core::System& system, lp64::PhysicalMemoryInfo* out_info, uint64_t address);
+Result QueryIoMapping(Core::System& system, uintptr_t* out_address, uintptr_t* out_size, uint64_t physical_address, uint64_t size);
+Result CreateDeviceAddressSpace(Core::System& system, Handle* out_handle, uint64_t das_address, uint64_t das_size);
+Result AttachDeviceAddressSpace(Core::System& system, DeviceName device_name, Handle das_handle);
+Result DetachDeviceAddressSpace(Core::System& system, DeviceName device_name, Handle das_handle);
+Result MapDeviceAddressSpaceByForce(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address, uint32_t option);
+Result MapDeviceAddressSpaceAligned(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address, uint32_t option);
+Result UnmapDeviceAddressSpace(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address);
+Result InvalidateProcessDataCache(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result StoreProcessDataCache(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result FlushProcessDataCache(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result DebugActiveProcess(Core::System& system, Handle* out_handle, uint64_t process_id);
+Result BreakDebugProcess(Core::System& system, Handle debug_handle);
+Result TerminateDebugProcess(Core::System& system, Handle debug_handle);
+Result GetDebugEvent(Core::System& system, uint64_t out_info, Handle debug_handle);
+Result ContinueDebugEvent(Core::System& system, Handle debug_handle, uint32_t flags, uint64_t thread_ids, int32_t num_thread_ids);
+Result GetProcessList(Core::System& system, int32_t* out_num_processes, uint64_t out_process_ids, int32_t max_out_count);
+Result GetThreadList(Core::System& system, int32_t* out_num_threads, uint64_t out_thread_ids, int32_t max_out_count, Handle debug_handle);
+Result GetDebugThreadContext(Core::System& system, uint64_t out_context, Handle debug_handle, uint64_t thread_id, uint32_t context_flags);
+Result SetDebugThreadContext(Core::System& system, Handle debug_handle, uint64_t thread_id, uint64_t context, uint32_t context_flags);
+Result QueryDebugProcessMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
+Result ReadDebugProcessMemory(Core::System& system, uint64_t buffer, Handle debug_handle, uint64_t address, uint64_t size);
+Result WriteDebugProcessMemory(Core::System& system, Handle debug_handle, uint64_t buffer, uint64_t address, uint64_t size);
+Result SetHardwareBreakPoint(Core::System& system, HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value);
+Result GetDebugThreadParam(Core::System& system, uint64_t* out_64, uint32_t* out_32, Handle debug_handle, uint64_t thread_id, DebugThreadParam param);
+Result GetSystemInfo(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle, uint64_t info_subtype);
+Result CreatePort(Core::System& system, Handle* out_server_handle, Handle* out_client_handle, int32_t max_sessions, bool is_light, uint64_t name);
+Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t name, int32_t max_sessions);
+Result ConnectToPort(Core::System& system, Handle* out_handle, Handle port);
+Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, uint64_t address, uint64_t size, MemoryPermission perm);
+Result MapProcessMemory(Core::System& system, uint64_t dst_address, Handle process_handle, uint64_t src_address, uint64_t size);
+Result UnmapProcessMemory(Core::System& system, uint64_t dst_address, Handle process_handle, uint64_t src_address, uint64_t size);
+Result QueryProcessMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
+Result MapProcessCodeMemory(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result CreateProcess(Core::System& system, Handle* out_handle, uint64_t parameters, uint64_t caps, int32_t num_caps);
+Result StartProcess(Core::System& system, Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size);
+Result TerminateProcess(Core::System& system, Handle process_handle);
+Result GetProcessInfo(Core::System& system, int64_t* out_info, Handle process_handle, ProcessInfoType info_type);
 Result CreateResourceLimit(Core::System& system, Handle* out_handle);
-Result SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_handle,
-                                  LimitableResource which, u64 limit_value);
-
-//
-
-Result SetHeapSize32(Core::System& system, u32* heap_addr, u32 heap_size);
-Result SetMemoryAttribute32(Core::System& system, u32 address, u32 size, u32 mask, u32 attr);
-Result MapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size);
-Result UnmapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size);
-Result QueryMemory32(Core::System& system, u32 memory_info_address, u32 page_info_address,
-                     u32 query_address);
-void ExitProcess32(Core::System& system);
-Result CreateThread32(Core::System& system, Handle* out_handle, u32 priority, u32 entry_point,
-                      u32 arg, u32 stack_top, s32 processor_id);
-Result StartThread32(Core::System& system, Handle thread_handle);
-void ExitThread32(Core::System& system);
-void SleepThread32(Core::System& system, u32 nanoseconds_low, u32 nanoseconds_high);
-Result GetThreadPriority32(Core::System& system, u32* out_priority, Handle handle);
-Result SetThreadPriority32(Core::System& system, Handle thread_handle, u32 priority);
-Result GetThreadCoreMask32(Core::System& system, Handle thread_handle, s32* out_core_id,
-                           u32* out_affinity_mask_low, u32* out_affinity_mask_high);
-Result SetThreadCoreMask32(Core::System& system, Handle thread_handle, s32 core_id,
-                           u32 affinity_mask_low, u32 affinity_mask_high);
-u32 GetCurrentProcessorNumber32(Core::System& system);
-Result SignalEvent32(Core::System& system, Handle event_handle);
-Result ClearEvent32(Core::System& system, Handle event_handle);
-Result MapSharedMemory32(Core::System& system, Handle shmem_handle, u32 address, u32 size,
-                         MemoryPermission map_perm);
-Result UnmapSharedMemory32(Core::System& system, Handle shmem_handle, u32 address, u32 size);
-Result CreateTransferMemory32(Core::System& system, Handle* out, u32 address, u32 size,
-                              MemoryPermission map_perm);
-Result CloseHandle32(Core::System& system, Handle handle);
-Result ResetSignal32(Core::System& system, Handle handle);
-Result WaitSynchronization32(Core::System& system, u32 timeout_low, u32 handles_address,
-                             s32 num_handles, u32 timeout_high, s32* index);
-Result CancelSynchronization32(Core::System& system, Handle handle);
-Result ArbitrateLock32(Core::System& system, Handle thread_handle, u32 address, u32 tag);
-Result ArbitrateUnlock32(Core::System& system, u32 address);
-Result WaitProcessWideKeyAtomic32(Core::System& system, u32 address, u32 cv_key, u32 tag,
-                                  u32 timeout_ns_low, u32 timeout_ns_high);
-void SignalProcessWideKey32(Core::System& system, u32 cv_key, s32 count);
-void GetSystemTick32(Core::System& system, u32* time_low, u32* time_high);
-Result ConnectToNamedPort32(Core::System& system, Handle* out_handle, u32 port_name_address);
-Result SendSyncRequest32(Core::System& system, Handle handle);
-Result GetProcessId32(Core::System& system, u32* out_process_id_low, u32* out_process_id_high,
-                      Handle handle);
-Result GetThreadId32(Core::System& system, u32* out_thread_id_low, u32* out_thread_id_high,
-                     Handle thread_handle);
-void Break32(Core::System& system, u32 reason, u32 info1, u32 info2);
-void OutputDebugString32(Core::System& system, u32 address, u32 len);
-Result GetInfo32(Core::System& system, u32* result_low, u32* result_high, u32 sub_id_low,
-                 u32 info_id, u32 handle, u32 sub_id_high);
-Result MapPhysicalMemory32(Core::System& system, u32 addr, u32 size);
-Result UnmapPhysicalMemory32(Core::System& system, u32 addr, u32 size);
-Result SetThreadActivity32(Core::System& system, Handle thread_handle,
-                           ThreadActivity thread_activity);
-Result GetThreadContext32(Core::System& system, u32 out_context, Handle thread_handle);
-Result WaitForAddress32(Core::System& system, u32 address, ArbitrationType arb_type, s32 value,
-                        u32 timeout_ns_low, u32 timeout_ns_high);
-Result SignalToAddress32(Core::System& system, u32 address, SignalType signal_type, s32 value,
-                         s32 count);
-Result CreateEvent32(Core::System& system, Handle* out_write, Handle* out_read);
-Result CreateCodeMemory32(Core::System& system, Handle* out, u32 address, u32 size);
-Result ControlCodeMemory32(Core::System& system, Handle code_memory_handle, u32 operation,
-                           u64 address, u64 size, MemoryPermission perm);
-Result FlushProcessDataCache32(Core::System& system, Handle process_handle, u64 address, u64 size);
+Result SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_handle, LimitableResource which, int64_t limit_value);
+Result MapInsecureMemory(Core::System& system, uint64_t address, uint64_t size);
+Result UnmapInsecureMemory(Core::System& system, uint64_t address, uint64_t size);
+
+Result SetHeapSize64From32(Core::System& system, uintptr_t* out_address, uint32_t size);
+Result SetMemoryPermission64From32(Core::System& system, uint32_t address, uint32_t size, MemoryPermission perm);
+Result SetMemoryAttribute64From32(Core::System& system, uint32_t address, uint32_t size, uint32_t mask, uint32_t attr);
+Result MapMemory64From32(Core::System& system, uint32_t dst_address, uint32_t src_address, uint32_t size);
+Result UnmapMemory64From32(Core::System& system, uint32_t dst_address, uint32_t src_address, uint32_t size);
+Result QueryMemory64From32(Core::System& system, uint32_t out_memory_info, PageInfo* out_page_info, uint32_t address);
+void ExitProcess64From32(Core::System& system);
+Result CreateThread64From32(Core::System& system, Handle* out_handle, uint32_t func, uint32_t arg, uint32_t stack_bottom, int32_t priority, int32_t core_id);
+Result StartThread64From32(Core::System& system, Handle thread_handle);
+void ExitThread64From32(Core::System& system);
+void SleepThread64From32(Core::System& system, int64_t ns);
+Result GetThreadPriority64From32(Core::System& system, int32_t* out_priority, Handle thread_handle);
+Result SetThreadPriority64From32(Core::System& system, Handle thread_handle, int32_t priority);
+Result GetThreadCoreMask64From32(Core::System& system, int32_t* out_core_id, uint64_t* out_affinity_mask, Handle thread_handle);
+Result SetThreadCoreMask64From32(Core::System& system, Handle thread_handle, int32_t core_id, uint64_t affinity_mask);
+int32_t GetCurrentProcessorNumber64From32(Core::System& system);
+Result SignalEvent64From32(Core::System& system, Handle event_handle);
+Result ClearEvent64From32(Core::System& system, Handle event_handle);
+Result MapSharedMemory64From32(Core::System& system, Handle shmem_handle, uint32_t address, uint32_t size, MemoryPermission map_perm);
+Result UnmapSharedMemory64From32(Core::System& system, Handle shmem_handle, uint32_t address, uint32_t size);
+Result CreateTransferMemory64From32(Core::System& system, Handle* out_handle, uint32_t address, uint32_t size, MemoryPermission map_perm);
+Result CloseHandle64From32(Core::System& system, Handle handle);
+Result ResetSignal64From32(Core::System& system, Handle handle);
+Result WaitSynchronization64From32(Core::System& system, int32_t* out_index, uint32_t handles, int32_t num_handles, int64_t timeout_ns);
+Result CancelSynchronization64From32(Core::System& system, Handle handle);
+Result ArbitrateLock64From32(Core::System& system, Handle thread_handle, uint32_t address, uint32_t tag);
+Result ArbitrateUnlock64From32(Core::System& system, uint32_t address);
+Result WaitProcessWideKeyAtomic64From32(Core::System& system, uint32_t address, uint32_t cv_key, uint32_t tag, int64_t timeout_ns);
+void SignalProcessWideKey64From32(Core::System& system, uint32_t cv_key, int32_t count);
+int64_t GetSystemTick64From32(Core::System& system);
+Result ConnectToNamedPort64From32(Core::System& system, Handle* out_handle, uint32_t name);
+Result SendSyncRequest64From32(Core::System& system, Handle session_handle);
+Result SendSyncRequestWithUserBuffer64From32(Core::System& system, uint32_t message_buffer, uint32_t message_buffer_size, Handle session_handle);
+Result SendAsyncRequestWithUserBuffer64From32(Core::System& system, Handle* out_event_handle, uint32_t message_buffer, uint32_t message_buffer_size, Handle session_handle);
+Result GetProcessId64From32(Core::System& system, uint64_t* out_process_id, Handle process_handle);
+Result GetThreadId64From32(Core::System& system, uint64_t* out_thread_id, Handle thread_handle);
+void Break64From32(Core::System& system, BreakReason break_reason, uint32_t arg, uint32_t size);
+Result OutputDebugString64From32(Core::System& system, uint32_t debug_str, uint32_t len);
+void ReturnFromException64From32(Core::System& system, Result result);
+Result GetInfo64From32(Core::System& system, uint64_t* out, InfoType info_type, Handle handle, uint64_t info_subtype);
+void FlushEntireDataCache64From32(Core::System& system);
+Result FlushDataCache64From32(Core::System& system, uint32_t address, uint32_t size);
+Result MapPhysicalMemory64From32(Core::System& system, uint32_t address, uint32_t size);
+Result UnmapPhysicalMemory64From32(Core::System& system, uint32_t address, uint32_t size);
+Result GetDebugFutureThreadInfo64From32(Core::System& system, ilp32::LastThreadContext* out_context, uint64_t* out_thread_id, Handle debug_handle, int64_t ns);
+Result GetLastThreadInfo64From32(Core::System& system, ilp32::LastThreadContext* out_context, uintptr_t* out_tls_address, uint32_t* out_flags);
+Result GetResourceLimitLimitValue64From32(Core::System& system, int64_t* out_limit_value, Handle resource_limit_handle, LimitableResource which);
+Result GetResourceLimitCurrentValue64From32(Core::System& system, int64_t* out_current_value, Handle resource_limit_handle, LimitableResource which);
+Result SetThreadActivity64From32(Core::System& system, Handle thread_handle, ThreadActivity thread_activity);
+Result GetThreadContext364From32(Core::System& system, uint32_t out_context, Handle thread_handle);
+Result WaitForAddress64From32(Core::System& system, uint32_t address, ArbitrationType arb_type, int32_t value, int64_t timeout_ns);
+Result SignalToAddress64From32(Core::System& system, uint32_t address, SignalType signal_type, int32_t value, int32_t count);
+void SynchronizePreemptionState64From32(Core::System& system);
+Result GetResourceLimitPeakValue64From32(Core::System& system, int64_t* out_peak_value, Handle resource_limit_handle, LimitableResource which);
+Result CreateIoPool64From32(Core::System& system, Handle* out_handle, IoPoolType which);
+Result CreateIoRegion64From32(Core::System& system, Handle* out_handle, Handle io_pool, uint64_t physical_address, uint32_t size, MemoryMapping mapping, MemoryPermission perm);
+void KernelDebug64From32(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2);
+void ChangeKernelTraceState64From32(Core::System& system, KernelTraceState kern_trace_state);
+Result CreateSession64From32(Core::System& system, Handle* out_server_session_handle, Handle* out_client_session_handle, bool is_light, uint32_t name);
+Result AcceptSession64From32(Core::System& system, Handle* out_handle, Handle port);
+Result ReplyAndReceive64From32(Core::System& system, int32_t* out_index, uint32_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
+Result ReplyAndReceiveWithUserBuffer64From32(Core::System& system, int32_t* out_index, uint32_t message_buffer, uint32_t message_buffer_size, uint32_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
+Result CreateEvent64From32(Core::System& system, Handle* out_write_handle, Handle* out_read_handle);
+Result MapIoRegion64From32(Core::System& system, Handle io_region, uint32_t address, uint32_t size, MemoryPermission perm);
+Result UnmapIoRegion64From32(Core::System& system, Handle io_region, uint32_t address, uint32_t size);
+Result MapPhysicalMemoryUnsafe64From32(Core::System& system, uint32_t address, uint32_t size);
+Result UnmapPhysicalMemoryUnsafe64From32(Core::System& system, uint32_t address, uint32_t size);
+Result SetUnsafeLimit64From32(Core::System& system, uint32_t limit);
+Result CreateCodeMemory64From32(Core::System& system, Handle* out_handle, uint32_t address, uint32_t size);
+Result ControlCodeMemory64From32(Core::System& system, Handle code_memory_handle, CodeMemoryOperation operation, uint64_t address, uint64_t size, MemoryPermission perm);
+void SleepSystem64From32(Core::System& system);
+Result ReadWriteRegister64From32(Core::System& system, uint32_t* out_value, uint64_t address, uint32_t mask, uint32_t value);
+Result SetProcessActivity64From32(Core::System& system, Handle process_handle, ProcessActivity process_activity);
+Result CreateSharedMemory64From32(Core::System& system, Handle* out_handle, uint32_t size, MemoryPermission owner_perm, MemoryPermission remote_perm);
+Result MapTransferMemory64From32(Core::System& system, Handle trmem_handle, uint32_t address, uint32_t size, MemoryPermission owner_perm);
+Result UnmapTransferMemory64From32(Core::System& system, Handle trmem_handle, uint32_t address, uint32_t size);
+Result CreateInterruptEvent64From32(Core::System& system, Handle* out_read_handle, int32_t interrupt_id, InterruptType interrupt_type);
+Result QueryPhysicalAddress64From32(Core::System& system, ilp32::PhysicalMemoryInfo* out_info, uint32_t address);
+Result QueryIoMapping64From32(Core::System& system, uintptr_t* out_address, uintptr_t* out_size, uint64_t physical_address, uint32_t size);
+Result CreateDeviceAddressSpace64From32(Core::System& system, Handle* out_handle, uint64_t das_address, uint64_t das_size);
+Result AttachDeviceAddressSpace64From32(Core::System& system, DeviceName device_name, Handle das_handle);
+Result DetachDeviceAddressSpace64From32(Core::System& system, DeviceName device_name, Handle das_handle);
+Result MapDeviceAddressSpaceByForce64From32(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint32_t size, uint64_t device_address, uint32_t option);
+Result MapDeviceAddressSpaceAligned64From32(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint32_t size, uint64_t device_address, uint32_t option);
+Result UnmapDeviceAddressSpace64From32(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint32_t size, uint64_t device_address);
+Result InvalidateProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result StoreProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result FlushProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result DebugActiveProcess64From32(Core::System& system, Handle* out_handle, uint64_t process_id);
+Result BreakDebugProcess64From32(Core::System& system, Handle debug_handle);
+Result TerminateDebugProcess64From32(Core::System& system, Handle debug_handle);
+Result GetDebugEvent64From32(Core::System& system, uint32_t out_info, Handle debug_handle);
+Result ContinueDebugEvent64From32(Core::System& system, Handle debug_handle, uint32_t flags, uint32_t thread_ids, int32_t num_thread_ids);
+Result GetProcessList64From32(Core::System& system, int32_t* out_num_processes, uint32_t out_process_ids, int32_t max_out_count);
+Result GetThreadList64From32(Core::System& system, int32_t* out_num_threads, uint32_t out_thread_ids, int32_t max_out_count, Handle debug_handle);
+Result GetDebugThreadContext64From32(Core::System& system, uint32_t out_context, Handle debug_handle, uint64_t thread_id, uint32_t context_flags);
+Result SetDebugThreadContext64From32(Core::System& system, Handle debug_handle, uint64_t thread_id, uint32_t context, uint32_t context_flags);
+Result QueryDebugProcessMemory64From32(Core::System& system, uint32_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint32_t address);
+Result ReadDebugProcessMemory64From32(Core::System& system, uint32_t buffer, Handle debug_handle, uint32_t address, uint32_t size);
+Result WriteDebugProcessMemory64From32(Core::System& system, Handle debug_handle, uint32_t buffer, uint32_t address, uint32_t size);
+Result SetHardwareBreakPoint64From32(Core::System& system, HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value);
+Result GetDebugThreadParam64From32(Core::System& system, uint64_t* out_64, uint32_t* out_32, Handle debug_handle, uint64_t thread_id, DebugThreadParam param);
+Result GetSystemInfo64From32(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle, uint64_t info_subtype);
+Result CreatePort64From32(Core::System& system, Handle* out_server_handle, Handle* out_client_handle, int32_t max_sessions, bool is_light, uint32_t name);
+Result ManageNamedPort64From32(Core::System& system, Handle* out_server_handle, uint32_t name, int32_t max_sessions);
+Result ConnectToPort64From32(Core::System& system, Handle* out_handle, Handle port);
+Result SetProcessMemoryPermission64From32(Core::System& system, Handle process_handle, uint64_t address, uint64_t size, MemoryPermission perm);
+Result MapProcessMemory64From32(Core::System& system, uint32_t dst_address, Handle process_handle, uint64_t src_address, uint32_t size);
+Result UnmapProcessMemory64From32(Core::System& system, uint32_t dst_address, Handle process_handle, uint64_t src_address, uint32_t size);
+Result QueryProcessMemory64From32(Core::System& system, uint32_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
+Result MapProcessCodeMemory64From32(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result UnmapProcessCodeMemory64From32(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result CreateProcess64From32(Core::System& system, Handle* out_handle, uint32_t parameters, uint32_t caps, int32_t num_caps);
+Result StartProcess64From32(Core::System& system, Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size);
+Result TerminateProcess64From32(Core::System& system, Handle process_handle);
+Result GetProcessInfo64From32(Core::System& system, int64_t* out_info, Handle process_handle, ProcessInfoType info_type);
+Result CreateResourceLimit64From32(Core::System& system, Handle* out_handle);
+Result SetResourceLimitLimitValue64From32(Core::System& system, Handle resource_limit_handle, LimitableResource which, int64_t limit_value);
+Result MapInsecureMemory64From32(Core::System& system, uint32_t address, uint32_t size);
+Result UnmapInsecureMemory64From32(Core::System& system, uint32_t address, uint32_t size);
+
+Result SetHeapSize64(Core::System& system, uintptr_t* out_address, uint64_t size);
+Result SetMemoryPermission64(Core::System& system, uint64_t address, uint64_t size, MemoryPermission perm);
+Result SetMemoryAttribute64(Core::System& system, uint64_t address, uint64_t size, uint32_t mask, uint32_t attr);
+Result MapMemory64(Core::System& system, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result UnmapMemory64(Core::System& system, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result QueryMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, uint64_t address);
+void ExitProcess64(Core::System& system);
+Result CreateThread64(Core::System& system, Handle* out_handle, uint64_t func, uint64_t arg, uint64_t stack_bottom, int32_t priority, int32_t core_id);
+Result StartThread64(Core::System& system, Handle thread_handle);
+void ExitThread64(Core::System& system);
+void SleepThread64(Core::System& system, int64_t ns);
+Result GetThreadPriority64(Core::System& system, int32_t* out_priority, Handle thread_handle);
+Result SetThreadPriority64(Core::System& system, Handle thread_handle, int32_t priority);
+Result GetThreadCoreMask64(Core::System& system, int32_t* out_core_id, uint64_t* out_affinity_mask, Handle thread_handle);
+Result SetThreadCoreMask64(Core::System& system, Handle thread_handle, int32_t core_id, uint64_t affinity_mask);
+int32_t GetCurrentProcessorNumber64(Core::System& system);
+Result SignalEvent64(Core::System& system, Handle event_handle);
+Result ClearEvent64(Core::System& system, Handle event_handle);
+Result MapSharedMemory64(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size, MemoryPermission map_perm);
+Result UnmapSharedMemory64(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size);
+Result CreateTransferMemory64(Core::System& system, Handle* out_handle, uint64_t address, uint64_t size, MemoryPermission map_perm);
+Result CloseHandle64(Core::System& system, Handle handle);
+Result ResetSignal64(Core::System& system, Handle handle);
+Result WaitSynchronization64(Core::System& system, int32_t* out_index, uint64_t handles, int32_t num_handles, int64_t timeout_ns);
+Result CancelSynchronization64(Core::System& system, Handle handle);
+Result ArbitrateLock64(Core::System& system, Handle thread_handle, uint64_t address, uint32_t tag);
+Result ArbitrateUnlock64(Core::System& system, uint64_t address);
+Result WaitProcessWideKeyAtomic64(Core::System& system, uint64_t address, uint64_t cv_key, uint32_t tag, int64_t timeout_ns);
+void SignalProcessWideKey64(Core::System& system, uint64_t cv_key, int32_t count);
+int64_t GetSystemTick64(Core::System& system);
+Result ConnectToNamedPort64(Core::System& system, Handle* out_handle, uint64_t name);
+Result SendSyncRequest64(Core::System& system, Handle session_handle);
+Result SendSyncRequestWithUserBuffer64(Core::System& system, uint64_t message_buffer, uint64_t message_buffer_size, Handle session_handle);
+Result SendAsyncRequestWithUserBuffer64(Core::System& system, Handle* out_event_handle, uint64_t message_buffer, uint64_t message_buffer_size, Handle session_handle);
+Result GetProcessId64(Core::System& system, uint64_t* out_process_id, Handle process_handle);
+Result GetThreadId64(Core::System& system, uint64_t* out_thread_id, Handle thread_handle);
+void Break64(Core::System& system, BreakReason break_reason, uint64_t arg, uint64_t size);
+Result OutputDebugString64(Core::System& system, uint64_t debug_str, uint64_t len);
+void ReturnFromException64(Core::System& system, Result result);
+Result GetInfo64(Core::System& system, uint64_t* out, InfoType info_type, Handle handle, uint64_t info_subtype);
+void FlushEntireDataCache64(Core::System& system);
+Result FlushDataCache64(Core::System& system, uint64_t address, uint64_t size);
+Result MapPhysicalMemory64(Core::System& system, uint64_t address, uint64_t size);
+Result UnmapPhysicalMemory64(Core::System& system, uint64_t address, uint64_t size);
+Result GetDebugFutureThreadInfo64(Core::System& system, lp64::LastThreadContext* out_context, uint64_t* out_thread_id, Handle debug_handle, int64_t ns);
+Result GetLastThreadInfo64(Core::System& system, lp64::LastThreadContext* out_context, uintptr_t* out_tls_address, uint32_t* out_flags);
+Result GetResourceLimitLimitValue64(Core::System& system, int64_t* out_limit_value, Handle resource_limit_handle, LimitableResource which);
+Result GetResourceLimitCurrentValue64(Core::System& system, int64_t* out_current_value, Handle resource_limit_handle, LimitableResource which);
+Result SetThreadActivity64(Core::System& system, Handle thread_handle, ThreadActivity thread_activity);
+Result GetThreadContext364(Core::System& system, uint64_t out_context, Handle thread_handle);
+Result WaitForAddress64(Core::System& system, uint64_t address, ArbitrationType arb_type, int32_t value, int64_t timeout_ns);
+Result SignalToAddress64(Core::System& system, uint64_t address, SignalType signal_type, int32_t value, int32_t count);
+void SynchronizePreemptionState64(Core::System& system);
+Result GetResourceLimitPeakValue64(Core::System& system, int64_t* out_peak_value, Handle resource_limit_handle, LimitableResource which);
+Result CreateIoPool64(Core::System& system, Handle* out_handle, IoPoolType which);
+Result CreateIoRegion64(Core::System& system, Handle* out_handle, Handle io_pool, uint64_t physical_address, uint64_t size, MemoryMapping mapping, MemoryPermission perm);
+void KernelDebug64(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2);
+void ChangeKernelTraceState64(Core::System& system, KernelTraceState kern_trace_state);
+Result CreateSession64(Core::System& system, Handle* out_server_session_handle, Handle* out_client_session_handle, bool is_light, uint64_t name);
+Result AcceptSession64(Core::System& system, Handle* out_handle, Handle port);
+Result ReplyAndReceive64(Core::System& system, int32_t* out_index, uint64_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
+Result ReplyAndReceiveWithUserBuffer64(Core::System& system, int32_t* out_index, uint64_t message_buffer, uint64_t message_buffer_size, uint64_t handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);
+Result CreateEvent64(Core::System& system, Handle* out_write_handle, Handle* out_read_handle);
+Result MapIoRegion64(Core::System& system, Handle io_region, uint64_t address, uint64_t size, MemoryPermission perm);
+Result UnmapIoRegion64(Core::System& system, Handle io_region, uint64_t address, uint64_t size);
+Result MapPhysicalMemoryUnsafe64(Core::System& system, uint64_t address, uint64_t size);
+Result UnmapPhysicalMemoryUnsafe64(Core::System& system, uint64_t address, uint64_t size);
+Result SetUnsafeLimit64(Core::System& system, uint64_t limit);
+Result CreateCodeMemory64(Core::System& system, Handle* out_handle, uint64_t address, uint64_t size);
+Result ControlCodeMemory64(Core::System& system, Handle code_memory_handle, CodeMemoryOperation operation, uint64_t address, uint64_t size, MemoryPermission perm);
+void SleepSystem64(Core::System& system);
+Result ReadWriteRegister64(Core::System& system, uint32_t* out_value, uint64_t address, uint32_t mask, uint32_t value);
+Result SetProcessActivity64(Core::System& system, Handle process_handle, ProcessActivity process_activity);
+Result CreateSharedMemory64(Core::System& system, Handle* out_handle, uint64_t size, MemoryPermission owner_perm, MemoryPermission remote_perm);
+Result MapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size, MemoryPermission owner_perm);
+Result UnmapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size);
+Result CreateInterruptEvent64(Core::System& system, Handle* out_read_handle, int32_t interrupt_id, InterruptType interrupt_type);
+Result QueryPhysicalAddress64(Core::System& system, lp64::PhysicalMemoryInfo* out_info, uint64_t address);
+Result QueryIoMapping64(Core::System& system, uintptr_t* out_address, uintptr_t* out_size, uint64_t physical_address, uint64_t size);
+Result CreateDeviceAddressSpace64(Core::System& system, Handle* out_handle, uint64_t das_address, uint64_t das_size);
+Result AttachDeviceAddressSpace64(Core::System& system, DeviceName device_name, Handle das_handle);
+Result DetachDeviceAddressSpace64(Core::System& system, DeviceName device_name, Handle das_handle);
+Result MapDeviceAddressSpaceByForce64(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address, uint32_t option);
+Result MapDeviceAddressSpaceAligned64(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address, uint32_t option);
+Result UnmapDeviceAddressSpace64(Core::System& system, Handle das_handle, Handle process_handle, uint64_t process_address, uint64_t size, uint64_t device_address);
+Result InvalidateProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result StoreProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result FlushProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address, uint64_t size);
+Result DebugActiveProcess64(Core::System& system, Handle* out_handle, uint64_t process_id);
+Result BreakDebugProcess64(Core::System& system, Handle debug_handle);
+Result TerminateDebugProcess64(Core::System& system, Handle debug_handle);
+Result GetDebugEvent64(Core::System& system, uint64_t out_info, Handle debug_handle);
+Result ContinueDebugEvent64(Core::System& system, Handle debug_handle, uint32_t flags, uint64_t thread_ids, int32_t num_thread_ids);
+Result GetProcessList64(Core::System& system, int32_t* out_num_processes, uint64_t out_process_ids, int32_t max_out_count);
+Result GetThreadList64(Core::System& system, int32_t* out_num_threads, uint64_t out_thread_ids, int32_t max_out_count, Handle debug_handle);
+Result GetDebugThreadContext64(Core::System& system, uint64_t out_context, Handle debug_handle, uint64_t thread_id, uint32_t context_flags);
+Result SetDebugThreadContext64(Core::System& system, Handle debug_handle, uint64_t thread_id, uint64_t context, uint32_t context_flags);
+Result QueryDebugProcessMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
+Result ReadDebugProcessMemory64(Core::System& system, uint64_t buffer, Handle debug_handle, uint64_t address, uint64_t size);
+Result WriteDebugProcessMemory64(Core::System& system, Handle debug_handle, uint64_t buffer, uint64_t address, uint64_t size);
+Result SetHardwareBreakPoint64(Core::System& system, HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value);
+Result GetDebugThreadParam64(Core::System& system, uint64_t* out_64, uint32_t* out_32, Handle debug_handle, uint64_t thread_id, DebugThreadParam param);
+Result GetSystemInfo64(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle, uint64_t info_subtype);
+Result CreatePort64(Core::System& system, Handle* out_server_handle, Handle* out_client_handle, int32_t max_sessions, bool is_light, uint64_t name);
+Result ManageNamedPort64(Core::System& system, Handle* out_server_handle, uint64_t name, int32_t max_sessions);
+Result ConnectToPort64(Core::System& system, Handle* out_handle, Handle port);
+Result SetProcessMemoryPermission64(Core::System& system, Handle process_handle, uint64_t address, uint64_t size, MemoryPermission perm);
+Result MapProcessMemory64(Core::System& system, uint64_t dst_address, Handle process_handle, uint64_t src_address, uint64_t size);
+Result UnmapProcessMemory64(Core::System& system, uint64_t dst_address, Handle process_handle, uint64_t src_address, uint64_t size);
+Result QueryProcessMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);
+Result MapProcessCodeMemory64(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result UnmapProcessCodeMemory64(Core::System& system, Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);
+Result CreateProcess64(Core::System& system, Handle* out_handle, uint64_t parameters, uint64_t caps, int32_t num_caps);
+Result StartProcess64(Core::System& system, Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size);
+Result TerminateProcess64(Core::System& system, Handle process_handle);
+Result GetProcessInfo64(Core::System& system, int64_t* out_info, Handle process_handle, ProcessInfoType info_type);
+Result CreateResourceLimit64(Core::System& system, Handle* out_handle);
+Result SetResourceLimitLimitValue64(Core::System& system, Handle resource_limit_handle, LimitableResource which, int64_t limit_value);
+Result MapInsecureMemory64(Core::System& system, uint64_t address, uint64_t size);
+Result UnmapInsecureMemory64(Core::System& system, uint64_t address, uint64_t size);
+
+enum class SvcId : u32 {
+    SetHeapSize = 0x1,
+    SetMemoryPermission = 0x2,
+    SetMemoryAttribute = 0x3,
+    MapMemory = 0x4,
+    UnmapMemory = 0x5,
+    QueryMemory = 0x6,
+    ExitProcess = 0x7,
+    CreateThread = 0x8,
+    StartThread = 0x9,
+    ExitThread = 0xa,
+    SleepThread = 0xb,
+    GetThreadPriority = 0xc,
+    SetThreadPriority = 0xd,
+    GetThreadCoreMask = 0xe,
+    SetThreadCoreMask = 0xf,
+    GetCurrentProcessorNumber = 0x10,
+    SignalEvent = 0x11,
+    ClearEvent = 0x12,
+    MapSharedMemory = 0x13,
+    UnmapSharedMemory = 0x14,
+    CreateTransferMemory = 0x15,
+    CloseHandle = 0x16,
+    ResetSignal = 0x17,
+    WaitSynchronization = 0x18,
+    CancelSynchronization = 0x19,
+    ArbitrateLock = 0x1a,
+    ArbitrateUnlock = 0x1b,
+    WaitProcessWideKeyAtomic = 0x1c,
+    SignalProcessWideKey = 0x1d,
+    GetSystemTick = 0x1e,
+    ConnectToNamedPort = 0x1f,
+    SendSyncRequestLight = 0x20,
+    SendSyncRequest = 0x21,
+    SendSyncRequestWithUserBuffer = 0x22,
+    SendAsyncRequestWithUserBuffer = 0x23,
+    GetProcessId = 0x24,
+    GetThreadId = 0x25,
+    Break = 0x26,
+    OutputDebugString = 0x27,
+    ReturnFromException = 0x28,
+    GetInfo = 0x29,
+    FlushEntireDataCache = 0x2a,
+    FlushDataCache = 0x2b,
+    MapPhysicalMemory = 0x2c,
+    UnmapPhysicalMemory = 0x2d,
+    GetDebugFutureThreadInfo = 0x2e,
+    GetLastThreadInfo = 0x2f,
+    GetResourceLimitLimitValue = 0x30,
+    GetResourceLimitCurrentValue = 0x31,
+    SetThreadActivity = 0x32,
+    GetThreadContext3 = 0x33,
+    WaitForAddress = 0x34,
+    SignalToAddress = 0x35,
+    SynchronizePreemptionState = 0x36,
+    GetResourceLimitPeakValue = 0x37,
+    CreateIoPool = 0x39,
+    CreateIoRegion = 0x3a,
+    KernelDebug = 0x3c,
+    ChangeKernelTraceState = 0x3d,
+    CreateSession = 0x40,
+    AcceptSession = 0x41,
+    ReplyAndReceiveLight = 0x42,
+    ReplyAndReceive = 0x43,
+    ReplyAndReceiveWithUserBuffer = 0x44,
+    CreateEvent = 0x45,
+    MapIoRegion = 0x46,
+    UnmapIoRegion = 0x47,
+    MapPhysicalMemoryUnsafe = 0x48,
+    UnmapPhysicalMemoryUnsafe = 0x49,
+    SetUnsafeLimit = 0x4a,
+    CreateCodeMemory = 0x4b,
+    ControlCodeMemory = 0x4c,
+    SleepSystem = 0x4d,
+    ReadWriteRegister = 0x4e,
+    SetProcessActivity = 0x4f,
+    CreateSharedMemory = 0x50,
+    MapTransferMemory = 0x51,
+    UnmapTransferMemory = 0x52,
+    CreateInterruptEvent = 0x53,
+    QueryPhysicalAddress = 0x54,
+    QueryIoMapping = 0x55,
+    CreateDeviceAddressSpace = 0x56,
+    AttachDeviceAddressSpace = 0x57,
+    DetachDeviceAddressSpace = 0x58,
+    MapDeviceAddressSpaceByForce = 0x59,
+    MapDeviceAddressSpaceAligned = 0x5a,
+    UnmapDeviceAddressSpace = 0x5c,
+    InvalidateProcessDataCache = 0x5d,
+    StoreProcessDataCache = 0x5e,
+    FlushProcessDataCache = 0x5f,
+    DebugActiveProcess = 0x60,
+    BreakDebugProcess = 0x61,
+    TerminateDebugProcess = 0x62,
+    GetDebugEvent = 0x63,
+    ContinueDebugEvent = 0x64,
+    GetProcessList = 0x65,
+    GetThreadList = 0x66,
+    GetDebugThreadContext = 0x67,
+    SetDebugThreadContext = 0x68,
+    QueryDebugProcessMemory = 0x69,
+    ReadDebugProcessMemory = 0x6a,
+    WriteDebugProcessMemory = 0x6b,
+    SetHardwareBreakPoint = 0x6c,
+    GetDebugThreadParam = 0x6d,
+    GetSystemInfo = 0x6f,
+    CreatePort = 0x70,
+    ManageNamedPort = 0x71,
+    ConnectToPort = 0x72,
+    SetProcessMemoryPermission = 0x73,
+    MapProcessMemory = 0x74,
+    UnmapProcessMemory = 0x75,
+    QueryProcessMemory = 0x76,
+    MapProcessCodeMemory = 0x77,
+    UnmapProcessCodeMemory = 0x78,
+    CreateProcess = 0x79,
+    StartProcess = 0x7a,
+    TerminateProcess = 0x7b,
+    GetProcessInfo = 0x7c,
+    CreateResourceLimit = 0x7d,
+    SetResourceLimitLimitValue = 0x7e,
+    CallSecureMonitor = 0x7f,
+    MapInsecureMemory = 0x90,
+    UnmapInsecureMemory = 0x91,
+};
+// clang-format on
+
+// Custom ABI.
+Result ReplyAndReceiveLight(Core::System& system, Handle handle, uint32_t* args);
+Result ReplyAndReceiveLight64From32(Core::System& system, Handle handle, uint32_t* args);
+Result ReplyAndReceiveLight64(Core::System& system, Handle handle, uint32_t* args);
+
+Result SendSyncRequestLight(Core::System& system, Handle session_handle, uint32_t* args);
+Result SendSyncRequestLight64From32(Core::System& system, Handle session_handle, uint32_t* args);
+Result SendSyncRequestLight64(Core::System& system, Handle session_handle, uint32_t* args);
+
+void CallSecureMonitor(Core::System& system, lp64::SecureMonitorArguments* args);
+void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArguments* args);
+void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args);
+
+// Defined in svc_light_ipc.cpp.
+void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system);
+void SvcWrap_ReplyAndReceiveLight64(Core::System& system);
+
+void SvcWrap_SendSyncRequestLight64From32(Core::System& system);
+void SvcWrap_SendSyncRequestLight64(Core::System& system);
+
+// Defined in svc_secure_monitor_call.cpp.
+void SvcWrap_CallSecureMonitor64From32(Core::System& system);
+void SvcWrap_CallSecureMonitor64(Core::System& system);
+
+// Perform a supervisor call by index.
+void Call(Core::System& system, u32 imm);
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_activity.cpp b/src/core/hle/kernel/svc/svc_activity.cpp
index 8774a5c98..63bc08555 100644
--- a/src/core/hle/kernel/svc/svc_activity.cpp
+++ b/src/core/hle/kernel/svc/svc_activity.cpp
@@ -16,18 +16,19 @@ Result SetThreadActivity(Core::System& system, Handle thread_handle,
               thread_activity);
 
     // Validate the activity.
-    constexpr auto IsValidThreadActivity = [](ThreadActivity activity) {
+    static constexpr auto IsValidThreadActivity = [](ThreadActivity activity) {
         return activity == ThreadActivity::Runnable || activity == ThreadActivity::Paused;
     };
     R_UNLESS(IsValidThreadActivity(thread_activity), ResultInvalidEnumValue);
 
     // Get the thread from its handle.
     KScopedAutoObject thread =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KThread>(thread_handle);
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Check that the activity is being set on a non-current thread for the current process.
-    R_UNLESS(thread->GetOwnerProcess() == system.Kernel().CurrentProcess(), ResultInvalidHandle);
+    R_UNLESS(thread->GetOwnerProcess() == GetCurrentProcessPointer(system.Kernel()),
+             ResultInvalidHandle);
     R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(system.Kernel()), ResultBusy);
 
     // Set the activity.
@@ -36,9 +37,30 @@ Result SetThreadActivity(Core::System& system, Handle thread_handle,
     return ResultSuccess;
 }
 
-Result SetThreadActivity32(Core::System& system, Handle thread_handle,
+Result SetProcessActivity(Core::System& system, Handle process_handle,
+                          ProcessActivity process_activity) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result SetThreadActivity64(Core::System& system, Handle thread_handle,
                            ThreadActivity thread_activity) {
     return SetThreadActivity(system, thread_handle, thread_activity);
 }
 
+Result SetProcessActivity64(Core::System& system, Handle process_handle,
+                            ProcessActivity process_activity) {
+    return SetProcessActivity(system, process_handle, process_activity);
+}
+
+Result SetThreadActivity64From32(Core::System& system, Handle thread_handle,
+                                 ThreadActivity thread_activity) {
+    return SetThreadActivity(system, thread_handle, thread_activity);
+}
+
+Result SetProcessActivity64From32(Core::System& system, Handle process_handle,
+                                  ProcessActivity process_activity) {
+    return SetProcessActivity(system, process_handle, process_activity);
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_address_arbiter.cpp b/src/core/hle/kernel/svc/svc_address_arbiter.cpp
index 842107726..998bd3f22 100644
--- a/src/core/hle/kernel/svc/svc_address_arbiter.cpp
+++ b/src/core/hle/kernel/svc/svc_address_arbiter.cpp
@@ -72,13 +72,7 @@ Result WaitForAddress(Core::System& system, VAddr address, ArbitrationType arb_t
         timeout = timeout_ns;
     }
 
-    return system.Kernel().CurrentProcess()->WaitAddressArbiter(address, arb_type, value, timeout);
-}
-
-Result WaitForAddress32(Core::System& system, u32 address, ArbitrationType arb_type, s32 value,
-                        u32 timeout_ns_low, u32 timeout_ns_high) {
-    const auto timeout = static_cast<s64>(timeout_ns_low | (u64{timeout_ns_high} << 32));
-    return WaitForAddress(system, address, arb_type, value, timeout);
+    return GetCurrentProcess(system.Kernel()).WaitAddressArbiter(address, arb_type, value, timeout);
 }
 
 // Signals to an address (via Address Arbiter)
@@ -101,13 +95,28 @@ Result SignalToAddress(Core::System& system, VAddr address, SignalType signal_ty
         return ResultInvalidEnumValue;
     }
 
-    return system.Kernel().CurrentProcess()->SignalAddressArbiter(address, signal_type, value,
-                                                                  count);
+    return GetCurrentProcess(system.Kernel())
+        .SignalAddressArbiter(address, signal_type, value, count);
 }
 
-Result SignalToAddress32(Core::System& system, u32 address, SignalType signal_type, s32 value,
+Result WaitForAddress64(Core::System& system, VAddr address, ArbitrationType arb_type, s32 value,
+                        s64 timeout_ns) {
+    return WaitForAddress(system, address, arb_type, value, timeout_ns);
+}
+
+Result SignalToAddress64(Core::System& system, VAddr address, SignalType signal_type, s32 value,
                          s32 count) {
     return SignalToAddress(system, address, signal_type, value, count);
 }
 
+Result WaitForAddress64From32(Core::System& system, u32 address, ArbitrationType arb_type,
+                              s32 value, s64 timeout_ns) {
+    return WaitForAddress(system, address, arb_type, value, timeout_ns);
+}
+
+Result SignalToAddress64From32(Core::System& system, u32 address, SignalType signal_type, s32 value,
+                               s32 count) {
+    return SignalToAddress(system, address, signal_type, value, count);
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_address_translation.cpp b/src/core/hle/kernel/svc/svc_address_translation.cpp
index 299e22ae6..c25e144cd 100644
--- a/src/core/hle/kernel/svc/svc_address_translation.cpp
+++ b/src/core/hle/kernel/svc/svc_address_translation.cpp
@@ -2,5 +2,49 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+Result QueryPhysicalAddress(Core::System& system, lp64::PhysicalMemoryInfo* out_info,
+                            uint64_t address) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result QueryIoMapping(Core::System& system, uintptr_t* out_address, uintptr_t* out_size,
+                      uint64_t physical_address, uint64_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result QueryPhysicalAddress64(Core::System& system, lp64::PhysicalMemoryInfo* out_info,
+                              uint64_t address) {
+    R_RETURN(QueryPhysicalAddress(system, out_info, address));
+}
+
+Result QueryIoMapping64(Core::System& system, uintptr_t* out_address, uintptr_t* out_size,
+                        uint64_t physical_address, uint64_t size) {
+    R_RETURN(QueryIoMapping(system, out_address, out_size, physical_address, size));
+}
+
+Result QueryPhysicalAddress64From32(Core::System& system, ilp32::PhysicalMemoryInfo* out_info,
+                                    uint32_t address) {
+    lp64::PhysicalMemoryInfo info{};
+    R_TRY(QueryPhysicalAddress(system, std::addressof(info), address));
+
+    *out_info = {
+        .physical_address = info.physical_address,
+        .virtual_address = static_cast<u32>(info.virtual_address),
+        .size = static_cast<u32>(info.size),
+    };
+    R_SUCCEED();
+}
+
+Result QueryIoMapping64From32(Core::System& system, uintptr_t* out_address, uintptr_t* out_size,
+                              uint64_t physical_address, uint32_t size) {
+    R_RETURN(QueryIoMapping(system, reinterpret_cast<uintptr_t*>(out_address),
+                            reinterpret_cast<uintptr_t*>(out_size), physical_address, size));
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_cache.cpp b/src/core/hle/kernel/svc/svc_cache.cpp
index 42167d35b..598b71da5 100644
--- a/src/core/hle/kernel/svc/svc_cache.cpp
+++ b/src/core/hle/kernel/svc/svc_cache.cpp
@@ -9,7 +9,28 @@
 
 namespace Kernel::Svc {
 
-Result FlushProcessDataCache32(Core::System& system, Handle process_handle, u64 address, u64 size) {
+void FlushEntireDataCache(Core::System& system) {
+    UNIMPLEMENTED();
+}
+
+Result FlushDataCache(Core::System& system, VAddr address, size_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result InvalidateProcessDataCache(Core::System& system, Handle process_handle, uint64_t address,
+                                  uint64_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result StoreProcessDataCache(Core::System& system, Handle process_handle, uint64_t address,
+                             uint64_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result FlushProcessDataCache(Core::System& system, Handle process_handle, u64 address, u64 size) {
     // Validate address/size.
     R_UNLESS(size > 0, ResultInvalidSize);
     R_UNLESS(address == static_cast<uintptr_t>(address), ResultInvalidCurrentMemory);
@@ -17,7 +38,7 @@ Result FlushProcessDataCache32(Core::System& system, Handle process_handle, u64
 
     // Get the process from its handle.
     KScopedAutoObject process =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KProcess>(process_handle);
     R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
 
     // Verify the region is within range.
@@ -28,4 +49,50 @@ Result FlushProcessDataCache32(Core::System& system, Handle process_handle, u64
     R_RETURN(system.Memory().FlushDataCache(*process, address, size));
 }
 
+void FlushEntireDataCache64(Core::System& system) {
+    FlushEntireDataCache(system);
+}
+
+Result FlushDataCache64(Core::System& system, VAddr address, size_t size) {
+    R_RETURN(FlushDataCache(system, address, size));
+}
+
+Result InvalidateProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address,
+                                    uint64_t size) {
+    R_RETURN(InvalidateProcessDataCache(system, process_handle, address, size));
+}
+
+Result StoreProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address,
+                               uint64_t size) {
+    R_RETURN(StoreProcessDataCache(system, process_handle, address, size));
+}
+
+Result FlushProcessDataCache64(Core::System& system, Handle process_handle, uint64_t address,
+                               uint64_t size) {
+    R_RETURN(FlushProcessDataCache(system, process_handle, address, size));
+}
+
+void FlushEntireDataCache64From32(Core::System& system) {
+    return FlushEntireDataCache(system);
+}
+
+Result FlushDataCache64From32(Core::System& system, uint32_t address, uint32_t size) {
+    R_RETURN(FlushDataCache(system, address, size));
+}
+
+Result InvalidateProcessDataCache64From32(Core::System& system, Handle process_handle,
+                                          uint64_t address, uint64_t size) {
+    R_RETURN(InvalidateProcessDataCache(system, process_handle, address, size));
+}
+
+Result StoreProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address,
+                                     uint64_t size) {
+    R_RETURN(StoreProcessDataCache(system, process_handle, address, size));
+}
+
+Result FlushProcessDataCache64From32(Core::System& system, Handle process_handle, uint64_t address,
+                                     uint64_t size) {
+    R_RETURN(FlushProcessDataCache(system, process_handle, address, size));
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_code_memory.cpp b/src/core/hle/kernel/svc/svc_code_memory.cpp
index 4cb21e101..538ff1c71 100644
--- a/src/core/hle/kernel/svc/svc_code_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_code_memory.cpp
@@ -46,7 +46,7 @@ Result CreateCodeMemory(Core::System& system, Handle* out, VAddr address, size_t
     R_UNLESS(code_mem != nullptr, ResultOutOfResource);
 
     // Verify that the region is in range.
-    R_UNLESS(system.CurrentProcess()->PageTable().Contains(address, size),
+    R_UNLESS(GetCurrentProcess(system.Kernel()).PageTable().Contains(address, size),
              ResultInvalidCurrentMemory);
 
     // Initialize the code memory.
@@ -56,19 +56,16 @@ Result CreateCodeMemory(Core::System& system, Handle* out, VAddr address, size_t
     KCodeMemory::Register(kernel, code_mem);
 
     // Add the code memory to the handle table.
-    R_TRY(system.CurrentProcess()->GetHandleTable().Add(out, code_mem));
+    R_TRY(GetCurrentProcess(system.Kernel()).GetHandleTable().Add(out, code_mem));
 
     code_mem->Close();
 
     return ResultSuccess;
 }
 
-Result CreateCodeMemory32(Core::System& system, Handle* out, u32 address, u32 size) {
-    return CreateCodeMemory(system, out, address, size);
-}
-
-Result ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 operation,
-                         VAddr address, size_t size, MemoryPermission perm) {
+Result ControlCodeMemory(Core::System& system, Handle code_memory_handle,
+                         CodeMemoryOperation operation, VAddr address, size_t size,
+                         MemoryPermission perm) {
 
     LOG_TRACE(Kernel_SVC,
               "called, code_memory_handle=0x{:X}, operation=0x{:X}, address=0x{:X}, size=0x{:X}, "
@@ -82,20 +79,22 @@ Result ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 op
     R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
 
     // Get the code memory from its handle.
-    KScopedAutoObject code_mem =
-        system.CurrentProcess()->GetHandleTable().GetObject<KCodeMemory>(code_memory_handle);
+    KScopedAutoObject code_mem = GetCurrentProcess(system.Kernel())
+                                     .GetHandleTable()
+                                     .GetObject<KCodeMemory>(code_memory_handle);
     R_UNLESS(code_mem.IsNotNull(), ResultInvalidHandle);
 
     // NOTE: Here, Atmosphere extends the SVC to allow code memory operations on one's own process.
     // This enables homebrew usage of these SVCs for JIT.
 
     // Perform the operation.
-    switch (static_cast<CodeMemoryOperation>(operation)) {
+    switch (operation) {
     case CodeMemoryOperation::Map: {
         // Check that the region is in range.
-        R_UNLESS(
-            system.CurrentProcess()->PageTable().CanContain(address, size, KMemoryState::CodeOut),
-            ResultInvalidMemoryRegion);
+        R_UNLESS(GetCurrentProcess(system.Kernel())
+                     .PageTable()
+                     .CanContain(address, size, KMemoryState::CodeOut),
+                 ResultInvalidMemoryRegion);
 
         // Check the memory permission.
         R_UNLESS(IsValidMapCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
@@ -105,9 +104,10 @@ Result ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 op
     } break;
     case CodeMemoryOperation::Unmap: {
         // Check that the region is in range.
-        R_UNLESS(
-            system.CurrentProcess()->PageTable().CanContain(address, size, KMemoryState::CodeOut),
-            ResultInvalidMemoryRegion);
+        R_UNLESS(GetCurrentProcess(system.Kernel())
+                     .PageTable()
+                     .CanContain(address, size, KMemoryState::CodeOut),
+                 ResultInvalidMemoryRegion);
 
         // Check the memory permission.
         R_UNLESS(IsValidUnmapCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
@@ -146,9 +146,26 @@ Result ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 op
     return ResultSuccess;
 }
 
-Result ControlCodeMemory32(Core::System& system, Handle code_memory_handle, u32 operation,
-                           u64 address, u64 size, MemoryPermission perm) {
-    return ControlCodeMemory(system, code_memory_handle, operation, address, size, perm);
+Result CreateCodeMemory64(Core::System& system, Handle* out_handle, uint64_t address,
+                          uint64_t size) {
+    R_RETURN(CreateCodeMemory(system, out_handle, address, size));
+}
+
+Result ControlCodeMemory64(Core::System& system, Handle code_memory_handle,
+                           CodeMemoryOperation operation, uint64_t address, uint64_t size,
+                           MemoryPermission perm) {
+    R_RETURN(ControlCodeMemory(system, code_memory_handle, operation, address, size, perm));
+}
+
+Result CreateCodeMemory64From32(Core::System& system, Handle* out_handle, uint32_t address,
+                                uint32_t size) {
+    R_RETURN(CreateCodeMemory(system, out_handle, address, size));
+}
+
+Result ControlCodeMemory64From32(Core::System& system, Handle code_memory_handle,
+                                 CodeMemoryOperation operation, uint64_t address, uint64_t size,
+                                 MemoryPermission perm) {
+    R_RETURN(ControlCodeMemory(system, code_memory_handle, operation, address, size, perm));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_condition_variable.cpp b/src/core/hle/kernel/svc/svc_condition_variable.cpp
index d6cfc87c5..8ad1a0b8f 100644
--- a/src/core/hle/kernel/svc/svc_condition_variable.cpp
+++ b/src/core/hle/kernel/svc/svc_condition_variable.cpp
@@ -43,14 +43,8 @@ Result WaitProcessWideKeyAtomic(Core::System& system, VAddr address, VAddr cv_ke
     }
 
     // Wait on the condition variable.
-    return system.Kernel().CurrentProcess()->WaitConditionVariable(
-        address, Common::AlignDown(cv_key, sizeof(u32)), tag, timeout);
-}
-
-Result WaitProcessWideKeyAtomic32(Core::System& system, u32 address, u32 cv_key, u32 tag,
-                                  u32 timeout_ns_low, u32 timeout_ns_high) {
-    const auto timeout_ns = static_cast<s64>(timeout_ns_low | (u64{timeout_ns_high} << 32));
-    return WaitProcessWideKeyAtomic(system, address, cv_key, tag, timeout_ns);
+    return GetCurrentProcess(system.Kernel())
+        .WaitConditionVariable(address, Common::AlignDown(cv_key, sizeof(u32)), tag, timeout);
 }
 
 /// Signal process wide key
@@ -58,11 +52,25 @@ void SignalProcessWideKey(Core::System& system, VAddr cv_key, s32 count) {
     LOG_TRACE(Kernel_SVC, "called, cv_key=0x{:X}, count=0x{:08X}", cv_key, count);
 
     // Signal the condition variable.
-    return system.Kernel().CurrentProcess()->SignalConditionVariable(
-        Common::AlignDown(cv_key, sizeof(u32)), count);
+    return GetCurrentProcess(system.Kernel())
+        .SignalConditionVariable(Common::AlignDown(cv_key, sizeof(u32)), count);
+}
+
+Result WaitProcessWideKeyAtomic64(Core::System& system, uint64_t address, uint64_t cv_key,
+                                  uint32_t tag, int64_t timeout_ns) {
+    R_RETURN(WaitProcessWideKeyAtomic(system, address, cv_key, tag, timeout_ns));
+}
+
+void SignalProcessWideKey64(Core::System& system, uint64_t cv_key, int32_t count) {
+    SignalProcessWideKey(system, cv_key, count);
+}
+
+Result WaitProcessWideKeyAtomic64From32(Core::System& system, uint32_t address, uint32_t cv_key,
+                                        uint32_t tag, int64_t timeout_ns) {
+    R_RETURN(WaitProcessWideKeyAtomic(system, address, cv_key, tag, timeout_ns));
 }
 
-void SignalProcessWideKey32(Core::System& system, u32 cv_key, s32 count) {
+void SignalProcessWideKey64From32(Core::System& system, uint32_t cv_key, int32_t count) {
     SignalProcessWideKey(system, cv_key, count);
 }
 
diff --git a/src/core/hle/kernel/svc/svc_debug.cpp b/src/core/hle/kernel/svc/svc_debug.cpp
index 299e22ae6..a14050fa7 100644
--- a/src/core/hle/kernel/svc/svc_debug.cpp
+++ b/src/core/hle/kernel/svc/svc_debug.cpp
@@ -2,5 +2,193 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+Result DebugActiveProcess(Core::System& system, Handle* out_handle, uint64_t process_id) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result BreakDebugProcess(Core::System& system, Handle debug_handle) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result TerminateDebugProcess(Core::System& system, Handle debug_handle) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result GetDebugEvent(Core::System& system, uint64_t out_info, Handle debug_handle) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result ContinueDebugEvent(Core::System& system, Handle debug_handle, uint32_t flags,
+                          uint64_t user_thread_ids, int32_t num_thread_ids) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result GetDebugThreadContext(Core::System& system, uint64_t out_context, Handle debug_handle,
+                             uint64_t thread_id, uint32_t context_flags) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result SetDebugThreadContext(Core::System& system, Handle debug_handle, uint64_t thread_id,
+                             uint64_t user_context, uint32_t context_flags) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result QueryDebugProcessMemory(Core::System& system, uint64_t out_memory_info,
+                               PageInfo* out_page_info, Handle debug_handle, uintptr_t address) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result ReadDebugProcessMemory(Core::System& system, uintptr_t buffer, Handle debug_handle,
+                              uintptr_t address, size_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result WriteDebugProcessMemory(Core::System& system, Handle debug_handle, uintptr_t buffer,
+                               uintptr_t address, size_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result SetHardwareBreakPoint(Core::System& system, HardwareBreakPointRegisterName name,
+                             uint64_t flags, uint64_t value) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result GetDebugThreadParam(Core::System& system, uint64_t* out_64, uint32_t* out_32,
+                           Handle debug_handle, uint64_t thread_id, DebugThreadParam param) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result DebugActiveProcess64(Core::System& system, Handle* out_handle, uint64_t process_id) {
+    R_RETURN(DebugActiveProcess(system, out_handle, process_id));
+}
+
+Result BreakDebugProcess64(Core::System& system, Handle debug_handle) {
+    R_RETURN(BreakDebugProcess(system, debug_handle));
+}
+
+Result TerminateDebugProcess64(Core::System& system, Handle debug_handle) {
+    R_RETURN(TerminateDebugProcess(system, debug_handle));
+}
+
+Result GetDebugEvent64(Core::System& system, uint64_t out_info, Handle debug_handle) {
+    R_RETURN(GetDebugEvent(system, out_info, debug_handle));
+}
+
+Result ContinueDebugEvent64(Core::System& system, Handle debug_handle, uint32_t flags,
+                            uint64_t thread_ids, int32_t num_thread_ids) {
+    R_RETURN(ContinueDebugEvent(system, debug_handle, flags, thread_ids, num_thread_ids));
+}
+
+Result GetDebugThreadContext64(Core::System& system, uint64_t out_context, Handle debug_handle,
+                               uint64_t thread_id, uint32_t context_flags) {
+    R_RETURN(GetDebugThreadContext(system, out_context, debug_handle, thread_id, context_flags));
+}
+
+Result SetDebugThreadContext64(Core::System& system, Handle debug_handle, uint64_t thread_id,
+                               uint64_t context, uint32_t context_flags) {
+    R_RETURN(SetDebugThreadContext(system, debug_handle, thread_id, context, context_flags));
+}
+
+Result QueryDebugProcessMemory64(Core::System& system, uint64_t out_memory_info,
+                                 PageInfo* out_page_info, Handle debug_handle, uint64_t address) {
+    R_RETURN(
+        QueryDebugProcessMemory(system, out_memory_info, out_page_info, debug_handle, address));
+}
+
+Result ReadDebugProcessMemory64(Core::System& system, uint64_t buffer, Handle debug_handle,
+                                uint64_t address, uint64_t size) {
+    R_RETURN(ReadDebugProcessMemory(system, buffer, debug_handle, address, size));
+}
+
+Result WriteDebugProcessMemory64(Core::System& system, Handle debug_handle, uint64_t buffer,
+                                 uint64_t address, uint64_t size) {
+    R_RETURN(WriteDebugProcessMemory(system, debug_handle, buffer, address, size));
+}
+
+Result SetHardwareBreakPoint64(Core::System& system, HardwareBreakPointRegisterName name,
+                               uint64_t flags, uint64_t value) {
+    R_RETURN(SetHardwareBreakPoint(system, name, flags, value));
+}
+
+Result GetDebugThreadParam64(Core::System& system, uint64_t* out_64, uint32_t* out_32,
+                             Handle debug_handle, uint64_t thread_id, DebugThreadParam param) {
+    R_RETURN(GetDebugThreadParam(system, out_64, out_32, debug_handle, thread_id, param));
+}
+
+Result DebugActiveProcess64From32(Core::System& system, Handle* out_handle, uint64_t process_id) {
+    R_RETURN(DebugActiveProcess(system, out_handle, process_id));
+}
+
+Result BreakDebugProcess64From32(Core::System& system, Handle debug_handle) {
+    R_RETURN(BreakDebugProcess(system, debug_handle));
+}
+
+Result TerminateDebugProcess64From32(Core::System& system, Handle debug_handle) {
+    R_RETURN(TerminateDebugProcess(system, debug_handle));
+}
+
+Result GetDebugEvent64From32(Core::System& system, uint32_t out_info, Handle debug_handle) {
+    R_RETURN(GetDebugEvent(system, out_info, debug_handle));
+}
+
+Result ContinueDebugEvent64From32(Core::System& system, Handle debug_handle, uint32_t flags,
+                                  uint32_t thread_ids, int32_t num_thread_ids) {
+    R_RETURN(ContinueDebugEvent(system, debug_handle, flags, thread_ids, num_thread_ids));
+}
+
+Result GetDebugThreadContext64From32(Core::System& system, uint32_t out_context,
+                                     Handle debug_handle, uint64_t thread_id,
+                                     uint32_t context_flags) {
+    R_RETURN(GetDebugThreadContext(system, out_context, debug_handle, thread_id, context_flags));
+}
+
+Result SetDebugThreadContext64From32(Core::System& system, Handle debug_handle, uint64_t thread_id,
+                                     uint32_t context, uint32_t context_flags) {
+    R_RETURN(SetDebugThreadContext(system, debug_handle, thread_id, context, context_flags));
+}
+
+Result QueryDebugProcessMemory64From32(Core::System& system, uint32_t out_memory_info,
+                                       PageInfo* out_page_info, Handle debug_handle,
+                                       uint32_t address) {
+    R_RETURN(
+        QueryDebugProcessMemory(system, out_memory_info, out_page_info, debug_handle, address));
+}
+
+Result ReadDebugProcessMemory64From32(Core::System& system, uint32_t buffer, Handle debug_handle,
+                                      uint32_t address, uint32_t size) {
+    R_RETURN(ReadDebugProcessMemory(system, buffer, debug_handle, address, size));
+}
+
+Result WriteDebugProcessMemory64From32(Core::System& system, Handle debug_handle, uint32_t buffer,
+                                       uint32_t address, uint32_t size) {
+    R_RETURN(WriteDebugProcessMemory(system, debug_handle, buffer, address, size));
+}
+
+Result SetHardwareBreakPoint64From32(Core::System& system, HardwareBreakPointRegisterName name,
+                                     uint64_t flags, uint64_t value) {
+    R_RETURN(SetHardwareBreakPoint(system, name, flags, value));
+}
+
+Result GetDebugThreadParam64From32(Core::System& system, uint64_t* out_64, uint32_t* out_32,
+                                   Handle debug_handle, uint64_t thread_id,
+                                   DebugThreadParam param) {
+    R_RETURN(GetDebugThreadParam(system, out_64, out_32, debug_handle, thread_id, param));
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_debug_string.cpp b/src/core/hle/kernel/svc/svc_debug_string.cpp
index 486e62cc4..d4bf062d1 100644
--- a/src/core/hle/kernel/svc/svc_debug_string.cpp
+++ b/src/core/hle/kernel/svc/svc_debug_string.cpp
@@ -8,18 +8,22 @@
 namespace Kernel::Svc {
 
 /// Used to output a message on a debug hardware unit - does nothing on a retail unit
-void OutputDebugString(Core::System& system, VAddr address, u64 len) {
-    if (len == 0) {
-        return;
-    }
+Result OutputDebugString(Core::System& system, VAddr address, u64 len) {
+    R_SUCCEED_IF(len == 0);
 
     std::string str(len, '\0');
     system.Memory().ReadBlock(address, str.data(), str.size());
     LOG_DEBUG(Debug_Emulated, "{}", str);
+
+    R_SUCCEED();
+}
+
+Result OutputDebugString64(Core::System& system, uint64_t debug_str, uint64_t len) {
+    R_RETURN(OutputDebugString(system, debug_str, len));
 }
 
-void OutputDebugString32(Core::System& system, u32 address, u32 len) {
-    OutputDebugString(system, address, len);
+Result OutputDebugString64From32(Core::System& system, uint32_t debug_str, uint32_t len) {
+    R_RETURN(OutputDebugString(system, debug_str, len));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_device_address_space.cpp b/src/core/hle/kernel/svc/svc_device_address_space.cpp
index 299e22ae6..f68c0e6a9 100644
--- a/src/core/hle/kernel/svc/svc_device_address_space.cpp
+++ b/src/core/hle/kernel/svc/svc_device_address_space.cpp
@@ -1,6 +1,258 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/alignment.h"
+#include "common/scope_exit.h"
+#include "core/core.h"
+#include "core/hle/kernel/k_device_address_space.h"
+#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/svc.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+constexpr inline u64 DeviceAddressSpaceAlignMask = (1ULL << 22) - 1;
+
+constexpr bool IsProcessAndDeviceAligned(uint64_t process_address, uint64_t device_address) {
+    return (process_address & DeviceAddressSpaceAlignMask) ==
+           (device_address & DeviceAddressSpaceAlignMask);
+}
+
+Result CreateDeviceAddressSpace(Core::System& system, Handle* out, uint64_t das_address,
+                                uint64_t das_size) {
+    // Validate input.
+    R_UNLESS(Common::IsAligned(das_address, PageSize), ResultInvalidMemoryRegion);
+    R_UNLESS(Common::IsAligned(das_size, PageSize), ResultInvalidMemoryRegion);
+    R_UNLESS(das_size > 0, ResultInvalidMemoryRegion);
+    R_UNLESS((das_address < das_address + das_size), ResultInvalidMemoryRegion);
+
+    // Create the device address space.
+    KDeviceAddressSpace* das = KDeviceAddressSpace::Create(system.Kernel());
+    R_UNLESS(das != nullptr, ResultOutOfResource);
+    SCOPE_EXIT({ das->Close(); });
+
+    // Initialize the device address space.
+    R_TRY(das->Initialize(das_address, das_size));
+
+    // Register the device address space.
+    KDeviceAddressSpace::Register(system.Kernel(), das);
+
+    // Add to the handle table.
+    R_TRY(GetCurrentProcess(system.Kernel()).GetHandleTable().Add(out, das));
+
+    R_SUCCEED();
+}
+
+Result AttachDeviceAddressSpace(Core::System& system, DeviceName device_name, Handle das_handle) {
+    // Get the device address space.
+    KScopedAutoObject das = GetCurrentProcess(system.Kernel())
+                                .GetHandleTable()
+                                .GetObject<KDeviceAddressSpace>(das_handle);
+    R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
+
+    // Attach.
+    R_RETURN(das->Attach(device_name));
+}
+
+Result DetachDeviceAddressSpace(Core::System& system, DeviceName device_name, Handle das_handle) {
+    // Get the device address space.
+    KScopedAutoObject das = GetCurrentProcess(system.Kernel())
+                                .GetHandleTable()
+                                .GetObject<KDeviceAddressSpace>(das_handle);
+    R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
+
+    // Detach.
+    R_RETURN(das->Detach(device_name));
+}
+
+constexpr bool IsValidDeviceMemoryPermission(MemoryPermission device_perm) {
+    switch (device_perm) {
+    case MemoryPermission::Read:
+    case MemoryPermission::Write:
+    case MemoryPermission::ReadWrite:
+        return true;
+    default:
+        return false;
+    }
+}
+
+Result MapDeviceAddressSpaceByForce(Core::System& system, Handle das_handle, Handle process_handle,
+                                    uint64_t process_address, size_t size, uint64_t device_address,
+                                    u32 option) {
+    // Decode the option.
+    const MapDeviceAddressSpaceOption option_pack{option};
+    const auto device_perm = option_pack.permission;
+    const auto reserved = option_pack.reserved;
+
+    // Validate input.
+    R_UNLESS(Common::IsAligned(process_address, PageSize), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(device_address, PageSize), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
+    R_UNLESS(size > 0, ResultInvalidSize);
+    R_UNLESS((process_address < process_address + size), ResultInvalidCurrentMemory);
+    R_UNLESS((device_address < device_address + size), ResultInvalidMemoryRegion);
+    R_UNLESS((process_address == static_cast<uintptr_t>(process_address)),
+             ResultInvalidCurrentMemory);
+    R_UNLESS(IsValidDeviceMemoryPermission(device_perm), ResultInvalidNewMemoryPermission);
+    R_UNLESS(reserved == 0, ResultInvalidEnumValue);
+
+    // Get the device address space.
+    KScopedAutoObject das = GetCurrentProcess(system.Kernel())
+                                .GetHandleTable()
+                                .GetObject<KDeviceAddressSpace>(das_handle);
+    R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
+
+    // Get the process.
+    KScopedAutoObject process =
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KProcess>(process_handle);
+    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
+
+    // Validate that the process address is within range.
+    auto& page_table = process->PageTable();
+    R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);
+
+    // Map.
+    R_RETURN(
+        das->MapByForce(std::addressof(page_table), process_address, size, device_address, option));
+}
+
+Result MapDeviceAddressSpaceAligned(Core::System& system, Handle das_handle, Handle process_handle,
+                                    uint64_t process_address, size_t size, uint64_t device_address,
+                                    u32 option) {
+    // Decode the option.
+    const MapDeviceAddressSpaceOption option_pack{option};
+    const auto device_perm = option_pack.permission;
+    const auto reserved = option_pack.reserved;
+
+    // Validate input.
+    R_UNLESS(Common::IsAligned(process_address, PageSize), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(device_address, PageSize), ResultInvalidAddress);
+    R_UNLESS(IsProcessAndDeviceAligned(process_address, device_address), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
+    R_UNLESS(size > 0, ResultInvalidSize);
+    R_UNLESS((process_address < process_address + size), ResultInvalidCurrentMemory);
+    R_UNLESS((device_address < device_address + size), ResultInvalidMemoryRegion);
+    R_UNLESS((process_address == static_cast<uintptr_t>(process_address)),
+             ResultInvalidCurrentMemory);
+    R_UNLESS(IsValidDeviceMemoryPermission(device_perm), ResultInvalidNewMemoryPermission);
+    R_UNLESS(reserved == 0, ResultInvalidEnumValue);
+
+    // Get the device address space.
+    KScopedAutoObject das = GetCurrentProcess(system.Kernel())
+                                .GetHandleTable()
+                                .GetObject<KDeviceAddressSpace>(das_handle);
+    R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
+
+    // Get the process.
+    KScopedAutoObject process =
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KProcess>(process_handle);
+    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
+
+    // Validate that the process address is within range.
+    auto& page_table = process->PageTable();
+    R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);
+
+    // Map.
+    R_RETURN(
+        das->MapAligned(std::addressof(page_table), process_address, size, device_address, option));
+}
+
+Result UnmapDeviceAddressSpace(Core::System& system, Handle das_handle, Handle process_handle,
+                               uint64_t process_address, size_t size, uint64_t device_address) {
+    // Validate input.
+    R_UNLESS(Common::IsAligned(process_address, PageSize), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(device_address, PageSize), ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
+    R_UNLESS(size > 0, ResultInvalidSize);
+    R_UNLESS((process_address < process_address + size), ResultInvalidCurrentMemory);
+    R_UNLESS((device_address < device_address + size), ResultInvalidMemoryRegion);
+    R_UNLESS((process_address == static_cast<uintptr_t>(process_address)),
+             ResultInvalidCurrentMemory);
+
+    // Get the device address space.
+    KScopedAutoObject das = GetCurrentProcess(system.Kernel())
+                                .GetHandleTable()
+                                .GetObject<KDeviceAddressSpace>(das_handle);
+    R_UNLESS(das.IsNotNull(), ResultInvalidHandle);
+
+    // Get the process.
+    KScopedAutoObject process =
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KProcess>(process_handle);
+    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
+
+    // Validate that the process address is within range.
+    auto& page_table = process->PageTable();
+    R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);
+
+    R_RETURN(das->Unmap(std::addressof(page_table), process_address, size, device_address));
+}
+
+Result CreateDeviceAddressSpace64(Core::System& system, Handle* out_handle, uint64_t das_address,
+                                  uint64_t das_size) {
+    R_RETURN(CreateDeviceAddressSpace(system, out_handle, das_address, das_size));
+}
+
+Result AttachDeviceAddressSpace64(Core::System& system, DeviceName device_name, Handle das_handle) {
+    R_RETURN(AttachDeviceAddressSpace(system, device_name, das_handle));
+}
+
+Result DetachDeviceAddressSpace64(Core::System& system, DeviceName device_name, Handle das_handle) {
+    R_RETURN(DetachDeviceAddressSpace(system, device_name, das_handle));
+}
+
+Result MapDeviceAddressSpaceByForce64(Core::System& system, Handle das_handle,
+                                      Handle process_handle, uint64_t process_address,
+                                      uint64_t size, uint64_t device_address, u32 option) {
+    R_RETURN(MapDeviceAddressSpaceByForce(system, das_handle, process_handle, process_address, size,
+                                          device_address, option));
+}
+
+Result MapDeviceAddressSpaceAligned64(Core::System& system, Handle das_handle,
+                                      Handle process_handle, uint64_t process_address,
+                                      uint64_t size, uint64_t device_address, u32 option) {
+    R_RETURN(MapDeviceAddressSpaceAligned(system, das_handle, process_handle, process_address, size,
+                                          device_address, option));
+}
+
+Result UnmapDeviceAddressSpace64(Core::System& system, Handle das_handle, Handle process_handle,
+                                 uint64_t process_address, uint64_t size, uint64_t device_address) {
+    R_RETURN(UnmapDeviceAddressSpace(system, das_handle, process_handle, process_address, size,
+                                     device_address));
+}
+
+Result CreateDeviceAddressSpace64From32(Core::System& system, Handle* out_handle,
+                                        uint64_t das_address, uint64_t das_size) {
+    R_RETURN(CreateDeviceAddressSpace(system, out_handle, das_address, das_size));
+}
+
+Result AttachDeviceAddressSpace64From32(Core::System& system, DeviceName device_name,
+                                        Handle das_handle) {
+    R_RETURN(AttachDeviceAddressSpace(system, device_name, das_handle));
+}
+
+Result DetachDeviceAddressSpace64From32(Core::System& system, DeviceName device_name,
+                                        Handle das_handle) {
+    R_RETURN(DetachDeviceAddressSpace(system, device_name, das_handle));
+}
+
+Result MapDeviceAddressSpaceByForce64From32(Core::System& system, Handle das_handle,
+                                            Handle process_handle, uint64_t process_address,
+                                            uint32_t size, uint64_t device_address, u32 option) {
+    R_RETURN(MapDeviceAddressSpaceByForce(system, das_handle, process_handle, process_address, size,
+                                          device_address, option));
+}
+
+Result MapDeviceAddressSpaceAligned64From32(Core::System& system, Handle das_handle,
+                                            Handle process_handle, uint64_t process_address,
+                                            uint32_t size, uint64_t device_address, u32 option) {
+    R_RETURN(MapDeviceAddressSpaceAligned(system, das_handle, process_handle, process_address, size,
+                                          device_address, option));
+}
+
+Result UnmapDeviceAddressSpace64From32(Core::System& system, Handle das_handle,
+                                       Handle process_handle, uint64_t process_address,
+                                       uint32_t size, uint64_t device_address) {
+    R_RETURN(UnmapDeviceAddressSpace(system, das_handle, process_handle, process_address, size,
+                                     device_address));
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_event.cpp b/src/core/hle/kernel/svc/svc_event.cpp
index 885f02f50..a948493e8 100644
--- a/src/core/hle/kernel/svc/svc_event.cpp
+++ b/src/core/hle/kernel/svc/svc_event.cpp
@@ -15,7 +15,7 @@ Result SignalEvent(Core::System& system, Handle event_handle) {
     LOG_DEBUG(Kernel_SVC, "called, event_handle=0x{:08X}", event_handle);
 
     // Get the current handle table.
-    const KHandleTable& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
+    const KHandleTable& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
 
     // Get the event.
     KScopedAutoObject event = handle_table.GetObject<KEvent>(event_handle);
@@ -24,15 +24,11 @@ Result SignalEvent(Core::System& system, Handle event_handle) {
     return event->Signal();
 }
 
-Result SignalEvent32(Core::System& system, Handle event_handle) {
-    return SignalEvent(system, event_handle);
-}
-
 Result ClearEvent(Core::System& system, Handle event_handle) {
     LOG_TRACE(Kernel_SVC, "called, event_handle=0x{:08X}", event_handle);
 
     // Get the current handle table.
-    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
+    const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
 
     // Try to clear the writable event.
     {
@@ -55,19 +51,15 @@ Result ClearEvent(Core::System& system, Handle event_handle) {
     return ResultInvalidHandle;
 }
 
-Result ClearEvent32(Core::System& system, Handle event_handle) {
-    return ClearEvent(system, event_handle);
-}
-
 Result CreateEvent(Core::System& system, Handle* out_write, Handle* out_read) {
     LOG_DEBUG(Kernel_SVC, "called");
 
     // Get the kernel reference and handle table.
     auto& kernel = system.Kernel();
-    auto& handle_table = kernel.CurrentProcess()->GetHandleTable();
+    auto& handle_table = GetCurrentProcess(kernel).GetHandleTable();
 
     // Reserve a new event from the process resource limit
-    KScopedResourceReservation event_reservation(kernel.CurrentProcess(),
+    KScopedResourceReservation event_reservation(GetCurrentProcessPointer(kernel),
                                                  LimitableResource::EventCountMax);
     R_UNLESS(event_reservation.Succeeded(), ResultLimitReached);
 
@@ -76,7 +68,7 @@ Result CreateEvent(Core::System& system, Handle* out_write, Handle* out_read) {
     R_UNLESS(event != nullptr, ResultOutOfResource);
 
     // Initialize the event.
-    event->Initialize(kernel.CurrentProcess());
+    event->Initialize(GetCurrentProcessPointer(kernel));
 
     // Commit the thread reservation.
     event_reservation.Commit();
@@ -104,8 +96,29 @@ Result CreateEvent(Core::System& system, Handle* out_write, Handle* out_read) {
     return ResultSuccess;
 }
 
-Result CreateEvent32(Core::System& system, Handle* out_write, Handle* out_read) {
-    return CreateEvent(system, out_write, out_read);
+Result SignalEvent64(Core::System& system, Handle event_handle) {
+    R_RETURN(SignalEvent(system, event_handle));
+}
+
+Result ClearEvent64(Core::System& system, Handle event_handle) {
+    R_RETURN(ClearEvent(system, event_handle));
+}
+
+Result CreateEvent64(Core::System& system, Handle* out_write_handle, Handle* out_read_handle) {
+    R_RETURN(CreateEvent(system, out_write_handle, out_read_handle));
+}
+
+Result SignalEvent64From32(Core::System& system, Handle event_handle) {
+    R_RETURN(SignalEvent(system, event_handle));
+}
+
+Result ClearEvent64From32(Core::System& system, Handle event_handle) {
+    R_RETURN(ClearEvent(system, event_handle));
+}
+
+Result CreateEvent64From32(Core::System& system, Handle* out_write_handle,
+                           Handle* out_read_handle) {
+    R_RETURN(CreateEvent(system, out_write_handle, out_read_handle));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_exception.cpp b/src/core/hle/kernel/svc/svc_exception.cpp
index fb9f133c1..c2782908d 100644
--- a/src/core/hle/kernel/svc/svc_exception.cpp
+++ b/src/core/hle/kernel/svc/svc_exception.cpp
@@ -12,10 +12,10 @@
 namespace Kernel::Svc {
 
 /// Break program execution
-void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
+void Break(Core::System& system, BreakReason reason, u64 info1, u64 info2) {
     BreakReason break_reason =
-        static_cast<BreakReason>(reason & ~static_cast<u32>(BreakReason::NotificationOnlyFlag));
-    bool notification_only = (reason & static_cast<u32>(BreakReason::NotificationOnlyFlag)) != 0;
+        reason & static_cast<BreakReason>(~BreakReason::NotificationOnlyFlag);
+    bool notification_only = True(reason & BreakReason::NotificationOnlyFlag);
 
     bool has_dumped_buffer{};
     std::vector<u8> debug_buffer;
@@ -90,9 +90,9 @@ void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
         break;
     }
 
-    system.GetReporter().SaveSvcBreakReport(reason, notification_only, info1, info2,
-                                            has_dumped_buffer ? std::make_optional(debug_buffer)
-                                                              : std::nullopt);
+    system.GetReporter().SaveSvcBreakReport(
+        static_cast<u32>(reason), notification_only, info1, info2,
+        has_dumped_buffer ? std::make_optional(debug_buffer) : std::nullopt);
 
     if (!notification_only) {
         LOG_CRITICAL(
@@ -114,8 +114,24 @@ void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
     }
 }
 
-void Break32(Core::System& system, u32 reason, u32 info1, u32 info2) {
-    Break(system, reason, info1, info2);
+void ReturnFromException(Core::System& system, Result result) {
+    UNIMPLEMENTED();
+}
+
+void Break64(Core::System& system, BreakReason break_reason, uint64_t arg, uint64_t size) {
+    Break(system, break_reason, arg, size);
+}
+
+void Break64From32(Core::System& system, BreakReason break_reason, uint32_t arg, uint32_t size) {
+    Break(system, break_reason, arg, size);
+}
+
+void ReturnFromException64(Core::System& system, Result result) {
+    ReturnFromException(system, result);
+}
+
+void ReturnFromException64From32(Core::System& system, Result result) {
+    ReturnFromException(system, result);
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_info.cpp b/src/core/hle/kernel/svc/svc_info.cpp
index df5dd85a4..58dc47508 100644
--- a/src/core/hle/kernel/svc/svc_info.cpp
+++ b/src/core/hle/kernel/svc/svc_info.cpp
@@ -10,11 +10,12 @@
 namespace Kernel::Svc {
 
 /// Gets system/memory information for the current process
-Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle, u64 info_sub_id) {
-    LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
-              info_sub_id, handle);
+Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle handle,
+               u64 info_sub_id) {
+    LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}",
+              info_id_type, info_sub_id, handle);
 
-    const auto info_id_type = static_cast<InfoType>(info_id);
+    u32 info_id = static_cast<u32>(info_id_type);
 
     switch (info_id_type) {
     case InfoType::CoreMask:
@@ -43,7 +44,7 @@ Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle, u6
             return ResultInvalidEnumValue;
         }
 
-        const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
+        const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
         KScopedAutoObject process = handle_table.GetObject<KProcess>(handle);
         if (process.IsNull()) {
             LOG_ERROR(Kernel_SVC, "Process is not valid! info_id={}, info_sub_id={}, handle={:08X}",
@@ -153,7 +154,7 @@ Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle, u6
             return ResultInvalidCombination;
         }
 
-        KProcess* const current_process = system.Kernel().CurrentProcess();
+        KProcess* const current_process = GetCurrentProcessPointer(system.Kernel());
         KHandleTable& handle_table = current_process->GetHandleTable();
         const auto resource_limit = current_process->GetResourceLimit();
         if (!resource_limit) {
@@ -182,7 +183,7 @@ Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle, u6
             return ResultInvalidCombination;
         }
 
-        *result = system.Kernel().CurrentProcess()->GetRandomEntropy(info_sub_id);
+        *result = GetCurrentProcess(system.Kernel()).GetRandomEntropy(info_sub_id);
         return ResultSuccess;
 
     case InfoType::InitialProcessIdRange:
@@ -199,9 +200,9 @@ Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle, u6
             return ResultInvalidCombination;
         }
 
-        KScopedAutoObject thread =
-            system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(
-                static_cast<Handle>(handle));
+        KScopedAutoObject thread = GetCurrentProcess(system.Kernel())
+                                       .GetHandleTable()
+                                       .GetObject<KThread>(static_cast<Handle>(handle));
         if (thread.IsNull()) {
             LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
                       static_cast<Handle>(handle));
@@ -248,7 +249,7 @@ Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle, u6
         R_UNLESS(info_sub_id == 0, ResultInvalidCombination);
 
         // Get the handle table.
-        KProcess* current_process = system.Kernel().CurrentProcess();
+        KProcess* current_process = GetCurrentProcessPointer(system.Kernel());
         KHandleTable& handle_table = current_process->GetHandleTable();
 
         // Get a new handle for the current process.
@@ -267,16 +268,30 @@ Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle, u6
     }
 }
 
-Result GetInfo32(Core::System& system, u32* result_low, u32* result_high, u32 sub_id_low,
-                 u32 info_id, u32 handle, u32 sub_id_high) {
-    const u64 sub_id{u64{sub_id_low} | (u64{sub_id_high} << 32)};
-    u64 res_value{};
+Result GetSystemInfo(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle,
+                     uint64_t info_subtype) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result GetInfo64(Core::System& system, uint64_t* out, InfoType info_type, Handle handle,
+                 uint64_t info_subtype) {
+    R_RETURN(GetInfo(system, out, info_type, handle, info_subtype));
+}
 
-    const Result result{GetInfo(system, &res_value, info_id, handle, sub_id)};
-    *result_high = static_cast<u32>(res_value >> 32);
-    *result_low = static_cast<u32>(res_value & std::numeric_limits<u32>::max());
+Result GetSystemInfo64(Core::System& system, uint64_t* out, SystemInfoType info_type, Handle handle,
+                       uint64_t info_subtype) {
+    R_RETURN(GetSystemInfo(system, out, info_type, handle, info_subtype));
+}
+
+Result GetInfo64From32(Core::System& system, uint64_t* out, InfoType info_type, Handle handle,
+                       uint64_t info_subtype) {
+    R_RETURN(GetInfo(system, out, info_type, handle, info_subtype));
+}
 
-    return result;
+Result GetSystemInfo64From32(Core::System& system, uint64_t* out, SystemInfoType info_type,
+                             Handle handle, uint64_t info_subtype) {
+    R_RETURN(GetSystemInfo(system, out, info_type, handle, info_subtype));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_insecure_memory.cpp b/src/core/hle/kernel/svc/svc_insecure_memory.cpp
new file mode 100644
index 000000000..79882685d
--- /dev/null
+++ b/src/core/hle/kernel/svc/svc_insecure_memory.cpp
@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel::Svc {
+
+Result MapInsecureMemory(Core::System& system, uintptr_t address, size_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result UnmapInsecureMemory(Core::System& system, uintptr_t address, size_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result MapInsecureMemory64(Core::System& system, uint64_t address, uint64_t size) {
+    R_RETURN(MapInsecureMemory(system, address, size));
+}
+
+Result UnmapInsecureMemory64(Core::System& system, uint64_t address, uint64_t size) {
+    R_RETURN(UnmapInsecureMemory(system, address, size));
+}
+
+Result MapInsecureMemory64From32(Core::System& system, uint32_t address, uint32_t size) {
+    R_RETURN(MapInsecureMemory(system, address, size));
+}
+
+Result UnmapInsecureMemory64From32(Core::System& system, uint32_t address, uint32_t size) {
+    R_RETURN(UnmapInsecureMemory(system, address, size));
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_interrupt_event.cpp b/src/core/hle/kernel/svc/svc_interrupt_event.cpp
index 299e22ae6..768b30a1f 100644
--- a/src/core/hle/kernel/svc/svc_interrupt_event.cpp
+++ b/src/core/hle/kernel/svc/svc_interrupt_event.cpp
@@ -2,5 +2,24 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+Result CreateInterruptEvent(Core::System& system, Handle* out, int32_t interrupt_id,
+                            InterruptType type) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result CreateInterruptEvent64(Core::System& system, Handle* out_read_handle, int32_t interrupt_id,
+                              InterruptType interrupt_type) {
+    R_RETURN(CreateInterruptEvent(system, out_read_handle, interrupt_id, interrupt_type));
+}
+
+Result CreateInterruptEvent64From32(Core::System& system, Handle* out_read_handle,
+                                    int32_t interrupt_id, InterruptType interrupt_type) {
+    R_RETURN(CreateInterruptEvent(system, out_read_handle, interrupt_id, interrupt_type));
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_io_pool.cpp b/src/core/hle/kernel/svc/svc_io_pool.cpp
index 299e22ae6..33f3d69bf 100644
--- a/src/core/hle/kernel/svc/svc_io_pool.cpp
+++ b/src/core/hle/kernel/svc/svc_io_pool.cpp
@@ -2,5 +2,70 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+Result CreateIoPool(Core::System& system, Handle* out, IoPoolType pool_type) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result CreateIoRegion(Core::System& system, Handle* out, Handle io_pool_handle, uint64_t phys_addr,
+                      size_t size, MemoryMapping mapping, MemoryPermission perm) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result MapIoRegion(Core::System& system, Handle io_region_handle, uintptr_t address, size_t size,
+                   MemoryPermission map_perm) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result UnmapIoRegion(Core::System& system, Handle io_region_handle, uintptr_t address,
+                     size_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result CreateIoPool64(Core::System& system, Handle* out_handle, IoPoolType pool_type) {
+    R_RETURN(CreateIoPool(system, out_handle, pool_type));
+}
+
+Result CreateIoRegion64(Core::System& system, Handle* out_handle, Handle io_pool,
+                        uint64_t physical_address, uint64_t size, MemoryMapping mapping,
+                        MemoryPermission perm) {
+    R_RETURN(CreateIoRegion(system, out_handle, io_pool, physical_address, size, mapping, perm));
+}
+
+Result MapIoRegion64(Core::System& system, Handle io_region, uint64_t address, uint64_t size,
+                     MemoryPermission perm) {
+    R_RETURN(MapIoRegion(system, io_region, address, size, perm));
+}
+
+Result UnmapIoRegion64(Core::System& system, Handle io_region, uint64_t address, uint64_t size) {
+    R_RETURN(UnmapIoRegion(system, io_region, address, size));
+}
+
+Result CreateIoPool64From32(Core::System& system, Handle* out_handle, IoPoolType pool_type) {
+    R_RETURN(CreateIoPool(system, out_handle, pool_type));
+}
+
+Result CreateIoRegion64From32(Core::System& system, Handle* out_handle, Handle io_pool,
+                              uint64_t physical_address, uint32_t size, MemoryMapping mapping,
+                              MemoryPermission perm) {
+    R_RETURN(CreateIoRegion(system, out_handle, io_pool, physical_address, size, mapping, perm));
+}
+
+Result MapIoRegion64From32(Core::System& system, Handle io_region, uint32_t address, uint32_t size,
+                           MemoryPermission perm) {
+    R_RETURN(MapIoRegion(system, io_region, address, size, perm));
+}
+
+Result UnmapIoRegion64From32(Core::System& system, Handle io_region, uint32_t address,
+                             uint32_t size) {
+    R_RETURN(UnmapIoRegion(system, io_region, address, size));
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_ipc.cpp b/src/core/hle/kernel/svc/svc_ipc.cpp
index dbb68e89a..a7a2c3b92 100644
--- a/src/core/hle/kernel/svc/svc_ipc.cpp
+++ b/src/core/hle/kernel/svc/svc_ipc.cpp
@@ -12,11 +12,9 @@ namespace Kernel::Svc {
 
 /// Makes a blocking IPC call to a service.
 Result SendSyncRequest(Core::System& system, Handle handle) {
-    auto& kernel = system.Kernel();
-
     // Get the client session from its handle.
     KScopedAutoObject session =
-        kernel.CurrentProcess()->GetHandleTable().GetObject<KClientSession>(handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KClientSession>(handle);
     R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
 
     LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName());
@@ -24,20 +22,37 @@ Result SendSyncRequest(Core::System& system, Handle handle) {
     return session->SendSyncRequest();
 }
 
-Result SendSyncRequest32(Core::System& system, Handle handle) {
-    return SendSyncRequest(system, handle);
+Result SendSyncRequestWithUserBuffer(Core::System& system, uint64_t message_buffer,
+                                     uint64_t message_buffer_size, Handle session_handle) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result SendAsyncRequestWithUserBuffer(Core::System& system, Handle* out_event_handle,
+                                      uint64_t message_buffer, uint64_t message_buffer_size,
+                                      Handle session_handle) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
 }
 
-Result ReplyAndReceive(Core::System& system, s32* out_index, Handle* handles, s32 num_handles,
+Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles_addr, s32 num_handles,
                        Handle reply_target, s64 timeout_ns) {
     auto& kernel = system.Kernel();
-    auto& handle_table = GetCurrentThread(kernel).GetOwnerProcess()->GetHandleTable();
+    auto& handle_table = GetCurrentProcess(kernel).GetHandleTable();
+
+    R_UNLESS(0 <= num_handles && num_handles <= ArgumentHandleCountMax, ResultOutOfRange);
+    R_UNLESS(system.Memory().IsValidVirtualAddressRange(
+                 handles_addr, static_cast<u64>(sizeof(Handle) * num_handles)),
+             ResultInvalidPointer);
+
+    std::vector<Handle> handles(num_handles);
+    system.Memory().ReadBlock(handles_addr, handles.data(), sizeof(Handle) * num_handles);
 
     // Convert handle list to object table.
     std::vector<KSynchronizationObject*> objs(num_handles);
-    R_UNLESS(
-        handle_table.GetMultipleObjects<KSynchronizationObject>(objs.data(), handles, num_handles),
-        ResultInvalidHandle);
+    R_UNLESS(handle_table.GetMultipleObjects<KSynchronizationObject>(objs.data(), handles.data(),
+                                                                     num_handles),
+             ResultInvalidHandle);
 
     // Ensure handles are closed when we're done.
     SCOPE_EXIT({
@@ -86,4 +101,72 @@ Result ReplyAndReceive(Core::System& system, s32* out_index, Handle* handles, s3
     }
 }
 
+Result ReplyAndReceiveWithUserBuffer(Core::System& system, int32_t* out_index,
+                                     uint64_t message_buffer, uint64_t message_buffer_size,
+                                     uint64_t handles, int32_t num_handles, Handle reply_target,
+                                     int64_t timeout_ns) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result SendSyncRequest64(Core::System& system, Handle session_handle) {
+    R_RETURN(SendSyncRequest(system, session_handle));
+}
+
+Result SendSyncRequestWithUserBuffer64(Core::System& system, uint64_t message_buffer,
+                                       uint64_t message_buffer_size, Handle session_handle) {
+    R_RETURN(
+        SendSyncRequestWithUserBuffer(system, message_buffer, message_buffer_size, session_handle));
+}
+
+Result SendAsyncRequestWithUserBuffer64(Core::System& system, Handle* out_event_handle,
+                                        uint64_t message_buffer, uint64_t message_buffer_size,
+                                        Handle session_handle) {
+    R_RETURN(SendAsyncRequestWithUserBuffer(system, out_event_handle, message_buffer,
+                                            message_buffer_size, session_handle));
+}
+
+Result ReplyAndReceive64(Core::System& system, int32_t* out_index, uint64_t handles,
+                         int32_t num_handles, Handle reply_target, int64_t timeout_ns) {
+    R_RETURN(ReplyAndReceive(system, out_index, handles, num_handles, reply_target, timeout_ns));
+}
+
+Result ReplyAndReceiveWithUserBuffer64(Core::System& system, int32_t* out_index,
+                                       uint64_t message_buffer, uint64_t message_buffer_size,
+                                       uint64_t handles, int32_t num_handles, Handle reply_target,
+                                       int64_t timeout_ns) {
+    R_RETURN(ReplyAndReceiveWithUserBuffer(system, out_index, message_buffer, message_buffer_size,
+                                           handles, num_handles, reply_target, timeout_ns));
+}
+
+Result SendSyncRequest64From32(Core::System& system, Handle session_handle) {
+    R_RETURN(SendSyncRequest(system, session_handle));
+}
+
+Result SendSyncRequestWithUserBuffer64From32(Core::System& system, uint32_t message_buffer,
+                                             uint32_t message_buffer_size, Handle session_handle) {
+    R_RETURN(
+        SendSyncRequestWithUserBuffer(system, message_buffer, message_buffer_size, session_handle));
+}
+
+Result SendAsyncRequestWithUserBuffer64From32(Core::System& system, Handle* out_event_handle,
+                                              uint32_t message_buffer, uint32_t message_buffer_size,
+                                              Handle session_handle) {
+    R_RETURN(SendAsyncRequestWithUserBuffer(system, out_event_handle, message_buffer,
+                                            message_buffer_size, session_handle));
+}
+
+Result ReplyAndReceive64From32(Core::System& system, int32_t* out_index, uint32_t handles,
+                               int32_t num_handles, Handle reply_target, int64_t timeout_ns) {
+    R_RETURN(ReplyAndReceive(system, out_index, handles, num_handles, reply_target, timeout_ns));
+}
+
+Result ReplyAndReceiveWithUserBuffer64From32(Core::System& system, int32_t* out_index,
+                                             uint32_t message_buffer, uint32_t message_buffer_size,
+                                             uint32_t handles, int32_t num_handles,
+                                             Handle reply_target, int64_t timeout_ns) {
+    R_RETURN(ReplyAndReceiveWithUserBuffer(system, out_index, message_buffer, message_buffer_size,
+                                           handles, num_handles, reply_target, timeout_ns));
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_kernel_debug.cpp b/src/core/hle/kernel/svc/svc_kernel_debug.cpp
index 454255e7a..cee048279 100644
--- a/src/core/hle/kernel/svc/svc_kernel_debug.cpp
+++ b/src/core/hle/kernel/svc/svc_kernel_debug.cpp
@@ -5,15 +5,31 @@
 
 namespace Kernel::Svc {
 
-void KernelDebug([[maybe_unused]] Core::System& system, [[maybe_unused]] u32 kernel_debug_type,
-                 [[maybe_unused]] u64 param1, [[maybe_unused]] u64 param2,
-                 [[maybe_unused]] u64 param3) {
+void KernelDebug(Core::System& system, KernelDebugType kernel_debug_type, u64 arg0, u64 arg1,
+                 u64 arg2) {
     // Intentionally do nothing, as this does nothing in released kernel binaries.
 }
 
-void ChangeKernelTraceState([[maybe_unused]] Core::System& system,
-                            [[maybe_unused]] u32 trace_state) {
+void ChangeKernelTraceState(Core::System& system, KernelTraceState trace_state) {
     // Intentionally do nothing, as this does nothing in released kernel binaries.
 }
 
+void KernelDebug64(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0,
+                   uint64_t arg1, uint64_t arg2) {
+    KernelDebug(system, kern_debug_type, arg0, arg1, arg2);
+}
+
+void ChangeKernelTraceState64(Core::System& system, KernelTraceState kern_trace_state) {
+    ChangeKernelTraceState(system, kern_trace_state);
+}
+
+void KernelDebug64From32(Core::System& system, KernelDebugType kern_debug_type, uint64_t arg0,
+                         uint64_t arg1, uint64_t arg2) {
+    KernelDebug(system, kern_debug_type, arg0, arg1, arg2);
+}
+
+void ChangeKernelTraceState64From32(Core::System& system, KernelTraceState kern_trace_state) {
+    ChangeKernelTraceState(system, kern_trace_state);
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_light_ipc.cpp b/src/core/hle/kernel/svc/svc_light_ipc.cpp
index 299e22ae6..b76ce984c 100644
--- a/src/core/hle/kernel/svc/svc_light_ipc.cpp
+++ b/src/core/hle/kernel/svc/svc_light_ipc.cpp
@@ -1,6 +1,73 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/arm/arm_interface.h"
+#include "core/core.h"
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+Result SendSyncRequestLight(Core::System& system, Handle session_handle, u32* args) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result ReplyAndReceiveLight(Core::System& system, Handle session_handle, u32* args) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result SendSyncRequestLight64(Core::System& system, Handle session_handle, u32* args) {
+    R_RETURN(SendSyncRequestLight(system, session_handle, args));
+}
+
+Result ReplyAndReceiveLight64(Core::System& system, Handle session_handle, u32* args) {
+    R_RETURN(ReplyAndReceiveLight(system, session_handle, args));
+}
+
+Result SendSyncRequestLight64From32(Core::System& system, Handle session_handle, u32* args) {
+    R_RETURN(SendSyncRequestLight(system, session_handle, args));
+}
+
+Result ReplyAndReceiveLight64From32(Core::System& system, Handle session_handle, u32* args) {
+    R_RETURN(ReplyAndReceiveLight(system, session_handle, args));
+}
+
+// Custom ABI implementation for light IPC.
+
+template <typename F>
+static void SvcWrap_LightIpc(Core::System& system, F&& cb) {
+    auto& core = system.CurrentArmInterface();
+    std::array<u32, 7> arguments{};
+
+    Handle session_handle = static_cast<Handle>(core.GetReg(0));
+    for (int i = 0; i < 7; i++) {
+        arguments[i] = static_cast<u32>(core.GetReg(i + 1));
+    }
+
+    Result ret = cb(system, session_handle, arguments.data());
+
+    core.SetReg(0, ret.raw);
+    for (int i = 0; i < 7; i++) {
+        core.SetReg(i + 1, arguments[i]);
+    }
+}
+
+void SvcWrap_SendSyncRequestLight64(Core::System& system) {
+    SvcWrap_LightIpc(system, SendSyncRequestLight64);
+}
+
+void SvcWrap_ReplyAndReceiveLight64(Core::System& system) {
+    SvcWrap_LightIpc(system, ReplyAndReceiveLight64);
+}
+
+void SvcWrap_SendSyncRequestLight64From32(Core::System& system) {
+    SvcWrap_LightIpc(system, SendSyncRequestLight64From32);
+}
+
+void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system) {
+    SvcWrap_LightIpc(system, ReplyAndReceiveLight64From32);
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_lock.cpp b/src/core/hle/kernel/svc/svc_lock.cpp
index 45f2a6553..f3d3e140b 100644
--- a/src/core/hle/kernel/svc/svc_lock.cpp
+++ b/src/core/hle/kernel/svc/svc_lock.cpp
@@ -24,11 +24,7 @@ Result ArbitrateLock(Core::System& system, Handle thread_handle, VAddr address,
         return ResultInvalidAddress;
     }
 
-    return system.Kernel().CurrentProcess()->WaitForAddress(thread_handle, address, tag);
-}
-
-Result ArbitrateLock32(Core::System& system, Handle thread_handle, u32 address, u32 tag) {
-    return ArbitrateLock(system, thread_handle, address, tag);
+    return GetCurrentProcess(system.Kernel()).WaitForAddress(thread_handle, address, tag);
 }
 
 /// Unlock a mutex
@@ -47,11 +43,24 @@ Result ArbitrateUnlock(Core::System& system, VAddr address) {
         return ResultInvalidAddress;
     }
 
-    return system.Kernel().CurrentProcess()->SignalToAddress(address);
+    return GetCurrentProcess(system.Kernel()).SignalToAddress(address);
+}
+
+Result ArbitrateLock64(Core::System& system, Handle thread_handle, uint64_t address, uint32_t tag) {
+    R_RETURN(ArbitrateLock(system, thread_handle, address, tag));
+}
+
+Result ArbitrateUnlock64(Core::System& system, uint64_t address) {
+    R_RETURN(ArbitrateUnlock(system, address));
+}
+
+Result ArbitrateLock64From32(Core::System& system, Handle thread_handle, uint32_t address,
+                             uint32_t tag) {
+    R_RETURN(ArbitrateLock(system, thread_handle, address, tag));
 }
 
-Result ArbitrateUnlock32(Core::System& system, u32 address) {
-    return ArbitrateUnlock(system, address);
+Result ArbitrateUnlock64From32(Core::System& system, uint32_t address) {
+    R_RETURN(ArbitrateUnlock(system, address));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_memory.cpp b/src/core/hle/kernel/svc/svc_memory.cpp
index f78b1239b..214bcd073 100644
--- a/src/core/hle/kernel/svc/svc_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_memory.cpp
@@ -113,7 +113,7 @@ Result SetMemoryPermission(Core::System& system, VAddr address, u64 size, Memory
     R_UNLESS(IsValidSetMemoryPermission(perm), ResultInvalidNewMemoryPermission);
 
     // Validate that the region is in range for the current process.
-    auto& page_table = system.Kernel().CurrentProcess()->PageTable();
+    auto& page_table = GetCurrentProcess(system.Kernel()).PageTable();
     R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
 
     // Set the memory attribute.
@@ -137,23 +137,19 @@ Result SetMemoryAttribute(Core::System& system, VAddr address, u64 size, u32 mas
     R_UNLESS((mask | attr | SupportedMask) == SupportedMask, ResultInvalidCombination);
 
     // Validate that the region is in range for the current process.
-    auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
+    auto& page_table{GetCurrentProcess(system.Kernel()).PageTable()};
     R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
 
     // Set the memory attribute.
     return page_table.SetMemoryAttribute(address, size, mask, attr);
 }
 
-Result SetMemoryAttribute32(Core::System& system, u32 address, u32 size, u32 mask, u32 attr) {
-    return SetMemoryAttribute(system, address, size, mask, attr);
-}
-
 /// Maps a memory range into a different range.
 Result MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
               src_addr, size);
 
-    auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
+    auto& page_table{GetCurrentProcess(system.Kernel()).PageTable()};
 
     if (const Result result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
         result.IsError()) {
@@ -163,16 +159,12 @@ Result MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size)
     return page_table.MapMemory(dst_addr, src_addr, size);
 }
 
-Result MapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
-    return MapMemory(system, dst_addr, src_addr, size);
-}
-
 /// Unmaps a region that was previously mapped with svcMapMemory
 Result UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
               src_addr, size);
 
-    auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
+    auto& page_table{GetCurrentProcess(system.Kernel()).PageTable()};
 
     if (const Result result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
         result.IsError()) {
@@ -182,8 +174,44 @@ Result UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 siz
     return page_table.UnmapMemory(dst_addr, src_addr, size);
 }
 
-Result UnmapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
-    return UnmapMemory(system, dst_addr, src_addr, size);
+Result SetMemoryPermission64(Core::System& system, uint64_t address, uint64_t size,
+                             MemoryPermission perm) {
+    R_RETURN(SetMemoryPermission(system, address, size, perm));
+}
+
+Result SetMemoryAttribute64(Core::System& system, uint64_t address, uint64_t size, uint32_t mask,
+                            uint32_t attr) {
+    R_RETURN(SetMemoryAttribute(system, address, size, mask, attr));
+}
+
+Result MapMemory64(Core::System& system, uint64_t dst_address, uint64_t src_address,
+                   uint64_t size) {
+    R_RETURN(MapMemory(system, dst_address, src_address, size));
+}
+
+Result UnmapMemory64(Core::System& system, uint64_t dst_address, uint64_t src_address,
+                     uint64_t size) {
+    R_RETURN(UnmapMemory(system, dst_address, src_address, size));
+}
+
+Result SetMemoryPermission64From32(Core::System& system, uint32_t address, uint32_t size,
+                                   MemoryPermission perm) {
+    R_RETURN(SetMemoryPermission(system, address, size, perm));
+}
+
+Result SetMemoryAttribute64From32(Core::System& system, uint32_t address, uint32_t size,
+                                  uint32_t mask, uint32_t attr) {
+    R_RETURN(SetMemoryAttribute(system, address, size, mask, attr));
+}
+
+Result MapMemory64From32(Core::System& system, uint32_t dst_address, uint32_t src_address,
+                         uint32_t size) {
+    R_RETURN(MapMemory(system, dst_address, src_address, size));
+}
+
+Result UnmapMemory64From32(Core::System& system, uint32_t dst_address, uint32_t src_address,
+                           uint32_t size) {
+    R_RETURN(UnmapMemory(system, dst_address, src_address, size));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_physical_memory.cpp b/src/core/hle/kernel/svc/svc_physical_memory.cpp
index 0fc262203..a1f534454 100644
--- a/src/core/hle/kernel/svc/svc_physical_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_physical_memory.cpp
@@ -16,18 +16,11 @@ Result SetHeapSize(Core::System& system, VAddr* out_address, u64 size) {
     R_UNLESS(size < MainMemorySizeMax, ResultInvalidSize);
 
     // Set the heap size.
-    R_TRY(system.Kernel().CurrentProcess()->PageTable().SetHeapSize(out_address, size));
+    R_TRY(GetCurrentProcess(system.Kernel()).PageTable().SetHeapSize(out_address, size));
 
     return ResultSuccess;
 }
 
-Result SetHeapSize32(Core::System& system, u32* heap_addr, u32 heap_size) {
-    VAddr temp_heap_addr{};
-    const Result result{SetHeapSize(system, &temp_heap_addr, heap_size)};
-    *heap_addr = static_cast<u32>(temp_heap_addr);
-    return result;
-}
-
 /// Maps memory at a desired address
 Result MapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
     LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
@@ -52,7 +45,7 @@ Result MapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
         return ResultInvalidMemoryRegion;
     }
 
-    KProcess* const current_process{system.Kernel().CurrentProcess()};
+    KProcess* const current_process{GetCurrentProcessPointer(system.Kernel())};
     auto& page_table{current_process->PageTable()};
 
     if (current_process->GetSystemResourceSize() == 0) {
@@ -77,10 +70,6 @@ Result MapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
     return page_table.MapPhysicalMemory(addr, size);
 }
 
-Result MapPhysicalMemory32(Core::System& system, u32 addr, u32 size) {
-    return MapPhysicalMemory(system, addr, size);
-}
-
 /// Unmaps memory previously mapped via MapPhysicalMemory
 Result UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
     LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
@@ -105,7 +94,7 @@ Result UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
         return ResultInvalidMemoryRegion;
     }
 
-    KProcess* const current_process{system.Kernel().CurrentProcess()};
+    KProcess* const current_process{GetCurrentProcessPointer(system.Kernel())};
     auto& page_table{current_process->PageTable()};
 
     if (current_process->GetSystemResourceSize() == 0) {
@@ -130,8 +119,67 @@ Result UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
     return page_table.UnmapPhysicalMemory(addr, size);
 }
 
-Result UnmapPhysicalMemory32(Core::System& system, u32 addr, u32 size) {
-    return UnmapPhysicalMemory(system, addr, size);
+Result MapPhysicalMemoryUnsafe(Core::System& system, uint64_t address, uint64_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result UnmapPhysicalMemoryUnsafe(Core::System& system, uint64_t address, uint64_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result SetUnsafeLimit(Core::System& system, uint64_t limit) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result SetHeapSize64(Core::System& system, uint64_t* out_address, uint64_t size) {
+    R_RETURN(SetHeapSize(system, out_address, size));
+}
+
+Result MapPhysicalMemory64(Core::System& system, uint64_t address, uint64_t size) {
+    R_RETURN(MapPhysicalMemory(system, address, size));
+}
+
+Result UnmapPhysicalMemory64(Core::System& system, uint64_t address, uint64_t size) {
+    R_RETURN(UnmapPhysicalMemory(system, address, size));
+}
+
+Result MapPhysicalMemoryUnsafe64(Core::System& system, uint64_t address, uint64_t size) {
+    R_RETURN(MapPhysicalMemoryUnsafe(system, address, size));
+}
+
+Result UnmapPhysicalMemoryUnsafe64(Core::System& system, uint64_t address, uint64_t size) {
+    R_RETURN(UnmapPhysicalMemoryUnsafe(system, address, size));
+}
+
+Result SetUnsafeLimit64(Core::System& system, uint64_t limit) {
+    R_RETURN(SetUnsafeLimit(system, limit));
+}
+
+Result SetHeapSize64From32(Core::System& system, uintptr_t* out_address, uint32_t size) {
+    R_RETURN(SetHeapSize(system, out_address, size));
+}
+
+Result MapPhysicalMemory64From32(Core::System& system, uint32_t address, uint32_t size) {
+    R_RETURN(MapPhysicalMemory(system, address, size));
+}
+
+Result UnmapPhysicalMemory64From32(Core::System& system, uint32_t address, uint32_t size) {
+    R_RETURN(UnmapPhysicalMemory(system, address, size));
+}
+
+Result MapPhysicalMemoryUnsafe64From32(Core::System& system, uint32_t address, uint32_t size) {
+    R_RETURN(MapPhysicalMemoryUnsafe(system, address, size));
+}
+
+Result UnmapPhysicalMemoryUnsafe64From32(Core::System& system, uint32_t address, uint32_t size) {
+    R_RETURN(UnmapPhysicalMemoryUnsafe(system, address, size));
+}
+
+Result SetUnsafeLimit64From32(Core::System& system, uint32_t limit) {
+    R_RETURN(SetUnsafeLimit(system, limit));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_port.cpp b/src/core/hle/kernel/svc/svc_port.cpp
index cdfe0dd16..2f9bfcb52 100644
--- a/src/core/hle/kernel/svc/svc_port.cpp
+++ b/src/core/hle/kernel/svc/svc_port.cpp
@@ -5,6 +5,7 @@
 #include "core/core.h"
 #include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_client_session.h"
+#include "core/hle/kernel/k_object_name.h"
 #include "core/hle/kernel/k_port.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/svc.h"
@@ -34,7 +35,7 @@ Result ConnectToNamedPort(Core::System& system, Handle* out, VAddr port_name_add
 
     // Get the current handle table.
     auto& kernel = system.Kernel();
-    auto& handle_table = kernel.CurrentProcess()->GetHandleTable();
+    auto& handle_table = GetCurrentProcess(kernel).GetHandleTable();
 
     // Find the client port.
     auto port = kernel.CreateNamedServicePort(port_name);
@@ -63,9 +64,107 @@ Result ConnectToNamedPort(Core::System& system, Handle* out, VAddr port_name_add
     return ResultSuccess;
 }
 
-Result ConnectToNamedPort32(Core::System& system, Handle* out_handle, u32 port_name_address) {
+Result CreatePort(Core::System& system, Handle* out_server, Handle* out_client,
+                  int32_t max_sessions, bool is_light, uintptr_t name) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result ConnectToPort(Core::System& system, Handle* out_handle, Handle port) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t user_name,
+                       int32_t max_sessions) {
+    // Copy the provided name from user memory to kernel memory.
+    std::array<char, KObjectName::NameLengthMax> name{};
+    system.Memory().ReadBlock(user_name, name.data(), sizeof(name));
+
+    // Validate that sessions and name are valid.
+    R_UNLESS(max_sessions >= 0, ResultOutOfRange);
+    R_UNLESS(name[sizeof(name) - 1] == '\x00', ResultOutOfRange);
+
+    if (max_sessions > 0) {
+        // Get the current handle table.
+        auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
+
+        // Create a new port.
+        KPort* port = KPort::Create(system.Kernel());
+        R_UNLESS(port != nullptr, ResultOutOfResource);
+
+        // Initialize the new port.
+        port->Initialize(max_sessions, false, "");
+
+        // Register the port.
+        KPort::Register(system.Kernel(), port);
+
+        // Ensure that our only reference to the port is in the handle table when we're done.
+        SCOPE_EXIT({
+            port->GetClientPort().Close();
+            port->GetServerPort().Close();
+        });
+
+        // Register the handle in the table.
+        R_TRY(handle_table.Add(out_server_handle, std::addressof(port->GetServerPort())));
+        ON_RESULT_FAILURE {
+            handle_table.Remove(*out_server_handle);
+        };
+
+        // Create a new object name.
+        R_TRY(KObjectName::NewFromName(system.Kernel(), std::addressof(port->GetClientPort()),
+                                       name.data()));
+    } else /* if (max_sessions == 0) */ {
+        // Ensure that this else case is correct.
+        ASSERT(max_sessions == 0);
+
+        // If we're closing, there's no server handle.
+        *out_server_handle = InvalidHandle;
+
+        // Delete the object.
+        R_TRY(KObjectName::Delete<KClientPort>(system.Kernel(), name.data()));
+    }
+
+    R_SUCCEED();
+}
+
+Result ConnectToNamedPort64(Core::System& system, Handle* out_handle, uint64_t name) {
+    R_RETURN(ConnectToNamedPort(system, out_handle, name));
+}
+
+Result CreatePort64(Core::System& system, Handle* out_server_handle, Handle* out_client_handle,
+                    int32_t max_sessions, bool is_light, uint64_t name) {
+    R_RETURN(
+        CreatePort(system, out_server_handle, out_client_handle, max_sessions, is_light, name));
+}
+
+Result ManageNamedPort64(Core::System& system, Handle* out_server_handle, uint64_t name,
+                         int32_t max_sessions) {
+    R_RETURN(ManageNamedPort(system, out_server_handle, name, max_sessions));
+}
+
+Result ConnectToPort64(Core::System& system, Handle* out_handle, Handle port) {
+    R_RETURN(ConnectToPort(system, out_handle, port));
+}
+
+Result ConnectToNamedPort64From32(Core::System& system, Handle* out_handle, uint32_t name) {
+    R_RETURN(ConnectToNamedPort(system, out_handle, name));
+}
+
+Result CreatePort64From32(Core::System& system, Handle* out_server_handle,
+                          Handle* out_client_handle, int32_t max_sessions, bool is_light,
+                          uint32_t name) {
+    R_RETURN(
+        CreatePort(system, out_server_handle, out_client_handle, max_sessions, is_light, name));
+}
+
+Result ManageNamedPort64From32(Core::System& system, Handle* out_server_handle, uint32_t name,
+                               int32_t max_sessions) {
+    R_RETURN(ManageNamedPort(system, out_server_handle, name, max_sessions));
+}
 
-    return ConnectToNamedPort(system, out_handle, port_name_address);
+Result ConnectToPort64From32(Core::System& system, Handle* out_handle, Handle port) {
+    R_RETURN(ConnectToPort(system, out_handle, port));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_power_management.cpp b/src/core/hle/kernel/svc/svc_power_management.cpp
index 299e22ae6..f605a0317 100644
--- a/src/core/hle/kernel/svc/svc_power_management.cpp
+++ b/src/core/hle/kernel/svc/svc_power_management.cpp
@@ -2,5 +2,20 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+void SleepSystem(Core::System& system) {
+    UNIMPLEMENTED();
+}
+
+void SleepSystem64(Core::System& system) {
+    return SleepSystem(system);
+}
+
+void SleepSystem64From32(Core::System& system) {
+    return SleepSystem(system);
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_process.cpp b/src/core/hle/kernel/svc/svc_process.cpp
index d6c8b4561..c35d2be76 100644
--- a/src/core/hle/kernel/svc/svc_process.cpp
+++ b/src/core/hle/kernel/svc/svc_process.cpp
@@ -9,7 +9,7 @@ namespace Kernel::Svc {
 
 /// Exits the current process
 void ExitProcess(Core::System& system) {
-    auto* current_process = system.Kernel().CurrentProcess();
+    auto* current_process = GetCurrentProcessPointer(system.Kernel());
 
     LOG_INFO(Kernel_SVC, "Process {} exiting", current_process->GetProcessID());
     ASSERT_MSG(current_process->GetState() == KProcess::State::Running,
@@ -18,18 +18,14 @@ void ExitProcess(Core::System& system) {
     system.Exit();
 }
 
-void ExitProcess32(Core::System& system) {
-    ExitProcess(system);
-}
-
 /// Gets the ID of the specified process or a specified thread's owning process.
 Result GetProcessId(Core::System& system, u64* out_process_id, Handle handle) {
     LOG_DEBUG(Kernel_SVC, "called handle=0x{:08X}", handle);
 
     // Get the object from the handle table.
-    KScopedAutoObject obj =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KAutoObject>(
-            static_cast<Handle>(handle));
+    KScopedAutoObject obj = GetCurrentProcess(system.Kernel())
+                                .GetHandleTable()
+                                .GetObject<KAutoObject>(static_cast<Handle>(handle));
     R_UNLESS(obj.IsNotNull(), ResultInvalidHandle);
 
     // Get the process from the object.
@@ -54,17 +50,8 @@ Result GetProcessId(Core::System& system, u64* out_process_id, Handle handle) {
     return ResultSuccess;
 }
 
-Result GetProcessId32(Core::System& system, u32* out_process_id_low, u32* out_process_id_high,
-                      Handle handle) {
-    u64 out_process_id{};
-    const auto result = GetProcessId(system, &out_process_id, handle);
-    *out_process_id_low = static_cast<u32>(out_process_id);
-    *out_process_id_high = static_cast<u32>(out_process_id >> 32);
-    return result;
-}
-
-Result GetProcessList(Core::System& system, u32* out_num_processes, VAddr out_process_ids,
-                      u32 out_process_ids_size) {
+Result GetProcessList(Core::System& system, s32* out_num_processes, VAddr out_process_ids,
+                      int32_t out_process_ids_size) {
     LOG_DEBUG(Kernel_SVC, "called. out_process_ids=0x{:016X}, out_process_ids_size={}",
               out_process_ids, out_process_ids_size);
 
@@ -76,10 +63,10 @@ Result GetProcessList(Core::System& system, u32* out_num_processes, VAddr out_pr
         return ResultOutOfRange;
     }
 
-    const auto& kernel = system.Kernel();
+    auto& kernel = system.Kernel();
     const auto total_copy_size = out_process_ids_size * sizeof(u64);
 
-    if (out_process_ids_size > 0 && !kernel.CurrentProcess()->PageTable().IsInsideAddressSpace(
+    if (out_process_ids_size > 0 && !GetCurrentProcess(kernel).PageTable().IsInsideAddressSpace(
                                         out_process_ids, total_copy_size)) {
         LOG_ERROR(Kernel_SVC, "Address range outside address space. begin=0x{:016X}, end=0x{:016X}",
                   out_process_ids, out_process_ids + total_copy_size);
@@ -89,7 +76,8 @@ Result GetProcessList(Core::System& system, u32* out_num_processes, VAddr out_pr
     auto& memory = system.Memory();
     const auto& process_list = kernel.GetProcessList();
     const auto num_processes = process_list.size();
-    const auto copy_amount = std::min(std::size_t{out_process_ids_size}, num_processes);
+    const auto copy_amount =
+        std::min(static_cast<std::size_t>(out_process_ids_size), num_processes);
 
     for (std::size_t i = 0; i < copy_amount; ++i) {
         memory.Write64(out_process_ids, process_list[i]->GetProcessID());
@@ -100,10 +88,11 @@ Result GetProcessList(Core::System& system, u32* out_num_processes, VAddr out_pr
     return ResultSuccess;
 }
 
-Result GetProcessInfo(Core::System& system, u64* out, Handle process_handle, u32 type) {
-    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, type=0x{:X}", process_handle, type);
+Result GetProcessInfo(Core::System& system, s64* out, Handle process_handle,
+                      ProcessInfoType info_type) {
+    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, type=0x{:X}", process_handle, info_type);
 
-    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
+    const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
     KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
     if (process.IsNull()) {
         LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
@@ -111,14 +100,95 @@ Result GetProcessInfo(Core::System& system, u64* out, Handle process_handle, u32
         return ResultInvalidHandle;
     }
 
-    const auto info_type = static_cast<ProcessInfoType>(type);
     if (info_type != ProcessInfoType::ProcessState) {
-        LOG_ERROR(Kernel_SVC, "Expected info_type to be ProcessState but got {} instead", type);
+        LOG_ERROR(Kernel_SVC, "Expected info_type to be ProcessState but got {} instead",
+                  info_type);
         return ResultInvalidEnumValue;
     }
 
-    *out = static_cast<u64>(process->GetState());
+    *out = static_cast<s64>(process->GetState());
     return ResultSuccess;
 }
 
+Result CreateProcess(Core::System& system, Handle* out_handle, uint64_t parameters, uint64_t caps,
+                     int32_t num_caps) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result StartProcess(Core::System& system, Handle process_handle, int32_t priority, int32_t core_id,
+                    uint64_t main_thread_stack_size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result TerminateProcess(Core::System& system, Handle process_handle) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+void ExitProcess64(Core::System& system) {
+    ExitProcess(system);
+}
+
+Result GetProcessId64(Core::System& system, uint64_t* out_process_id, Handle process_handle) {
+    R_RETURN(GetProcessId(system, out_process_id, process_handle));
+}
+
+Result GetProcessList64(Core::System& system, int32_t* out_num_processes, uint64_t out_process_ids,
+                        int32_t max_out_count) {
+    R_RETURN(GetProcessList(system, out_num_processes, out_process_ids, max_out_count));
+}
+
+Result CreateProcess64(Core::System& system, Handle* out_handle, uint64_t parameters, uint64_t caps,
+                       int32_t num_caps) {
+    R_RETURN(CreateProcess(system, out_handle, parameters, caps, num_caps));
+}
+
+Result StartProcess64(Core::System& system, Handle process_handle, int32_t priority,
+                      int32_t core_id, uint64_t main_thread_stack_size) {
+    R_RETURN(StartProcess(system, process_handle, priority, core_id, main_thread_stack_size));
+}
+
+Result TerminateProcess64(Core::System& system, Handle process_handle) {
+    R_RETURN(TerminateProcess(system, process_handle));
+}
+
+Result GetProcessInfo64(Core::System& system, int64_t* out_info, Handle process_handle,
+                        ProcessInfoType info_type) {
+    R_RETURN(GetProcessInfo(system, out_info, process_handle, info_type));
+}
+
+void ExitProcess64From32(Core::System& system) {
+    ExitProcess(system);
+}
+
+Result GetProcessId64From32(Core::System& system, uint64_t* out_process_id, Handle process_handle) {
+    R_RETURN(GetProcessId(system, out_process_id, process_handle));
+}
+
+Result GetProcessList64From32(Core::System& system, int32_t* out_num_processes,
+                              uint32_t out_process_ids, int32_t max_out_count) {
+    R_RETURN(GetProcessList(system, out_num_processes, out_process_ids, max_out_count));
+}
+
+Result CreateProcess64From32(Core::System& system, Handle* out_handle, uint32_t parameters,
+                             uint32_t caps, int32_t num_caps) {
+    R_RETURN(CreateProcess(system, out_handle, parameters, caps, num_caps));
+}
+
+Result StartProcess64From32(Core::System& system, Handle process_handle, int32_t priority,
+                            int32_t core_id, uint64_t main_thread_stack_size) {
+    R_RETURN(StartProcess(system, process_handle, priority, core_id, main_thread_stack_size));
+}
+
+Result TerminateProcess64From32(Core::System& system, Handle process_handle) {
+    R_RETURN(TerminateProcess(system, process_handle));
+}
+
+Result GetProcessInfo64From32(Core::System& system, int64_t* out_info, Handle process_handle,
+                              ProcessInfoType info_type) {
+    R_RETURN(GetProcessInfo(system, out_info, process_handle, info_type));
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_process_memory.cpp b/src/core/hle/kernel/svc/svc_process_memory.cpp
index b6ac43af2..4dfd9e5bb 100644
--- a/src/core/hle/kernel/svc/svc_process_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_process_memory.cpp
@@ -45,7 +45,7 @@ Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, V
 
     // Get the process from its handle.
     KScopedAutoObject process =
-        system.CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KProcess>(process_handle);
     R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
 
     // Validate that the address is in range.
@@ -71,7 +71,7 @@ Result MapProcessMemory(Core::System& system, VAddr dst_address, Handle process_
     R_UNLESS((src_address < src_address + size), ResultInvalidCurrentMemory);
 
     // Get the processes.
-    KProcess* dst_process = system.CurrentProcess();
+    KProcess* dst_process = GetCurrentProcessPointer(system.Kernel());
     KScopedAutoObject src_process =
         dst_process->GetHandleTable().GetObjectWithoutPseudoHandle<KProcess>(process_handle);
     R_UNLESS(src_process.IsNotNull(), ResultInvalidHandle);
@@ -114,7 +114,7 @@ Result UnmapProcessMemory(Core::System& system, VAddr dst_address, Handle proces
     R_UNLESS((src_address < src_address + size), ResultInvalidCurrentMemory);
 
     // Get the processes.
-    KProcess* dst_process = system.CurrentProcess();
+    KProcess* dst_process = GetCurrentProcessPointer(system.Kernel());
     KScopedAutoObject src_process =
         dst_process->GetHandleTable().GetObjectWithoutPseudoHandle<KProcess>(process_handle);
     R_UNLESS(src_process.IsNotNull(), ResultInvalidHandle);
@@ -174,7 +174,7 @@ Result MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst
         return ResultInvalidCurrentMemory;
     }
 
-    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
+    const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
     KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
     if (process.IsNull()) {
         LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).",
@@ -242,7 +242,7 @@ Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 d
         return ResultInvalidCurrentMemory;
     }
 
-    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
+    const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
     KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
     if (process.IsNull()) {
         LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).",
@@ -271,4 +271,54 @@ Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 d
                                       KPageTable::ICacheInvalidationStrategy::InvalidateAll);
 }
 
+Result SetProcessMemoryPermission64(Core::System& system, Handle process_handle, uint64_t address,
+                                    uint64_t size, MemoryPermission perm) {
+    R_RETURN(SetProcessMemoryPermission(system, process_handle, address, size, perm));
+}
+
+Result MapProcessMemory64(Core::System& system, uint64_t dst_address, Handle process_handle,
+                          uint64_t src_address, uint64_t size) {
+    R_RETURN(MapProcessMemory(system, dst_address, process_handle, src_address, size));
+}
+
+Result UnmapProcessMemory64(Core::System& system, uint64_t dst_address, Handle process_handle,
+                            uint64_t src_address, uint64_t size) {
+    R_RETURN(UnmapProcessMemory(system, dst_address, process_handle, src_address, size));
+}
+
+Result MapProcessCodeMemory64(Core::System& system, Handle process_handle, uint64_t dst_address,
+                              uint64_t src_address, uint64_t size) {
+    R_RETURN(MapProcessCodeMemory(system, process_handle, dst_address, src_address, size));
+}
+
+Result UnmapProcessCodeMemory64(Core::System& system, Handle process_handle, uint64_t dst_address,
+                                uint64_t src_address, uint64_t size) {
+    R_RETURN(UnmapProcessCodeMemory(system, process_handle, dst_address, src_address, size));
+}
+
+Result SetProcessMemoryPermission64From32(Core::System& system, Handle process_handle,
+                                          uint64_t address, uint64_t size, MemoryPermission perm) {
+    R_RETURN(SetProcessMemoryPermission(system, process_handle, address, size, perm));
+}
+
+Result MapProcessMemory64From32(Core::System& system, uint32_t dst_address, Handle process_handle,
+                                uint64_t src_address, uint32_t size) {
+    R_RETURN(MapProcessMemory(system, dst_address, process_handle, src_address, size));
+}
+
+Result UnmapProcessMemory64From32(Core::System& system, uint32_t dst_address, Handle process_handle,
+                                  uint64_t src_address, uint32_t size) {
+    R_RETURN(UnmapProcessMemory(system, dst_address, process_handle, src_address, size));
+}
+
+Result MapProcessCodeMemory64From32(Core::System& system, Handle process_handle,
+                                    uint64_t dst_address, uint64_t src_address, uint64_t size) {
+    R_RETURN(MapProcessCodeMemory(system, process_handle, dst_address, src_address, size));
+}
+
+Result UnmapProcessCodeMemory64From32(Core::System& system, Handle process_handle,
+                                      uint64_t dst_address, uint64_t src_address, uint64_t size) {
+    R_RETURN(UnmapProcessCodeMemory(system, process_handle, dst_address, src_address, size));
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_processor.cpp b/src/core/hle/kernel/svc/svc_processor.cpp
index 8561cf74f..7602ce6c0 100644
--- a/src/core/hle/kernel/svc/svc_processor.cpp
+++ b/src/core/hle/kernel/svc/svc_processor.cpp
@@ -9,12 +9,16 @@
 namespace Kernel::Svc {
 
 /// Get which CPU core is executing the current thread
-u32 GetCurrentProcessorNumber(Core::System& system) {
+int32_t GetCurrentProcessorNumber(Core::System& system) {
     LOG_TRACE(Kernel_SVC, "called");
-    return static_cast<u32>(system.CurrentPhysicalCore().CoreIndex());
+    return static_cast<int32_t>(system.CurrentPhysicalCore().CoreIndex());
 }
 
-u32 GetCurrentProcessorNumber32(Core::System& system) {
+int32_t GetCurrentProcessorNumber64(Core::System& system) {
+    return GetCurrentProcessorNumber(system);
+}
+
+int32_t GetCurrentProcessorNumber64From32(Core::System& system) {
     return GetCurrentProcessorNumber(system);
 }
 
diff --git a/src/core/hle/kernel/svc/svc_query_memory.cpp b/src/core/hle/kernel/svc/svc_query_memory.cpp
index aac3b2eca..ee75ad370 100644
--- a/src/core/hle/kernel/svc/svc_query_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_query_memory.cpp
@@ -7,26 +7,22 @@
 
 namespace Kernel::Svc {
 
-Result QueryMemory(Core::System& system, VAddr memory_info_address, VAddr page_info_address,
+Result QueryMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info,
                    VAddr query_address) {
     LOG_TRACE(Kernel_SVC,
-              "called, memory_info_address=0x{:016X}, page_info_address=0x{:016X}, "
+              "called, out_memory_info=0x{:016X}, "
               "query_address=0x{:016X}",
-              memory_info_address, page_info_address, query_address);
+              out_memory_info, query_address);
 
-    return QueryProcessMemory(system, memory_info_address, page_info_address, CurrentProcess,
+    // Query memory is just QueryProcessMemory on the current process.
+    return QueryProcessMemory(system, out_memory_info, out_page_info, CurrentProcess,
                               query_address);
 }
 
-Result QueryMemory32(Core::System& system, u32 memory_info_address, u32 page_info_address,
-                     u32 query_address) {
-    return QueryMemory(system, memory_info_address, page_info_address, query_address);
-}
-
-Result QueryProcessMemory(Core::System& system, VAddr memory_info_address, VAddr page_info_address,
-                          Handle process_handle, VAddr address) {
+Result QueryProcessMemory(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info,
+                          Handle process_handle, uint64_t address) {
     LOG_TRACE(Kernel_SVC, "called process=0x{:08X} address={:X}", process_handle, address);
-    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
+    const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
     KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
     if (process.IsNull()) {
         LOG_ERROR(Kernel_SVC, "Process handle does not exist, process_handle=0x{:08X}",
@@ -37,19 +33,33 @@ Result QueryProcessMemory(Core::System& system, VAddr memory_info_address, VAddr
     auto& memory{system.Memory()};
     const auto memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()};
 
-    memory.Write64(memory_info_address + 0x00, memory_info.base_address);
-    memory.Write64(memory_info_address + 0x08, memory_info.size);
-    memory.Write32(memory_info_address + 0x10, static_cast<u32>(memory_info.state) & 0xff);
-    memory.Write32(memory_info_address + 0x14, static_cast<u32>(memory_info.attribute));
-    memory.Write32(memory_info_address + 0x18, static_cast<u32>(memory_info.permission));
-    memory.Write32(memory_info_address + 0x1c, memory_info.ipc_count);
-    memory.Write32(memory_info_address + 0x20, memory_info.device_count);
-    memory.Write32(memory_info_address + 0x24, 0);
+    memory.WriteBlock(out_memory_info, &memory_info, sizeof(memory_info));
+
+    //! This is supposed to be part of the QueryInfo call.
+    *out_page_info = {};
+
+    R_SUCCEED();
+}
+
+Result QueryMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info,
+                     uint64_t address) {
+    R_RETURN(QueryMemory(system, out_memory_info, out_page_info, address));
+}
 
-    // Page info appears to be currently unused by the kernel and is always set to zero.
-    memory.Write32(page_info_address, 0);
+Result QueryProcessMemory64(Core::System& system, uint64_t out_memory_info, PageInfo* out_page_info,
+                            Handle process_handle, uint64_t address) {
+    R_RETURN(QueryProcessMemory(system, out_memory_info, out_page_info, process_handle, address));
+}
+
+Result QueryMemory64From32(Core::System& system, uint32_t out_memory_info, PageInfo* out_page_info,
+                           uint32_t address) {
+    R_RETURN(QueryMemory(system, out_memory_info, out_page_info, address));
+}
 
-    return ResultSuccess;
+Result QueryProcessMemory64From32(Core::System& system, uint32_t out_memory_info,
+                                  PageInfo* out_page_info, Handle process_handle,
+                                  uint64_t address) {
+    R_RETURN(QueryProcessMemory(system, out_memory_info, out_page_info, process_handle, address));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_register.cpp b/src/core/hle/kernel/svc/svc_register.cpp
index 299e22ae6..b883e6618 100644
--- a/src/core/hle/kernel/svc/svc_register.cpp
+++ b/src/core/hle/kernel/svc/svc_register.cpp
@@ -2,5 +2,26 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+Result ReadWriteRegister(Core::System& system, uint32_t* out, uint64_t address, uint32_t mask,
+                         uint32_t value) {
+    *out = 0;
+
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result ReadWriteRegister64(Core::System& system, uint32_t* out_value, uint64_t address,
+                           uint32_t mask, uint32_t value) {
+    R_RETURN(ReadWriteRegister(system, out_value, address, mask, value));
+}
+
+Result ReadWriteRegister64From32(Core::System& system, uint32_t* out_value, uint64_t address,
+                                 uint32_t mask, uint32_t value) {
+    R_RETURN(ReadWriteRegister(system, out_value, address, mask, value));
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_resource_limit.cpp b/src/core/hle/kernel/svc/svc_resource_limit.cpp
index 679ba10fa..88166299e 100644
--- a/src/core/hle/kernel/svc/svc_resource_limit.cpp
+++ b/src/core/hle/kernel/svc/svc_resource_limit.cpp
@@ -27,12 +27,12 @@ Result CreateResourceLimit(Core::System& system, Handle* out_handle) {
     KResourceLimit::Register(kernel, resource_limit);
 
     // Add the limit to the handle table.
-    R_TRY(kernel.CurrentProcess()->GetHandleTable().Add(out_handle, resource_limit));
+    R_TRY(GetCurrentProcess(kernel).GetHandleTable().Add(out_handle, resource_limit));
 
     return ResultSuccess;
 }
 
-Result GetResourceLimitLimitValue(Core::System& system, u64* out_limit_value,
+Result GetResourceLimitLimitValue(Core::System& system, s64* out_limit_value,
                                   Handle resource_limit_handle, LimitableResource which) {
     LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}", resource_limit_handle,
               which);
@@ -41,9 +41,9 @@ Result GetResourceLimitLimitValue(Core::System& system, u64* out_limit_value,
     R_UNLESS(IsValidResourceType(which), ResultInvalidEnumValue);
 
     // Get the resource limit.
-    auto& kernel = system.Kernel();
-    KScopedAutoObject resource_limit =
-        kernel.CurrentProcess()->GetHandleTable().GetObject<KResourceLimit>(resource_limit_handle);
+    KScopedAutoObject resource_limit = GetCurrentProcess(system.Kernel())
+                                           .GetHandleTable()
+                                           .GetObject<KResourceLimit>(resource_limit_handle);
     R_UNLESS(resource_limit.IsNotNull(), ResultInvalidHandle);
 
     // Get the limit value.
@@ -52,7 +52,7 @@ Result GetResourceLimitLimitValue(Core::System& system, u64* out_limit_value,
     return ResultSuccess;
 }
 
-Result GetResourceLimitCurrentValue(Core::System& system, u64* out_current_value,
+Result GetResourceLimitCurrentValue(Core::System& system, s64* out_current_value,
                                     Handle resource_limit_handle, LimitableResource which) {
     LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}", resource_limit_handle,
               which);
@@ -61,9 +61,9 @@ Result GetResourceLimitCurrentValue(Core::System& system, u64* out_current_value
     R_UNLESS(IsValidResourceType(which), ResultInvalidEnumValue);
 
     // Get the resource limit.
-    auto& kernel = system.Kernel();
-    KScopedAutoObject resource_limit =
-        kernel.CurrentProcess()->GetHandleTable().GetObject<KResourceLimit>(resource_limit_handle);
+    KScopedAutoObject resource_limit = GetCurrentProcess(system.Kernel())
+                                           .GetHandleTable()
+                                           .GetObject<KResourceLimit>(resource_limit_handle);
     R_UNLESS(resource_limit.IsNotNull(), ResultInvalidHandle);
 
     // Get the current value.
@@ -73,7 +73,7 @@ Result GetResourceLimitCurrentValue(Core::System& system, u64* out_current_value
 }
 
 Result SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_handle,
-                                  LimitableResource which, u64 limit_value) {
+                                  LimitableResource which, s64 limit_value) {
     LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}, limit_value={}",
               resource_limit_handle, which, limit_value);
 
@@ -81,9 +81,9 @@ Result SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_ha
     R_UNLESS(IsValidResourceType(which), ResultInvalidEnumValue);
 
     // Get the resource limit.
-    auto& kernel = system.Kernel();
-    KScopedAutoObject resource_limit =
-        kernel.CurrentProcess()->GetHandleTable().GetObject<KResourceLimit>(resource_limit_handle);
+    KScopedAutoObject resource_limit = GetCurrentProcess(system.Kernel())
+                                           .GetHandleTable()
+                                           .GetObject<KResourceLimit>(resource_limit_handle);
     R_UNLESS(resource_limit.IsNotNull(), ResultInvalidHandle);
 
     // Set the limit value.
@@ -92,4 +92,58 @@ Result SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_ha
     return ResultSuccess;
 }
 
+Result GetResourceLimitPeakValue(Core::System& system, int64_t* out_peak_value,
+                                 Handle resource_limit_handle, LimitableResource which) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result GetResourceLimitLimitValue64(Core::System& system, int64_t* out_limit_value,
+                                    Handle resource_limit_handle, LimitableResource which) {
+    R_RETURN(GetResourceLimitLimitValue(system, out_limit_value, resource_limit_handle, which));
+}
+
+Result GetResourceLimitCurrentValue64(Core::System& system, int64_t* out_current_value,
+                                      Handle resource_limit_handle, LimitableResource which) {
+    R_RETURN(GetResourceLimitCurrentValue(system, out_current_value, resource_limit_handle, which));
+}
+
+Result GetResourceLimitPeakValue64(Core::System& system, int64_t* out_peak_value,
+                                   Handle resource_limit_handle, LimitableResource which) {
+    R_RETURN(GetResourceLimitPeakValue(system, out_peak_value, resource_limit_handle, which));
+}
+
+Result CreateResourceLimit64(Core::System& system, Handle* out_handle) {
+    R_RETURN(CreateResourceLimit(system, out_handle));
+}
+
+Result SetResourceLimitLimitValue64(Core::System& system, Handle resource_limit_handle,
+                                    LimitableResource which, int64_t limit_value) {
+    R_RETURN(SetResourceLimitLimitValue(system, resource_limit_handle, which, limit_value));
+}
+
+Result GetResourceLimitLimitValue64From32(Core::System& system, int64_t* out_limit_value,
+                                          Handle resource_limit_handle, LimitableResource which) {
+    R_RETURN(GetResourceLimitLimitValue(system, out_limit_value, resource_limit_handle, which));
+}
+
+Result GetResourceLimitCurrentValue64From32(Core::System& system, int64_t* out_current_value,
+                                            Handle resource_limit_handle, LimitableResource which) {
+    R_RETURN(GetResourceLimitCurrentValue(system, out_current_value, resource_limit_handle, which));
+}
+
+Result GetResourceLimitPeakValue64From32(Core::System& system, int64_t* out_peak_value,
+                                         Handle resource_limit_handle, LimitableResource which) {
+    R_RETURN(GetResourceLimitPeakValue(system, out_peak_value, resource_limit_handle, which));
+}
+
+Result CreateResourceLimit64From32(Core::System& system, Handle* out_handle) {
+    R_RETURN(CreateResourceLimit(system, out_handle));
+}
+
+Result SetResourceLimitLimitValue64From32(Core::System& system, Handle resource_limit_handle,
+                                          LimitableResource which, int64_t limit_value) {
+    R_RETURN(SetResourceLimitLimitValue(system, resource_limit_handle, which, limit_value));
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp b/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
index 299e22ae6..20f6ec643 100644
--- a/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
+++ b/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
@@ -1,6 +1,53 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/core.h"
+#include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/svc.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+void CallSecureMonitor(Core::System& system, lp64::SecureMonitorArguments* args) {
+    UNIMPLEMENTED();
+}
+
+void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args) {
+    CallSecureMonitor(system, args);
+}
+
+void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArguments* args) {
+    // CallSecureMonitor64From32 is not supported.
+    UNIMPLEMENTED_MSG("CallSecureMonitor64From32");
+}
+
+// Custom ABI for CallSecureMonitor.
+
+void SvcWrap_CallSecureMonitor64(Core::System& system) {
+    auto& core = system.CurrentPhysicalCore().ArmInterface();
+    lp64::SecureMonitorArguments args{};
+    for (int i = 0; i < 8; i++) {
+        args.r[i] = core.GetReg(i);
+    }
+
+    CallSecureMonitor64(system, &args);
+
+    for (int i = 0; i < 8; i++) {
+        core.SetReg(i, args.r[i]);
+    }
+}
+
+void SvcWrap_CallSecureMonitor64From32(Core::System& system) {
+    auto& core = system.CurrentPhysicalCore().ArmInterface();
+    ilp32::SecureMonitorArguments args{};
+    for (int i = 0; i < 8; i++) {
+        args.r[i] = static_cast<u32>(core.GetReg(i));
+    }
+
+    CallSecureMonitor64From32(system, &args);
+
+    for (int i = 0; i < 8; i++) {
+        core.SetReg(i, args.r[i]);
+    }
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_session.cpp b/src/core/hle/kernel/svc/svc_session.cpp
index dac8ce33c..00fd1605e 100644
--- a/src/core/hle/kernel/svc/svc_session.cpp
+++ b/src/core/hle/kernel/svc/svc_session.cpp
@@ -13,7 +13,7 @@ namespace {
 
 template <typename T>
 Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, u64 name) {
-    auto& process = *system.CurrentProcess();
+    auto& process = GetCurrentProcess(system.Kernel());
     auto& handle_table = process.GetHandleTable();
 
     // Declare the session we're going to allocate.
@@ -90,14 +90,39 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien
 
 } // namespace
 
-Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, u32 is_light,
+Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, bool is_light,
                      u64 name) {
     if (is_light) {
         // return CreateSession<KLightSession>(system, out_server, out_client, name);
-        return ResultUnknown;
+        return ResultNotImplemented;
     } else {
         return CreateSession<KSession>(system, out_server, out_client, name);
     }
 }
 
+Result AcceptSession(Core::System& system, Handle* out_handle, Handle port_handle) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result CreateSession64(Core::System& system, Handle* out_server_session_handle,
+                       Handle* out_client_session_handle, bool is_light, uint64_t name) {
+    R_RETURN(CreateSession(system, out_server_session_handle, out_client_session_handle, is_light,
+                           name));
+}
+
+Result AcceptSession64(Core::System& system, Handle* out_handle, Handle port) {
+    R_RETURN(AcceptSession(system, out_handle, port));
+}
+
+Result CreateSession64From32(Core::System& system, Handle* out_server_session_handle,
+                             Handle* out_client_session_handle, bool is_light, uint32_t name) {
+    R_RETURN(CreateSession(system, out_server_session_handle, out_client_session_handle, is_light,
+                           name));
+}
+
+Result AcceptSession64From32(Core::System& system, Handle* out_handle, Handle port) {
+    R_RETURN(AcceptSession(system, out_handle, port));
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_shared_memory.cpp b/src/core/hle/kernel/svc/svc_shared_memory.cpp
index d465bcbe7..18e0dc904 100644
--- a/src/core/hle/kernel/svc/svc_shared_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_shared_memory.cpp
@@ -42,7 +42,7 @@ Result MapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address,
     R_UNLESS(IsValidSharedMemoryPermission(map_perm), ResultInvalidNewMemoryPermission);
 
     // Get the current process.
-    auto& process = *system.Kernel().CurrentProcess();
+    auto& process = GetCurrentProcess(system.Kernel());
     auto& page_table = process.PageTable();
 
     // Get the shared memory.
@@ -67,11 +67,6 @@ Result MapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address,
     return ResultSuccess;
 }
 
-Result MapSharedMemory32(Core::System& system, Handle shmem_handle, u32 address, u32 size,
-                         Svc::MemoryPermission map_perm) {
-    return MapSharedMemory(system, shmem_handle, address, size, map_perm);
-}
-
 Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address, u64 size) {
     // Validate the address/size.
     R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
@@ -80,7 +75,7 @@ Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, VAddr addres
     R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
 
     // Get the current process.
-    auto& process = *system.Kernel().CurrentProcess();
+    auto& process = GetCurrentProcess(system.Kernel());
     auto& page_table = process.PageTable();
 
     // Get the shared memory.
@@ -99,8 +94,40 @@ Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, VAddr addres
     return ResultSuccess;
 }
 
-Result UnmapSharedMemory32(Core::System& system, Handle shmem_handle, u32 address, u32 size) {
-    return UnmapSharedMemory(system, shmem_handle, address, size);
+Result CreateSharedMemory(Core::System& system, Handle* out_handle, uint64_t size,
+                          MemoryPermission owner_perm, MemoryPermission remote_perm) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result MapSharedMemory64(Core::System& system, Handle shmem_handle, uint64_t address, uint64_t size,
+                         MemoryPermission map_perm) {
+    R_RETURN(MapSharedMemory(system, shmem_handle, address, size, map_perm));
+}
+
+Result UnmapSharedMemory64(Core::System& system, Handle shmem_handle, uint64_t address,
+                           uint64_t size) {
+    R_RETURN(UnmapSharedMemory(system, shmem_handle, address, size));
+}
+
+Result CreateSharedMemory64(Core::System& system, Handle* out_handle, uint64_t size,
+                            MemoryPermission owner_perm, MemoryPermission remote_perm) {
+    R_RETURN(CreateSharedMemory(system, out_handle, size, owner_perm, remote_perm));
+}
+
+Result MapSharedMemory64From32(Core::System& system, Handle shmem_handle, uint32_t address,
+                               uint32_t size, MemoryPermission map_perm) {
+    R_RETURN(MapSharedMemory(system, shmem_handle, address, size, map_perm));
+}
+
+Result UnmapSharedMemory64From32(Core::System& system, Handle shmem_handle, uint32_t address,
+                                 uint32_t size) {
+    R_RETURN(UnmapSharedMemory(system, shmem_handle, address, size));
+}
+
+Result CreateSharedMemory64From32(Core::System& system, Handle* out_handle, uint32_t size,
+                                  MemoryPermission owner_perm, MemoryPermission remote_perm) {
+    R_RETURN(CreateSharedMemory(system, out_handle, size, owner_perm, remote_perm));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_synchronization.cpp b/src/core/hle/kernel/svc/svc_synchronization.cpp
index 1bf6a612a..1a8f7e191 100644
--- a/src/core/hle/kernel/svc/svc_synchronization.cpp
+++ b/src/core/hle/kernel/svc/svc_synchronization.cpp
@@ -14,22 +14,18 @@ Result CloseHandle(Core::System& system, Handle handle) {
     LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
 
     // Remove the handle.
-    R_UNLESS(system.Kernel().CurrentProcess()->GetHandleTable().Remove(handle),
+    R_UNLESS(GetCurrentProcess(system.Kernel()).GetHandleTable().Remove(handle),
              ResultInvalidHandle);
 
     return ResultSuccess;
 }
 
-Result CloseHandle32(Core::System& system, Handle handle) {
-    return CloseHandle(system, handle);
-}
-
 /// Clears the signaled state of an event or process.
 Result ResetSignal(Core::System& system, Handle handle) {
     LOG_DEBUG(Kernel_SVC, "called handle 0x{:08X}", handle);
 
     // Get the current handle table.
-    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
+    const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
 
     // Try to reset as readable event.
     {
@@ -52,10 +48,6 @@ Result ResetSignal(Core::System& system, Handle handle) {
     return ResultInvalidHandle;
 }
 
-Result ResetSignal32(Core::System& system, Handle handle) {
-    return ResetSignal(system, handle);
-}
-
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
 Result WaitSynchronization(Core::System& system, s32* index, VAddr handles_address, s32 num_handles,
                            s64 nano_seconds) {
@@ -67,7 +59,7 @@ Result WaitSynchronization(Core::System& system, s32* index, VAddr handles_addre
 
     auto& kernel = system.Kernel();
     std::vector<KSynchronizationObject*> objs(num_handles);
-    const auto& handle_table = kernel.CurrentProcess()->GetHandleTable();
+    const auto& handle_table = GetCurrentProcess(kernel).GetHandleTable();
     Handle* handles = system.Memory().GetPointer<Handle>(handles_address);
 
     // Copy user handles.
@@ -93,19 +85,13 @@ Result WaitSynchronization(Core::System& system, s32* index, VAddr handles_addre
                                         nano_seconds);
 }
 
-Result WaitSynchronization32(Core::System& system, u32 timeout_low, u32 handles_address,
-                             s32 num_handles, u32 timeout_high, s32* index) {
-    const s64 nano_seconds{(static_cast<s64>(timeout_high) << 32) | static_cast<s64>(timeout_low)};
-    return WaitSynchronization(system, index, handles_address, num_handles, nano_seconds);
-}
-
 /// Resumes a thread waiting on WaitSynchronization
 Result CancelSynchronization(Core::System& system, Handle handle) {
     LOG_TRACE(Kernel_SVC, "called handle=0x{:X}", handle);
 
     // Get the thread from its handle.
     KScopedAutoObject thread =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KThread>(handle);
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Cancel the thread's wait.
@@ -113,10 +99,6 @@ Result CancelSynchronization(Core::System& system, Handle handle) {
     return ResultSuccess;
 }
 
-Result CancelSynchronization32(Core::System& system, Handle handle) {
-    return CancelSynchronization(system, handle);
-}
-
 void SynchronizePreemptionState(Core::System& system) {
     auto& kernel = system.Kernel();
 
@@ -124,7 +106,7 @@ void SynchronizePreemptionState(Core::System& system) {
     KScopedSchedulerLock sl{kernel};
 
     // If the current thread is pinned, unpin it.
-    KProcess* cur_process = system.Kernel().CurrentProcess();
+    KProcess* cur_process = GetCurrentProcessPointer(kernel);
     const auto core_id = GetCurrentCoreId(kernel);
 
     if (cur_process->GetPinnedThread(core_id) == GetCurrentThreadPointer(kernel)) {
@@ -136,4 +118,46 @@ void SynchronizePreemptionState(Core::System& system) {
     }
 }
 
+Result CloseHandle64(Core::System& system, Handle handle) {
+    R_RETURN(CloseHandle(system, handle));
+}
+
+Result ResetSignal64(Core::System& system, Handle handle) {
+    R_RETURN(ResetSignal(system, handle));
+}
+
+Result WaitSynchronization64(Core::System& system, int32_t* out_index, uint64_t handles,
+                             int32_t num_handles, int64_t timeout_ns) {
+    R_RETURN(WaitSynchronization(system, out_index, handles, num_handles, timeout_ns));
+}
+
+Result CancelSynchronization64(Core::System& system, Handle handle) {
+    R_RETURN(CancelSynchronization(system, handle));
+}
+
+void SynchronizePreemptionState64(Core::System& system) {
+    SynchronizePreemptionState(system);
+}
+
+Result CloseHandle64From32(Core::System& system, Handle handle) {
+    R_RETURN(CloseHandle(system, handle));
+}
+
+Result ResetSignal64From32(Core::System& system, Handle handle) {
+    R_RETURN(ResetSignal(system, handle));
+}
+
+Result WaitSynchronization64From32(Core::System& system, int32_t* out_index, uint32_t handles,
+                                   int32_t num_handles, int64_t timeout_ns) {
+    R_RETURN(WaitSynchronization(system, out_index, handles, num_handles, timeout_ns));
+}
+
+Result CancelSynchronization64From32(Core::System& system, Handle handle) {
+    R_RETURN(CancelSynchronization(system, handle));
+}
+
+void SynchronizePreemptionState64From32(Core::System& system) {
+    SynchronizePreemptionState(system);
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_thread.cpp b/src/core/hle/kernel/svc/svc_thread.cpp
index dd9f8e8b1..b39807841 100644
--- a/src/core/hle/kernel/svc/svc_thread.cpp
+++ b/src/core/hle/kernel/svc/svc_thread.cpp
@@ -20,7 +20,7 @@ constexpr bool IsValidVirtualCoreId(int32_t core_id) {
 
 /// Creates a new thread
 Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point, u64 arg,
-                    VAddr stack_bottom, u32 priority, s32 core_id) {
+                    VAddr stack_bottom, s32 priority, s32 core_id) {
     LOG_DEBUG(Kernel_SVC,
               "called entry_point=0x{:08X}, arg=0x{:08X}, stack_bottom=0x{:08X}, "
               "priority=0x{:08X}, core_id=0x{:08X}",
@@ -28,7 +28,7 @@ Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point,
 
     // Adjust core id, if it's the default magic.
     auto& kernel = system.Kernel();
-    auto& process = *kernel.CurrentProcess();
+    auto& process = GetCurrentProcess(kernel);
     if (core_id == IdealCoreUseProcessValue) {
         core_id = process.GetIdealCoreId();
     }
@@ -53,9 +53,9 @@ Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point,
     }
 
     // Reserve a new thread from the process resource limit (waiting up to 100ms).
-    KScopedResourceReservation thread_reservation(
-        kernel.CurrentProcess(), LimitableResource::ThreadCountMax, 1,
-        system.CoreTiming().GetGlobalTimeNs().count() + 100000000);
+    KScopedResourceReservation thread_reservation(&process, LimitableResource::ThreadCountMax, 1,
+                                                  system.CoreTiming().GetGlobalTimeNs().count() +
+                                                      100000000);
     if (!thread_reservation.Succeeded()) {
         LOG_ERROR(Kernel_SVC, "Could not reserve a new thread");
         return ResultLimitReached;
@@ -91,18 +91,13 @@ Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point,
     return ResultSuccess;
 }
 
-Result CreateThread32(Core::System& system, Handle* out_handle, u32 priority, u32 entry_point,
-                      u32 arg, u32 stack_top, s32 processor_id) {
-    return CreateThread(system, out_handle, entry_point, arg, stack_top, priority, processor_id);
-}
-
 /// Starts the thread for the provided handle
 Result StartThread(Core::System& system, Handle thread_handle) {
     LOG_DEBUG(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
     // Get the thread from its handle.
     KScopedAutoObject thread =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KThread>(thread_handle);
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Try to start the thread.
@@ -115,10 +110,6 @@ Result StartThread(Core::System& system, Handle thread_handle) {
     return ResultSuccess;
 }
 
-Result StartThread32(Core::System& system, Handle thread_handle) {
-    return StartThread(system, thread_handle);
-}
-
 /// Called when a thread exits
 void ExitThread(Core::System& system) {
     LOG_DEBUG(Kernel_SVC, "called, pc=0x{:08X}", system.CurrentArmInterface().GetPC());
@@ -129,10 +120,6 @@ void ExitThread(Core::System& system) {
     system.Kernel().UnregisterInUseObject(current_thread);
 }
 
-void ExitThread32(Core::System& system) {
-    ExitThread(system);
-}
-
 /// Sleep the current thread
 void SleepThread(Core::System& system, s64 nanoseconds) {
     auto& kernel = system.Kernel();
@@ -160,13 +147,8 @@ void SleepThread(Core::System& system, s64 nanoseconds) {
     }
 }
 
-void SleepThread32(Core::System& system, u32 nanoseconds_low, u32 nanoseconds_high) {
-    const auto nanoseconds = static_cast<s64>(u64{nanoseconds_low} | (u64{nanoseconds_high} << 32));
-    SleepThread(system, nanoseconds);
-}
-
 /// Gets the thread context
-Result GetThreadContext(Core::System& system, VAddr out_context, Handle thread_handle) {
+Result GetThreadContext3(Core::System& system, VAddr out_context, Handle thread_handle) {
     LOG_DEBUG(Kernel_SVC, "called, out_context=0x{:08X}, thread_handle=0x{:X}", out_context,
               thread_handle);
 
@@ -174,11 +156,11 @@ Result GetThreadContext(Core::System& system, VAddr out_context, Handle thread_h
 
     // Get the thread from its handle.
     KScopedAutoObject thread =
-        kernel.CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
+        GetCurrentProcess(kernel).GetHandleTable().GetObject<KThread>(thread_handle);
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Require the handle be to a non-current thread in the current process.
-    const auto* current_process = kernel.CurrentProcess();
+    const auto* current_process = GetCurrentProcessPointer(kernel);
     R_UNLESS(current_process == thread->GetOwnerProcess(), ResultInvalidId);
 
     // Verify that the thread isn't terminated.
@@ -223,17 +205,13 @@ Result GetThreadContext(Core::System& system, VAddr out_context, Handle thread_h
     return ResultSuccess;
 }
 
-Result GetThreadContext32(Core::System& system, u32 out_context, Handle thread_handle) {
-    return GetThreadContext(system, out_context, thread_handle);
-}
-
 /// Gets the priority for the specified thread
-Result GetThreadPriority(Core::System& system, u32* out_priority, Handle handle) {
+Result GetThreadPriority(Core::System& system, s32* out_priority, Handle handle) {
     LOG_TRACE(Kernel_SVC, "called");
 
     // Get the thread from its handle.
     KScopedAutoObject thread =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KThread>(handle);
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Get the thread's priority.
@@ -241,14 +219,10 @@ Result GetThreadPriority(Core::System& system, u32* out_priority, Handle handle)
     return ResultSuccess;
 }
 
-Result GetThreadPriority32(Core::System& system, u32* out_priority, Handle handle) {
-    return GetThreadPriority(system, out_priority, handle);
-}
-
 /// Sets the priority for the specified thread
-Result SetThreadPriority(Core::System& system, Handle thread_handle, u32 priority) {
+Result SetThreadPriority(Core::System& system, Handle thread_handle, s32 priority) {
     // Get the current process.
-    KProcess& process = *system.Kernel().CurrentProcess();
+    KProcess& process = GetCurrentProcess(system.Kernel());
 
     // Validate the priority.
     R_UNLESS(HighestThreadPriority <= priority && priority <= LowestThreadPriority,
@@ -264,12 +238,8 @@ Result SetThreadPriority(Core::System& system, Handle thread_handle, u32 priorit
     return ResultSuccess;
 }
 
-Result SetThreadPriority32(Core::System& system, Handle thread_handle, u32 priority) {
-    return SetThreadPriority(system, thread_handle, priority);
-}
-
-Result GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_thread_ids,
-                     u32 out_thread_ids_size, Handle debug_handle) {
+Result GetThreadList(Core::System& system, s32* out_num_threads, VAddr out_thread_ids,
+                     s32 out_thread_ids_size, Handle debug_handle) {
     // TODO: Handle this case when debug events are supported.
     UNIMPLEMENTED_IF(debug_handle != InvalidHandle);
 
@@ -283,7 +253,7 @@ Result GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_threa
         return ResultOutOfRange;
     }
 
-    auto* const current_process = system.Kernel().CurrentProcess();
+    auto* const current_process = GetCurrentProcessPointer(system.Kernel());
     const auto total_copy_size = out_thread_ids_size * sizeof(u64);
 
     if (out_thread_ids_size > 0 &&
@@ -296,7 +266,7 @@ Result GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_threa
     auto& memory = system.Memory();
     const auto& thread_list = current_process->GetThreadList();
     const auto num_threads = thread_list.size();
-    const auto copy_amount = std::min(std::size_t{out_thread_ids_size}, num_threads);
+    const auto copy_amount = std::min(static_cast<std::size_t>(out_thread_ids_size), num_threads);
 
     auto list_iter = thread_list.cbegin();
     for (std::size_t i = 0; i < copy_amount; ++i, ++list_iter) {
@@ -308,13 +278,13 @@ Result GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_threa
     return ResultSuccess;
 }
 
-Result GetThreadCoreMask(Core::System& system, Handle thread_handle, s32* out_core_id,
-                         u64* out_affinity_mask) {
+Result GetThreadCoreMask(Core::System& system, s32* out_core_id, u64* out_affinity_mask,
+                         Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
 
     // Get the thread from its handle.
     KScopedAutoObject thread =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KThread>(thread_handle);
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Get the core mask.
@@ -323,24 +293,15 @@ Result GetThreadCoreMask(Core::System& system, Handle thread_handle, s32* out_co
     return ResultSuccess;
 }
 
-Result GetThreadCoreMask32(Core::System& system, Handle thread_handle, s32* out_core_id,
-                           u32* out_affinity_mask_low, u32* out_affinity_mask_high) {
-    u64 out_affinity_mask{};
-    const auto result = GetThreadCoreMask(system, thread_handle, out_core_id, &out_affinity_mask);
-    *out_affinity_mask_high = static_cast<u32>(out_affinity_mask >> 32);
-    *out_affinity_mask_low = static_cast<u32>(out_affinity_mask);
-    return result;
-}
-
 Result SetThreadCoreMask(Core::System& system, Handle thread_handle, s32 core_id,
                          u64 affinity_mask) {
     // Determine the core id/affinity mask.
     if (core_id == IdealCoreUseProcessValue) {
-        core_id = system.Kernel().CurrentProcess()->GetIdealCoreId();
+        core_id = GetCurrentProcess(system.Kernel()).GetIdealCoreId();
         affinity_mask = (1ULL << core_id);
     } else {
         // Validate the affinity mask.
-        const u64 process_core_mask = system.Kernel().CurrentProcess()->GetCoreMask();
+        const u64 process_core_mask = GetCurrentProcess(system.Kernel()).GetCoreMask();
         R_UNLESS((affinity_mask | process_core_mask) == process_core_mask, ResultInvalidCoreId);
         R_UNLESS(affinity_mask != 0, ResultInvalidCombination);
 
@@ -355,7 +316,7 @@ Result SetThreadCoreMask(Core::System& system, Handle thread_handle, s32 core_id
 
     // Get the thread from its handle.
     KScopedAutoObject thread =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KThread>(thread_handle);
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Set the core mask.
@@ -364,17 +325,11 @@ Result SetThreadCoreMask(Core::System& system, Handle thread_handle, s32 core_id
     return ResultSuccess;
 }
 
-Result SetThreadCoreMask32(Core::System& system, Handle thread_handle, s32 core_id,
-                           u32 affinity_mask_low, u32 affinity_mask_high) {
-    const auto affinity_mask = u64{affinity_mask_low} | (u64{affinity_mask_high} << 32);
-    return SetThreadCoreMask(system, thread_handle, core_id, affinity_mask);
-}
-
 /// Get the ID for the specified thread.
 Result GetThreadId(Core::System& system, u64* out_thread_id, Handle thread_handle) {
     // Get the thread from its handle.
     KScopedAutoObject thread =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
+        GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KThread>(thread_handle);
     R_UNLESS(thread.IsNotNull(), ResultInvalidHandle);
 
     // Get the thread's id.
@@ -382,15 +337,101 @@ Result GetThreadId(Core::System& system, u64* out_thread_id, Handle thread_handl
     return ResultSuccess;
 }
 
-Result GetThreadId32(Core::System& system, u32* out_thread_id_low, u32* out_thread_id_high,
-                     Handle thread_handle) {
-    u64 out_thread_id{};
-    const Result result{GetThreadId(system, &out_thread_id, thread_handle)};
+Result CreateThread64(Core::System& system, Handle* out_handle, uint64_t func, uint64_t arg,
+                      uint64_t stack_bottom, int32_t priority, int32_t core_id) {
+    R_RETURN(CreateThread(system, out_handle, func, arg, stack_bottom, priority, core_id));
+}
+
+Result StartThread64(Core::System& system, Handle thread_handle) {
+    R_RETURN(StartThread(system, thread_handle));
+}
+
+void ExitThread64(Core::System& system) {
+    return ExitThread(system);
+}
+
+void SleepThread64(Core::System& system, int64_t ns) {
+    return SleepThread(system, ns);
+}
+
+Result GetThreadPriority64(Core::System& system, int32_t* out_priority, Handle thread_handle) {
+    R_RETURN(GetThreadPriority(system, out_priority, thread_handle));
+}
+
+Result SetThreadPriority64(Core::System& system, Handle thread_handle, int32_t priority) {
+    R_RETURN(SetThreadPriority(system, thread_handle, priority));
+}
+
+Result GetThreadCoreMask64(Core::System& system, int32_t* out_core_id, uint64_t* out_affinity_mask,
+                           Handle thread_handle) {
+    R_RETURN(GetThreadCoreMask(system, out_core_id, out_affinity_mask, thread_handle));
+}
+
+Result SetThreadCoreMask64(Core::System& system, Handle thread_handle, int32_t core_id,
+                           uint64_t affinity_mask) {
+    R_RETURN(SetThreadCoreMask(system, thread_handle, core_id, affinity_mask));
+}
+
+Result GetThreadId64(Core::System& system, uint64_t* out_thread_id, Handle thread_handle) {
+    R_RETURN(GetThreadId(system, out_thread_id, thread_handle));
+}
+
+Result GetThreadContext364(Core::System& system, uint64_t out_context, Handle thread_handle) {
+    R_RETURN(GetThreadContext3(system, out_context, thread_handle));
+}
 
-    *out_thread_id_low = static_cast<u32>(out_thread_id >> 32);
-    *out_thread_id_high = static_cast<u32>(out_thread_id & std::numeric_limits<u32>::max());
+Result GetThreadList64(Core::System& system, int32_t* out_num_threads, uint64_t out_thread_ids,
+                       int32_t max_out_count, Handle debug_handle) {
+    R_RETURN(GetThreadList(system, out_num_threads, out_thread_ids, max_out_count, debug_handle));
+}
+
+Result CreateThread64From32(Core::System& system, Handle* out_handle, uint32_t func, uint32_t arg,
+                            uint32_t stack_bottom, int32_t priority, int32_t core_id) {
+    R_RETURN(CreateThread(system, out_handle, func, arg, stack_bottom, priority, core_id));
+}
+
+Result StartThread64From32(Core::System& system, Handle thread_handle) {
+    R_RETURN(StartThread(system, thread_handle));
+}
+
+void ExitThread64From32(Core::System& system) {
+    return ExitThread(system);
+}
+
+void SleepThread64From32(Core::System& system, int64_t ns) {
+    return SleepThread(system, ns);
+}
+
+Result GetThreadPriority64From32(Core::System& system, int32_t* out_priority,
+                                 Handle thread_handle) {
+    R_RETURN(GetThreadPriority(system, out_priority, thread_handle));
+}
+
+Result SetThreadPriority64From32(Core::System& system, Handle thread_handle, int32_t priority) {
+    R_RETURN(SetThreadPriority(system, thread_handle, priority));
+}
+
+Result GetThreadCoreMask64From32(Core::System& system, int32_t* out_core_id,
+                                 uint64_t* out_affinity_mask, Handle thread_handle) {
+    R_RETURN(GetThreadCoreMask(system, out_core_id, out_affinity_mask, thread_handle));
+}
+
+Result SetThreadCoreMask64From32(Core::System& system, Handle thread_handle, int32_t core_id,
+                                 uint64_t affinity_mask) {
+    R_RETURN(SetThreadCoreMask(system, thread_handle, core_id, affinity_mask));
+}
+
+Result GetThreadId64From32(Core::System& system, uint64_t* out_thread_id, Handle thread_handle) {
+    R_RETURN(GetThreadId(system, out_thread_id, thread_handle));
+}
+
+Result GetThreadContext364From32(Core::System& system, uint32_t out_context, Handle thread_handle) {
+    R_RETURN(GetThreadContext3(system, out_context, thread_handle));
+}
 
-    return result;
+Result GetThreadList64From32(Core::System& system, int32_t* out_num_threads,
+                             uint32_t out_thread_ids, int32_t max_out_count, Handle debug_handle) {
+    R_RETURN(GetThreadList(system, out_num_threads, out_thread_ids, max_out_count, debug_handle));
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_thread_profiler.cpp b/src/core/hle/kernel/svc/svc_thread_profiler.cpp
index 299e22ae6..40de7708b 100644
--- a/src/core/hle/kernel/svc/svc_thread_profiler.cpp
+++ b/src/core/hle/kernel/svc/svc_thread_profiler.cpp
@@ -2,5 +2,59 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/svc_results.h"
 
-namespace Kernel::Svc {} // namespace Kernel::Svc
+namespace Kernel::Svc {
+
+Result GetDebugFutureThreadInfo(Core::System& system, lp64::LastThreadContext* out_context,
+                                uint64_t* out_thread_id, Handle debug_handle, int64_t ns) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result GetLastThreadInfo(Core::System& system, lp64::LastThreadContext* out_context,
+                         uint64_t* out_tls_address, uint32_t* out_flags) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result GetDebugFutureThreadInfo64(Core::System& system, lp64::LastThreadContext* out_context,
+                                  uint64_t* out_thread_id, Handle debug_handle, int64_t ns) {
+    R_RETURN(GetDebugFutureThreadInfo(system, out_context, out_thread_id, debug_handle, ns));
+}
+
+Result GetLastThreadInfo64(Core::System& system, lp64::LastThreadContext* out_context,
+                           uint64_t* out_tls_address, uint32_t* out_flags) {
+    R_RETURN(GetLastThreadInfo(system, out_context, out_tls_address, out_flags));
+}
+
+Result GetDebugFutureThreadInfo64From32(Core::System& system, ilp32::LastThreadContext* out_context,
+                                        uint64_t* out_thread_id, Handle debug_handle, int64_t ns) {
+    lp64::LastThreadContext context{};
+    R_TRY(
+        GetDebugFutureThreadInfo(system, std::addressof(context), out_thread_id, debug_handle, ns));
+
+    *out_context = {
+        .fp = static_cast<u32>(context.fp),
+        .sp = static_cast<u32>(context.sp),
+        .lr = static_cast<u32>(context.lr),
+        .pc = static_cast<u32>(context.pc),
+    };
+    R_SUCCEED();
+}
+
+Result GetLastThreadInfo64From32(Core::System& system, ilp32::LastThreadContext* out_context,
+                                 uint64_t* out_tls_address, uint32_t* out_flags) {
+    lp64::LastThreadContext context{};
+    R_TRY(GetLastThreadInfo(system, std::addressof(context), out_tls_address, out_flags));
+
+    *out_context = {
+        .fp = static_cast<u32>(context.fp),
+        .sp = static_cast<u32>(context.sp),
+        .lr = static_cast<u32>(context.lr),
+        .pc = static_cast<u32>(context.pc),
+    };
+    R_SUCCEED();
+}
+
+} // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_tick.cpp b/src/core/hle/kernel/svc/svc_tick.cpp
index e9b4fd5a6..561336482 100644
--- a/src/core/hle/kernel/svc/svc_tick.cpp
+++ b/src/core/hle/kernel/svc/svc_tick.cpp
@@ -9,7 +9,7 @@
 namespace Kernel::Svc {
 
 /// This returns the total CPU ticks elapsed since the CPU was powered-on
-u64 GetSystemTick(Core::System& system) {
+int64_t GetSystemTick(Core::System& system) {
     LOG_TRACE(Kernel_SVC, "called");
 
     auto& core_timing = system.CoreTiming();
@@ -21,13 +21,15 @@ u64 GetSystemTick(Core::System& system) {
         core_timing.AddTicks(400U);
     }
 
-    return result;
+    return static_cast<int64_t>(result);
 }
 
-void GetSystemTick32(Core::System& system, u32* time_low, u32* time_high) {
-    const auto time = GetSystemTick(system);
-    *time_low = static_cast<u32>(time);
-    *time_high = static_cast<u32>(time >> 32);
+int64_t GetSystemTick64(Core::System& system) {
+    return GetSystemTick(system);
+}
+
+int64_t GetSystemTick64From32(Core::System& system) {
+    return GetSystemTick(system);
 }
 
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc/svc_transfer_memory.cpp b/src/core/hle/kernel/svc/svc_transfer_memory.cpp
index b14ae24a1..7ffc24adf 100644
--- a/src/core/hle/kernel/svc/svc_transfer_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_transfer_memory.cpp
@@ -39,11 +39,11 @@ Result CreateTransferMemory(Core::System& system, Handle* out, VAddr address, u6
     R_UNLESS(IsValidTransferMemoryPermission(map_perm), ResultInvalidNewMemoryPermission);
 
     // Get the current process and handle table.
-    auto& process = *kernel.CurrentProcess();
+    auto& process = GetCurrentProcess(kernel);
     auto& handle_table = process.GetHandleTable();
 
     // Reserve a new transfer memory from the process resource limit.
-    KScopedResourceReservation trmem_reservation(kernel.CurrentProcess(),
+    KScopedResourceReservation trmem_reservation(&process,
                                                  LimitableResource::TransferMemoryCountMax);
     R_UNLESS(trmem_reservation.Succeeded(), ResultLimitReached);
 
@@ -72,8 +72,46 @@ Result CreateTransferMemory(Core::System& system, Handle* out, VAddr address, u6
     return ResultSuccess;
 }
 
-Result CreateTransferMemory32(Core::System& system, Handle* out, u32 address, u32 size,
-                              MemoryPermission map_perm) {
-    return CreateTransferMemory(system, out, address, size, map_perm);
+Result MapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address, uint64_t size,
+                         MemoryPermission owner_perm) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
 }
+
+Result UnmapTransferMemory(Core::System& system, Handle trmem_handle, uint64_t address,
+                           uint64_t size) {
+    UNIMPLEMENTED();
+    R_THROW(ResultNotImplemented);
+}
+
+Result MapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address,
+                           uint64_t size, MemoryPermission owner_perm) {
+    R_RETURN(MapTransferMemory(system, trmem_handle, address, size, owner_perm));
+}
+
+Result UnmapTransferMemory64(Core::System& system, Handle trmem_handle, uint64_t address,
+                             uint64_t size) {
+    R_RETURN(UnmapTransferMemory(system, trmem_handle, address, size));
+}
+
+Result CreateTransferMemory64(Core::System& system, Handle* out_handle, uint64_t address,
+                              uint64_t size, MemoryPermission map_perm) {
+    R_RETURN(CreateTransferMemory(system, out_handle, address, size, map_perm));
+}
+
+Result MapTransferMemory64From32(Core::System& system, Handle trmem_handle, uint32_t address,
+                                 uint32_t size, MemoryPermission owner_perm) {
+    R_RETURN(MapTransferMemory(system, trmem_handle, address, size, owner_perm));
+}
+
+Result UnmapTransferMemory64From32(Core::System& system, Handle trmem_handle, uint32_t address,
+                                   uint32_t size) {
+    R_RETURN(UnmapTransferMemory(system, trmem_handle, address, size));
+}
+
+Result CreateTransferMemory64From32(Core::System& system, Handle* out_handle, uint32_t address,
+                                    uint32_t size, MemoryPermission map_perm) {
+    R_RETURN(CreateTransferMemory(system, out_handle, address, size, map_perm));
+}
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc_generator.py b/src/core/hle/kernel/svc_generator.py
new file mode 100644
index 000000000..34d2ac659
--- /dev/null
+++ b/src/core/hle/kernel/svc_generator.py
@@ -0,0 +1,716 @@
+# SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+# Raw SVC definitions from the kernel.
+#
+# Avoid modifying the prototypes; see below for how to customize generation
+# for a given typename.
+SVCS = [
+     [0x01, "Result SetHeapSize(Address* out_address, Size size);"],
+     [0x02, "Result SetMemoryPermission(Address address, Size size, MemoryPermission perm);"],
+     [0x03, "Result SetMemoryAttribute(Address address, Size size, uint32_t mask, uint32_t attr);"],
+     [0x04, "Result MapMemory(Address dst_address, Address src_address, Size size);"],
+     [0x05, "Result UnmapMemory(Address dst_address, Address src_address, Size size);"],
+     [0x06, "Result QueryMemory(Address out_memory_info, PageInfo* out_page_info, Address address);"],
+     [0x07, "void ExitProcess();"],
+     [0x08, "Result CreateThread(Handle* out_handle, ThreadFunc func, Address arg, Address stack_bottom, int32_t priority, int32_t core_id);"],
+     [0x09, "Result StartThread(Handle thread_handle);"],
+     [0x0A, "void ExitThread();"],
+     [0x0B, "void SleepThread(int64_t ns);"],
+     [0x0C, "Result GetThreadPriority(int32_t* out_priority, Handle thread_handle);"],
+     [0x0D, "Result SetThreadPriority(Handle thread_handle, int32_t priority);"],
+     [0x0E, "Result GetThreadCoreMask(int32_t* out_core_id, uint64_t* out_affinity_mask, Handle thread_handle);"],
+     [0x0F, "Result SetThreadCoreMask(Handle thread_handle, int32_t core_id, uint64_t affinity_mask);"],
+     [0x10, "int32_t GetCurrentProcessorNumber();"],
+     [0x11, "Result SignalEvent(Handle event_handle);"],
+     [0x12, "Result ClearEvent(Handle event_handle);"],
+     [0x13, "Result MapSharedMemory(Handle shmem_handle, Address address, Size size, MemoryPermission map_perm);"],
+     [0x14, "Result UnmapSharedMemory(Handle shmem_handle, Address address, Size size);"],
+     [0x15, "Result CreateTransferMemory(Handle* out_handle, Address address, Size size, MemoryPermission map_perm);"],
+     [0x16, "Result CloseHandle(Handle handle);"],
+     [0x17, "Result ResetSignal(Handle handle);"],
+     [0x18, "Result WaitSynchronization(int32_t* out_index, Address handles, int32_t num_handles, int64_t timeout_ns);"],
+     [0x19, "Result CancelSynchronization(Handle handle);"],
+     [0x1A, "Result ArbitrateLock(Handle thread_handle, Address address, uint32_t tag);"],
+     [0x1B, "Result ArbitrateUnlock(Address address);"],
+     [0x1C, "Result WaitProcessWideKeyAtomic(Address address, Address cv_key, uint32_t tag, int64_t timeout_ns);"],
+     [0x1D, "void SignalProcessWideKey(Address cv_key, int32_t count);"],
+     [0x1E, "int64_t GetSystemTick();"],
+     [0x1F, "Result ConnectToNamedPort(Handle* out_handle, Address name);"],
+     [0x20, "Result SendSyncRequestLight(Handle session_handle);"],
+     [0x21, "Result SendSyncRequest(Handle session_handle);"],
+     [0x22, "Result SendSyncRequestWithUserBuffer(Address message_buffer, Size message_buffer_size, Handle session_handle);"],
+     [0x23, "Result SendAsyncRequestWithUserBuffer(Handle* out_event_handle, Address message_buffer, Size message_buffer_size, Handle session_handle);"],
+     [0x24, "Result GetProcessId(uint64_t* out_process_id, Handle process_handle);"],
+     [0x25, "Result GetThreadId(uint64_t* out_thread_id, Handle thread_handle);"],
+     [0x26, "void Break(BreakReason break_reason, Address arg, Size size);"],
+     [0x27, "Result OutputDebugString(Address debug_str, Size len);"],
+     [0x28, "void ReturnFromException(Result result);"],
+     [0x29, "Result GetInfo(uint64_t* out, InfoType info_type, Handle handle, uint64_t info_subtype);"],
+     [0x2A, "void FlushEntireDataCache();"],
+     [0x2B, "Result FlushDataCache(Address address, Size size);"],
+     [0x2C, "Result MapPhysicalMemory(Address address, Size size);"],
+     [0x2D, "Result UnmapPhysicalMemory(Address address, Size size);"],
+     [0x2E, "Result GetDebugFutureThreadInfo(LastThreadContext* out_context, uint64_t* out_thread_id, Handle debug_handle, int64_t ns);"],
+     [0x2F, "Result GetLastThreadInfo(LastThreadContext* out_context, Address* out_tls_address, uint32_t* out_flags);"],
+     [0x30, "Result GetResourceLimitLimitValue(int64_t* out_limit_value, Handle resource_limit_handle, LimitableResource which);"],
+     [0x31, "Result GetResourceLimitCurrentValue(int64_t* out_current_value, Handle resource_limit_handle, LimitableResource which);"],
+     [0x32, "Result SetThreadActivity(Handle thread_handle, ThreadActivity thread_activity);"],
+     [0x33, "Result GetThreadContext3(Address out_context, Handle thread_handle);"],
+     [0x34, "Result WaitForAddress(Address address, ArbitrationType arb_type, int32_t value, int64_t timeout_ns);"],
+     [0x35, "Result SignalToAddress(Address address, SignalType signal_type, int32_t value, int32_t count);"],
+     [0x36, "void SynchronizePreemptionState();"],
+     [0x37, "Result GetResourceLimitPeakValue(int64_t* out_peak_value, Handle resource_limit_handle, LimitableResource which);"],
+
+     [0x39, "Result CreateIoPool(Handle* out_handle, IoPoolType which);"],
+     [0x3A, "Result CreateIoRegion(Handle* out_handle, Handle io_pool, PhysicalAddress physical_address, Size size, MemoryMapping mapping, MemoryPermission perm);"],
+
+     [0x3C, "void KernelDebug(KernelDebugType kern_debug_type, uint64_t arg0, uint64_t arg1, uint64_t arg2);"],
+     [0x3D, "void ChangeKernelTraceState(KernelTraceState kern_trace_state);"],
+
+     [0x40, "Result CreateSession(Handle* out_server_session_handle, Handle* out_client_session_handle, bool is_light, Address name);"],
+     [0x41, "Result AcceptSession(Handle* out_handle, Handle port);"],
+     [0x42, "Result ReplyAndReceiveLight(Handle handle);"],
+     [0x43, "Result ReplyAndReceive(int32_t* out_index, Address handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);"],
+     [0x44, "Result ReplyAndReceiveWithUserBuffer(int32_t* out_index, Address message_buffer, Size message_buffer_size, Address handles, int32_t num_handles, Handle reply_target, int64_t timeout_ns);"],
+     [0x45, "Result CreateEvent(Handle* out_write_handle, Handle* out_read_handle);"],
+     [0x46, "Result MapIoRegion(Handle io_region, Address address, Size size, MemoryPermission perm);"],
+     [0x47, "Result UnmapIoRegion(Handle io_region, Address address, Size size);"],
+     [0x48, "Result MapPhysicalMemoryUnsafe(Address address, Size size);"],
+     [0x49, "Result UnmapPhysicalMemoryUnsafe(Address address, Size size);"],
+     [0x4A, "Result SetUnsafeLimit(Size limit);"],
+     [0x4B, "Result CreateCodeMemory(Handle* out_handle, Address address, Size size);"],
+     [0x4C, "Result ControlCodeMemory(Handle code_memory_handle, CodeMemoryOperation operation, uint64_t address, uint64_t size, MemoryPermission perm);"],
+     [0x4D, "void SleepSystem();"],
+     [0x4E, "Result ReadWriteRegister(uint32_t* out_value, PhysicalAddress address, uint32_t mask, uint32_t value);"],
+     [0x4F, "Result SetProcessActivity(Handle process_handle, ProcessActivity process_activity);"],
+     [0x50, "Result CreateSharedMemory(Handle* out_handle, Size size, MemoryPermission owner_perm, MemoryPermission remote_perm);"],
+     [0x51, "Result MapTransferMemory(Handle trmem_handle, Address address, Size size, MemoryPermission owner_perm);"],
+     [0x52, "Result UnmapTransferMemory(Handle trmem_handle, Address address, Size size);"],
+     [0x53, "Result CreateInterruptEvent(Handle* out_read_handle, int32_t interrupt_id, InterruptType interrupt_type);"],
+     [0x54, "Result QueryPhysicalAddress(PhysicalMemoryInfo* out_info, Address address);"],
+     [0x55, "Result QueryIoMapping(Address* out_address, Size* out_size, PhysicalAddress physical_address, Size size);"],
+     [0x56, "Result CreateDeviceAddressSpace(Handle* out_handle, uint64_t das_address, uint64_t das_size);"],
+     [0x57, "Result AttachDeviceAddressSpace(DeviceName device_name, Handle das_handle);"],
+     [0x58, "Result DetachDeviceAddressSpace(DeviceName device_name, Handle das_handle);"],
+     [0x59, "Result MapDeviceAddressSpaceByForce(Handle das_handle, Handle process_handle, uint64_t process_address, Size size, uint64_t device_address, uint32_t option);"],
+     [0x5A, "Result MapDeviceAddressSpaceAligned(Handle das_handle, Handle process_handle, uint64_t process_address, Size size, uint64_t device_address, uint32_t option);"],
+     [0x5C, "Result UnmapDeviceAddressSpace(Handle das_handle, Handle process_handle, uint64_t process_address, Size size, uint64_t device_address);"],
+     [0x5D, "Result InvalidateProcessDataCache(Handle process_handle, uint64_t address, uint64_t size);"],
+     [0x5E, "Result StoreProcessDataCache(Handle process_handle, uint64_t address, uint64_t size);"],
+     [0x5F, "Result FlushProcessDataCache(Handle process_handle, uint64_t address, uint64_t size);"],
+     [0x60, "Result DebugActiveProcess(Handle* out_handle, uint64_t process_id);"],
+     [0x61, "Result BreakDebugProcess(Handle debug_handle);"],
+     [0x62, "Result TerminateDebugProcess(Handle debug_handle);"],
+     [0x63, "Result GetDebugEvent(Address out_info, Handle debug_handle);"],
+     [0x64, "Result ContinueDebugEvent(Handle debug_handle, uint32_t flags, Address thread_ids, int32_t num_thread_ids);"],
+     [0x65, "Result GetProcessList(int32_t* out_num_processes, Address out_process_ids, int32_t max_out_count);"],
+     [0x66, "Result GetThreadList(int32_t* out_num_threads, Address out_thread_ids, int32_t max_out_count, Handle debug_handle);"],
+     [0x67, "Result GetDebugThreadContext(Address out_context, Handle debug_handle, uint64_t thread_id, uint32_t context_flags);"],
+     [0x68, "Result SetDebugThreadContext(Handle debug_handle, uint64_t thread_id, Address context, uint32_t context_flags);"],
+     [0x69, "Result QueryDebugProcessMemory(Address out_memory_info, PageInfo* out_page_info, Handle process_handle, Address address);"],
+     [0x6A, "Result ReadDebugProcessMemory(Address buffer, Handle debug_handle, Address address, Size size);"],
+     [0x6B, "Result WriteDebugProcessMemory(Handle debug_handle, Address buffer, Address address, Size size);"],
+     [0x6C, "Result SetHardwareBreakPoint(HardwareBreakPointRegisterName name, uint64_t flags, uint64_t value);"],
+     [0x6D, "Result GetDebugThreadParam(uint64_t* out_64, uint32_t* out_32, Handle debug_handle, uint64_t thread_id, DebugThreadParam param);"],
+
+     [0x6F, "Result GetSystemInfo(uint64_t* out, SystemInfoType info_type, Handle handle, uint64_t info_subtype);"],
+     [0x70, "Result CreatePort(Handle* out_server_handle, Handle* out_client_handle, int32_t max_sessions, bool is_light, Address name);"],
+     [0x71, "Result ManageNamedPort(Handle* out_server_handle, Address name, int32_t max_sessions);"],
+     [0x72, "Result ConnectToPort(Handle* out_handle, Handle port);"],
+     [0x73, "Result SetProcessMemoryPermission(Handle process_handle, uint64_t address, uint64_t size, MemoryPermission perm);"],
+     [0x74, "Result MapProcessMemory(Address dst_address, Handle process_handle, uint64_t src_address, Size size);"],
+     [0x75, "Result UnmapProcessMemory(Address dst_address, Handle process_handle, uint64_t src_address, Size size);"],
+     [0x76, "Result QueryProcessMemory(Address out_memory_info, PageInfo* out_page_info, Handle process_handle, uint64_t address);"],
+     [0x77, "Result MapProcessCodeMemory(Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);"],
+     [0x78, "Result UnmapProcessCodeMemory(Handle process_handle, uint64_t dst_address, uint64_t src_address, uint64_t size);"],
+     [0x79, "Result CreateProcess(Handle* out_handle, Address parameters, Address caps, int32_t num_caps);"],
+     [0x7A, "Result StartProcess(Handle process_handle, int32_t priority, int32_t core_id, uint64_t main_thread_stack_size);"],
+     [0x7B, "Result TerminateProcess(Handle process_handle);"],
+     [0x7C, "Result GetProcessInfo(int64_t* out_info, Handle process_handle, ProcessInfoType info_type);"],
+     [0x7D, "Result CreateResourceLimit(Handle* out_handle);"],
+     [0x7E, "Result SetResourceLimitLimitValue(Handle resource_limit_handle, LimitableResource which, int64_t limit_value);"],
+     [0x7F, "void CallSecureMonitor(SecureMonitorArguments args);"],
+
+     [0x90, "Result MapInsecureMemory(Address address, Size size);"],
+     [0x91, "Result UnmapInsecureMemory(Address address, Size size);"],
+]
+
+# These use a custom ABI, and therefore require custom wrappers
+SKIP_WRAPPERS = {
+    0x20: "SendSyncRequestLight",
+    0x42: "ReplyAndReceiveLight",
+    0x7F: "CallSecureMonitor",
+}
+
+BIT_32 = 0
+BIT_64 = 1
+
+REG_SIZES = [4, 8]
+SUFFIX_NAMES = ["64From32", "64"]
+TYPE_SIZES = {
+    # SVC types
+    "ArbitrationType": 4,
+    "BreakReason": 4,
+    "CodeMemoryOperation": 4,
+    "DebugThreadParam": 4,
+    "DeviceName": 4,
+    "HardwareBreakPointRegisterName": 4,
+    "Handle": 4,
+    "InfoType": 4,
+    "InterruptType": 4,
+    "IoPoolType": 4,
+    "KernelDebugType": 4,
+    "KernelTraceState": 4,
+    "LimitableResource": 4,
+    "MemoryMapping": 4,
+    "MemoryPermission": 4,
+    "PageInfo": 4,
+    "ProcessActivity": 4,
+    "ProcessInfoType": 4,
+    "Result": 4,
+    "SignalType": 4,
+    "SystemInfoType": 4,
+    "ThreadActivity": 4,
+
+    # Arch-specific types
+    "ilp32::LastThreadContext": 16,
+    "ilp32::PhysicalMemoryInfo": 16,
+    "ilp32::SecureMonitorArguments": 32,
+    "lp64::LastThreadContext": 32,
+    "lp64::PhysicalMemoryInfo": 24,
+    "lp64::SecureMonitorArguments": 64,
+
+    # Generic types
+    "bool": 1,
+    "int32_t": 4,
+    "int64_t": 8,
+    "uint32_t": 4,
+    "uint64_t": 8,
+    "void": 0,
+}
+
+TYPE_REPLACEMENTS = {
+    "Address": ["uint32_t", "uint64_t"],
+    "LastThreadContext": ["ilp32::LastThreadContext", "lp64::LastThreadContext"],
+    "PhysicalAddress": ["uint64_t", "uint64_t"],
+    "PhysicalMemoryInfo": ["ilp32::PhysicalMemoryInfo", "lp64::PhysicalMemoryInfo"],
+    "SecureMonitorArguments": ["ilp32::SecureMonitorArguments", "lp64::SecureMonitorArguments"],
+    "Size": ["uint32_t", "uint64_t"],
+    "ThreadFunc": ["uint32_t", "uint64_t"],
+}
+
+# Statically verify that the hardcoded sizes match the intended
+# sizes in C++.
+def emit_size_check():
+    lines = []
+
+    for type, size in TYPE_SIZES.items():
+        if type != "void":
+            lines.append(f"static_assert(sizeof({type}) == {size});")
+
+    return "\n".join(lines)
+
+
+# Replaces a type with an arch-specific one, if it exists.
+def substitute_type(name, bitness):
+    if name in TYPE_REPLACEMENTS:
+        return TYPE_REPLACEMENTS[name][bitness]
+    else:
+        return name
+
+
+class Argument:
+    def __init__(self, type_name, var_name, is_output, is_outptr, is_address):
+        self.type_name = type_name
+        self.var_name = var_name
+        self.is_output = is_output
+        self.is_outptr = is_outptr
+        self.is_address = is_address
+
+
+# Parses C-style string declarations for SVCs.
+def parse_declaration(declaration, bitness):
+    return_type, rest = declaration.split(" ", 1)
+    func_name, rest = rest.split("(", 1)
+    arg_names, rest = rest.split(")", 1)
+    argument_types = []
+
+    return_type = substitute_type(return_type, bitness)
+    assert return_type in TYPE_SIZES, f"Unknown type '{return_type}'"
+
+    if arg_names:
+        for arg_name in arg_names.split(", "):
+            type_name, var_name = arg_name.replace("*", "").split(" ", 1)
+
+            # All outputs must contain out_ in the name.
+            is_output = var_name == "out" or var_name.find("out_") != -1
+
+            # User-pointer outputs are not written to registers.
+            is_outptr = is_output and arg_name.find("*") == -1
+
+            # Special handling is performed for output addresses to avoid awkwardness
+            # in conversion for the 32-bit equivalents.
+            is_address = is_output and not is_outptr and \
+                type_name in ["Address", "Size"]
+            type_name = substitute_type(type_name, bitness)
+
+            assert type_name in TYPE_SIZES, f"Unknown type '{type_name}'"
+
+            argument_types.append(
+                Argument(type_name, var_name, is_output, is_outptr, is_address))
+
+    return (return_type, func_name, argument_types)
+
+
+class RegisterAllocator:
+    def __init__(self, num_regs, byte_size, parameter_count):
+        self.registers = {}
+        self.num_regs = num_regs
+        self.byte_size = byte_size
+        self.parameter_count = parameter_count
+
+    # Mark the given register as allocated, for use in layout
+    # calculation if the NGRN exceeds the ABI parameter count.
+    def allocate(self, i):
+        assert i not in self.registers, f"Register R{i} already allocated"
+        self.registers[i] = True
+        return i
+
+    # Calculate the next available location for a register;
+    # the NGRN has exceeded the ABI parameter count.
+    def allocate_first_free(self):
+        for i in range(0, self.num_regs):
+            if i in self.registers:
+                continue
+
+            self.allocate(i)
+            return i
+
+        assert False, "No registers available"
+
+    # Add a single register at the given NGRN.
+    # If the index exceeds the ABI parameter count, try to find a
+    # location to add it. Returns the output location and increment.
+    def add_single(self, ngrn):
+        if ngrn >= self.parameter_count:
+            return (self.allocate_first_free(), 0)
+        else:
+            return (self.allocate(ngrn), 1)
+
+    # Add registers at the given NGRN for a data type of
+    # the given size. Returns the output locations and increment.
+    def add(self, ngrn, data_size, align=True):
+        if data_size <= self.byte_size:
+            r, i = self.add_single(ngrn)
+            return ([r], i)
+
+        regs = []
+        inc = ngrn % 2 if align else 0
+        remaining_size = data_size
+        while remaining_size > 0:
+            r, i = self.add_single(ngrn + inc)
+            regs.append(r)
+            inc += i
+            remaining_size -= self.byte_size
+
+        return (regs, inc)
+
+
+def reg_alloc(bitness):
+    if bitness == 0:
+        # aapcs32: 4 4-byte registers
+        return RegisterAllocator(8, 4, 4)
+    elif bitness == 1:
+        # aapcs64: 8 8-byte registers
+        return RegisterAllocator(8, 8, 8)
+
+
+# Converts a parsed SVC declaration into register lists for
+# the return value, outputs, and inputs.
+def get_registers(parse_result, bitness):
+    output_alloc = reg_alloc(bitness)
+    input_alloc = reg_alloc(bitness)
+    return_type, _, arguments = parse_result
+
+    return_write = []
+    output_writes = []
+    input_reads = []
+
+    input_ngrn = 0
+    output_ngrn = 0
+
+    # Run the input calculation.
+    for arg in arguments:
+        if arg.is_output and not arg.is_outptr:
+            input_ngrn += 1
+            continue
+
+        regs, increment = input_alloc.add(
+            input_ngrn, TYPE_SIZES[arg.type_name], align=True)
+        input_reads.append([arg.type_name, arg.var_name, regs])
+        input_ngrn += increment
+
+    # Include the return value if this SVC returns a value.
+    if return_type != "void":
+        regs, increment = output_alloc.add(
+            output_ngrn, TYPE_SIZES[return_type], align=False)
+        return_write.append([return_type, regs])
+        output_ngrn += increment
+
+    # Run the output calculation.
+    for arg in arguments:
+        if not arg.is_output or arg.is_outptr:
+            continue
+
+        regs, increment = output_alloc.add(
+            output_ngrn, TYPE_SIZES[arg.type_name], align=False)
+        output_writes.append(
+            [arg.type_name, arg.var_name, regs, arg.is_address])
+        output_ngrn += increment
+
+    return (return_write, output_writes, input_reads)
+
+
+# Collects possibly multiple source registers into the named C++ value.
+def emit_gather(sources, name, type_name, reg_size):
+    get_fn = f"GetReg{reg_size*8}"
+
+    if len(sources) == 1:
+        s, = sources
+        line = f"{name} = Convert<{type_name}>({get_fn}(system, {s}));"
+        return [line]
+
+    var_type = f"std::array<uint{reg_size*8}_t, {len(sources)}>"
+    lines = [
+        f"{var_type} {name}_gather{{}};"
+    ]
+    for i in range(0, len(sources)):
+        lines.append(
+            f"{name}_gather[{i}] = {get_fn}(system, {sources[i]});")
+
+    lines.append(f"{name} = Convert<{type_name}>({name}_gather);")
+    return lines
+
+
+# Produces one or more statements which assign the named C++ value
+# into possibly multiple registers.
+def emit_scatter(destinations, name, reg_size):
+    set_fn = f"SetReg{reg_size*8}"
+    reg_type = f"uint{reg_size*8}_t"
+
+    if len(destinations) == 1:
+        d, = destinations
+        line = f"{set_fn}(system, {d}, Convert<{reg_type}>({name}));"
+        return [line]
+
+    var_type = f"std::array<{reg_type}, {len(destinations)}>"
+    lines = [
+        f"auto {name}_scatter = Convert<{var_type}>({name});"
+    ]
+
+    for i in range(0, len(destinations)):
+        lines.append(
+            f"{set_fn}(system, {destinations[i]}, {name}_scatter[{i}]);")
+
+    return lines
+
+
+def emit_lines(lines, indent='    '):
+    output_lines = []
+    first = True
+    for line in lines:
+        if line and not first:
+            output_lines.append(indent + line)
+        else:
+            output_lines.append(line)
+        first = False
+
+    return "\n".join(output_lines)
+
+
+# Emit a C++ function to wrap a guest SVC.
+def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size):
+    return_write, output_writes, input_reads = register_info
+    lines = [
+        f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system) {{"
+    ]
+
+    # Get everything ready.
+    for return_type, _ in return_write:
+        lines.append(f"{return_type} ret{{}};")
+    if return_write:
+        lines.append("")
+
+    for output_type, var_name, _, is_address in output_writes:
+        output_type = "uintptr_t" if is_address else output_type
+        lines.append(f"{output_type} {var_name}{{}};")
+    for input_type, var_name, _ in input_reads:
+        lines.append(f"{input_type} {var_name}{{}};")
+
+    if output_writes or input_reads:
+        lines.append("")
+
+    for input_type, var_name, sources in input_reads:
+        lines += emit_gather(sources, var_name, input_type, byte_size)
+    if input_reads:
+        lines.append("")
+
+    # Build the call.
+    call_arguments = ["system"]
+    for arg in arguments:
+        if arg.is_output and not arg.is_outptr:
+            call_arguments.append(f"&{arg.var_name}")
+        else:
+            call_arguments.append(arg.var_name)
+
+    line = ""
+    if return_write:
+        line += "ret = "
+
+    line += f"{wrapped_fn}{suffix}({', '.join(call_arguments)});"
+    lines.append(line)
+
+    if return_write or output_writes:
+        lines.append("")
+
+    # Write back the return value and outputs.
+    for _, destinations in return_write:
+        lines += emit_scatter(destinations, "ret", byte_size)
+    for _, var_name, destinations, _ in output_writes:
+        lines += emit_scatter(destinations, var_name, byte_size)
+
+    # Finish.
+    return emit_lines(lines) + "\n}"
+
+
+COPYRIGHT = """\
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// This file is automatically generated using svc_generator.py.
+"""
+
+PROLOGUE_H = """
+#pragma once
+
+namespace Core {
+class System;
+}
+
+#include "common/common_types.h"
+#include "core/hle/kernel/svc_types.h"
+#include "core/hle/result.h"
+
+namespace Kernel::Svc {
+
+// clang-format off
+"""
+
+EPILOGUE_H = """
+// clang-format on
+
+// Custom ABI.
+Result ReplyAndReceiveLight(Core::System& system, Handle handle, uint32_t* args);
+Result ReplyAndReceiveLight64From32(Core::System& system, Handle handle, uint32_t* args);
+Result ReplyAndReceiveLight64(Core::System& system, Handle handle, uint32_t* args);
+
+Result SendSyncRequestLight(Core::System& system, Handle session_handle, uint32_t* args);
+Result SendSyncRequestLight64From32(Core::System& system, Handle session_handle, uint32_t* args);
+Result SendSyncRequestLight64(Core::System& system, Handle session_handle, uint32_t* args);
+
+void CallSecureMonitor(Core::System& system, lp64::SecureMonitorArguments* args);
+void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArguments* args);
+void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args);
+
+// Defined in svc_light_ipc.cpp.
+void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system);
+void SvcWrap_ReplyAndReceiveLight64(Core::System& system);
+
+void SvcWrap_SendSyncRequestLight64From32(Core::System& system);
+void SvcWrap_SendSyncRequestLight64(Core::System& system);
+
+// Defined in svc_secure_monitor_call.cpp.
+void SvcWrap_CallSecureMonitor64From32(Core::System& system);
+void SvcWrap_CallSecureMonitor64(Core::System& system);
+
+// Perform a supervisor call by index.
+void Call(Core::System& system, u32 imm);
+
+} // namespace Kernel::Svc
+"""
+
+PROLOGUE_CPP = """
+#include <type_traits>
+
+#include "core/arm/arm_interface.h"
+#include "core/core.h"
+#include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/svc.h"
+
+namespace Kernel::Svc {
+
+static uint32_t GetReg32(Core::System& system, int n) {
+    return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n));
+}
+
+static void SetReg32(Core::System& system, int n, uint32_t result) {
+    system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result));
+}
+
+static uint64_t GetReg64(Core::System& system, int n) {
+    return system.CurrentArmInterface().GetReg(n);
+}
+
+static void SetReg64(Core::System& system, int n, uint64_t result) {
+    system.CurrentArmInterface().SetReg(n, result);
+}
+
+// Like bit_cast, but handles the case when the source and dest
+// are differently-sized.
+template <typename To, typename From>
+    requires(std::is_trivial_v<To> && std::is_trivially_copyable_v<From>)
+static To Convert(const From& from) {
+    To to{};
+
+    if constexpr (sizeof(To) >= sizeof(From)) {
+        std::memcpy(&to, &from, sizeof(From));
+    } else {
+        std::memcpy(&to, &from, sizeof(To));
+    }
+
+    return to;
+}
+
+// clang-format off
+"""
+
+EPILOGUE_CPP = """
+// clang-format on
+
+void Call(Core::System& system, u32 imm) {
+    auto& kernel = system.Kernel();
+    kernel.EnterSVCProfile();
+
+    if (GetCurrentProcess(system.Kernel()).Is64BitProcess()) {
+        Call64(system, imm);
+    } else {
+        Call32(system, imm);
+    }
+
+    kernel.ExitSVCProfile();
+}
+
+} // namespace Kernel::Svc
+"""
+
+
+def emit_call(bitness, names, suffix):
+    bit_size = REG_SIZES[bitness]*8
+    indent = "    "
+    lines = [
+        f"static void Call{bit_size}(Core::System& system, u32 imm) {{",
+        f"{indent}switch (static_cast<SvcId>(imm)) {{"
+    ]
+
+    for _, name in names:
+        lines.append(f"{indent}case SvcId::{name}:")
+        lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system);")
+
+    lines.append(f"{indent}default:")
+    lines.append(
+        f"{indent*2}LOG_CRITICAL(Kernel_SVC, \"Unknown SVC {{:x}}!\", imm);")
+    lines.append(f"{indent*2}break;")
+    lines.append(f"{indent}}}")
+    lines.append("}")
+
+    return "\n".join(lines)
+
+
+def build_fn_declaration(return_type, name, arguments):
+    arg_list = ["Core::System& system"]
+    for arg in arguments:
+        type_name = "uintptr_t" if arg.is_address else arg.type_name
+        pointer = "*" if arg.is_output and not arg.is_outptr else ""
+        arg_list.append(f"{type_name}{pointer} {arg.var_name}")
+
+    return f"{return_type} {name}({', '.join(arg_list)});"
+
+
+def build_enum_declarations():
+    lines = ["enum class SvcId : u32 {"]
+    indent = "    "
+
+    for imm, decl in SVCS:
+        _, name, _ = parse_declaration(decl, BIT_64)
+        lines.append(f"{indent}{name} = {hex(imm)},")
+
+    lines.append("};")
+    return "\n".join(lines)
+
+
+def main():
+    arch_fw_declarations = [[], []]
+    svc_fw_declarations = []
+    wrapper_fns = []
+    names = []
+
+    for imm, decl in SVCS:
+        return_type, name, arguments = parse_declaration(decl, BIT_64)
+
+        if imm not in SKIP_WRAPPERS:
+            svc_fw_declarations.append(
+                build_fn_declaration(return_type, name, arguments))
+
+        names.append([imm, name])
+
+    for bitness in range(2):
+        byte_size = REG_SIZES[bitness]
+        suffix = SUFFIX_NAMES[bitness]
+
+        for imm, decl in SVCS:
+            if imm in SKIP_WRAPPERS:
+                continue
+
+            parse_result = parse_declaration(decl, bitness)
+            return_type, name, arguments = parse_result
+
+            register_info = get_registers(parse_result, bitness)
+            wrapper_fns.append(
+                emit_wrapper(name, suffix, register_info, arguments, byte_size))
+            arch_fw_declarations[bitness].append(
+                build_fn_declaration(return_type, name + suffix, arguments))
+
+    call_32 = emit_call(BIT_32, names, SUFFIX_NAMES[BIT_32])
+    call_64 = emit_call(BIT_64, names, SUFFIX_NAMES[BIT_64])
+    enum_decls = build_enum_declarations()
+
+    with open("svc.h", "w") as f:
+        f.write(COPYRIGHT)
+        f.write(PROLOGUE_H)
+        f.write("\n".join(svc_fw_declarations))
+        f.write("\n\n")
+        f.write("\n".join(arch_fw_declarations[BIT_32]))
+        f.write("\n\n")
+        f.write("\n".join(arch_fw_declarations[BIT_64]))
+        f.write("\n\n")
+        f.write(enum_decls)
+        f.write(EPILOGUE_H)
+
+    with open("svc.cpp", "w") as f:
+        f.write(COPYRIGHT)
+        f.write(PROLOGUE_CPP)
+        f.write(emit_size_check())
+        f.write("\n\n")
+        f.write("\n\n".join(wrapper_fns))
+        f.write("\n\n")
+        f.write(call_32)
+        f.write("\n\n")
+        f.write(call_64)
+        f.write(EPILOGUE_CPP)
+
+    print(f"Done (emitted {len(names)} definitions)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/core/hle/kernel/svc_results.h b/src/core/hle/kernel/svc_results.h
index b7ca53085..e1ad78607 100644
--- a/src/core/hle/kernel/svc_results.h
+++ b/src/core/hle/kernel/svc_results.h
@@ -11,6 +11,7 @@ namespace Kernel {
 
 constexpr Result ResultOutOfSessions{ErrorModule::Kernel, 7};
 constexpr Result ResultInvalidArgument{ErrorModule::Kernel, 14};
+constexpr Result ResultNotImplemented{ErrorModule::Kernel, 33};
 constexpr Result ResultNoSynchronizationObject{ErrorModule::Kernel, 57};
 constexpr Result ResultTerminationRequested{ErrorModule::Kernel, 59};
 constexpr Result ResultInvalidSize{ErrorModule::Kernel, 101};
diff --git a/src/core/hle/kernel/svc_types.h b/src/core/hle/kernel/svc_types.h
index e90c35601..542c13461 100644
--- a/src/core/hle/kernel/svc_types.h
+++ b/src/core/hle/kernel/svc_types.h
@@ -168,6 +168,7 @@ enum class BreakReason : u32 {
 
     NotificationOnlyFlag = 0x80000000,
 };
+DECLARE_ENUM_FLAG_OPERATORS(BreakReason);
 
 enum class DebugEvent : u32 {
     CreateProcess = 0,
@@ -596,6 +597,11 @@ enum class ProcessInfoType : u32 {
     ProcessState = 0,
 };
 
+enum class ProcessActivity : u32 {
+    Runnable,
+    Paused,
+};
+
 struct CreateProcessParameter {
     std::array<char, 12> name;
     u32 version;
@@ -611,4 +617,9 @@ static_assert(sizeof(CreateProcessParameter) == 0x30);
 constexpr size_t NumSupervisorCalls = 0xC0;
 using SvcAccessFlagSet = std::bitset<NumSupervisorCalls>;
 
+enum class InitialProcessIdRangeInfo : u64 {
+    Minimum = 0,
+    Maximum = 1,
+};
+
 } // namespace Kernel::Svc
diff --git a/src/core/hle/kernel/svc_version.h b/src/core/hle/kernel/svc_version.h
index e4f47b34b..3eb95aa7b 100644
--- a/src/core/hle/kernel/svc_version.h
+++ b/src/core/hle/kernel/svc_version.h
@@ -35,11 +35,11 @@ constexpr inline u32 EncodeKernelVersion(u32 major, u32 minor) {
 }
 
 constexpr inline u32 GetKernelMajorVersion(u32 encoded) {
-    return std::bit_cast<decltype(KernelVersion::major_version)>(encoded).Value();
+    return decltype(KernelVersion::major_version)::ExtractValue(encoded);
 }
 
 constexpr inline u32 GetKernelMinorVersion(u32 encoded) {
-    return std::bit_cast<decltype(KernelVersion::minor_version)>(encoded).Value();
+    return decltype(KernelVersion::minor_version)::ExtractValue(encoded);
 }
 
 // Nintendo doesn't support programs targeting SVC versions < 3.0.
diff --git a/src/core/hle/kernel/svc_wrap.h b/src/core/hle/kernel/svc_wrap.h
deleted file mode 100644
index 052be40dd..000000000
--- a/src/core/hle/kernel/svc_wrap.h
+++ /dev/null
@@ -1,733 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/common_types.h"
-#include "core/arm/arm_interface.h"
-#include "core/core.h"
-#include "core/hle/kernel/svc_types.h"
-#include "core/hle/result.h"
-#include "core/memory.h"
-
-namespace Kernel {
-
-static inline u64 Param(const Core::System& system, int n) {
-    return system.CurrentArmInterface().GetReg(n);
-}
-
-static inline u32 Param32(const Core::System& system, int n) {
-    return static_cast<u32>(system.CurrentArmInterface().GetReg(n));
-}
-
-/**
- * HLE a function return from the current ARM userland process
- * @param system System context
- * @param result Result to return
- */
-static inline void FuncReturn(Core::System& system, u64 result) {
-    system.CurrentArmInterface().SetReg(0, result);
-}
-
-static inline void FuncReturn32(Core::System& system, u32 result) {
-    system.CurrentArmInterface().SetReg(0, (u64)result);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Function wrappers that return type Result
-
-template <Result func(Core::System&, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0)).raw);
-}
-
-template <Result func(Core::System&, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1)).raw);
-}
-
-template <Result func(Core::System&, u32)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);
-}
-
-template <Result func(Core::System&, u32, u32)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(
-        system,
-        func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1))).raw);
-}
-
-// Used by SetThreadActivity
-template <Result func(Core::System&, Handle, Svc::ThreadActivity)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)),
-                            static_cast<Svc::ThreadActivity>(Param(system, 1)))
-                           .raw);
-}
-
-template <Result func(Core::System&, u32, u64, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
-                            Param(system, 2), Param(system, 3))
-                           .raw);
-}
-
-// Used by MapProcessMemory and UnmapProcessMemory
-template <Result func(Core::System&, u64, u32, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
-                            Param(system, 2), Param(system, 3))
-                           .raw);
-}
-
-// Used by ControlCodeMemory
-template <Result func(Core::System&, Handle, u32, VAddr, size_t, Svc::MemoryPermission)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<Handle>(Param(system, 0)),
-                            static_cast<u32>(Param(system, 1)), Param(system, 2), Param(system, 3),
-                            static_cast<Svc::MemoryPermission>(Param(system, 4)))
-                           .raw);
-}
-
-template <Result func(Core::System&, u32*)>
-void SvcWrap64(Core::System& system) {
-    u32 param = 0;
-    const u32 retval = func(system, &param).raw;
-    system.CurrentArmInterface().SetReg(1, param);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u32*, u32)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u32*, u32*)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    u32 param_2 = 0;
-    const u32 retval = func(system, &param_1, &param_2).raw;
-
-    auto& arm_interface = system.CurrentArmInterface();
-    arm_interface.SetReg(1, param_1);
-    arm_interface.SetReg(2, param_2);
-
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u32*, u64)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1)).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u32*, u64, u32)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval =
-        func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2))).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u64*, u32)>
-void SvcWrap64(Core::System& system) {
-    u64 param_1 = 0;
-    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u64, u32)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1))).raw);
-}
-
-template <Result func(Core::System&, u64*, u64)>
-void SvcWrap64(Core::System& system) {
-    u64 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1)).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u64*, u32, u32)>
-void SvcWrap64(Core::System& system) {
-    u64 param_1 = 0;
-    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1)),
-                            static_cast<u32>(Param(system, 2)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-// Used by GetResourceLimitLimitValue.
-template <Result func(Core::System&, u64*, Handle, Svc::LimitableResource)>
-void SvcWrap64(Core::System& system) {
-    u64 param_1 = 0;
-    const u32 retval = func(system, &param_1, static_cast<Handle>(Param(system, 1)),
-                            static_cast<Svc::LimitableResource>(Param(system, 2)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u32, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1)).raw);
-}
-
-// Used by SetResourceLimitLimitValue
-template <Result func(Core::System&, Handle, Svc::LimitableResource, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<Handle>(Param(system, 0)),
-                            static_cast<Svc::LimitableResource>(Param(system, 1)), Param(system, 2))
-                           .raw);
-}
-
-// Used by SetThreadCoreMask
-template <Result func(Core::System&, Handle, s32, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)),
-                            static_cast<s32>(Param(system, 1)), Param(system, 2))
-                           .raw);
-}
-
-// Used by GetThreadCoreMask
-template <Result func(Core::System&, Handle, s32*, u64*)>
-void SvcWrap64(Core::System& system) {
-    s32 param_1 = 0;
-    u64 param_2 = 0;
-    const Result retval = func(system, static_cast<u32>(Param(system, 2)), &param_1, &param_2);
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    system.CurrentArmInterface().SetReg(2, param_2);
-    FuncReturn(system, retval.raw);
-}
-
-template <Result func(Core::System&, u64, u64, u32, u32)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
-                            static_cast<u32>(Param(system, 2)), static_cast<u32>(Param(system, 3)))
-                           .raw);
-}
-
-template <Result func(Core::System&, u64, u64, u32, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
-                            static_cast<u32>(Param(system, 2)), Param(system, 3))
-                           .raw);
-}
-
-template <Result func(Core::System&, u32, u64, u32)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
-                            static_cast<u32>(Param(system, 2)))
-                           .raw);
-}
-
-template <Result func(Core::System&, u64, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1), Param(system, 2)).raw);
-}
-
-template <Result func(Core::System&, u64, u64, u32)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(
-        system,
-        func(system, Param(system, 0), Param(system, 1), static_cast<u32>(Param(system, 2))).raw);
-}
-
-// Used by SetMemoryPermission
-template <Result func(Core::System&, u64, u64, Svc::MemoryPermission)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
-                            static_cast<Svc::MemoryPermission>(Param(system, 2)))
-                           .raw);
-}
-
-// Used by MapSharedMemory
-template <Result func(Core::System&, Handle, u64, u64, Svc::MemoryPermission)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<Handle>(Param(system, 0)), Param(system, 1),
-                            Param(system, 2), static_cast<Svc::MemoryPermission>(Param(system, 3)))
-                           .raw);
-}
-
-template <Result func(Core::System&, u32, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(
-        system,
-        func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2)).raw);
-}
-
-// Used by WaitSynchronization
-template <Result func(Core::System&, s32*, u64, s32, s64)>
-void SvcWrap64(Core::System& system) {
-    s32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), static_cast<s32>(Param(system, 2)),
-                            static_cast<s64>(Param(system, 3)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u64, u64, u32, s64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
-                            static_cast<u32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
-                           .raw);
-}
-
-// Used by GetInfo
-template <Result func(Core::System&, u64*, u64, Handle, u64)>
-void SvcWrap64(Core::System& system) {
-    u64 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1),
-                            static_cast<Handle>(Param(system, 2)), Param(system, 3))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, u32*, u64, u64, u64, u32, s32)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2), Param(system, 3),
-                            static_cast<u32>(Param(system, 4)), static_cast<s32>(Param(system, 5)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-// Used by CreateTransferMemory
-template <Result func(Core::System&, Handle*, u64, u64, Svc::MemoryPermission)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2),
-                            static_cast<Svc::MemoryPermission>(Param(system, 3)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-// Used by CreateCodeMemory
-template <Result func(Core::System&, Handle*, VAddr, size_t)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2)).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <Result func(Core::System&, Handle*, u64, u32, u32)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
-                            static_cast<u32>(Param(system, 3)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-// Used by CreateSession
-template <Result func(Core::System&, Handle*, Handle*, u32, u64)>
-void SvcWrap64(Core::System& system) {
-    Handle param_1 = 0;
-    Handle param_2 = 0;
-    const u32 retval = func(system, &param_1, &param_2, static_cast<u32>(Param(system, 2)),
-                            static_cast<u32>(Param(system, 3)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    system.CurrentArmInterface().SetReg(2, param_2);
-    FuncReturn(system, retval);
-}
-
-// Used by ReplyAndReceive
-template <Result func(Core::System&, s32*, Handle*, s32, Handle, s64)>
-void SvcWrap64(Core::System& system) {
-    s32 param_1 = 0;
-    s32 num_handles = static_cast<s32>(Param(system, 2));
-
-    std::vector<Handle> handles(num_handles);
-    system.Memory().ReadBlock(Param(system, 1), handles.data(), num_handles * sizeof(Handle));
-
-    const u32 retval = func(system, &param_1, handles.data(), num_handles,
-                            static_cast<s32>(Param(system, 3)), static_cast<s64>(Param(system, 4)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-// Used by WaitForAddress
-template <Result func(Core::System&, u64, Svc::ArbitrationType, s32, s64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system,
-               func(system, Param(system, 0), static_cast<Svc::ArbitrationType>(Param(system, 1)),
-                    static_cast<s32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
-                   .raw);
-}
-
-// Used by SignalToAddress
-template <Result func(Core::System&, u64, Svc::SignalType, s32, s32)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system,
-               func(system, Param(system, 0), static_cast<Svc::SignalType>(Param(system, 1)),
-                    static_cast<s32>(Param(system, 2)), static_cast<s32>(Param(system, 3)))
-                   .raw);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Function wrappers that return type u32
-
-template <u32 func(Core::System&)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Function wrappers that return type u64
-
-template <u64 func(Core::System&)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-/// Function wrappers that return type void
-
-template <void func(Core::System&)>
-void SvcWrap64(Core::System& system) {
-    func(system);
-}
-
-template <void func(Core::System&, u32)>
-void SvcWrap64(Core::System& system) {
-    func(system, static_cast<u32>(Param(system, 0)));
-}
-
-template <void func(Core::System&, u32, u64, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2),
-         Param(system, 3));
-}
-
-template <void func(Core::System&, s64)>
-void SvcWrap64(Core::System& system) {
-    func(system, static_cast<s64>(Param(system, 0)));
-}
-
-template <void func(Core::System&, u64, s32)>
-void SvcWrap64(Core::System& system) {
-    func(system, Param(system, 0), static_cast<s32>(Param(system, 1)));
-}
-
-template <void func(Core::System&, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    func(system, Param(system, 0), Param(system, 1));
-}
-
-template <void func(Core::System&, u64, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    func(system, Param(system, 0), Param(system, 1), Param(system, 2));
-}
-
-template <void func(Core::System&, u32, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2));
-}
-
-// Used by QueryMemory32, ArbitrateLock32
-template <Result func(Core::System&, u32, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    FuncReturn32(system,
-                 func(system, Param32(system, 0), Param32(system, 1), Param32(system, 2)).raw);
-}
-
-// Used by Break32
-template <void func(Core::System&, u32, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    func(system, Param32(system, 0), Param32(system, 1), Param32(system, 2));
-}
-
-// Used by ExitProcess32, ExitThread32
-template <void func(Core::System&)>
-void SvcWrap32(Core::System& system) {
-    func(system);
-}
-
-// Used by GetCurrentProcessorNumber32
-template <u32 func(Core::System&)>
-void SvcWrap32(Core::System& system) {
-    FuncReturn32(system, func(system));
-}
-
-// Used by SleepThread32
-template <void func(Core::System&, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    func(system, Param32(system, 0), Param32(system, 1));
-}
-
-// Used by CreateThread32
-template <Result func(Core::System&, Handle*, u32, u32, u32, u32, s32)>
-void SvcWrap32(Core::System& system) {
-    Handle param_1 = 0;
-
-    const u32 retval = func(system, &param_1, Param32(system, 0), Param32(system, 1),
-                            Param32(system, 2), Param32(system, 3), Param32(system, 4))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-// Used by GetInfo32
-template <Result func(Core::System&, u32*, u32*, u32, u32, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    u32 param_1 = 0;
-    u32 param_2 = 0;
-
-    const u32 retval = func(system, &param_1, &param_2, Param32(system, 0), Param32(system, 1),
-                            Param32(system, 2), Param32(system, 3))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    system.CurrentArmInterface().SetReg(2, param_2);
-    FuncReturn(system, retval);
-}
-
-// Used by GetThreadPriority32, ConnectToNamedPort32
-template <Result func(Core::System&, u32*, u32)>
-void SvcWrap32(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param32(system, 1)).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-// Used by GetThreadId32
-template <Result func(Core::System&, u32*, u32*, u32)>
-void SvcWrap32(Core::System& system) {
-    u32 param_1 = 0;
-    u32 param_2 = 0;
-
-    const u32 retval = func(system, &param_1, &param_2, Param32(system, 1)).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    system.CurrentArmInterface().SetReg(2, param_2);
-    FuncReturn(system, retval);
-}
-
-// Used by GetSystemTick32
-template <void func(Core::System&, u32*, u32*)>
-void SvcWrap32(Core::System& system) {
-    u32 param_1 = 0;
-    u32 param_2 = 0;
-
-    func(system, &param_1, &param_2);
-    system.CurrentArmInterface().SetReg(0, param_1);
-    system.CurrentArmInterface().SetReg(1, param_2);
-}
-
-// Used by CreateEvent32
-template <Result func(Core::System&, Handle*, Handle*)>
-void SvcWrap32(Core::System& system) {
-    Handle param_1 = 0;
-    Handle param_2 = 0;
-
-    const u32 retval = func(system, &param_1, &param_2).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    system.CurrentArmInterface().SetReg(2, param_2);
-    FuncReturn(system, retval);
-}
-
-// Used by GetThreadId32
-template <Result func(Core::System&, Handle, u32*, u32*, u32*)>
-void SvcWrap32(Core::System& system) {
-    u32 param_1 = 0;
-    u32 param_2 = 0;
-    u32 param_3 = 0;
-
-    const u32 retval = func(system, Param32(system, 2), &param_1, &param_2, &param_3).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    system.CurrentArmInterface().SetReg(2, param_2);
-    system.CurrentArmInterface().SetReg(3, param_3);
-    FuncReturn(system, retval);
-}
-
-// Used by GetThreadCoreMask32
-template <Result func(Core::System&, Handle, s32*, u32*, u32*)>
-void SvcWrap32(Core::System& system) {
-    s32 param_1 = 0;
-    u32 param_2 = 0;
-    u32 param_3 = 0;
-
-    const u32 retval = func(system, Param32(system, 2), &param_1, &param_2, &param_3).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    system.CurrentArmInterface().SetReg(2, param_2);
-    system.CurrentArmInterface().SetReg(3, param_3);
-    FuncReturn(system, retval);
-}
-
-// Used by SignalProcessWideKey32
-template <void func(Core::System&, u32, s32)>
-void SvcWrap32(Core::System& system) {
-    func(system, static_cast<u32>(Param(system, 0)), static_cast<s32>(Param(system, 1)));
-}
-
-// Used by SetThreadActivity32
-template <Result func(Core::System&, Handle, Svc::ThreadActivity)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval = func(system, static_cast<Handle>(Param(system, 0)),
-                            static_cast<Svc::ThreadActivity>(Param(system, 1)))
-                           .raw;
-    FuncReturn(system, retval);
-}
-
-// Used by SetThreadPriority32
-template <Result func(Core::System&, Handle, u32)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval =
-        func(system, static_cast<Handle>(Param(system, 0)), static_cast<u32>(Param(system, 1))).raw;
-    FuncReturn(system, retval);
-}
-
-// Used by SetMemoryAttribute32
-template <Result func(Core::System&, Handle, u32, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval =
-        func(system, static_cast<Handle>(Param(system, 0)), static_cast<u32>(Param(system, 1)),
-             static_cast<u32>(Param(system, 2)), static_cast<u32>(Param(system, 3)))
-            .raw;
-    FuncReturn(system, retval);
-}
-
-// Used by MapSharedMemory32
-template <Result func(Core::System&, Handle, u32, u32, Svc::MemoryPermission)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval = func(system, static_cast<Handle>(Param(system, 0)),
-                            static_cast<u32>(Param(system, 1)), static_cast<u32>(Param(system, 2)),
-                            static_cast<Svc::MemoryPermission>(Param(system, 3)))
-                           .raw;
-    FuncReturn(system, retval);
-}
-
-// Used by SetThreadCoreMask32
-template <Result func(Core::System&, Handle, s32, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval =
-        func(system, static_cast<Handle>(Param(system, 0)), static_cast<s32>(Param(system, 1)),
-             static_cast<u32>(Param(system, 2)), static_cast<u32>(Param(system, 3)))
-            .raw;
-    FuncReturn(system, retval);
-}
-
-// Used by WaitProcessWideKeyAtomic32
-template <Result func(Core::System&, u32, u32, Handle, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval =
-        func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1)),
-             static_cast<Handle>(Param(system, 2)), static_cast<u32>(Param(system, 3)),
-             static_cast<u32>(Param(system, 4)))
-            .raw;
-    FuncReturn(system, retval);
-}
-
-// Used by WaitForAddress32
-template <Result func(Core::System&, u32, Svc::ArbitrationType, s32, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval = func(system, static_cast<u32>(Param(system, 0)),
-                            static_cast<Svc::ArbitrationType>(Param(system, 1)),
-                            static_cast<s32>(Param(system, 2)), static_cast<u32>(Param(system, 3)),
-                            static_cast<u32>(Param(system, 4)))
-                           .raw;
-    FuncReturn(system, retval);
-}
-
-// Used by SignalToAddress32
-template <Result func(Core::System&, u32, Svc::SignalType, s32, s32)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval = func(system, static_cast<u32>(Param(system, 0)),
-                            static_cast<Svc::SignalType>(Param(system, 1)),
-                            static_cast<s32>(Param(system, 2)), static_cast<s32>(Param(system, 3)))
-                           .raw;
-    FuncReturn(system, retval);
-}
-
-// Used by SendSyncRequest32, ArbitrateUnlock32
-template <Result func(Core::System&, u32)>
-void SvcWrap32(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);
-}
-
-// Used by CreateTransferMemory32
-template <Result func(Core::System&, Handle*, u32, u32, Svc::MemoryPermission)>
-void SvcWrap32(Core::System& system) {
-    Handle handle = 0;
-    const u32 retval = func(system, &handle, Param32(system, 1), Param32(system, 2),
-                            static_cast<Svc::MemoryPermission>(Param32(system, 3)))
-                           .raw;
-    system.CurrentArmInterface().SetReg(1, handle);
-    FuncReturn(system, retval);
-}
-
-// Used by WaitSynchronization32
-template <Result func(Core::System&, u32, u32, s32, u32, s32*)>
-void SvcWrap32(Core::System& system) {
-    s32 param_1 = 0;
-    const u32 retval = func(system, Param32(system, 0), Param32(system, 1), Param32(system, 2),
-                            Param32(system, 3), &param_1)
-                           .raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-// Used by CreateCodeMemory32
-template <Result func(Core::System&, Handle*, u32, u32)>
-void SvcWrap32(Core::System& system) {
-    Handle handle = 0;
-
-    const u32 retval = func(system, &handle, Param32(system, 1), Param32(system, 2)).raw;
-
-    system.CurrentArmInterface().SetReg(1, handle);
-    FuncReturn(system, retval);
-}
-
-// Used by ControlCodeMemory32
-template <Result func(Core::System&, Handle, u32, u64, u64, Svc::MemoryPermission)>
-void SvcWrap32(Core::System& system) {
-    const u32 retval =
-        func(system, Param32(system, 0), Param32(system, 1), Param(system, 2), Param(system, 4),
-             static_cast<Svc::MemoryPermission>(Param32(system, 6)))
-            .raw;
-
-    FuncReturn(system, retval);
-}
-
-// Used by Invalidate/Store/FlushProcessDataCache32
-template <Result func(Core::System&, Handle, u64, u64)>
-void SvcWrap32(Core::System& system) {
-    const u64 address = (Param(system, 3) << 32) | Param(system, 2);
-    const u64 size = (Param(system, 4) << 32) | Param(system, 1);
-    FuncReturn32(system, func(system, Param32(system, 0), address, size).raw);
-}
-
-} // namespace Kernel
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index 6d1084fd1..1495d64de 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -762,7 +762,7 @@ Result Module::Interface::InitializeApplicationInfoBase() {
     // processes emulated. As we don't actually have pid support we should assume we're just using
     // our own process
     const auto launch_property =
-        system.GetARPManager().GetLaunchProperty(system.GetCurrentProcessProgramID());
+        system.GetARPManager().GetLaunchProperty(system.GetApplicationProcessProgramID());
 
     if (launch_property.Failed()) {
         LOG_ERROR(Service_ACC, "Failed to get launch property");
@@ -806,7 +806,7 @@ void Module::Interface::IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx
     bool is_locked = false;
 
     if (res != Loader::ResultStatus::Success) {
-        const FileSys::PatchManager pm{system.GetCurrentProcessProgramID(),
+        const FileSys::PatchManager pm{system.GetApplicationProcessProgramID(),
                                        system.GetFileSystemController(),
                                        system.GetContentProvider()};
         const auto nacp_unique = pm.GetControlMetadata().first;
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index ebcf6e164..beb2da06e 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -24,7 +24,6 @@
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
-#include "core/hle/service/am/tcap.h"
 #include "core/hle/service/apm/apm_controller.h"
 #include "core/hle/service/apm/apm_interface.h"
 #include "core/hle/service/bcat/backend/backend.h"
@@ -79,7 +78,7 @@ IWindowController::IWindowController(Core::System& system_)
 IWindowController::~IWindowController() = default;
 
 void IWindowController::GetAppletResourceUserId(Kernel::HLERequestContext& ctx) {
-    const u64 process_id = system.CurrentProcess()->GetProcessID();
+    const u64 process_id = system.ApplicationProcess()->GetProcessID();
 
     LOG_DEBUG(Service_AM, "called. Process ID=0x{:016X}", process_id);
 
@@ -1252,7 +1251,7 @@ void ILibraryAppletCreator::CreateTransferMemoryStorage(Kernel::HLERequestContex
     }
 
     auto transfer_mem =
-        system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(handle);
+        system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(handle);
 
     if (transfer_mem.IsNull()) {
         LOG_ERROR(Service_AM, "transfer_mem is a nullptr for handle={:08X}", handle);
@@ -1286,7 +1285,7 @@ void ILibraryAppletCreator::CreateHandleStorage(Kernel::HLERequestContext& ctx)
     }
 
     auto transfer_mem =
-        system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(handle);
+        system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(handle);
 
     if (transfer_mem.IsNull()) {
         LOG_ERROR(Service_AM, "transfer_mem is a nullptr for handle={:08X}", handle);
@@ -1465,11 +1464,12 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
         const auto backend = BCAT::CreateBackendFromSettings(system, [this](u64 tid) {
             return system.GetFileSystemController().GetBCATDirectory(tid);
         });
-        const auto build_id_full = system.GetCurrentProcessBuildID();
+        const auto build_id_full = system.GetApplicationProcessBuildID();
         u64 build_id{};
         std::memcpy(&build_id, build_id_full.data(), sizeof(u64));
 
-        auto data = backend->GetLaunchParameter({system.GetCurrentProcessProgramID(), build_id});
+        auto data =
+            backend->GetLaunchParameter({system.GetApplicationProcessProgramID(), build_id});
         if (data.has_value()) {
             IPC::ResponseBuilder rb{ctx, 2, 0, 1};
             rb.Push(ResultSuccess);
@@ -1521,7 +1521,7 @@ void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_AM, "called, uid={:016X}{:016X}", user_id[1], user_id[0]);
 
     FileSys::SaveDataAttribute attribute{};
-    attribute.title_id = system.GetCurrentProcessProgramID();
+    attribute.title_id = system.GetApplicationProcessProgramID();
     attribute.user_id = user_id;
     attribute.type = FileSys::SaveDataType::SaveData;
     const auto res = system.GetFileSystemController().CreateSaveData(
@@ -1551,7 +1551,7 @@ void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
     std::array<u8, 0x10> version_string{};
 
     const auto res = [this] {
-        const auto title_id = system.GetCurrentProcessProgramID();
+        const auto title_id = system.GetApplicationProcessProgramID();
 
         const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
                                        system.GetContentProvider()};
@@ -1570,7 +1570,7 @@ void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
         const auto& version = res.first->GetVersionString();
         std::copy(version.begin(), version.end(), version_string.begin());
     } else {
-        constexpr char default_version[]{"1.0.0"};
+        static constexpr char default_version[]{"1.0.0"};
         std::memcpy(version_string.data(), default_version, sizeof(default_version));
     }
 
@@ -1588,7 +1588,7 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
     u32 supported_languages = 0;
 
     const auto res = [this] {
-        const auto title_id = system.GetCurrentProcessProgramID();
+        const auto title_id = system.GetApplicationProcessProgramID();
 
         const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
                                        system.GetContentProvider()};
@@ -1696,7 +1696,8 @@ void IApplicationFunctions::ExtendSaveData(Kernel::HLERequestContext& ctx) {
               static_cast<u8>(type), user_id[1], user_id[0], new_normal_size, new_journal_size);
 
     system.GetFileSystemController().WriteSaveDataSize(
-        type, system.GetCurrentProcessProgramID(), user_id, {new_normal_size, new_journal_size});
+        type, system.GetApplicationProcessProgramID(), user_id,
+        {new_normal_size, new_journal_size});
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
@@ -1720,7 +1721,7 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
               user_id[0]);
 
     const auto size = system.GetFileSystemController().ReadSaveDataSize(
-        type, system.GetCurrentProcessProgramID(), user_id);
+        type, system.GetApplicationProcessProgramID(), user_id);
 
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(ResultSuccess);
@@ -1838,7 +1839,6 @@ void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger
     std::make_shared<IdleSys>(system)->InstallAsService(service_manager);
     std::make_shared<OMM>(system)->InstallAsService(service_manager);
     std::make_shared<SPSM>(system)->InstallAsService(service_manager);
-    std::make_shared<TCAP>(system)->InstallAsService(service_manager);
 }
 
 IHomeMenuFunctions::IHomeMenuFunctions(Core::System& system_)
diff --git a/src/core/hle/service/am/applets/applet_error.cpp b/src/core/hle/service/am/applets/applet_error.cpp
index bae0d99a6..b013896b4 100644
--- a/src/core/hle/service/am/applets/applet_error.cpp
+++ b/src/core/hle/service/am/applets/applet_error.cpp
@@ -166,7 +166,7 @@ void Error::Execute() {
     }
 
     const auto callback = [this] { DisplayCompleted(); };
-    const auto title_id = system.GetCurrentProcessProgramID();
+    const auto title_id = system.GetApplicationProcessProgramID();
     const auto& reporter{system.GetReporter()};
 
     switch (mode) {
diff --git a/src/core/hle/service/am/applets/applet_general_backend.cpp b/src/core/hle/service/am/applets/applet_general_backend.cpp
index e50acdaf6..1eefa85e3 100644
--- a/src/core/hle/service/am/applets/applet_general_backend.cpp
+++ b/src/core/hle/service/am/applets/applet_general_backend.cpp
@@ -186,7 +186,7 @@ void PhotoViewer::Execute() {
     const auto callback = [this] { ViewFinished(); };
     switch (mode) {
     case PhotoViewerAppletMode::CurrentApp:
-        frontend.ShowPhotosForApplication(system.GetCurrentProcessProgramID(), callback);
+        frontend.ShowPhotosForApplication(system.GetApplicationProcessProgramID(), callback);
         break;
     case PhotoViewerAppletMode::AllApps:
         frontend.ShowAllPhotos(callback);
diff --git a/src/core/hle/service/am/applets/applet_web_browser.cpp b/src/core/hle/service/am/applets/applet_web_browser.cpp
index 14aa6f69e..f061bae80 100644
--- a/src/core/hle/service/am/applets/applet_web_browser.cpp
+++ b/src/core/hle/service/am/applets/applet_web_browser.cpp
@@ -393,7 +393,7 @@ void WebBrowser::InitializeOffline() {
     switch (document_kind) {
     case DocumentKind::OfflineHtmlPage:
     default:
-        title_id = system.GetCurrentProcessProgramID();
+        title_id = system.GetApplicationProcessProgramID();
         nca_type = FileSys::ContentRecordType::HtmlDocument;
         additional_paths = "html-document";
         break;
diff --git a/src/core/hle/service/am/tcap.cpp b/src/core/hle/service/am/tcap.cpp
deleted file mode 100644
index 818420e22..000000000
--- a/src/core/hle/service/am/tcap.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/am/tcap.h"
-
-namespace Service::AM {
-
-TCAP::TCAP(Core::System& system_) : ServiceFramework{system_, "tcap"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetContinuousHighSkinTemperatureEvent"},
-        {1, nullptr, "SetOperationMode"},
-        {2, nullptr, "LoadAndApplySettings"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-TCAP::~TCAP() = default;
-
-} // namespace Service::AM
diff --git a/src/core/hle/service/am/tcap.h b/src/core/hle/service/am/tcap.h
deleted file mode 100644
index 6b2148c29..000000000
--- a/src/core/hle/service/am/tcap.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::AM {
-
-class TCAP final : public ServiceFramework<TCAP> {
-public:
-    explicit TCAP(Core::System& system_);
-    ~TCAP() override;
-};
-
-} // namespace Service::AM
diff --git a/src/core/hle/service/aoc/aoc_u.cpp b/src/core/hle/service/aoc/aoc_u.cpp
index 368ccd52f..7264f23f9 100644
--- a/src/core/hle/service/aoc/aoc_u.cpp
+++ b/src/core/hle/service/aoc/aoc_u.cpp
@@ -155,7 +155,7 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
 
-    const auto current = system.GetCurrentProcessProgramID();
+    const auto current = system.GetApplicationProcessProgramID();
 
     const auto& disabled = Settings::values.disabled_addons[current];
     if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end()) {
@@ -182,7 +182,7 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_AOC, "called with offset={}, count={}, process_id={}", offset, count,
               process_id);
 
-    const auto current = system.GetCurrentProcessProgramID();
+    const auto current = system.GetApplicationProcessProgramID();
 
     std::vector<u32> out;
     const auto& disabled = Settings::values.disabled_addons[current];
@@ -228,7 +228,7 @@ void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
 
-    const auto title_id = system.GetCurrentProcessProgramID();
+    const auto title_id = system.GetApplicationProcessProgramID();
     const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
                                    system.GetContentProvider()};
 
diff --git a/src/core/hle/service/apm/apm.cpp b/src/core/hle/service/apm/apm.cpp
index 8a338d9b1..44b2927a6 100644
--- a/src/core/hle/service/apm/apm.cpp
+++ b/src/core/hle/service/apm/apm.cpp
@@ -14,8 +14,6 @@ void InstallInterfaces(Core::System& system) {
     auto module_ = std::make_shared<Module>();
     std::make_shared<APM>(system, module_, system.GetAPMController(), "apm")
         ->InstallAsService(system.ServiceManager());
-    std::make_shared<APM>(system, module_, system.GetAPMController(), "apm:p")
-        ->InstallAsService(system.ServiceManager());
     std::make_shared<APM>(system, module_, system.GetAPMController(), "apm:am")
         ->InstallAsService(system.ServiceManager());
     std::make_shared<APM_Sys>(system, system.GetAPMController())
diff --git a/src/core/hle/service/apm/apm_controller.cpp b/src/core/hle/service/apm/apm_controller.cpp
index d6de84066..227fdd0cf 100644
--- a/src/core/hle/service/apm/apm_controller.cpp
+++ b/src/core/hle/service/apm/apm_controller.cpp
@@ -56,7 +56,7 @@ void Controller::SetPerformanceConfiguration(PerformanceMode mode,
 }
 
 void Controller::SetFromCpuBoostMode(CpuBoostMode mode) {
-    constexpr std::array<PerformanceConfiguration, 3> BOOST_MODE_TO_CONFIG_MAP{{
+    static constexpr std::array<PerformanceConfiguration, 3> BOOST_MODE_TO_CONFIG_MAP{{
         PerformanceConfiguration::Config7,
         PerformanceConfiguration::Config13,
         PerformanceConfiguration::Config15,
diff --git a/src/core/hle/service/audio/auddbg.cpp b/src/core/hle/service/audio/auddbg.cpp
deleted file mode 100644
index 5541af300..000000000
--- a/src/core/hle/service/audio/auddbg.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/audio/auddbg.h"
-
-namespace Service::Audio {
-
-AudDbg::AudDbg(Core::System& system_, const char* name) : ServiceFramework{system_, name} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestSuspendForDebug"},
-        {1, nullptr, "RequestResumeForDebug"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-AudDbg::~AudDbg() = default;
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/auddbg.h b/src/core/hle/service/audio/auddbg.h
deleted file mode 100644
index 8f26be5dc..000000000
--- a/src/core/hle/service/audio/auddbg.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Audio {
-
-class AudDbg final : public ServiceFramework<AudDbg> {
-public:
-    explicit AudDbg(Core::System& system_, const char* name);
-    ~AudDbg() override;
-};
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audin_a.cpp b/src/core/hle/service/audio/audin_a.cpp
deleted file mode 100644
index 98f4a6048..000000000
--- a/src/core/hle/service/audio/audin_a.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/audio/audin_a.h"
-
-namespace Service::Audio {
-
-AudInA::AudInA(Core::System& system_) : ServiceFramework{system_, "audin:a"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestSuspend"},
-        {1, nullptr, "RequestResume"},
-        {2, nullptr, "GetProcessMasterVolume"},
-        {3, nullptr, "SetProcessMasterVolume"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-AudInA::~AudInA() = default;
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audin_a.h b/src/core/hle/service/audio/audin_a.h
deleted file mode 100644
index 19a927de5..000000000
--- a/src/core/hle/service/audio/audin_a.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Audio {
-
-class AudInA final : public ServiceFramework<AudInA> {
-public:
-    explicit AudInA(Core::System& system_);
-    ~AudInA() override;
-};
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audio.cpp b/src/core/hle/service/audio/audio.cpp
index 97da71dfa..ed36e3448 100644
--- a/src/core/hle/service/audio/audio.cpp
+++ b/src/core/hle/service/audio/audio.cpp
@@ -2,17 +2,12 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/service/audio/audctl.h"
-#include "core/hle/service/audio/auddbg.h"
-#include "core/hle/service/audio/audin_a.h"
 #include "core/hle/service/audio/audin_u.h"
 #include "core/hle/service/audio/audio.h"
-#include "core/hle/service/audio/audout_a.h"
 #include "core/hle/service/audio/audout_u.h"
 #include "core/hle/service/audio/audrec_a.h"
 #include "core/hle/service/audio/audrec_u.h"
-#include "core/hle/service/audio/audren_a.h"
 #include "core/hle/service/audio/audren_u.h"
-#include "core/hle/service/audio/codecctl.h"
 #include "core/hle/service/audio/hwopus.h"
 #include "core/hle/service/service.h"
 
@@ -20,21 +15,12 @@ namespace Service::Audio {
 
 void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
     std::make_shared<AudCtl>(system)->InstallAsService(service_manager);
-    std::make_shared<AudOutA>(system)->InstallAsService(service_manager);
     std::make_shared<AudOutU>(system)->InstallAsService(service_manager);
-    std::make_shared<AudInA>(system)->InstallAsService(service_manager);
     std::make_shared<AudInU>(system)->InstallAsService(service_manager);
     std::make_shared<AudRecA>(system)->InstallAsService(service_manager);
     std::make_shared<AudRecU>(system)->InstallAsService(service_manager);
-    std::make_shared<AudRenA>(system)->InstallAsService(service_manager);
     std::make_shared<AudRenU>(system)->InstallAsService(service_manager);
-    std::make_shared<CodecCtl>(system)->InstallAsService(service_manager);
     std::make_shared<HwOpus>(system)->InstallAsService(service_manager);
-
-    std::make_shared<AudDbg>(system, "audin:d")->InstallAsService(service_manager);
-    std::make_shared<AudDbg>(system, "audout:d")->InstallAsService(service_manager);
-    std::make_shared<AudDbg>(system, "audrec:d")->InstallAsService(service_manager);
-    std::make_shared<AudDbg>(system, "audren:d")->InstallAsService(service_manager);
 }
 
 } // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audout_a.cpp b/src/core/hle/service/audio/audout_a.cpp
deleted file mode 100644
index 5ecb99236..000000000
--- a/src/core/hle/service/audio/audout_a.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/audio/audout_a.h"
-
-namespace Service::Audio {
-
-AudOutA::AudOutA(Core::System& system_) : ServiceFramework{system_, "audout:a"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestSuspend"},
-        {1, nullptr, "RequestResume"},
-        {2, nullptr, "GetProcessMasterVolume"},
-        {3, nullptr, "SetProcessMasterVolume"},
-        {4, nullptr, "GetProcessRecordVolume"},
-        {5, nullptr, "SetProcessRecordVolume"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-AudOutA::~AudOutA() = default;
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audout_a.h b/src/core/hle/service/audio/audout_a.h
deleted file mode 100644
index f641cffeb..000000000
--- a/src/core/hle/service/audio/audout_a.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Audio {
-
-class AudOutA final : public ServiceFramework<AudOutA> {
-public:
-    explicit AudOutA(Core::System& system_);
-    ~AudOutA() override;
-};
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audren_a.cpp b/src/core/hle/service/audio/audren_a.cpp
deleted file mode 100644
index e775ac3bf..000000000
--- a/src/core/hle/service/audio/audren_a.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/audio/audren_a.h"
-
-namespace Service::Audio {
-
-AudRenA::AudRenA(Core::System& system_) : ServiceFramework{system_, "audren:a"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestSuspend"},
-        {1, nullptr, "RequestResume"},
-        {2, nullptr, "GetProcessMasterVolume"},
-        {3, nullptr, "SetProcessMasterVolume"},
-        {4, nullptr, "RegisterAppletResourceUserId"},
-        {5, nullptr, "UnregisterAppletResourceUserId"},
-        {6, nullptr, "GetProcessRecordVolume"},
-        {7, nullptr, "SetProcessRecordVolume"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-AudRenA::~AudRenA() = default;
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audren_a.h b/src/core/hle/service/audio/audren_a.h
deleted file mode 100644
index 9e08b4245..000000000
--- a/src/core/hle/service/audio/audren_a.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Audio {
-
-class AudRenA final : public ServiceFramework<AudRenA> {
-public:
-    explicit AudRenA(Core::System& system_);
-    ~AudRenA() override;
-};
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audren_u.cpp b/src/core/hle/service/audio/audren_u.cpp
index 0ee28752c..7d730421d 100644
--- a/src/core/hle/service/audio/audren_u.cpp
+++ b/src/core/hle/service/audio/audren_u.cpp
@@ -455,7 +455,7 @@ void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    const auto& handle_table{system.CurrentProcess()->GetHandleTable()};
+    const auto& handle_table{system.ApplicationProcess()->GetHandleTable()};
     auto process{handle_table.GetObject<Kernel::KProcess>(process_handle)};
     auto transfer_memory{
         process->GetHandleTable().GetObject<Kernel::KTransferMemory>(transfer_memory_handle)};
diff --git a/src/core/hle/service/audio/codecctl.cpp b/src/core/hle/service/audio/codecctl.cpp
deleted file mode 100644
index 81b956d7e..000000000
--- a/src/core/hle/service/audio/codecctl.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/audio/codecctl.h"
-
-namespace Service::Audio {
-
-CodecCtl::CodecCtl(Core::System& system_) : ServiceFramework{system_, "codecctl"} {
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "Initialize"},
-        {1, nullptr, "Finalize"},
-        {2, nullptr, "Sleep"},
-        {3, nullptr, "Wake"},
-        {4, nullptr, "SetVolume"},
-        {5, nullptr, "GetVolumeMax"},
-        {6, nullptr, "GetVolumeMin"},
-        {7, nullptr, "SetActiveTarget"},
-        {8, nullptr, "GetActiveTarget"},
-        {9, nullptr, "BindHeadphoneMicJackInterrupt"},
-        {10, nullptr, "IsHeadphoneMicJackInserted"},
-        {11, nullptr, "ClearHeadphoneMicJackInterrupt"},
-        {12, nullptr, "IsRequested"},
-    };
-    RegisterHandlers(functions);
-}
-
-CodecCtl::~CodecCtl() = default;
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/audio/codecctl.h b/src/core/hle/service/audio/codecctl.h
deleted file mode 100644
index 34da98212..000000000
--- a/src/core/hle/service/audio/codecctl.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Audio {
-
-class CodecCtl final : public ServiceFramework<CodecCtl> {
-public:
-    explicit CodecCtl(Core::System& system_);
-    ~CodecCtl() override;
-};
-
-} // namespace Service::Audio
diff --git a/src/core/hle/service/bcat/bcat_module.cpp b/src/core/hle/service/bcat/bcat_module.cpp
index cbe690a5d..6e6fed227 100644
--- a/src/core/hle/service/bcat/bcat_module.cpp
+++ b/src/core/hle/service/bcat/bcat_module.cpp
@@ -176,8 +176,8 @@ private:
     void RequestSyncDeliveryCache(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_BCAT, "called");
 
-        backend.Synchronize({system.GetCurrentProcessProgramID(),
-                             GetCurrentBuildID(system.GetCurrentProcessBuildID())},
+        backend.Synchronize({system.GetApplicationProcessProgramID(),
+                             GetCurrentBuildID(system.GetApplicationProcessBuildID())},
                             GetProgressBackend(SyncType::Normal));
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -193,8 +193,8 @@ private:
 
         LOG_DEBUG(Service_BCAT, "called, name={}", name);
 
-        backend.SynchronizeDirectory({system.GetCurrentProcessProgramID(),
-                                      GetCurrentBuildID(system.GetCurrentProcessBuildID())},
+        backend.SynchronizeDirectory({system.GetApplicationProcessProgramID(),
+                                      GetCurrentBuildID(system.GetApplicationProcessBuildID())},
                                      name, GetProgressBackend(SyncType::Directory));
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -554,7 +554,7 @@ private:
 void Module::Interface::CreateDeliveryCacheStorageService(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_BCAT, "called");
 
-    const auto title_id = system.GetCurrentProcessProgramID();
+    const auto title_id = system.GetApplicationProcessProgramID();
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
     rb.PushIpcInterface<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));
diff --git a/src/core/hle/service/fatal/fatal.cpp b/src/core/hle/service/fatal/fatal.cpp
index 27675615b..2e5919330 100644
--- a/src/core/hle/service/fatal/fatal.cpp
+++ b/src/core/hle/service/fatal/fatal.cpp
@@ -63,7 +63,7 @@ enum class FatalType : u32 {
 };
 
 static void GenerateErrorReport(Core::System& system, Result error_code, const FatalInfo& info) {
-    const auto title_id = system.GetCurrentProcessProgramID();
+    const auto title_id = system.GetApplicationProcessProgramID();
     std::string crash_report = fmt::format(
         "Yuzu {}-{} crash report\n"
         "Title ID:                        {:016x}\n"
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index 11c604a0f..177447bc1 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -317,7 +317,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess()
         return ResultUnknown;
     }
 
-    return romfs_factory->OpenCurrentProcess(system.GetCurrentProcessProgramID());
+    return romfs_factory->OpenCurrentProcess(system.GetApplicationProcessProgramID());
 }
 
 ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFS(
@@ -502,7 +502,7 @@ FileSys::SaveDataSize FileSystemController::ReadSaveDataSize(FileSys::SaveDataTy
         const auto res = system.GetAppLoader().ReadControlData(nacp);
 
         if (res != Loader::ResultStatus::Success) {
-            const FileSys::PatchManager pm{system.GetCurrentProcessProgramID(),
+            const FileSys::PatchManager pm{system.GetApplicationProcessProgramID(),
                                            system.GetFileSystemController(),
                                            system.GetContentProvider()};
             const auto metadata = pm.GetControlMetadata();
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index 447d624e1..e76346ca9 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -1036,8 +1036,9 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(Kernel::HLERequestContext& ctx) {
 
     LOG_DEBUG(Service_FS, "called, program_index={}", program_index);
 
-    auto patched_romfs = fsc.OpenPatchedRomFSWithProgramIndex(
-        system.GetCurrentProcessProgramID(), program_index, FileSys::ContentRecordType::Program);
+    auto patched_romfs =
+        fsc.OpenPatchedRomFSWithProgramIndex(system.GetApplicationProcessProgramID(), program_index,
+                                             FileSys::ContentRecordType::Program);
 
     if (patched_romfs.Failed()) {
         // TODO: Find the right error code to use here
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index 80eba22e8..ba6f04d8d 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -1132,7 +1132,8 @@ Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
     return ResultSuccess;
 }
 Result Controller_NPad::SetGyroscopeZeroDriftMode(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle, GyroscopeZeroDriftMode drift_mode) {
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+    Core::HID::GyroscopeZeroDriftMode drift_mode) {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
         LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
@@ -1140,14 +1141,16 @@ Result Controller_NPad::SetGyroscopeZeroDriftMode(
     }
 
     auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    auto& controller = GetControllerFromHandle(sixaxis_handle);
     sixaxis.gyroscope_zero_drift_mode = drift_mode;
+    controller.device->SetGyroscopeZeroDriftMode(drift_mode);
 
     return ResultSuccess;
 }
 
 Result Controller_NPad::GetGyroscopeZeroDriftMode(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-    GyroscopeZeroDriftMode& drift_mode) const {
+    Core::HID::GyroscopeZeroDriftMode& drift_mode) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
         LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index 02cc00920..a5998c453 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -52,13 +52,6 @@ public:
     // When the controller is requesting a motion update for the shared memory
     void OnMotionUpdate(const Core::Timing::CoreTiming& core_timing) override;
 
-    // This is nn::hid::GyroscopeZeroDriftMode
-    enum class GyroscopeZeroDriftMode : u32 {
-        Loose = 0,
-        Standard = 1,
-        Tight = 2,
-    };
-
     // This is nn::hid::NpadJoyHoldType
     enum class NpadJoyHoldType : u64 {
         Vertical = 0,
@@ -146,9 +139,9 @@ public:
     Result DisconnectNpad(Core::HID::NpadIdType npad_id);
 
     Result SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                     GyroscopeZeroDriftMode drift_mode);
+                                     Core::HID::GyroscopeZeroDriftMode drift_mode);
     Result GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                     GyroscopeZeroDriftMode& drift_mode) const;
+                                     Core::HID::GyroscopeZeroDriftMode& drift_mode) const;
     Result IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
                                  bool& is_at_rest) const;
     Result IsFirmwareUpdateAvailableForSixAxisSensor(
@@ -489,7 +482,8 @@ private:
         Core::HID::SixAxisSensorFusionParameters fusion{};
         Core::HID::SixAxisSensorCalibrationParameter calibration{};
         Core::HID::SixAxisSensorIcInformation ic_information{};
-        GyroscopeZeroDriftMode gyroscope_zero_drift_mode{GyroscopeZeroDriftMode::Standard};
+        Core::HID::GyroscopeZeroDriftMode gyroscope_zero_drift_mode{
+            Core::HID::GyroscopeZeroDriftMode::Standard};
     };
 
     struct NpadControllerData {
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index ac2c0c76d..eb3c45a58 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -712,7 +712,7 @@ void Hid::ResetSixAxisSensorFusionParameters(Kernel::HLERequestContext& ctx) {
 void Hid::SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto sixaxis_handle{rp.PopRaw<Core::HID::SixAxisSensorHandle>()};
-    const auto drift_mode{rp.PopEnum<Controller_NPad::GyroscopeZeroDriftMode>()};
+    const auto drift_mode{rp.PopEnum<Core::HID::GyroscopeZeroDriftMode>()};
     const auto applet_resource_user_id{rp.Pop<u64>()};
 
     auto& controller = GetAppletResource()->GetController<Controller_NPad>(HidController::NPad);
@@ -739,7 +739,7 @@ void Hid::GetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
 
     const auto parameters{rp.PopRaw<Parameters>()};
 
-    auto drift_mode{Controller_NPad::GyroscopeZeroDriftMode::Standard};
+    auto drift_mode{Core::HID::GyroscopeZeroDriftMode::Standard};
     auto& controller = GetAppletResource()->GetController<Controller_NPad>(HidController::NPad);
     const auto result = controller.GetGyroscopeZeroDriftMode(parameters.sixaxis_handle, drift_mode);
 
@@ -764,7 +764,7 @@ void Hid::ResetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
 
     const auto parameters{rp.PopRaw<Parameters>()};
 
-    const auto drift_mode{Controller_NPad::GyroscopeZeroDriftMode::Standard};
+    const auto drift_mode{Core::HID::GyroscopeZeroDriftMode::Standard};
     auto& controller = GetAppletResource()->GetController<Controller_NPad>(HidController::NPad);
     const auto result = controller.SetGyroscopeZeroDriftMode(parameters.sixaxis_handle, drift_mode);
 
@@ -1830,7 +1830,7 @@ void Hid::InitializeSevenSixAxisSensor(Kernel::HLERequestContext& ctx) {
     ASSERT_MSG(t_mem_1_size == 0x1000, "t_mem_1_size is not 0x1000 bytes");
     ASSERT_MSG(t_mem_2_size == 0x7F000, "t_mem_2_size is not 0x7F000 bytes");
 
-    auto t_mem_1 = system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
+    auto t_mem_1 = system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
         t_mem_1_handle);
 
     if (t_mem_1.IsNull()) {
@@ -1840,7 +1840,7 @@ void Hid::InitializeSevenSixAxisSensor(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    auto t_mem_2 = system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
+    auto t_mem_2 = system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
         t_mem_2_handle);
 
     if (t_mem_2.IsNull()) {
@@ -2127,8 +2127,8 @@ void Hid::WritePalmaWaveEntry(Kernel::HLERequestContext& ctx) {
 
     ASSERT_MSG(t_mem_size == 0x3000, "t_mem_size is not 0x3000 bytes");
 
-    auto t_mem =
-        system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(t_mem_handle);
+    auto t_mem = system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
+        t_mem_handle);
 
     if (t_mem.IsNull()) {
         LOG_ERROR(Service_HID, "t_mem is a nullptr for handle=0x{:08X}", t_mem_handle);
@@ -2734,25 +2734,11 @@ private:
     }
 };
 
-class HidTmp final : public ServiceFramework<HidTmp> {
-public:
-    explicit HidTmp(Core::System& system_) : ServiceFramework{system_, "hid:tmp"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetConsoleSixAxisSensorCalibrationValues"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
     std::make_shared<Hid>(system)->InstallAsService(service_manager);
     std::make_shared<HidBus>(system)->InstallAsService(service_manager);
     std::make_shared<HidDbg>(system)->InstallAsService(service_manager);
     std::make_shared<HidSys>(system)->InstallAsService(service_manager);
-    std::make_shared<HidTmp>(system)->InstallAsService(service_manager);
 
     std::make_shared<Service::IRS::IRS>(system)->InstallAsService(service_manager);
     std::make_shared<Service::IRS::IRS_SYS>(system)->InstallAsService(service_manager);
diff --git a/src/core/hle/service/hid/hidbus.cpp b/src/core/hle/service/hid/hidbus.cpp
index 17252a84a..bd94e8f3d 100644
--- a/src/core/hle/service/hid/hidbus.cpp
+++ b/src/core/hle/service/hid/hidbus.cpp
@@ -449,8 +449,8 @@ void HidBus::EnableJoyPollingReceiveMode(Kernel::HLERequestContext& ctx) {
 
     ASSERT_MSG(t_mem_size == 0x1000, "t_mem_size is not 0x1000 bytes");
 
-    auto t_mem =
-        system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(t_mem_handle);
+    auto t_mem = system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
+        t_mem_handle);
 
     if (t_mem.IsNull()) {
         LOG_ERROR(Service_HID, "t_mem is a nullptr for handle=0x{:08X}", t_mem_handle);
diff --git a/src/core/hle/service/hid/irs.cpp b/src/core/hle/service/hid/irs.cpp
index 52f402c56..3bd418e92 100644
--- a/src/core/hle/service/hid/irs.cpp
+++ b/src/core/hle/service/hid/irs.cpp
@@ -196,8 +196,8 @@ void IRS::RunImageTransferProcessor(Kernel::HLERequestContext& ctx) {
     const auto parameters{rp.PopRaw<Parameters>()};
     const auto t_mem_handle{ctx.GetCopyHandle(0)};
 
-    auto t_mem =
-        system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(t_mem_handle);
+    auto t_mem = system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
+        t_mem_handle);
 
     if (t_mem.IsNull()) {
         LOG_ERROR(Service_IRS, "t_mem is a nullptr for handle=0x{:08X}", t_mem_handle);
@@ -445,8 +445,8 @@ void IRS::RunImageTransferExProcessor(Kernel::HLERequestContext& ctx) {
     const auto parameters{rp.PopRaw<Parameters>()};
     const auto t_mem_handle{ctx.GetCopyHandle(0)};
 
-    auto t_mem =
-        system.CurrentProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(t_mem_handle);
+    auto t_mem = system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
+        t_mem_handle);
 
     u8* transfer_memory = system.Memory().GetPointer(t_mem->GetSourceAddress());
 
diff --git a/src/core/hle/service/jit/jit.cpp b/src/core/hle/service/jit/jit.cpp
index 1295a44c7..47a1277ea 100644
--- a/src/core/hle/service/jit/jit.cpp
+++ b/src/core/hle/service/jit/jit.cpp
@@ -353,9 +353,9 @@ public:
             return;
         }
 
-        // Fetch using the handle table for the current process here,
+        // Fetch using the handle table for the application process here,
         // since we are not multiprocess yet.
-        const auto& handle_table{system.CurrentProcess()->GetHandleTable()};
+        const auto& handle_table{system.ApplicationProcess()->GetHandleTable()};
 
         auto process{handle_table.GetObject<Kernel::KProcess>(process_handle)};
         if (process.IsNull()) {
diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp
index 652441bc2..2d4d6fe3e 100644
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@@ -246,7 +246,7 @@ public:
             return;
         }
 
-        if (system.GetCurrentProcessProgramID() != header.application_id) {
+        if (system.GetApplicationProcessProgramID() != header.application_id) {
             LOG_ERROR(Service_LDR,
                       "Attempting to load NRR with title ID other than current process. (actual "
                       "{:016X})!",
@@ -542,15 +542,16 @@ public:
         }
 
         // Map memory for the NRO
-        const auto map_result{MapNro(system.CurrentProcess(), nro_address, nro_size, bss_address,
-                                     bss_size, nro_size + bss_size)};
+        const auto map_result{MapNro(system.ApplicationProcess(), nro_address, nro_size,
+                                     bss_address, bss_size, nro_size + bss_size)};
         if (map_result.Failed()) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(map_result.Code());
         }
 
         // Load the NRO into the mapped memory
-        if (const auto result{LoadNro(system.CurrentProcess(), header, nro_address, *map_result)};
+        if (const auto result{
+                LoadNro(system.ApplicationProcess(), header, nro_address, *map_result)};
             result.IsError()) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(map_result.Code());
@@ -570,7 +571,7 @@ public:
 
     Result UnmapNro(const NROInfo& info) {
         // Each region must be unmapped separately to validate memory state
-        auto& page_table{system.CurrentProcess()->PageTable()};
+        auto& page_table{system.ApplicationProcess()->PageTable()};
 
         if (info.bss_size != 0) {
             CASCADE_CODE(page_table.UnmapCodeMemory(
@@ -641,7 +642,7 @@ public:
         LOG_WARNING(Service_LDR, "(STUBBED) called");
 
         initialized = true;
-        current_map_addr = system.CurrentProcess()->PageTable().GetAliasCodeRegionStart();
+        current_map_addr = system.ApplicationProcess()->PageTable().GetAliasCodeRegionStart();
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
diff --git a/src/core/hle/service/nfp/nfp_device.cpp b/src/core/hle/service/nfp/nfp_device.cpp
index e67a76f55..7a6bbbba7 100644
--- a/src/core/hle/service/nfp/nfp_device.cpp
+++ b/src/core/hle/service/nfp/nfp_device.cpp
@@ -618,7 +618,7 @@ Result NfpDevice::RecreateApplicationArea(u32 access_id, std::span<const u8> dat
                             sizeof(ApplicationArea) - data.size());
 
     // TODO: Investigate why the title id needs to be moddified
-    tag_data.title_id = system.GetCurrentProcessProgramID();
+    tag_data.title_id = system.GetApplicationProcessProgramID();
     tag_data.title_id = tag_data.title_id | 0x30000000ULL;
     tag_data.settings.settings.appdata_initialized.Assign(1);
     tag_data.application_area_id = access_id;
diff --git a/src/core/hle/service/nvdrv/core/syncpoint_manager.h b/src/core/hle/service/nvdrv/core/syncpoint_manager.h
index 4f2cefae5..7728ff596 100644
--- a/src/core/hle/service/nvdrv/core/syncpoint_manager.h
+++ b/src/core/hle/service/nvdrv/core/syncpoint_manager.h
@@ -124,7 +124,7 @@ private:
                        //!< value
     };
 
-    constexpr static std::size_t SyncpointCount{192};
+    static constexpr std::size_t SyncpointCount{192};
     std::array<SyncpointInfo, SyncpointCount> syncpoints{};
     std::mutex reservation_lock;
 
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
index 0cdde82a7..e12025560 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
@@ -150,9 +150,9 @@ NvResult nvhost_ctrl::IocCtrlEventWait(std::span<const u8> input, std::vector<u8
     const auto check_failing = [&]() {
         if (events[slot].fails > 2) {
             {
-                auto lk = system.StallProcesses();
+                auto lk = system.StallApplication();
                 host1x_syncpoint_manager.WaitHost(fence_id, target_value);
-                system.UnstallProcesses();
+                system.UnstallApplication();
             }
             params.value.raw = target_value;
             return true;
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.cpp b/src/core/hle/service/nvdrv/devices/nvmap.cpp
index 29c1e0f01..277afe0b4 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvmap.cpp
@@ -127,7 +127,7 @@ NvResult nvmap::IocAlloc(std::span<const u8> input, std::vector<u8>& output) {
         return result;
     }
     bool is_out_io{};
-    ASSERT(system.CurrentProcess()
+    ASSERT(system.ApplicationProcess()
                ->PageTable()
                .LockForMapDeviceAddressSpace(&is_out_io, handle_description->address,
                                              handle_description->size,
@@ -254,7 +254,7 @@ NvResult nvmap::IocFree(std::span<const u8> input, std::vector<u8>& output) {
 
     if (auto freeInfo{file.FreeHandle(params.handle, false)}) {
         if (freeInfo->can_unlock) {
-            ASSERT(system.CurrentProcess()
+            ASSERT(system.ApplicationProcess()
                        ->PageTable()
                        .UnlockForDeviceAddressSpace(freeInfo->address, freeInfo->size)
                        .IsSuccess());
diff --git a/src/core/hle/service/pctl/pctl_module.cpp b/src/core/hle/service/pctl/pctl_module.cpp
index 2a123b42d..083609b34 100644
--- a/src/core/hle/service/pctl/pctl_module.cpp
+++ b/src/core/hle/service/pctl/pctl_module.cpp
@@ -187,7 +187,7 @@ private:
 
         // TODO(ogniK): Recovery flag initialization for pctl:r
 
-        const auto tid = system.GetCurrentProcessProgramID();
+        const auto tid = system.GetApplicationProcessProgramID();
         if (tid != 0) {
             const FileSys::PatchManager pm{tid, system.GetFileSystemController(),
                                            system.GetContentProvider()};
diff --git a/src/core/hle/service/pcv/pcv.cpp b/src/core/hle/service/pcv/pcv.cpp
index f7a497a14..98037a8d4 100644
--- a/src/core/hle/service/pcv/pcv.cpp
+++ b/src/core/hle/service/pcv/pcv.cpp
@@ -52,32 +52,6 @@ public:
     }
 };
 
-class PCV_ARB final : public ServiceFramework<PCV_ARB> {
-public:
-    explicit PCV_ARB(Core::System& system_) : ServiceFramework{system_, "pcv:arb"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "ReleaseControl"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class PCV_IMM final : public ServiceFramework<PCV_IMM> {
-public:
-    explicit PCV_IMM(Core::System& system_) : ServiceFramework{system_, "pcv:imm"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "SetClockRate"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 class IClkrstSession final : public ServiceFramework<IClkrstSession> {
 public:
     explicit IClkrstSession(Core::System& system_, DeviceCode deivce_code_)
@@ -169,8 +143,6 @@ public:
 
 void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
     std::make_shared<PCV>(system)->InstallAsService(sm);
-    std::make_shared<PCV_ARB>(system)->InstallAsService(sm);
-    std::make_shared<PCV_IMM>(system)->InstallAsService(sm);
     std::make_shared<CLKRST>(system, "clkrst")->InstallAsService(sm);
     std::make_shared<CLKRST>(system, "clkrst:i")->InstallAsService(sm);
     std::make_shared<CLKRST_A>(system)->InstallAsService(sm);
diff --git a/src/core/hle/service/prepo/prepo.cpp b/src/core/hle/service/prepo/prepo.cpp
index 01040b32a..90c5f8756 100644
--- a/src/core/hle/service/prepo/prepo.cpp
+++ b/src/core/hle/service/prepo/prepo.cpp
@@ -71,7 +71,7 @@ private:
                   Type, process_id, data1.size(), data2.size());
 
         const auto& reporter{system.GetReporter()};
-        reporter.SavePlayReport(Type, system.GetCurrentProcessProgramID(), {data1, data2},
+        reporter.SavePlayReport(Type, system.GetApplicationProcessProgramID(), {data1, data2},
                                 process_id);
 
         IPC::ResponseBuilder rb{ctx, 2};
@@ -99,7 +99,7 @@ private:
                   Type, user_id[1], user_id[0], process_id, data1.size(), data2.size());
 
         const auto& reporter{system.GetReporter()};
-        reporter.SavePlayReport(Type, system.GetCurrentProcessProgramID(), {data1, data2},
+        reporter.SavePlayReport(Type, system.GetApplicationProcessProgramID(), {data1, data2},
                                 process_id, user_id);
 
         IPC::ResponseBuilder rb{ctx, 2};
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 0de67f1e1..1ffc1c694 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -68,7 +68,6 @@
 #include "core/hle/service/time/time.h"
 #include "core/hle/service/usb/usb.h"
 #include "core/hle/service/vi/vi.h"
-#include "core/hle/service/wlan/wlan.h"
 #include "core/reporter.h"
 
 namespace Service {
@@ -306,7 +305,6 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
     Time::InstallInterfaces(system);
     USB::InstallInterfaces(*sm, system);
     VI::InstallInterfaces(*sm, system, *nv_flinger, *hos_binder_driver_server);
-    WLAN::InstallInterfaces(*sm, system);
 }
 
 Services::~Services() = default;
diff --git a/src/core/hle/service/sockets/ethc.cpp b/src/core/hle/service/sockets/ethc.cpp
deleted file mode 100644
index c12ea999b..000000000
--- a/src/core/hle/service/sockets/ethc.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/sockets/ethc.h"
-
-namespace Service::Sockets {
-
-ETHC_C::ETHC_C(Core::System& system_) : ServiceFramework{system_, "ethc:c"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "Initialize"},
-        {1, nullptr, "Cancel"},
-        {2, nullptr, "GetResult"},
-        {3, nullptr, "GetMediaList"},
-        {4, nullptr, "SetMediaType"},
-        {5, nullptr, "GetMediaType"},
-        {6, nullptr, "Unknown6"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-ETHC_C::~ETHC_C() = default;
-
-ETHC_I::ETHC_I(Core::System& system_) : ServiceFramework{system_, "ethc:i"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetReadableHandle"},
-        {1, nullptr, "Cancel"},
-        {2, nullptr, "GetResult"},
-        {3, nullptr, "GetInterfaceList"},
-        {4, nullptr, "GetInterfaceCount"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-ETHC_I::~ETHC_I() = default;
-
-} // namespace Service::Sockets
diff --git a/src/core/hle/service/sockets/ethc.h b/src/core/hle/service/sockets/ethc.h
deleted file mode 100644
index 7c5759a96..000000000
--- a/src/core/hle/service/sockets/ethc.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Sockets {
-
-class ETHC_C final : public ServiceFramework<ETHC_C> {
-public:
-    explicit ETHC_C(Core::System& system_);
-    ~ETHC_C() override;
-};
-
-class ETHC_I final : public ServiceFramework<ETHC_I> {
-public:
-    explicit ETHC_I(Core::System& system_);
-    ~ETHC_I() override;
-};
-
-} // namespace Service::Sockets
diff --git a/src/core/hle/service/sockets/sockets.cpp b/src/core/hle/service/sockets/sockets.cpp
index 8d3ba6f96..b191b5cf5 100644
--- a/src/core/hle/service/sockets/sockets.cpp
+++ b/src/core/hle/service/sockets/sockets.cpp
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/service/sockets/bsd.h"
-#include "core/hle/service/sockets/ethc.h"
 #include "core/hle/service/sockets/nsd.h"
 #include "core/hle/service/sockets/sfdnsres.h"
 #include "core/hle/service/sockets/sockets.h"
@@ -14,9 +13,6 @@ void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system
     std::make_shared<BSD>(system, "bsd:u")->InstallAsService(service_manager);
     std::make_shared<BSDCFG>(system)->InstallAsService(service_manager);
 
-    std::make_shared<ETHC_C>(system)->InstallAsService(service_manager);
-    std::make_shared<ETHC_I>(system)->InstallAsService(service_manager);
-
     std::make_shared<NSD>(system, "nsd:a")->InstallAsService(service_manager);
     std::make_shared<NSD>(system, "nsd:u")->InstallAsService(service_manager);
 
diff --git a/src/core/hle/service/time/time_zone_manager.cpp b/src/core/hle/service/time/time_zone_manager.cpp
index f9ada7c93..973f7837a 100644
--- a/src/core/hle/service/time/time_zone_manager.cpp
+++ b/src/core/hle/service/time/time_zone_manager.cpp
@@ -286,7 +286,7 @@ static constexpr int TransitionTime(int year, Rule rule, int offset) {
 }
 
 static bool ParsePosixName(const char* name, TimeZoneRule& rule) {
-    constexpr char default_rule[]{",M4.1.0,M10.5.0"};
+    static constexpr char default_rule[]{",M4.1.0,M10.5.0"};
     const char* std_name{name};
     int std_len{};
     int offset{};
diff --git a/src/core/hle/service/wlan/wlan.cpp b/src/core/hle/service/wlan/wlan.cpp
deleted file mode 100644
index 226e3034c..000000000
--- a/src/core/hle/service/wlan/wlan.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <memory>
-
-#include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
-#include "core/hle/service/wlan/wlan.h"
-
-namespace Service::WLAN {
-
-class WLANInfra final : public ServiceFramework<WLANInfra> {
-public:
-    explicit WLANInfra(Core::System& system_) : ServiceFramework{system_, "wlan:inf"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "OpenMode"},
-            {1, nullptr, "CloseMode"},
-            {2, nullptr, "GetMacAddress"},
-            {3, nullptr, "StartScan"},
-            {4, nullptr, "StopScan"},
-            {5, nullptr, "Connect"},
-            {6, nullptr, "CancelConnect"},
-            {7, nullptr, "Disconnect"},
-            {8, nullptr, "GetConnectionEvent"},
-            {9, nullptr, "GetConnectionStatus"},
-            {10, nullptr, "GetState"},
-            {11, nullptr, "GetScanResult"},
-            {12, nullptr, "GetRssi"},
-            {13, nullptr, "ChangeRxAntenna"},
-            {14, nullptr, "GetFwVersion"},
-            {15, nullptr, "RequestSleep"},
-            {16, nullptr, "RequestWakeUp"},
-            {17, nullptr, "RequestIfUpDown"},
-            {18, nullptr, "Unknown18"},
-            {19, nullptr, "Unknown19"},
-            {20, nullptr, "Unknown20"},
-            {21, nullptr, "Unknown21"},
-            {22, nullptr, "Unknown22"},
-            {23, nullptr, "Unknown23"},
-            {24, nullptr, "Unknown24"},
-            {25, nullptr, "Unknown25"},
-            {26, nullptr, "Unknown26"},
-            {27, nullptr, "Unknown27"},
-            {28, nullptr, "Unknown28"},
-            {29, nullptr, "Unknown29"},
-            {30, nullptr, "Unknown30"},
-            {31, nullptr, "Unknown31"},
-            {32, nullptr, "Unknown32"},
-            {33, nullptr, "Unknown33"},
-            {34, nullptr, "Unknown34"},
-            {35, nullptr, "Unknown35"},
-            {36, nullptr, "Unknown36"},
-            {37, nullptr, "Unknown37"},
-            {38, nullptr, "Unknown38"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class WLANLocal final : public ServiceFramework<WLANLocal> {
-public:
-    explicit WLANLocal(Core::System& system_) : ServiceFramework{system_, "wlan:lcl"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown0"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "Unknown5"},
-            {6, nullptr, "GetMacAddress"},
-            {7, nullptr, "CreateBss"},
-            {8, nullptr, "DestroyBss"},
-            {9, nullptr, "StartScan"},
-            {10, nullptr, "StopScan"},
-            {11, nullptr, "Connect"},
-            {12, nullptr, "CancelConnect"},
-            {13, nullptr, "Join"},
-            {14, nullptr, "CancelJoin"},
-            {15, nullptr, "Disconnect"},
-            {16, nullptr, "SetBeaconLostCount"},
-            {17, nullptr, "Unknown17"},
-            {18, nullptr, "Unknown18"},
-            {19, nullptr, "Unknown19"},
-            {20, nullptr, "GetBssIndicationEvent"},
-            {21, nullptr, "GetBssIndicationInfo"},
-            {22, nullptr, "GetState"},
-            {23, nullptr, "GetAllowedChannels"},
-            {24, nullptr, "AddIe"},
-            {25, nullptr, "DeleteIe"},
-            {26, nullptr, "Unknown26"},
-            {27, nullptr, "Unknown27"},
-            {28, nullptr, "CreateRxEntry"},
-            {29, nullptr, "DeleteRxEntry"},
-            {30, nullptr, "Unknown30"},
-            {31, nullptr, "Unknown31"},
-            {32, nullptr, "AddMatchingDataToRxEntry"},
-            {33, nullptr, "RemoveMatchingDataFromRxEntry"},
-            {34, nullptr, "GetScanResult"},
-            {35, nullptr, "Unknown35"},
-            {36, nullptr, "SetActionFrameWithBeacon"},
-            {37, nullptr, "CancelActionFrameWithBeacon"},
-            {38, nullptr, "CreateRxEntryForActionFrame"},
-            {39, nullptr, "DeleteRxEntryForActionFrame"},
-            {40, nullptr, "Unknown40"},
-            {41, nullptr, "Unknown41"},
-            {42, nullptr, "CancelGetActionFrame"},
-            {43, nullptr, "GetRssi"},
-            {44, nullptr, "Unknown44"},
-            {45, nullptr, "Unknown45"},
-            {46, nullptr, "Unknown46"},
-            {47, nullptr, "Unknown47"},
-            {48, nullptr, "Unknown48"},
-            {49, nullptr, "Unknown49"},
-            {50, nullptr, "Unknown50"},
-            {51, nullptr, "Unknown51"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class WLANLocalGetFrame final : public ServiceFramework<WLANLocalGetFrame> {
-public:
-    explicit WLANLocalGetFrame(Core::System& system_) : ServiceFramework{system_, "wlan:lg"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class WLANSocketGetFrame final : public ServiceFramework<WLANSocketGetFrame> {
-public:
-    explicit WLANSocketGetFrame(Core::System& system_) : ServiceFramework{system_, "wlan:sg"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class WLANSocketManager final : public ServiceFramework<WLANSocketManager> {
-public:
-    explicit WLANSocketManager(Core::System& system_) : ServiceFramework{system_, "wlan:soc"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown0"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "Unknown5"},
-            {6, nullptr, "GetMacAddress"},
-            {7, nullptr, "SwitchTsfTimerFunction"},
-            {8, nullptr, "Unknown8"},
-            {9, nullptr, "Unknown9"},
-            {10, nullptr, "Unknown10"},
-            {11, nullptr, "Unknown11"},
-            {12, nullptr, "Unknown12"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<WLANInfra>(system)->InstallAsService(sm);
-    std::make_shared<WLANLocal>(system)->InstallAsService(sm);
-    std::make_shared<WLANLocalGetFrame>(system)->InstallAsService(sm);
-    std::make_shared<WLANSocketGetFrame>(system)->InstallAsService(sm);
-    std::make_shared<WLANSocketManager>(system)->InstallAsService(sm);
-}
-
-} // namespace Service::WLAN
diff --git a/src/core/hle/service/wlan/wlan.h b/src/core/hle/service/wlan/wlan.h
deleted file mode 100644
index 535c3bf0d..000000000
--- a/src/core/hle/service/wlan/wlan.h
+++ /dev/null
@@ -1,18 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-namespace Core {
-class System;
-}
-
-namespace Service::SM {
-class ServiceManager;
-}
-
-namespace Service::WLAN {
-
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
-
-} // namespace Service::WLAN
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
index 4c3b3c655..a5c384fb5 100644
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -145,7 +145,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
 
     // Apply cheats if they exist and the program has a valid title ID
     if (pm) {
-        system.SetCurrentProcessBuildID(nso_header.build_id);
+        system.SetApplicationProcessBuildID(nso_header.build_id);
         const auto cheats = pm->CreateCheatList(nso_header.build_id);
         if (!cheats.empty()) {
             system.RegisterCheatList(cheats, nso_header.build_id, load_base, image_size);
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index af9660b55..4397fcfb1 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -247,11 +247,11 @@ struct Memory::Impl {
     }
 
     void ReadBlock(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
-        ReadBlockImpl<false>(*system.CurrentProcess(), src_addr, dest_buffer, size);
+        ReadBlockImpl<false>(*system.ApplicationProcess(), src_addr, dest_buffer, size);
     }
 
     void ReadBlockUnsafe(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
-        ReadBlockImpl<true>(*system.CurrentProcess(), src_addr, dest_buffer, size);
+        ReadBlockImpl<true>(*system.ApplicationProcess(), src_addr, dest_buffer, size);
     }
 
     template <bool UNSAFE>
@@ -279,11 +279,11 @@ struct Memory::Impl {
     }
 
     void WriteBlock(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
-        WriteBlockImpl<false>(*system.CurrentProcess(), dest_addr, src_buffer, size);
+        WriteBlockImpl<false>(*system.ApplicationProcess(), dest_addr, src_buffer, size);
     }
 
     void WriteBlockUnsafe(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
-        WriteBlockImpl<true>(*system.CurrentProcess(), dest_addr, src_buffer, size);
+        WriteBlockImpl<true>(*system.ApplicationProcess(), dest_addr, src_buffer, size);
     }
 
     void ZeroBlock(const Kernel::KProcess& process, const VAddr dest_addr, const std::size_t size) {
@@ -711,7 +711,7 @@ void Memory::UnmapRegion(Common::PageTable& page_table, VAddr base, u64 size) {
 }
 
 bool Memory::IsValidVirtualAddress(const VAddr vaddr) const {
-    const Kernel::KProcess& process = *system.CurrentProcess();
+    const Kernel::KProcess& process = *system.ApplicationProcess();
     const auto& page_table = process.PageTable().PageTableImpl();
     const size_t page = vaddr >> YUZU_PAGEBITS;
     if (page >= page_table.pointers.size()) {
diff --git a/src/core/memory/cheat_engine.cpp b/src/core/memory/cheat_engine.cpp
index ffdbacc18..44ee39648 100644
--- a/src/core/memory/cheat_engine.cpp
+++ b/src/core/memory/cheat_engine.cpp
@@ -191,10 +191,10 @@ void CheatEngine::Initialize() {
         });
     core_timing.ScheduleLoopingEvent(CHEAT_ENGINE_NS, CHEAT_ENGINE_NS, event);
 
-    metadata.process_id = system.CurrentProcess()->GetProcessID();
-    metadata.title_id = system.GetCurrentProcessProgramID();
+    metadata.process_id = system.ApplicationProcess()->GetProcessID();
+    metadata.title_id = system.GetApplicationProcessProgramID();
 
-    const auto& page_table = system.CurrentProcess()->PageTable();
+    const auto& page_table = system.ApplicationProcess()->PageTable();
     metadata.heap_extents = {
         .base = page_table.GetHeapRegionStart(),
         .size = page_table.GetHeapRegionSize(),
diff --git a/src/core/reporter.cpp b/src/core/reporter.cpp
index 59dfb8767..708ae17aa 100644
--- a/src/core/reporter.cpp
+++ b/src/core/reporter.cpp
@@ -110,7 +110,7 @@ json GetProcessorStateData(const std::string& architecture, u64 entry_point, u64
 }
 
 json GetProcessorStateDataAuto(Core::System& system) {
-    const auto* process{system.CurrentProcess()};
+    const auto* process{system.ApplicationProcess()};
     auto& arm{system.CurrentArmInterface()};
 
     Core::ARM_Interface::ThreadContext64 context{};
@@ -234,7 +234,7 @@ void Reporter::SaveSvcBreakReport(u32 type, bool signal_debugger, u64 info1, u64
     }
 
     const auto timestamp = GetTimestamp();
-    const auto title_id = system.GetCurrentProcessProgramID();
+    const auto title_id = system.GetApplicationProcessProgramID();
     auto out = GetFullDataAuto(timestamp, title_id, system);
 
     auto break_out = json{
@@ -261,7 +261,7 @@ void Reporter::SaveUnimplementedFunctionReport(Kernel::HLERequestContext& ctx, u
     }
 
     const auto timestamp = GetTimestamp();
-    const auto title_id = system.GetCurrentProcessProgramID();
+    const auto title_id = system.GetApplicationProcessProgramID();
     auto out = GetFullDataAuto(timestamp, title_id, system);
 
     auto function_out = GetHLERequestContextData(ctx, system.Memory());
@@ -283,7 +283,7 @@ void Reporter::SaveUnimplementedAppletReport(
     }
 
     const auto timestamp = GetTimestamp();
-    const auto title_id = system.GetCurrentProcessProgramID();
+    const auto title_id = system.GetApplicationProcessProgramID();
     auto out = GetFullDataAuto(timestamp, title_id, system);
 
     out["applet_common_args"] = {
@@ -376,7 +376,7 @@ void Reporter::SaveUserReport() const {
     }
 
     const auto timestamp = GetTimestamp();
-    const auto title_id = system.GetCurrentProcessProgramID();
+    const auto title_id = system.GetApplicationProcessProgramID();
 
     SaveToFile(GetFullDataAuto(timestamp, title_id, system),
                GetPath("user_report", title_id, timestamp));
diff --git a/src/core/telemetry_session.cpp b/src/core/telemetry_session.cpp
index 8d5f2be2f..9178b00ca 100644
--- a/src/core/telemetry_session.cpp
+++ b/src/core/telemetry_session.cpp
@@ -34,7 +34,7 @@ static u64 GenerateTelemetryId() {
     mbedtls_entropy_context entropy;
     mbedtls_entropy_init(&entropy);
     mbedtls_ctr_drbg_context ctr_drbg;
-    constexpr std::array<char, 18> personalization{{"yuzu Telemetry ID"}};
+    static constexpr std::array<char, 18> personalization{{"yuzu Telemetry ID"}};
 
     mbedtls_ctr_drbg_init(&ctr_drbg);
     ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
diff --git a/src/input_common/drivers/joycon.cpp b/src/input_common/drivers/joycon.cpp
index 4fcfb4510..b4cd39a20 100644
--- a/src/input_common/drivers/joycon.cpp
+++ b/src/input_common/drivers/joycon.cpp
@@ -16,7 +16,7 @@ namespace InputCommon {
 
 Joycons::Joycons(const std::string& input_engine_) : InputEngine(input_engine_) {
     // Avoid conflicting with SDL driver
-    if (!Settings::values.enable_joycon_driver) {
+    if (!Settings::values.enable_joycon_driver && !Settings::values.enable_procon_driver) {
         return;
     }
     LOG_INFO(Input, "Joycon driver Initialization started");
@@ -46,6 +46,12 @@ void Joycons::Reset() {
         }
         device->Stop();
     }
+    for (const auto& device : pro_controller) {
+        if (!device) {
+            continue;
+        }
+        device->Stop();
+    }
     SDL_hid_exit();
 }
 
@@ -61,6 +67,11 @@ void Joycons::Setup() {
         PreSetController(GetIdentifier(port, Joycon::ControllerType::Right));
         device = std::make_shared<Joycon::JoyconDriver>(port++);
     }
+    port = 0;
+    for (auto& device : pro_controller) {
+        PreSetController(GetIdentifier(port, Joycon::ControllerType::Pro));
+        device = std::make_shared<Joycon::JoyconDriver>(port++);
+    }
 
     scan_thread = std::jthread([this](std::stop_token stop_token) { ScanThread(stop_token); });
 }
@@ -116,6 +127,9 @@ bool Joycons::IsDeviceNew(SDL_hid_device_info* device_info) const {
     // Check if device already exist
     switch (type) {
     case Joycon::ControllerType::Left:
+        if (!Settings::values.enable_joycon_driver) {
+            return false;
+        }
         for (const auto& device : left_joycons) {
             if (is_handle_identical(device)) {
                 return false;
@@ -123,12 +137,25 @@ bool Joycons::IsDeviceNew(SDL_hid_device_info* device_info) const {
         }
         break;
     case Joycon::ControllerType::Right:
+        if (!Settings::values.enable_joycon_driver) {
+            return false;
+        }
         for (const auto& device : right_joycons) {
             if (is_handle_identical(device)) {
                 return false;
             }
         }
         break;
+    case Joycon::ControllerType::Pro:
+        if (!Settings::values.enable_procon_driver) {
+            return false;
+        }
+        for (const auto& device : pro_controller) {
+            if (is_handle_identical(device)) {
+                return false;
+            }
+        }
+        break;
     default:
         return false;
     }
@@ -199,6 +226,14 @@ std::shared_ptr<Joycon::JoyconDriver> Joycons::GetNextFreeHandle(
             return *unconnected_device;
         }
     }
+    if (type == Joycon::ControllerType::Pro) {
+        const auto unconnected_device = std::ranges::find_if(
+            pro_controller, [](auto& device) { return !device->IsConnected(); });
+
+        if (unconnected_device != pro_controller.end()) {
+            return *unconnected_device;
+        }
+    }
     return nullptr;
 }
 
@@ -355,7 +390,7 @@ void Joycons::OnMotionUpdate(std::size_t port, Joycon::ControllerType type, int
 void Joycons::OnRingConUpdate(f32 ring_data) {
     // To simplify ring detection it will always be mapped to an empty identifier for all
     // controllers
-    constexpr PadIdentifier identifier = {
+    static constexpr PadIdentifier identifier = {
         .guid = Common::UUID{},
         .port = 0,
         .pad = 0,
@@ -409,6 +444,15 @@ std::shared_ptr<Joycon::JoyconDriver> Joycons::GetHandle(PadIdentifier identifie
         }
     }
 
+    if (type == Joycon::ControllerType::Pro) {
+        const auto matching_device = std::ranges::find_if(
+            pro_controller, [is_handle_active](auto& device) { return is_handle_active(device); });
+
+        if (matching_device != pro_controller.end()) {
+            return *matching_device;
+        }
+    }
+
     return nullptr;
 }
 
@@ -455,6 +499,9 @@ std::vector<Common::ParamPackage> Joycons::GetInputDevices() const {
     for (const auto& controller : right_joycons) {
         add_entry(controller);
     }
+    for (const auto& controller : pro_controller) {
+        add_entry(controller);
+    }
 
     // List dual joycon pairs
     for (std::size_t i = 0; i < MaxSupportedControllers; i++) {
diff --git a/src/input_common/drivers/joycon.h b/src/input_common/drivers/joycon.h
index 2149ab7fd..473ba1b9e 100644
--- a/src/input_common/drivers/joycon.h
+++ b/src/input_common/drivers/joycon.h
@@ -106,6 +106,7 @@ private:
     // Joycon types are split by type to ease supporting dualjoycon configurations
     std::array<std::shared_ptr<Joycon::JoyconDriver>, MaxSupportedControllers> left_joycons{};
     std::array<std::shared_ptr<Joycon::JoyconDriver>, MaxSupportedControllers> right_joycons{};
+    std::array<std::shared_ptr<Joycon::JoyconDriver>, MaxSupportedControllers> pro_controller{};
 };
 
 } // namespace InputCommon
diff --git a/src/input_common/drivers/mouse.cpp b/src/input_common/drivers/mouse.cpp
index faf9cbdc3..da50e0a24 100644
--- a/src/input_common/drivers/mouse.cpp
+++ b/src/input_common/drivers/mouse.cpp
@@ -15,23 +15,39 @@ constexpr int mouse_axis_y = 1;
 constexpr int wheel_axis_x = 2;
 constexpr int wheel_axis_y = 3;
 constexpr int motion_wheel_y = 4;
-constexpr int touch_axis_x = 10;
-constexpr int touch_axis_y = 11;
 constexpr PadIdentifier identifier = {
     .guid = Common::UUID{},
     .port = 0,
     .pad = 0,
 };
 
+constexpr PadIdentifier real_mouse_identifier = {
+    .guid = Common::UUID{},
+    .port = 1,
+    .pad = 0,
+};
+
+constexpr PadIdentifier touch_identifier = {
+    .guid = Common::UUID{},
+    .port = 2,
+    .pad = 0,
+};
+
 Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     PreSetController(identifier);
+    PreSetController(real_mouse_identifier);
+    PreSetController(touch_identifier);
+
+    // Initialize all mouse axis
     PreSetAxis(identifier, mouse_axis_x);
     PreSetAxis(identifier, mouse_axis_y);
     PreSetAxis(identifier, wheel_axis_x);
     PreSetAxis(identifier, wheel_axis_y);
     PreSetAxis(identifier, motion_wheel_y);
-    PreSetAxis(identifier, touch_axis_x);
-    PreSetAxis(identifier, touch_axis_y);
+    PreSetAxis(real_mouse_identifier, mouse_axis_x);
+    PreSetAxis(real_mouse_identifier, mouse_axis_y);
+    PreSetAxis(touch_identifier, mouse_axis_x);
+    PreSetAxis(touch_identifier, mouse_axis_y);
     update_thread = std::jthread([this](std::stop_token stop_token) { UpdateThread(stop_token); });
 }
 
@@ -39,7 +55,7 @@ void Mouse::UpdateThread(std::stop_token stop_token) {
     Common::SetCurrentThreadName("Mouse");
     constexpr int update_time = 10;
     while (!stop_token.stop_requested()) {
-        if (Settings::values.mouse_panning && !Settings::values.mouse_enabled) {
+        if (Settings::values.mouse_panning) {
             // Slow movement by 4%
             last_mouse_change *= 0.96f;
             const float sensitivity =
@@ -57,17 +73,7 @@ void Mouse::UpdateThread(std::stop_token stop_token) {
     }
 }
 
-void Mouse::MouseMove(int x, int y, f32 touch_x, f32 touch_y, int center_x, int center_y) {
-    // If native mouse is enabled just set the screen coordinates
-    if (Settings::values.mouse_enabled) {
-        SetAxis(identifier, mouse_axis_x, touch_x);
-        SetAxis(identifier, mouse_axis_y, touch_y);
-        return;
-    }
-
-    SetAxis(identifier, touch_axis_x, touch_x);
-    SetAxis(identifier, touch_axis_y, touch_y);
-
+void Mouse::Move(int x, int y, int center_x, int center_y) {
     if (Settings::values.mouse_panning) {
         auto mouse_change =
             (Common::MakeVec(x, y) - Common::MakeVec(center_x, center_y)).Cast<float>();
@@ -113,20 +119,41 @@ void Mouse::MouseMove(int x, int y, f32 touch_x, f32 touch_y, int center_x, int
     }
 }
 
-void Mouse::PressButton(int x, int y, f32 touch_x, f32 touch_y, MouseButton button) {
-    SetAxis(identifier, touch_axis_x, touch_x);
-    SetAxis(identifier, touch_axis_y, touch_y);
+void Mouse::MouseMove(f32 touch_x, f32 touch_y) {
+    SetAxis(real_mouse_identifier, mouse_axis_x, touch_x);
+    SetAxis(real_mouse_identifier, mouse_axis_y, touch_y);
+}
+
+void Mouse::TouchMove(f32 touch_x, f32 touch_y) {
+    SetAxis(touch_identifier, mouse_axis_x, touch_x);
+    SetAxis(touch_identifier, mouse_axis_y, touch_y);
+}
+
+void Mouse::PressButton(int x, int y, MouseButton button) {
     SetButton(identifier, static_cast<int>(button), true);
+
     // Set initial analog parameters
     mouse_origin = {x, y};
     last_mouse_position = {x, y};
     button_pressed = true;
 }
 
+void Mouse::PressMouseButton(MouseButton button) {
+    SetButton(real_mouse_identifier, static_cast<int>(button), true);
+}
+
+void Mouse::PressTouchButton(f32 touch_x, f32 touch_y, MouseButton button) {
+    SetAxis(touch_identifier, mouse_axis_x, touch_x);
+    SetAxis(touch_identifier, mouse_axis_y, touch_y);
+    SetButton(touch_identifier, static_cast<int>(button), true);
+}
+
 void Mouse::ReleaseButton(MouseButton button) {
     SetButton(identifier, static_cast<int>(button), false);
+    SetButton(real_mouse_identifier, static_cast<int>(button), false);
+    SetButton(touch_identifier, static_cast<int>(button), false);
 
-    if (!Settings::values.mouse_panning && !Settings::values.mouse_enabled) {
+    if (!Settings::values.mouse_panning) {
         SetAxis(identifier, mouse_axis_x, 0);
         SetAxis(identifier, mouse_axis_y, 0);
     }
diff --git a/src/input_common/drivers/mouse.h b/src/input_common/drivers/mouse.h
index 72073cc23..f3b65bdd1 100644
--- a/src/input_common/drivers/mouse.h
+++ b/src/input_common/drivers/mouse.h
@@ -37,13 +37,43 @@ public:
      * @param center_x the x-coordinate of the middle of the screen
      * @param center_y the y-coordinate of the middle of the screen
      */
-    void MouseMove(int x, int y, f32 touch_x, f32 touch_y, int center_x, int center_y);
+    void Move(int x, int y, int center_x, int center_y);
 
     /**
-     * Sets the status of all buttons bound with the key to pressed
-     * @param key_code the code of the key to press
+     * Signals that real mouse has moved.
+     * @param x the absolute position on the touchscreen of the cursor
+     * @param y the absolute position on the touchscreen of the cursor
      */
-    void PressButton(int x, int y, f32 touch_x, f32 touch_y, MouseButton button);
+    void MouseMove(f32 touch_x, f32 touch_y);
+
+    /**
+     * Signals that touch finger has moved.
+     * @param x the absolute position on the touchscreen of the cursor
+     * @param y the absolute position on the touchscreen of the cursor
+     */
+    void TouchMove(f32 touch_x, f32 touch_y);
+
+    /**
+     * Sets the status of a button to pressed
+     * @param x the x-coordinate of the cursor
+     * @param y the y-coordinate of the cursor
+     * @param button the id of the button to press
+     */
+    void PressButton(int x, int y, MouseButton button);
+
+    /**
+     * Sets the status of a mouse button to pressed
+     * @param button the id of the button to press
+     */
+    void PressMouseButton(MouseButton button);
+
+    /**
+     * Sets the status of touch finger to pressed
+     * @param x the absolute position on the touchscreen of the cursor
+     * @param y the absolute position on the touchscreen of the cursor
+     * @param button the id of the button to press
+     */
+    void PressTouchButton(f32 touch_x, f32 touch_y, MouseButton button);
 
     /**
      * Sets the status of all buttons bound with the key to released
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
index d975eb815..5c20b3426 100644
--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -343,6 +343,14 @@ void SDLDriver::InitJoystick(int joystick_index) {
         }
     }
 
+    if (Settings::values.enable_procon_driver) {
+        if (guid.uuid[5] == 0x05 && guid.uuid[4] == 0x7e && guid.uuid[8] == 0x09) {
+            LOG_WARNING(Input, "Preferring joycon driver for device index {}", joystick_index);
+            SDL_JoystickClose(sdl_joystick);
+            return;
+        }
+    }
+
     std::scoped_lock lock{joystick_map_mutex};
     if (joystick_map.find(guid) == joystick_map.end()) {
         auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick, sdl_gamecontroller);
@@ -465,13 +473,19 @@ SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_en
     SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE, "1");
     SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
 
-    // Disable hidapi drivers for switch controllers when the custom joycon driver is enabled
+    // Disable hidapi drivers for joycon controllers when the custom joycon driver is enabled
     if (Settings::values.enable_joycon_driver) {
         SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "0");
     } else {
         SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "1");
     }
-    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH, "1");
+
+    // Disable hidapi drivers for pro controllers when the custom joycon driver is enabled
+    if (Settings::values.enable_procon_driver) {
+        SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH, "0");
+    } else {
+        SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH, "1");
+    }
 
     // Disable hidapi driver for xbox. Already default on Windows, this causes conflict with native
     // driver on Linux.
@@ -602,7 +616,7 @@ bool SDLDriver::IsVibrationEnabled(const PadIdentifier& identifier) {
     const auto joystick =
         GetSDLJoystickByGUID(identifier.guid.RawString(), static_cast<int>(identifier.port));
 
-    constexpr Common::Input::VibrationStatus test_vibration{
+    static constexpr Common::Input::VibrationStatus test_vibration{
         .low_amplitude = 1,
         .low_frequency = 160.0f,
         .high_amplitude = 1,
@@ -610,7 +624,7 @@ bool SDLDriver::IsVibrationEnabled(const PadIdentifier& identifier) {
         .type = Common::Input::VibrationAmplificationType::Exponential,
     };
 
-    constexpr Common::Input::VibrationStatus zero_vibration{
+    static constexpr Common::Input::VibrationStatus zero_vibration{
         .low_amplitude = 0,
         .low_frequency = 160.0f,
         .high_amplitude = 0,
diff --git a/src/input_common/helpers/joycon_driver.cpp b/src/input_common/helpers/joycon_driver.cpp
index 8f94c9f45..e65b6b845 100644
--- a/src/input_common/helpers/joycon_driver.cpp
+++ b/src/input_common/helpers/joycon_driver.cpp
@@ -543,9 +543,10 @@ void JoyconDriver::SetCallbacks(const JoyconCallbacks& callbacks) {
 
 DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info,
                                          ControllerType& controller_type) {
-    static constexpr std::array<std::pair<u32, ControllerType>, 2> supported_devices{
+    static constexpr std::array<std::pair<u32, ControllerType>, 6> supported_devices{
         std::pair<u32, ControllerType>{0x2006, ControllerType::Left},
         {0x2007, ControllerType::Right},
+        {0x2009, ControllerType::Pro},
     };
     constexpr u16 nintendo_vendor_id = 0x057e;
 
diff --git a/src/input_common/input_mapping.cpp b/src/input_common/input_mapping.cpp
index d6e49d2c5..6990a86b9 100644
--- a/src/input_common/input_mapping.cpp
+++ b/src/input_common/input_mapping.cpp
@@ -194,6 +194,10 @@ bool MappingFactory::IsDriverValid(const MappingData& data) const {
     if (data.engine == "keyboard" && data.pad.port != 0) {
         return false;
     }
+    // Only port 0 can be mapped on the mouse
+    if (data.engine == "mouse" && data.pad.port != 0) {
+        return false;
+    }
     // To prevent mapping with two devices we disable any UDP except motion
     if (!Settings::values.enable_udp_controller && data.engine == "cemuhookudp" &&
         data.type != EngineInputType::Motion) {
diff --git a/src/shader_recompiler/backend/glsl/glsl_emit_context.cpp b/src/shader_recompiler/backend/glsl/glsl_emit_context.cpp
index 1b006e811..c3c2281bb 100644
--- a/src/shader_recompiler/backend/glsl/glsl_emit_context.cpp
+++ b/src/shader_recompiler/backend/glsl/glsl_emit_context.cpp
@@ -310,12 +310,6 @@ EmitContext::EmitContext(IR::Program& program, Bindings& bindings, const Profile
         if (runtime_info.force_early_z) {
             header += "layout(early_fragment_tests)in;";
         }
-        if (info.uses_sample_id) {
-            header += "in int gl_SampleID;";
-        }
-        if (info.stores_sample_mask) {
-            header += "out int gl_SampleMask[];";
-        }
         break;
     case Stage::Compute:
         stage_name = "cs";
diff --git a/src/shader_recompiler/frontend/maxwell/translate_program.cpp b/src/shader_recompiler/frontend/maxwell/translate_program.cpp
index a42453e90..17a6d4888 100644
--- a/src/shader_recompiler/frontend/maxwell/translate_program.cpp
+++ b/src/shader_recompiler/frontend/maxwell/translate_program.cpp
@@ -292,7 +292,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
 
     Optimization::PositionPass(env, program);
 
-    Optimization::GlobalMemoryToStorageBufferPass(program, host_info);
+    Optimization::GlobalMemoryToStorageBufferPass(program);
     Optimization::TexturePass(env, program, host_info);
 
     if (Settings::values.resolution_info.active) {
diff --git a/src/shader_recompiler/host_translate_info.h b/src/shader_recompiler/host_translate_info.h
index 55fc48768..2aaa6c5ea 100644
--- a/src/shader_recompiler/host_translate_info.h
+++ b/src/shader_recompiler/host_translate_info.h
@@ -15,7 +15,6 @@ struct HostTranslateInfo {
     bool needs_demote_reorder{}; ///< True when the device needs DemoteToHelperInvocation reordered
     bool support_snorm_render_buffer{};  ///< True when the device supports SNORM render buffers
     bool support_viewport_index_layer{}; ///< True when the device supports gl_Layer in VS
-    u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
     bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                 ///< passthrough shaders
 };
diff --git a/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp b/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp
index 9101722ba..336338e62 100644
--- a/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp
+++ b/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp
@@ -11,7 +11,6 @@
 #include "shader_recompiler/frontend/ir/breadth_first_search.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
 #include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/host_translate_info.h"
 #include "shader_recompiler/ir_opt/passes.h"
 
 namespace Shader::Optimization {
@@ -403,7 +402,7 @@ void CollectStorageBuffers(IR::Block& block, IR::Inst& inst, StorageInfo& info)
 }
 
 /// Returns the offset in indices (not bytes) for an equivalent storage instruction
-IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer, u32 alignment) {
+IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer) {
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
     IR::U32 offset;
     if (const std::optional<LowAddrInfo> low_addr{TrackLowAddress(&inst)}) {
@@ -416,10 +415,7 @@ IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer
     }
     // Subtract the least significant 32 bits from the guest offset. The result is the storage
     // buffer offset in bytes.
-    IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
-
-    // Align the offset base to match the host alignment requirements
-    low_cbuf = ir.BitwiseAnd(low_cbuf, ir.Imm32(~(alignment - 1U)));
+    const IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
     return ir.ISub(offset, low_cbuf);
 }
 
@@ -514,7 +510,7 @@ void Replace(IR::Block& block, IR::Inst& inst, const IR::U32& storage_index,
 }
 } // Anonymous namespace
 
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info) {
+void GlobalMemoryToStorageBufferPass(IR::Program& program) {
     StorageInfo info;
     for (IR::Block* const block : program.post_order_blocks) {
         for (IR::Inst& inst : block->Instructions()) {
@@ -538,8 +534,7 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn
         const IR::U32 index{IR::Value{static_cast<u32>(info.set.index_of(it))}};
         IR::Block* const block{storage_inst.block};
         IR::Inst* const inst{storage_inst.inst};
-        const IR::U32 offset{
-            StorageOffset(*block, *inst, storage_buffer, host_info.min_ssbo_alignment)};
+        const IR::U32 offset{StorageOffset(*block, *inst, storage_buffer)};
         Replace(*block, *inst, index, offset);
     }
 }
diff --git a/src/shader_recompiler/ir_opt/passes.h b/src/shader_recompiler/ir_opt/passes.h
index 4ffad1172..1f8f2ba95 100644
--- a/src/shader_recompiler/ir_opt/passes.h
+++ b/src/shader_recompiler/ir_opt/passes.h
@@ -15,7 +15,7 @@ namespace Shader::Optimization {
 void CollectShaderInfoPass(Environment& env, IR::Program& program);
 void ConstantPropagationPass(Environment& env, IR::Program& program);
 void DeadCodeEliminationPass(IR::Program& program);
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info);
+void GlobalMemoryToStorageBufferPass(IR::Program& program);
 void IdentityRemovalPass(IR::Program& program);
 void LowerFp16ToFp32(IR::Program& program);
 void LowerInt64ToInt32(IR::Program& program);
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index 627917ab6..06fd40851 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -1938,21 +1938,14 @@ typename BufferCache<P>::Binding BufferCache<P>::StorageBufferBinding(GPUVAddr s
                                                                       bool is_written) const {
     const GPUVAddr gpu_addr = gpu_memory->Read<u64>(ssbo_addr);
     const u32 size = gpu_memory->Read<u32>(ssbo_addr + 8);
-    const u32 alignment = runtime.GetStorageBufferAlignment();
-
-    const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);
-    const u32 aligned_size =
-        Common::AlignUp(static_cast<u32>(gpu_addr - aligned_gpu_addr) + size, alignment);
-
-    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(aligned_gpu_addr);
+    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
     if (!cpu_addr || size == 0) {
         return NULL_BINDING;
     }
-
-    const VAddr cpu_end = Common::AlignUp(*cpu_addr + aligned_size, Core::Memory::YUZU_PAGESIZE);
+    const VAddr cpu_end = Common::AlignUp(*cpu_addr + size, Core::Memory::YUZU_PAGESIZE);
     const Binding binding{
         .cpu_addr = *cpu_addr,
-        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *cpu_addr),
+        .size = is_written ? size : static_cast<u32>(cpu_end - *cpu_addr),
         .buffer_id = BufferId{},
     };
     return binding;
diff --git a/src/video_core/engines/maxwell_3d.cpp b/src/video_core/engines/maxwell_3d.cpp
index ae9da6290..614d61db4 100644
--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -186,6 +186,7 @@ bool Maxwell3D::IsMethodExecutable(u32 method) {
     case MAXWELL3D_REG_INDEX(launch_dma):
     case MAXWELL3D_REG_INDEX(inline_data):
     case MAXWELL3D_REG_INDEX(fragment_barrier):
+    case MAXWELL3D_REG_INDEX(invalidate_texture_data_cache):
     case MAXWELL3D_REG_INDEX(tiled_cache_barrier):
         return true;
     default:
@@ -258,7 +259,7 @@ u32 Maxwell3D::GetMaxCurrentVertices() {
 size_t Maxwell3D::EstimateIndexBufferSize() {
     GPUVAddr start_address = regs.index_buffer.StartAddress();
     GPUVAddr end_address = regs.index_buffer.EndAddress();
-    constexpr std::array<size_t, 4> max_sizes = {
+    static constexpr std::array<size_t, 4> max_sizes = {
         std::numeric_limits<u8>::max(), std::numeric_limits<u16>::max(),
         std::numeric_limits<u32>::max(), std::numeric_limits<u32>::max()};
     const size_t byte_size = regs.index_buffer.FormatSizeInBytes();
@@ -375,6 +376,9 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
         return;
     case MAXWELL3D_REG_INDEX(fragment_barrier):
         return rasterizer->FragmentBarrier();
+    case MAXWELL3D_REG_INDEX(invalidate_texture_data_cache):
+        rasterizer->InvalidateGPUCache();
+        return rasterizer->WaitForIdle();
     case MAXWELL3D_REG_INDEX(tiled_cache_barrier):
         return rasterizer->TiledCacheBarrier();
     default:
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index c6d54be63..7024a19cf 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -99,7 +99,7 @@ struct GPU::Impl {
 
     /// Signal the ending of command list.
     void OnCommandListEnd() {
-        gpu_thread.OnCommandListEnd();
+        rasterizer->ReleaseFences();
     }
 
     /// Request a host GPU memory flush from the CPU.
diff --git a/src/video_core/gpu_thread.cpp b/src/video_core/gpu_thread.cpp
index 164a5252a..9c103c0d4 100644
--- a/src/video_core/gpu_thread.cpp
+++ b/src/video_core/gpu_thread.cpp
@@ -40,8 +40,6 @@ static void RunThread(std::stop_token stop_token, Core::System& system,
             scheduler.Push(submit_list->channel, std::move(submit_list->entries));
         } else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
             renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
-        } else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
-            rasterizer->ReleaseFences();
         } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
             system.GPU().TickWork();
         } else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
@@ -110,10 +108,6 @@ void ThreadManager::FlushAndInvalidateRegion(VAddr addr, u64 size) {
     rasterizer->OnCPUWrite(addr, size);
 }
 
-void ThreadManager::OnCommandListEnd() {
-    PushCommand(OnCommandListEndCommand());
-}
-
 u64 ThreadManager::PushCommand(CommandData&& command_data, bool block) {
     if (!is_async) {
         // In synchronous GPU mode, block the caller until the command has executed
diff --git a/src/video_core/gpu_thread.h b/src/video_core/gpu_thread.h
index c71a419c7..90bcb5958 100644
--- a/src/video_core/gpu_thread.h
+++ b/src/video_core/gpu_thread.h
@@ -77,16 +77,12 @@ struct FlushAndInvalidateRegionCommand final {
     u64 size;
 };
 
-/// Command called within the gpu, to schedule actions after a command list end
-struct OnCommandListEndCommand final {};
-
 /// Command to make the gpu look into pending requests
 struct GPUTickCommand final {};
 
 using CommandData =
     std::variant<std::monostate, SubmitListCommand, SwapBuffersCommand, FlushRegionCommand,
-                 InvalidateRegionCommand, FlushAndInvalidateRegionCommand, OnCommandListEndCommand,
-                 GPUTickCommand>;
+                 InvalidateRegionCommand, FlushAndInvalidateRegionCommand, GPUTickCommand>;
 
 struct CommandDataContainer {
     CommandDataContainer() = default;
@@ -134,8 +130,6 @@ public:
     /// Notify rasterizer that any caches of the specified region should be flushed and invalidated
     void FlushAndInvalidateRegion(VAddr addr, u64 size);
 
-    void OnCommandListEnd();
-
     void TickGPU();
 
 private:
diff --git a/src/video_core/host1x/codecs/codec.cpp b/src/video_core/host1x/codecs/codec.cpp
index 42e7d6e4f..3e9022dce 100644
--- a/src/video_core/host1x/codecs/codec.cpp
+++ b/src/video_core/host1x/codecs/codec.cpp
@@ -152,6 +152,8 @@ bool Codec::CreateGpuAvDevice() {
 void Codec::InitializeAvCodecContext() {
     av_codec_ctx = avcodec_alloc_context3(av_codec);
     av_opt_set(av_codec_ctx->priv_data, "tune", "zerolatency", 0);
+    av_codec_ctx->thread_count = 0;
+    av_codec_ctx->thread_type &= ~FF_THREAD_FRAME;
 }
 
 void Codec::InitializeGpuDecoder() {
diff --git a/src/video_core/host1x/vic.cpp b/src/video_core/host1x/vic.cpp
index 36a04e4e0..10d7ef884 100644
--- a/src/video_core/host1x/vic.cpp
+++ b/src/video_core/host1x/vic.cpp
@@ -189,9 +189,7 @@ void Vic::WriteYUVFrame(const AVFrame* frame, const VicConfig& config) {
     for (std::size_t y = 0; y < frame_height; ++y) {
         const std::size_t src = y * stride;
         const std::size_t dst = y * aligned_width;
-        for (std::size_t x = 0; x < frame_width; ++x) {
-            luma_buffer[dst + x] = luma_src[src + x];
-        }
+        std::memcpy(luma_buffer.data() + dst, luma_src + src, frame_width);
     }
     host1x.MemoryManager().WriteBlock(output_surface_luma_address, luma_buffer.data(),
                                       luma_buffer.size());
@@ -205,15 +203,15 @@ void Vic::WriteYUVFrame(const AVFrame* frame, const VicConfig& config) {
         // Frame from FFmpeg software
         // Populate chroma buffer from both channels with interleaving.
         const std::size_t half_width = frame_width / 2;
+        u8* chroma_buffer_data = chroma_buffer.data();
         const u8* chroma_b_src = frame->data[1];
         const u8* chroma_r_src = frame->data[2];
         for (std::size_t y = 0; y < half_height; ++y) {
             const std::size_t src = y * half_stride;
             const std::size_t dst = y * aligned_width;
-
             for (std::size_t x = 0; x < half_width; ++x) {
-                chroma_buffer[dst + x * 2] = chroma_b_src[src + x];
-                chroma_buffer[dst + x * 2 + 1] = chroma_r_src[src + x];
+                chroma_buffer_data[dst + x * 2] = chroma_b_src[src + x];
+                chroma_buffer_data[dst + x * 2 + 1] = chroma_r_src[src + x];
             }
         }
         break;
@@ -225,9 +223,7 @@ void Vic::WriteYUVFrame(const AVFrame* frame, const VicConfig& config) {
         for (std::size_t y = 0; y < half_height; ++y) {
             const std::size_t src = y * stride;
             const std::size_t dst = y * aligned_width;
-            for (std::size_t x = 0; x < frame_width; ++x) {
-                chroma_buffer[dst + x] = chroma_src[src + x];
-            }
+            std::memcpy(chroma_buffer.data() + dst, chroma_src + src, frame_width);
         }
         break;
     }
diff --git a/src/video_core/host_shaders/CMakeLists.txt b/src/video_core/host_shaders/CMakeLists.txt
index 52cd5bb81..2442c3c29 100644
--- a/src/video_core/host_shaders/CMakeLists.txt
+++ b/src/video_core/host_shaders/CMakeLists.txt
@@ -22,6 +22,8 @@ set(SHADER_FILES
     convert_d24s8_to_abgr8.frag
     convert_depth_to_float.frag
     convert_float_to_depth.frag
+    convert_msaa_to_non_msaa.comp
+    convert_non_msaa_to_msaa.comp
     convert_s8d24_to_abgr8.frag
     full_screen_triangle.vert
     fxaa.frag
diff --git a/src/video_core/host_shaders/convert_msaa_to_non_msaa.comp b/src/video_core/host_shaders/convert_msaa_to_non_msaa.comp
new file mode 100644
index 000000000..fc3854d18
--- /dev/null
+++ b/src/video_core/host_shaders/convert_msaa_to_non_msaa.comp
@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 450 core
+layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout (binding = 0, rgba8) uniform readonly restrict image2DMSArray msaa_in;
+layout (binding = 1, rgba8) uniform writeonly restrict image2DArray output_img;
+
+void main() {
+    const ivec3 coords = ivec3(gl_GlobalInvocationID);
+    if (any(greaterThanEqual(coords, imageSize(msaa_in)))) {
+        return;
+    }
+
+    // TODO: Specialization constants for num_samples?
+    const int num_samples = imageSamples(msaa_in);
+    for (int curr_sample = 0; curr_sample < num_samples; ++curr_sample) {
+        const vec4 pixel = imageLoad(msaa_in, coords, curr_sample);
+
+        const int single_sample_x = 2 * coords.x + (curr_sample & 1);
+        const int single_sample_y = 2 * coords.y + ((curr_sample / 2) & 1);
+        const ivec3 dest_coords = ivec3(single_sample_x, single_sample_y, coords.z);
+
+        if (any(greaterThanEqual(dest_coords, imageSize(output_img)))) {
+            continue;
+        }
+        imageStore(output_img, dest_coords, pixel);
+    }
+}
diff --git a/src/video_core/host_shaders/convert_non_msaa_to_msaa.comp b/src/video_core/host_shaders/convert_non_msaa_to_msaa.comp
new file mode 100644
index 000000000..dedd962f1
--- /dev/null
+++ b/src/video_core/host_shaders/convert_non_msaa_to_msaa.comp
@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 450 core
+layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout (binding = 0, rgba8) uniform readonly restrict image2DArray img_in;
+layout (binding = 1, rgba8) uniform writeonly restrict image2DMSArray output_msaa;
+
+void main() {
+    const ivec3 coords = ivec3(gl_GlobalInvocationID);
+    if (any(greaterThanEqual(coords, imageSize(output_msaa)))) {
+        return;
+    }
+
+    // TODO: Specialization constants for num_samples?
+    const int num_samples = imageSamples(output_msaa);
+    for (int curr_sample = 0; curr_sample < num_samples; ++curr_sample) {
+        const int single_sample_x = 2 * coords.x + (curr_sample & 1);
+        const int single_sample_y = 2 * coords.y + ((curr_sample / 2) & 1);
+        const ivec3 single_coords = ivec3(single_sample_x, single_sample_y, coords.z);
+
+        if (any(greaterThanEqual(single_coords, imageSize(img_in)))) {
+            continue;
+        }
+        const vec4 pixel = imageLoad(img_in, single_coords);
+        imageStore(output_msaa, coords, curr_sample, pixel);
+    }
+}
diff --git a/src/video_core/memory_manager.h b/src/video_core/memory_manager.h
index 9ebfb6179..cf56392ef 100644
--- a/src/video_core/memory_manager.h
+++ b/src/video_core/memory_manager.h
@@ -216,7 +216,7 @@ private:
     std::vector<u64> big_page_continous;
     std::vector<std::pair<VAddr, std::size_t>> page_stash{};
 
-    constexpr static size_t continous_bits = 64;
+    static constexpr size_t continous_bits = 64;
 
     const size_t unique_identifier;
     std::unique_ptr<VideoCommon::InvalidationAccumulator> accumulator;
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.h b/src/video_core/renderer_opengl/gl_buffer_cache.h
index bb1962073..a8c3f8b67 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.h
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.h
@@ -160,10 +160,6 @@ public:
         return device.CanReportMemoryUsage();
     }
 
-    u32 GetStorageBufferAlignment() const {
-        return static_cast<u32>(device.GetShaderStorageBufferAlignment());
-    }
-
 private:
     static constexpr std::array PABO_LUT{
         GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV,          GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV,
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index 626ea7dcb..479bb8ba3 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -236,7 +236,6 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .needs_demote_reorder = device.IsAmd(),
           .support_snorm_render_buffer = false,
           .support_viewport_index_layer = device.HasVertexViewportLayer(),
-          .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
           .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
       } {
     if (use_asynchronous_shaders) {
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.cpp b/src/video_core/renderer_opengl/gl_texture_cache.cpp
index 9f7ce7414..eb6e43a08 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp
@@ -557,6 +557,14 @@ void TextureCacheRuntime::CopyImage(Image& dst_image, Image& src_image,
     }
 }
 
+void TextureCacheRuntime::CopyImageMSAA(Image& dst_image, Image& src_image,
+                                        std::span<const VideoCommon::ImageCopy> copies) {
+    LOG_DEBUG(Render_OpenGL, "Copying from {} samples to {} samples", src_image.info.num_samples,
+              dst_image.info.num_samples);
+    // TODO: Leverage the format conversion pass if possible/accurate.
+    util_shaders.CopyMSAA(dst_image, src_image, copies);
+}
+
 void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,
                                            std::span<const VideoCommon::ImageCopy> copies) {
     LOG_DEBUG(Render_OpenGL, "Converting {} to {}", src.info.format, dst.info.format);
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.h b/src/video_core/renderer_opengl/gl_texture_cache.h
index 5d9d370f2..e30875496 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -93,12 +93,19 @@ public:
         return device.CanReportMemoryUsage();
     }
 
-    bool ShouldReinterpret([[maybe_unused]] Image& dst, [[maybe_unused]] Image& src) {
+    bool ShouldReinterpret([[maybe_unused]] Image& dst,
+                           [[maybe_unused]] Image& src) const noexcept {
+        return true;
+    }
+
+    bool CanUploadMSAA() const noexcept {
         return true;
     }
 
     void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
 
+    void CopyImageMSAA(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
+
     void ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
 
     void ConvertImage(Framebuffer* dst, ImageView& dst_view, ImageView& src_view) {
diff --git a/src/video_core/renderer_opengl/util_shaders.cpp b/src/video_core/renderer_opengl/util_shaders.cpp
index 404def62e..2c7ac210b 100644
--- a/src/video_core/renderer_opengl/util_shaders.cpp
+++ b/src/video_core/renderer_opengl/util_shaders.cpp
@@ -12,6 +12,8 @@
 #include "video_core/host_shaders/astc_decoder_comp.h"
 #include "video_core/host_shaders/block_linear_unswizzle_2d_comp.h"
 #include "video_core/host_shaders/block_linear_unswizzle_3d_comp.h"
+#include "video_core/host_shaders/convert_msaa_to_non_msaa_comp.h"
+#include "video_core/host_shaders/convert_non_msaa_to_msaa_comp.h"
 #include "video_core/host_shaders/opengl_convert_s8d24_comp.h"
 #include "video_core/host_shaders/opengl_copy_bc4_comp.h"
 #include "video_core/host_shaders/pitch_unswizzle_comp.h"
@@ -51,7 +53,9 @@ UtilShaders::UtilShaders(ProgramManager& program_manager_)
       block_linear_unswizzle_3d_program(MakeProgram(BLOCK_LINEAR_UNSWIZZLE_3D_COMP)),
       pitch_unswizzle_program(MakeProgram(PITCH_UNSWIZZLE_COMP)),
       copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)),
-      convert_s8d24_program(MakeProgram(OPENGL_CONVERT_S8D24_COMP)) {
+      convert_s8d24_program(MakeProgram(OPENGL_CONVERT_S8D24_COMP)),
+      convert_ms_to_nonms_program(MakeProgram(CONVERT_MSAA_TO_NON_MSAA_COMP)),
+      convert_nonms_to_ms_program(MakeProgram(CONVERT_NON_MSAA_TO_MSAA_COMP)) {
     const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
     swizzle_table_buffer.Create();
     glNamedBufferStorage(swizzle_table_buffer.handle, sizeof(swizzle_table), &swizzle_table, 0);
@@ -269,6 +273,33 @@ void UtilShaders::ConvertS8D24(Image& dst_image, std::span<const ImageCopy> copi
     program_manager.RestoreGuestCompute();
 }
 
+void UtilShaders::CopyMSAA(Image& dst_image, Image& src_image,
+                           std::span<const VideoCommon::ImageCopy> copies) {
+    const bool is_ms_to_non_ms = src_image.info.num_samples > 1 && dst_image.info.num_samples == 1;
+    const auto program_handle =
+        is_ms_to_non_ms ? convert_ms_to_nonms_program.handle : convert_nonms_to_ms_program.handle;
+    program_manager.BindComputeProgram(program_handle);
+
+    for (const ImageCopy& copy : copies) {
+        ASSERT(copy.src_subresource.base_layer == 0);
+        ASSERT(copy.src_subresource.num_layers == 1);
+        ASSERT(copy.dst_subresource.base_layer == 0);
+        ASSERT(copy.dst_subresource.num_layers == 1);
+
+        glBindImageTexture(0, src_image.StorageHandle(), copy.src_subresource.base_level, GL_TRUE,
+                           0, GL_READ_ONLY, GL_RGBA8);
+        glBindImageTexture(1, dst_image.StorageHandle(), copy.dst_subresource.base_level, GL_TRUE,
+                           0, GL_WRITE_ONLY, GL_RGBA8);
+
+        const u32 num_dispatches_x = Common::DivCeil(copy.extent.width, 8U);
+        const u32 num_dispatches_y = Common::DivCeil(copy.extent.height, 8U);
+        const u32 num_dispatches_z = copy.extent.depth;
+
+        glDispatchCompute(num_dispatches_x, num_dispatches_y, num_dispatches_z);
+    }
+    program_manager.RestoreGuestCompute();
+}
+
 GLenum StoreFormat(u32 bytes_per_block) {
     switch (bytes_per_block) {
     case 1:
diff --git a/src/video_core/renderer_opengl/util_shaders.h b/src/video_core/renderer_opengl/util_shaders.h
index 44efb6ecf..9013808e7 100644
--- a/src/video_core/renderer_opengl/util_shaders.h
+++ b/src/video_core/renderer_opengl/util_shaders.h
@@ -40,6 +40,9 @@ public:
 
     void ConvertS8D24(Image& dst_image, std::span<const VideoCommon::ImageCopy> copies);
 
+    void CopyMSAA(Image& dst_image, Image& src_image,
+                  std::span<const VideoCommon::ImageCopy> copies);
+
 private:
     ProgramManager& program_manager;
 
@@ -51,6 +54,8 @@ private:
     OGLProgram pitch_unswizzle_program;
     OGLProgram copy_bc4_program;
     OGLProgram convert_s8d24_program;
+    OGLProgram convert_ms_to_nonms_program;
+    OGLProgram convert_nonms_to_ms_program;
 };
 
 GLenum StoreFormat(u32 bytes_per_block);
diff --git a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
index 1cfb4c2ff..b0153a502 100644
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
@@ -330,10 +330,6 @@ bool BufferCacheRuntime::CanReportMemoryUsage() const {
     return device.CanReportMemoryUsage();
 }
 
-u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
-    return static_cast<u32>(device.GetStorageBufferAlignment());
-}
-
 void BufferCacheRuntime::Finish() {
     scheduler.Finish();
 }
diff --git a/src/video_core/renderer_vulkan/vk_buffer_cache.h b/src/video_core/renderer_vulkan/vk_buffer_cache.h
index 06539c733..183b33632 100644
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.h
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.h
@@ -73,8 +73,6 @@ public:
 
     bool CanReportMemoryUsage() const;
 
-    u32 GetStorageBufferAlignment() const;
-
     [[nodiscard]] StagingBufferRef UploadStagingBuffer(size_t size);
 
     [[nodiscard]] StagingBufferRef DownloadStagingBuffer(size_t size);
diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
index f91bb5a1d..baedc4424 100644
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -548,31 +548,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
     static_vector<VkVertexInputBindingDescription, 32> vertex_bindings;
     static_vector<VkVertexInputBindingDivisorDescriptionEXT, 32> vertex_binding_divisors;
     static_vector<VkVertexInputAttributeDescription, 32> vertex_attributes;
-    if (key.state.dynamic_vertex_input) {
-        const size_t num_vertex_arrays = std::min(
-            key.state.attributes.size(), static_cast<size_t>(device.GetMaxVertexInputBindings()));
-        for (size_t index = 0; index < num_vertex_arrays; ++index) {
-            const u32 type = key.state.DynamicAttributeType(index);
-            if (!stage_infos[0].loads.Generic(index) || type == 0) {
-                continue;
-            }
-            vertex_attributes.push_back({
-                .location = static_cast<u32>(index),
-                .binding = 0,
-                .format = type == 1   ? VK_FORMAT_R32_SFLOAT
-                          : type == 2 ? VK_FORMAT_R32_SINT
-                                      : VK_FORMAT_R32_UINT,
-                .offset = 0,
-            });
-        }
-        if (!vertex_attributes.empty()) {
-            vertex_bindings.push_back({
-                .binding = 0,
-                .stride = 4,
-                .inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
-            });
-        }
-    } else {
+    if (!key.state.dynamic_vertex_input) {
         const size_t num_vertex_arrays = std::min(
             Maxwell::NumVertexArrays, static_cast<size_t>(device.GetMaxVertexInputBindings()));
         for (size_t index = 0; index < num_vertex_arrays; ++index) {
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
index 7e69b11d8..0684cceed 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -344,7 +344,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
             driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE,
         .support_snorm_render_buffer = true,
         .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
-        .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
     };
 
diff --git a/src/video_core/renderer_vulkan/vk_smaa.cpp b/src/video_core/renderer_vulkan/vk_smaa.cpp
index 8eb735489..f8735189d 100644
--- a/src/video_core/renderer_vulkan/vk_smaa.cpp
+++ b/src/video_core/renderer_vulkan/vk_smaa.cpp
@@ -468,7 +468,7 @@ VkWriteDescriptorSet CreateWriteDescriptorSet(std::vector<VkDescriptorImageInfo>
 }
 
 void ClearColorImage(vk::CommandBuffer& cmdbuf, VkImage image) {
-    constexpr std::array<VkImageSubresourceRange, 1> subresources{{{
+    static constexpr std::array<VkImageSubresourceRange, 1> subresources{{{
         .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
         .baseMipLevel = 0,
         .levelCount = 1,
@@ -528,8 +528,8 @@ SMAA::SMAA(const Device& device, MemoryAllocator& allocator, size_t image_count,
 }
 
 void SMAA::CreateImages() {
-    constexpr VkExtent2D area_extent{AREATEX_WIDTH, AREATEX_HEIGHT};
-    constexpr VkExtent2D search_extent{SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT};
+    static constexpr VkExtent2D area_extent{AREATEX_WIDTH, AREATEX_HEIGHT};
+    static constexpr VkExtent2D search_extent{SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT};
 
     std::tie(m_static_images[Area], m_static_buffer_commits[Area]) =
         CreateWrappedImage(m_device, m_allocator, area_extent, VK_FORMAT_R8G8_UNORM);
@@ -586,12 +586,12 @@ void SMAA::CreateSampler() {
 
 void SMAA::CreateShaders() {
     // These match the order of the SMAAStage enum
-    constexpr std::array vert_shader_sources{
+    static constexpr std::array vert_shader_sources{
         ARRAY_TO_SPAN(SMAA_EDGE_DETECTION_VERT_SPV),
         ARRAY_TO_SPAN(SMAA_BLENDING_WEIGHT_CALCULATION_VERT_SPV),
         ARRAY_TO_SPAN(SMAA_NEIGHBORHOOD_BLENDING_VERT_SPV),
     };
-    constexpr std::array frag_shader_sources{
+    static constexpr std::array frag_shader_sources{
         ARRAY_TO_SPAN(SMAA_EDGE_DETECTION_FRAG_SPV),
         ARRAY_TO_SPAN(SMAA_BLENDING_WEIGHT_CALCULATION_FRAG_SPV),
         ARRAY_TO_SPAN(SMAA_NEIGHBORHOOD_BLENDING_FRAG_SPV),
@@ -675,8 +675,8 @@ void SMAA::UploadImages(Scheduler& scheduler) {
         return;
     }
 
-    constexpr VkExtent2D area_extent{AREATEX_WIDTH, AREATEX_HEIGHT};
-    constexpr VkExtent2D search_extent{SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT};
+    static constexpr VkExtent2D area_extent{AREATEX_WIDTH, AREATEX_HEIGHT};
+    static constexpr VkExtent2D search_extent{SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT};
 
     UploadImage(m_device, m_allocator, scheduler, m_static_images[Area], area_extent,
                 VK_FORMAT_R8G8_UNORM, ARRAY_TO_SPAN(areaTexBytes));
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index d39372ec4..9b85dfb5e 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -1230,6 +1230,11 @@ void TextureCacheRuntime::CopyImage(Image& dst, Image& src,
     });
 }
 
+void TextureCacheRuntime::CopyImageMSAA(Image& dst, Image& src,
+                                        std::span<const VideoCommon::ImageCopy> copies) {
+    UNIMPLEMENTED_MSG("Copying images with different samples is not implemented in Vulkan.");
+}
+
 u64 TextureCacheRuntime::GetDeviceLocalMemory() const {
     return device.GetDeviceLocalMemory();
 }
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h
index 1f27a3589..0ce39616f 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -70,6 +70,8 @@ public:
 
     void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
 
+    void CopyImageMSAA(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
+
     bool ShouldReinterpret(Image& dst, Image& src);
 
     void ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
@@ -80,6 +82,11 @@ public:
         return false;
     }
 
+    bool CanUploadMSAA() const noexcept {
+        // TODO: Implement buffer to MSAA uploads
+        return false;
+    }
+
     void AccelerateImageUpload(Image&, const StagingBufferRef&,
                                std::span<const VideoCommon::SwizzleParameters>);
 
@@ -106,7 +113,7 @@ public:
     std::optional<ASTCDecoderPass> astc_decoder_pass;
     const Settings::ResolutionScalingInfo& resolution;
 
-    constexpr static size_t indexing_slots = 8 * sizeof(size_t);
+    static constexpr size_t indexing_slots = 8 * sizeof(size_t);
     std::array<vk::Buffer, indexing_slots> buffers{};
     std::array<std::unique_ptr<MemoryCommit>, indexing_slots> buffer_commits{};
 };
diff --git a/src/video_core/renderer_vulkan/vk_turbo_mode.cpp b/src/video_core/renderer_vulkan/vk_turbo_mode.cpp
index c42594149..db04943eb 100644
--- a/src/video_core/renderer_vulkan/vk_turbo_mode.cpp
+++ b/src/video_core/renderer_vulkan/vk_turbo_mode.cpp
@@ -48,7 +48,7 @@ void TurboMode::Run(std::stop_token stop_token) {
     auto commit = m_allocator.Commit(buffer, MemoryUsage::DeviceLocal);
 
     // Create the descriptor pool to contain our descriptor.
-    constexpr VkDescriptorPoolSize pool_size{
+    static constexpr VkDescriptorPoolSize pool_size{
         .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
         .descriptorCount = 1,
     };
@@ -63,7 +63,7 @@ void TurboMode::Run(std::stop_token stop_token) {
     });
 
     // Create the descriptor set layout from the pool.
-    constexpr VkDescriptorSetLayoutBinding layout_binding{
+    static constexpr VkDescriptorSetLayoutBinding layout_binding{
         .binding = 0,
         .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
         .descriptorCount = 1,
diff --git a/src/video_core/texture_cache/formatter.cpp b/src/video_core/texture_cache/formatter.cpp
index 418890126..30f72361d 100644
--- a/src/video_core/texture_cache/formatter.cpp
+++ b/src/video_core/texture_cache/formatter.cpp
@@ -22,6 +22,9 @@ std::string Name(const ImageBase& image) {
     const u32 num_layers = image.info.resources.layers;
     const u32 num_levels = image.info.resources.levels;
     std::string resource;
+    if (image.info.num_samples > 1) {
+        resource += fmt::format(":{}xMSAA", image.info.num_samples);
+    }
     if (num_layers > 1) {
         resource += fmt::format(":L{}", num_layers);
     }
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index 1b01990a4..3e2cbb0b0 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -773,7 +773,7 @@ void TextureCache<P>::RefreshContents(Image& image, ImageId image_id) {
     image.flags &= ~ImageFlagBits::CpuModified;
     TrackImage(image, image_id);
 
-    if (image.info.num_samples > 1) {
+    if (image.info.num_samples > 1 && !runtime.CanUploadMSAA()) {
         LOG_WARNING(HW_GPU, "MSAA image uploads are not implemented");
         return;
     }
@@ -1167,14 +1167,14 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         if (True(overlap.flags & ImageFlagBits::GpuModified)) {
             new_image.flags |= ImageFlagBits::GpuModified;
         }
+        const auto& resolution = Settings::values.resolution_info;
+        const SubresourceBase base = new_image.TryFindBase(overlap.gpu_addr).value();
+        const u32 up_scale = can_rescale ? resolution.up_scale : 1;
+        const u32 down_shift = can_rescale ? resolution.down_shift : 0;
+        auto copies = MakeShrinkImageCopies(new_info, overlap.info, base, up_scale, down_shift);
         if (overlap.info.num_samples != new_image.info.num_samples) {
-            LOG_WARNING(HW_GPU, "Copying between images with different samples is not implemented");
+            runtime.CopyImageMSAA(new_image, overlap, std::move(copies));
         } else {
-            const auto& resolution = Settings::values.resolution_info;
-            const SubresourceBase base = new_image.TryFindBase(overlap.gpu_addr).value();
-            const u32 up_scale = can_rescale ? resolution.up_scale : 1;
-            const u32 down_shift = can_rescale ? resolution.down_shift : 0;
-            auto copies = MakeShrinkImageCopies(new_info, overlap.info, base, up_scale, down_shift);
             runtime.CopyImage(new_image, overlap, std::move(copies));
         }
         if (True(overlap.flags & ImageFlagBits::Tracked)) {
diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp
index 03acc68d9..697f86641 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -573,10 +573,6 @@ u32 CalculateUnswizzledSizeBytes(const ImageInfo& info) noexcept {
     if (info.type == ImageType::Buffer) {
         return info.size.width * BytesPerBlock(info.format);
     }
-    if (info.num_samples > 1) {
-        // Multisample images can't be uploaded or downloaded to the host
-        return 0;
-    }
     if (info.type == ImageType::Linear) {
         return info.pitch * Common::DivCeil(info.size.height, DefaultBlockHeight(info.format));
     }
@@ -703,7 +699,6 @@ ImageViewType RenderTargetImageViewType(const ImageInfo& info) noexcept {
 std::vector<ImageCopy> MakeShrinkImageCopies(const ImageInfo& dst, const ImageInfo& src,
                                              SubresourceBase base, u32 up_scale, u32 down_shift) {
     ASSERT(dst.resources.levels >= src.resources.levels);
-    ASSERT(dst.num_samples == src.num_samples);
 
     const bool is_dst_3d = dst.type == ImageType::e3D;
     if (is_dst_3d) {
diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp
index 59120cd09..95bcdd37b 100644
--- a/src/video_core/textures/decoders.cpp
+++ b/src/video_core/textures/decoders.cpp
@@ -29,7 +29,7 @@ constexpr u32 pdep(u32 value) {
 
 template <u32 mask, u32 incr_amount>
 void incrpdep(u32& value) {
-    constexpr u32 swizzled_incr = pdep<mask>(incr_amount);
+    static constexpr u32 swizzled_incr = pdep<mask>(incr_amount);
     value = ((value | ~mask) + swizzled_incr) & mask;
 }
 
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index d65991734..17acd3933 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -67,7 +67,7 @@ void EmuThread::run() {
     emit LoadProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
     if (Settings::values.use_disk_shader_cache.GetValue()) {
         m_system.Renderer().ReadRasterizer()->LoadDiskResources(
-            m_system.GetCurrentProcessProgramID(), stop_token,
+            m_system.GetApplicationProcessProgramID(), stop_token,
             [this](VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total) {
                 emit LoadProgress(stage, value, total);
             });
@@ -401,12 +401,6 @@ qreal GRenderWindow::windowPixelRatio() const {
     return devicePixelRatioF();
 }
 
-std::pair<u32, u32> GRenderWindow::ScaleTouch(const QPointF& pos) const {
-    const qreal pixel_ratio = windowPixelRatio();
-    return {static_cast<u32>(std::max(std::round(pos.x() * pixel_ratio), qreal{0.0})),
-            static_cast<u32>(std::max(std::round(pos.y() * pixel_ratio), qreal{0.0}))};
-}
-
 void GRenderWindow::closeEvent(QCloseEvent* event) {
     emit Closed();
     QWidget::closeEvent(event);
@@ -649,10 +643,12 @@ void GRenderWindow::mousePressEvent(QMouseEvent* event) {
     // Qt sometimes returns the parent coordinates. To avoid this we read the global mouse
     // coordinates and map them to the current render area
     const auto pos = mapFromGlobal(QCursor::pos());
-    const auto [x, y] = ScaleTouch(pos);
-    const auto [touch_x, touch_y] = MapToTouchScreen(x, y);
+    const auto [touch_x, touch_y] = MapToTouchScreen(pos.x(), pos.y());
     const auto button = QtButtonToMouseButton(event->button());
-    input_subsystem->GetMouse()->PressButton(x, y, touch_x, touch_y, button);
+
+    input_subsystem->GetMouse()->PressMouseButton(button);
+    input_subsystem->GetMouse()->PressButton(pos.x(), pos.y(), button);
+    input_subsystem->GetMouse()->PressTouchButton(touch_x, touch_y, button);
 
     emit MouseActivity();
 }
@@ -665,11 +661,13 @@ void GRenderWindow::mouseMoveEvent(QMouseEvent* event) {
     // Qt sometimes returns the parent coordinates. To avoid this we read the global mouse
     // coordinates and map them to the current render area
     const auto pos = mapFromGlobal(QCursor::pos());
-    const auto [x, y] = ScaleTouch(pos);
-    const auto [touch_x, touch_y] = MapToTouchScreen(x, y);
+    const auto [touch_x, touch_y] = MapToTouchScreen(pos.x(), pos.y());
     const int center_x = width() / 2;
     const int center_y = height() / 2;
-    input_subsystem->GetMouse()->MouseMove(x, y, touch_x, touch_y, center_x, center_y);
+
+    input_subsystem->GetMouse()->MouseMove(touch_x, touch_y);
+    input_subsystem->GetMouse()->TouchMove(touch_x, touch_y);
+    input_subsystem->GetMouse()->Move(pos.x(), pos.y(), center_x, center_y);
 
     if (Settings::values.mouse_panning && !Settings::values.mouse_enabled) {
         QCursor::setPos(mapToGlobal(QPoint{center_x, center_y}));
@@ -697,8 +695,8 @@ void GRenderWindow::wheelEvent(QWheelEvent* event) {
 void GRenderWindow::TouchBeginEvent(const QTouchEvent* event) {
     QList<QTouchEvent::TouchPoint> touch_points = event->touchPoints();
     for (const auto& touch_point : touch_points) {
-        const auto [x, y] = ScaleTouch(touch_point.pos());
-        const auto [touch_x, touch_y] = MapToTouchScreen(x, y);
+        const auto pos = touch_point.pos();
+        const auto [touch_x, touch_y] = MapToTouchScreen(pos.x(), pos.y());
         input_subsystem->GetTouchScreen()->TouchPressed(touch_x, touch_y, touch_point.id());
     }
 }
@@ -707,8 +705,8 @@ void GRenderWindow::TouchUpdateEvent(const QTouchEvent* event) {
     QList<QTouchEvent::TouchPoint> touch_points = event->touchPoints();
     input_subsystem->GetTouchScreen()->ClearActiveFlag();
     for (const auto& touch_point : touch_points) {
-        const auto [x, y] = ScaleTouch(touch_point.pos());
-        const auto [touch_x, touch_y] = MapToTouchScreen(x, y);
+        const auto pos = touch_point.pos();
+        const auto [touch_x, touch_y] = MapToTouchScreen(pos.x(), pos.y());
         input_subsystem->GetTouchScreen()->TouchMoved(touch_x, touch_y, touch_point.id());
     }
     input_subsystem->GetTouchScreen()->ReleaseInactiveTouch();
diff --git a/src/yuzu/bootmanager.h b/src/yuzu/bootmanager.h
index 092c6206f..627e19f42 100644
--- a/src/yuzu/bootmanager.h
+++ b/src/yuzu/bootmanager.h
@@ -184,8 +184,6 @@ public:
 
     void CaptureScreenshot(const QString& screenshot_path);
 
-    std::pair<u32, u32> ScaleTouch(const QPointF& pos) const;
-
     /**
      * Instructs the window to re-launch the application using the specified program_index.
      * @param program_index Specifies the index within the application of the program to launch.
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 35fef506a..db68ed259 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -441,6 +441,7 @@ void Config::ReadControlValues() {
     Settings::values.mouse_panning = false;
     ReadBasicSetting(Settings::values.mouse_panning_sensitivity);
     ReadBasicSetting(Settings::values.enable_joycon_driver);
+    ReadBasicSetting(Settings::values.enable_procon_driver);
 
     ReadBasicSetting(Settings::values.tas_enable);
     ReadBasicSetting(Settings::values.tas_loop);
@@ -1102,6 +1103,7 @@ void Config::SaveValues() {
     SaveRendererValues();
     SaveAudioValues();
     SaveSystemValues();
+    qt_config->sync();
 }
 
 void Config::SaveAudioValues() {
@@ -1141,6 +1143,7 @@ void Config::SaveControlValues() {
     WriteGlobalSetting(Settings::values.motion_enabled);
     WriteBasicSetting(Settings::values.enable_raw_input);
     WriteBasicSetting(Settings::values.enable_joycon_driver);
+    WriteBasicSetting(Settings::values.enable_procon_driver);
     WriteBasicSetting(Settings::values.keyboard_enabled);
     WriteBasicSetting(Settings::values.emulate_analog_keyboard);
     WriteBasicSetting(Settings::values.mouse_panning_sensitivity);
diff --git a/src/yuzu/configuration/configure_input_advanced.cpp b/src/yuzu/configuration/configure_input_advanced.cpp
index 77b976e74..8d81322f3 100644
--- a/src/yuzu/configuration/configure_input_advanced.cpp
+++ b/src/yuzu/configuration/configure_input_advanced.cpp
@@ -139,6 +139,7 @@ void ConfigureInputAdvanced::ApplyConfiguration() {
     Settings::values.enable_ring_controller = ui->enable_ring_controller->isChecked();
     Settings::values.enable_ir_sensor = ui->enable_ir_sensor->isChecked();
     Settings::values.enable_joycon_driver = ui->enable_joycon_driver->isChecked();
+    Settings::values.enable_procon_driver = ui->enable_procon_driver->isChecked();
 }
 
 void ConfigureInputAdvanced::LoadConfiguration() {
@@ -174,6 +175,7 @@ void ConfigureInputAdvanced::LoadConfiguration() {
     ui->enable_ring_controller->setChecked(Settings::values.enable_ring_controller.GetValue());
     ui->enable_ir_sensor->setChecked(Settings::values.enable_ir_sensor.GetValue());
     ui->enable_joycon_driver->setChecked(Settings::values.enable_joycon_driver.GetValue());
+    ui->enable_procon_driver->setChecked(Settings::values.enable_procon_driver.GetValue());
 
     UpdateUIEnabled();
 }
diff --git a/src/yuzu/configuration/configure_input_advanced.ui b/src/yuzu/configuration/configure_input_advanced.ui
index 75d96d3ab..0eb2b34bc 100644
--- a/src/yuzu/configuration/configure_input_advanced.ui
+++ b/src/yuzu/configuration/configure_input_advanced.ui
@@ -2712,6 +2712,22 @@
                      </widget>
                    </item>
                    <item row="6" column="0">
+                      <widget class="QCheckBox" name="enable_procon_driver">
+                       <property name="toolTip">
+                         <string>Requires restarting yuzu</string>
+                       </property>
+                       <property name="minimumSize">
+                         <size>
+                           <width>0</width>
+                           <height>23</height>
+                         </size>
+                       </property>
+                       <property name="text">
+                         <string>Enable direct Pro Controller driver [EXPERIMENTAL]</string>
+                       </property>
+                     </widget>
+                   </item>
+                   <item row="7" column="0">
                      <widget class="QCheckBox" name="mouse_panning">
                        <property name="minimumSize">
                          <size>
@@ -2724,7 +2740,7 @@
                        </property>
                      </widget>
                    </item>
-                   <item row="6" column="2">
+                   <item row="7" column="2">
                      <widget class="QSpinBox" name="mouse_panning_sensitivity">
                        <property name="toolTip">
                          <string>Mouse sensitivity</string>
@@ -2746,14 +2762,14 @@
                        </property>
                      </widget>
                    </item>
-                   <item row="7" column="0">
+                   <item row="8" column="0">
                      <widget class="QLabel" name="motion_touch">
                        <property name="text">
                          <string>Motion / Touch</string>
                        </property>
                      </widget>
                    </item>
-                   <item row="7" column="2">
+                   <item row="8" column="2">
                      <widget class="QPushButton" name="buttonMotionTouch">
                        <property name="text">
                          <string>Configure</string>
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 723690e71..50b62293e 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -1490,7 +1490,7 @@ void ConfigureInputPlayer::mousePressEvent(QMouseEvent* event) {
     }
 
     const auto button = GRenderWindow::QtButtonToMouseButton(event->button());
-    input_subsystem->GetMouse()->PressButton(0, 0, 0, 0, button);
+    input_subsystem->GetMouse()->PressButton(0, 0, button);
 }
 
 void ConfigureInputPlayer::wheelEvent(QWheelEvent* event) {
diff --git a/src/yuzu/configuration/configure_ringcon.cpp b/src/yuzu/configuration/configure_ringcon.cpp
index 1275f10c8..71afbc423 100644
--- a/src/yuzu/configuration/configure_ringcon.cpp
+++ b/src/yuzu/configuration/configure_ringcon.cpp
@@ -371,7 +371,7 @@ void ConfigureRingController::mousePressEvent(QMouseEvent* event) {
     }
 
     const auto button = GRenderWindow::QtButtonToMouseButton(event->button());
-    input_subsystem->GetMouse()->PressButton(0, 0, 0, 0, button);
+    input_subsystem->GetMouse()->PressButton(0, 0, button);
 }
 
 void ConfigureRingController::keyPressEvent(QKeyEvent* event) {
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index 22aa19c56..c21828b1d 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -870,6 +870,7 @@ void GameList::ToggleFavorite(u64 program_id) {
             tree_view->setRowHidden(0, item_model->invisibleRootItem()->index(), true);
         }
     }
+    SaveConfig();
 }
 
 void GameList::AddFavorite(u64 program_id) {
diff --git a/src/yuzu/game_list.h b/src/yuzu/game_list.h
index f7ff93ed9..64e5af4c1 100644
--- a/src/yuzu/game_list.h
+++ b/src/yuzu/game_list.h
@@ -122,6 +122,7 @@ signals:
     void AddDirectory();
     void ShowList(bool show);
     void PopulatingCompleted();
+    void SaveConfig();
 
 private slots:
     void OnItemExpanded(const QModelIndex& item);
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index f28268e9b..f233b065e 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -219,7 +219,7 @@ static void LogRuntimes() {
 #ifdef _MSC_VER
     // It is possible that the name of the dll will change.
     // vcruntime140.dll is for 2015 and onwards
-    constexpr char runtime_dll_name[] = "vcruntime140.dll";
+    static constexpr char runtime_dll_name[] = "vcruntime140.dll";
     UINT sz = GetFileVersionInfoSizeA(runtime_dll_name, nullptr);
     bool runtime_version_inspection_worked = false;
     if (sz > 0) {
@@ -805,6 +805,8 @@ void GMainWindow::WebBrowserOpenWebPage(const std::string& main_url,
                                 layout.screen.GetHeight() / scale_ratio);
         web_browser_view.move(layout.screen.left / scale_ratio,
                               (layout.screen.top / scale_ratio) + menuBar()->height());
+        web_browser_view.setZoomFactor(static_cast<qreal>(layout.screen.GetWidth() / scale_ratio) /
+                                       static_cast<qreal>(Layout::ScreenUndocked::Width));
 
         web_browser_view.setFocus();
         web_browser_view.show();
@@ -1163,6 +1165,14 @@ void GMainWindow::InitializeHotkeys() {
         Settings::values.use_speed_limit.SetValue(!Settings::values.use_speed_limit.GetValue());
     });
     connect_shortcut(QStringLiteral("Toggle Mouse Panning"), [&] {
+        if (Settings::values.mouse_enabled) {
+            Settings::values.mouse_panning = false;
+            QMessageBox::warning(
+                this, tr("Emulated mouse is enabled"),
+                tr("Real mouse input and mouse panning are incompatible. Please disable the "
+                   "emulated mouse in input advanced settings to allow mouse panning."));
+            return;
+        }
         Settings::values.mouse_panning = !Settings::values.mouse_panning;
         if (Settings::values.mouse_panning) {
             render_window->installEventFilter(render_window);
@@ -1269,6 +1279,7 @@ void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::ShowList, this, &GMainWindow::OnGameListShowList);
     connect(game_list, &GameList::PopulatingCompleted,
             [this] { multiplayer_state->UpdateGameList(game_list->GetModel()); });
+    connect(game_list, &GameList::SaveConfig, this, &GMainWindow::OnSaveConfig);
 
     connect(game_list, &GameList::OpenPerGameGeneralRequested, this,
             &GMainWindow::OnGameListOpenPerGameProperties);
@@ -1777,7 +1788,7 @@ void GMainWindow::BootGame(const QString& filename, u64 program_id, std::size_t
             std::filesystem::path{Common::U16StringFromBuffer(filename.utf16(), filename.size())}
                 .filename());
     }
-    const bool is_64bit = system->Kernel().CurrentProcess()->Is64BitProcess();
+    const bool is_64bit = system->Kernel().ApplicationProcess()->Is64BitProcess();
     const auto instruction_set_suffix = is_64bit ? tr("(64-bit)") : tr("(32-bit)");
     title_name = tr("%1 %2", "%1 is the title name. %2 indicates if the title is 64-bit or 32-bit")
                      .arg(QString::fromStdString(title_name), instruction_set_suffix)
@@ -2652,6 +2663,8 @@ void GMainWindow::OnGameListAddDirectory() {
     } else {
         LOG_WARNING(Frontend, "Selected directory is already in the game list");
     }
+
+    OnSaveConfig();
 }
 
 void GMainWindow::OnGameListShowList(bool show) {
@@ -3013,8 +3026,10 @@ void GMainWindow::OnRestartGame() {
     if (!system->IsPoweredOn()) {
         return;
     }
-    // Make a copy since BootGame edits game_path
-    BootGame(QString(current_game_path));
+    // Make a copy since ShutdownGame edits game_path
+    const auto current_game = QString(current_game_path);
+    ShutdownGame();
+    BootGame(current_game);
 }
 
 void GMainWindow::OnPauseGame() {
@@ -3378,6 +3393,7 @@ void GMainWindow::OnConfigureTas() {
         return;
     } else if (result == QDialog::Accepted) {
         dialog.ApplyConfiguration();
+        OnSaveConfig();
     }
 }
 
@@ -3530,7 +3546,7 @@ void GMainWindow::OnToggleGraphicsAPI() {
 }
 
 void GMainWindow::OnConfigurePerGame() {
-    const u64 title_id = system->GetCurrentProcessProgramID();
+    const u64 title_id = system->GetApplicationProcessProgramID();
     OpenPerGameConfiguration(title_id, current_game_path.toStdString());
 }
 
@@ -3689,7 +3705,7 @@ void GMainWindow::OnCaptureScreenshot() {
         return;
     }
 
-    const u64 title_id = system->GetCurrentProcessProgramID();
+    const u64 title_id = system->GetApplicationProcessProgramID();
     const auto screenshot_path =
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::ScreenshotsDir));
     const auto date =
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index 9c34cdc6e..3b6dce296 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -178,6 +178,7 @@ void Config::ReadValues() {
 
     ReadSetting("ControlsGeneral", Settings::values.enable_raw_input);
     ReadSetting("ControlsGeneral", Settings::values.enable_joycon_driver);
+    ReadSetting("ControlsGeneral", Settings::values.enable_procon_driver);
     ReadSetting("ControlsGeneral", Settings::values.emulate_analog_keyboard);
     ReadSetting("ControlsGeneral", Settings::values.vibration_enabled);
     ReadSetting("ControlsGeneral", Settings::values.enable_accurate_vibrations);
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
index 5450b8c38..5153cdb79 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
@@ -62,7 +62,9 @@ void EmuWindow_SDL2::OnMouseButton(u32 button, u8 state, s32 x, s32 y) {
     const auto mouse_button = SDLButtonToMouseButton(button);
     if (state == SDL_PRESSED) {
         const auto [touch_x, touch_y] = MouseToTouchPos(x, y);
-        input_subsystem->GetMouse()->PressButton(x, y, touch_x, touch_y, mouse_button);
+        input_subsystem->GetMouse()->PressButton(x, y, mouse_button);
+        input_subsystem->GetMouse()->PressMouseButton(mouse_button);
+        input_subsystem->GetMouse()->PressTouchButton(touch_x, touch_y, mouse_button);
     } else {
         input_subsystem->GetMouse()->ReleaseButton(mouse_button);
     }
@@ -70,7 +72,9 @@ void EmuWindow_SDL2::OnMouseButton(u32 button, u8 state, s32 x, s32 y) {
 
 void EmuWindow_SDL2::OnMouseMotion(s32 x, s32 y) {
     const auto [touch_x, touch_y] = MouseToTouchPos(x, y);
-    input_subsystem->GetMouse()->MouseMove(x, y, touch_x, touch_y, 0, 0);
+    input_subsystem->GetMouse()->Move(x, y, 0, 0);
+    input_subsystem->GetMouse()->MouseMove(touch_x, touch_y);
+    input_subsystem->GetMouse()->TouchMove(touch_x, touch_y);
 }
 
 void EmuWindow_SDL2::OnFingerDown(float x, float y, std::size_t id) {
diff --git a/src/yuzu_cmd/yuzu.cpp b/src/yuzu_cmd/yuzu.cpp
index d1f7b1d49..77edd58ca 100644
--- a/src/yuzu_cmd/yuzu.cpp
+++ b/src/yuzu_cmd/yuzu.cpp
@@ -405,7 +405,7 @@ int main(int argc, char** argv) {
 
     if (Settings::values.use_disk_shader_cache.GetValue()) {
         system.Renderer().ReadRasterizer()->LoadDiskResources(
-            system.GetCurrentProcessProgramID(), std::stop_token{},
+            system.GetApplicationProcessProgramID(), std::stop_token{},
             [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
     }