Merge pull request #9912 from liamwhite/err

hle: rename legacy errors to Results
3 years ago · aaeb3f2cb9
35 changed files with 169 additions and 183 deletions
--- a/src/audio_core/audio_in_manager.cpp
+++ b/src/audio_core/audio_in_manager.cpp
@ -20,7 +20,7 @@ Manager::Manager(Core::System& system_) : system{system_} {
 Result Manager::AcquireSessionId(size_t& session_id) {
    if (num_free_sessions == 0) {
        LOG_ERROR(Service_Audio, "All 4 AudioIn sessions are in use, cannot create any more");
-        return Service::Audio::ERR_MAXIMUM_SESSIONS_REACHED;
+        return Service::Audio::ResultOutOfSessions;
    }
    session_id = session_ids[next_session_id];
    next_session_id = (next_session_id + 1) % MaxInSessions;
--- a/src/audio_core/audio_manager.cpp
+++ b/src/audio_core/audio_manager.cpp
@ -19,7 +19,7 @@ void AudioManager::Shutdown() {

 Result AudioManager::SetOutManager(BufferEventFunc buffer_func) {
    if (!running) {
-        return Service::Audio::ERR_OPERATION_FAILED;
+        return Service::Audio::ResultOperationFailed;
    }

    std::scoped_lock l{lock};
@ -35,7 +35,7 @@ Result AudioManager::SetOutManager(BufferEventFunc buffer_func) {

 Result AudioManager::SetInManager(BufferEventFunc buffer_func) {
    if (!running) {
-        return Service::Audio::ERR_OPERATION_FAILED;
+        return Service::Audio::ResultOperationFailed;
    }

    std::scoped_lock l{lock};
--- a/src/audio_core/audio_out_manager.cpp
+++ b/src/audio_core/audio_out_manager.cpp
@ -19,7 +19,7 @@ Manager::Manager(Core::System& system_) : system{system_} {
 Result Manager::AcquireSessionId(size_t& session_id) {
    if (num_free_sessions == 0) {
        LOG_ERROR(Service_Audio, "All 12 Audio Out sessions are in use, cannot create any more");
-        return Service::Audio::ERR_MAXIMUM_SESSIONS_REACHED;
+        return Service::Audio::ResultOutOfSessions;
    }
    session_id = session_ids[next_session_id];
    next_session_id = (next_session_id + 1) % MaxOutSessions;
--- a/src/audio_core/audio_render_manager.cpp
+++ b/src/audio_core/audio_render_manager.cpp
@ -28,7 +28,7 @@ SystemManager& Manager::GetSystemManager() {
 Result Manager::GetWorkBufferSize(const AudioRendererParameterInternal& params,
                                  u64& out_count) const {
    if (!CheckValidRevision(params.revision)) {
-        return Service::Audio::ERR_INVALID_REVISION;
+        return Service::Audio::ResultInvalidRevision;
    }

    out_count = System::GetWorkBufferSize(params);
--- a/src/audio_core/in/audio_in.cpp
+++ b/src/audio_core/in/audio_in.cpp
@ -46,7 +46,7 @@ Result In::AppendBuffer(const AudioInBuffer& buffer, u64 tag) {
    if (system.AppendBuffer(buffer, tag)) {
        return ResultSuccess;
    }
-    return Service::Audio::ERR_BUFFER_COUNT_EXCEEDED;
+    return Service::Audio::ResultBufferCountReached;
 }

 void In::ReleaseAndRegisterBuffers() {
--- a/src/audio_core/in/audio_in_system.cpp
+++ b/src/audio_core/in/audio_in_system.cpp
@ -45,11 +45,11 @@ Result System::IsConfigValid(const std::string_view device_name,
                             const AudioInParameter& in_params) const {
    if ((device_name.size() > 0) &&
        (device_name != GetDefaultDeviceName() && device_name != GetDefaultUacDeviceName())) {
-        return Service::Audio::ERR_INVALID_DEVICE_NAME;
+        return Service::Audio::ResultNotFound;
    }

    if (in_params.sample_rate != TargetSampleRate && in_params.sample_rate > 0) {
-        return Service::Audio::ERR_INVALID_SAMPLE_RATE;
+        return Service::Audio::ResultInvalidSampleRate;
    }

    return ResultSuccess;
@ -80,7 +80,7 @@ Result System::Initialize(std::string device_name, const AudioInParameter& in_pa

 Result System::Start() {
    if (state != State::Stopped) {
-        return Service::Audio::ERR_OPERATION_FAILED;
+        return Service::Audio::ResultOperationFailed;
    }

    session->Initialize(name, sample_format, channel_count, session_id, handle,
--- a/src/audio_core/out/audio_out.cpp
+++ b/src/audio_core/out/audio_out.cpp
@ -46,7 +46,7 @@ Result Out::AppendBuffer(const AudioOutBuffer& buffer, const u64 tag) {
    if (system.AppendBuffer(buffer, tag)) {
        return ResultSuccess;
    }
-    return Service::Audio::ERR_BUFFER_COUNT_EXCEEDED;
+    return Service::Audio::ResultBufferCountReached;
 }

 void Out::ReleaseAndRegisterBuffers() {
--- a/src/audio_core/out/audio_out_system.cpp
+++ b/src/audio_core/out/audio_out_system.cpp
@ -33,11 +33,11 @@ std::string_view System::GetDefaultOutputDeviceName() const {
 Result System::IsConfigValid(std::string_view device_name,
                             const AudioOutParameter& in_params) const {
    if ((device_name.size() > 0) && (device_name != GetDefaultOutputDeviceName())) {
-        return Service::Audio::ERR_INVALID_DEVICE_NAME;
+        return Service::Audio::ResultNotFound;
    }

    if (in_params.sample_rate != TargetSampleRate && in_params.sample_rate > 0) {
-        return Service::Audio::ERR_INVALID_SAMPLE_RATE;
+        return Service::Audio::ResultInvalidSampleRate;
    }

    if (in_params.channel_count == 0 || in_params.channel_count == 2 ||
@ -45,7 +45,7 @@ Result System::IsConfigValid(std::string_view device_name,
        return ResultSuccess;
    }

-    return Service::Audio::ERR_INVALID_CHANNEL_COUNT;
+    return Service::Audio::ResultInvalidChannelCount;
 }

 Result System::Initialize(std::string device_name, const AudioOutParameter& in_params, u32 handle_,
@ -80,7 +80,7 @@ size_t System::GetSessionId() const {

 Result System::Start() {
    if (state != State::Stopped) {
-        return Service::Audio::ERR_OPERATION_FAILED;
+        return Service::Audio::ResultOperationFailed;
    }

    session->Initialize(name, sample_format, channel_count, session_id, handle,
--- a/src/audio_core/renderer/audio_renderer.cpp
+++ b/src/audio_core/renderer/audio_renderer.cpp
@ -22,7 +22,7 @@ Result Renderer::Initialize(const AudioRendererParameterInternal& params,
        if (!manager.AddSystem(system)) {
            LOG_ERROR(Service_Audio,
                      "Both Audio Render sessions are in use, cannot create any more");
-            return Service::Audio::ERR_MAXIMUM_SESSIONS_REACHED;
+            return Service::Audio::ResultOutOfSessions;
        }
        system_registered = true;
    }
--- a/src/audio_core/renderer/behavior/info_updater.cpp
+++ b/src/audio_core/renderer/behavior/info_updater.cpp
@ -48,7 +48,7 @@ Result InfoUpdater::UpdateVoiceChannelResources(VoiceContext& voice_context) {
        LOG_ERROR(Service_Audio,
                  "Consumed an incorrect voice resource size, header size={}, consumed={}",
                  in_header->voice_resources_size, consumed_input_size);
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    input += consumed_input_size;
@ -123,7 +123,7 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
    if (consumed_input_size != in_header->voices_size) {
        LOG_ERROR(Service_Audio, "Consumed an incorrect voices size, header size={}, consumed={}",
                  in_header->voices_size, consumed_input_size);
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    out_header->voices_size = consumed_output_size;
@ -184,7 +184,7 @@ Result InfoUpdater::UpdateEffectsVersion1(EffectContext& effect_context, const b
    if (consumed_input_size != in_header->effects_size) {
        LOG_ERROR(Service_Audio, "Consumed an incorrect effects size, header size={}, consumed={}",
                  in_header->effects_size, consumed_input_size);
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    out_header->effects_size = consumed_output_size;
@ -239,7 +239,7 @@ Result InfoUpdater::UpdateEffectsVersion2(EffectContext& effect_context, const b
    if (consumed_input_size != in_header->effects_size) {
        LOG_ERROR(Service_Audio, "Consumed an incorrect effects size, header size={}, consumed={}",
                  in_header->effects_size, consumed_input_size);
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    out_header->effects_size = consumed_output_size;
@ -267,7 +267,7 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
    }

    if (mix_buffer_count == 0) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    std::span<const MixInfo::InParameter> in_params{
@ -281,13 +281,13 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
            total_buffer_count += params.buffer_count;
            if (params.dest_mix_id > static_cast<s32>(mix_context.GetCount()) &&
                params.dest_mix_id != UnusedMixId && params.mix_id != FinalMixId) {
-                return Service::Audio::ERR_INVALID_UPDATE_DATA;
+                return Service::Audio::ResultInvalidUpdateInfo;
            }
        }
    }

    if (total_buffer_count > mix_buffer_count) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    bool mix_dirty{false};
@ -317,7 +317,7 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
    if (mix_dirty) {
        if (behaviour.IsSplitterSupported() && splitter_context.UsingSplitter()) {
            if (!mix_context.TSortInfo(splitter_context)) {
-                return Service::Audio::ERR_INVALID_UPDATE_DATA;
+                return Service::Audio::ResultInvalidUpdateInfo;
            }
        } else {
            mix_context.SortInfo();
@ -327,7 +327,7 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
    if (consumed_input_size != in_header->mix_size) {
        LOG_ERROR(Service_Audio, "Consumed an incorrect mixes size, header size={}, consumed={}",
                  in_header->mix_size, consumed_input_size);
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    input += mix_count * sizeof(MixInfo::InParameter);
@ -384,7 +384,7 @@ Result InfoUpdater::UpdateSinks(SinkContext& sink_context, std::span<MemoryPoolI
    if (consumed_input_size != in_header->sinks_size) {
        LOG_ERROR(Service_Audio, "Consumed an incorrect sinks size, header size={}, consumed={}",
                  in_header->sinks_size, consumed_input_size);
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    input += consumed_input_size;
@ -411,7 +411,7 @@ Result InfoUpdater::UpdateMemoryPools(std::span<MemoryPoolInfo> memory_pools,
            state != MemoryPoolInfo::ResultState::MapFailed &&
            state != MemoryPoolInfo::ResultState::InUse) {
            LOG_WARNING(Service_Audio, "Invalid ResultState from updating memory pools");
-            return Service::Audio::ERR_INVALID_UPDATE_DATA;
+            return Service::Audio::ResultInvalidUpdateInfo;
        }
    }

@ -423,7 +423,7 @@ Result InfoUpdater::UpdateMemoryPools(std::span<MemoryPoolInfo> memory_pools,
        LOG_ERROR(Service_Audio,
                  "Consumed an incorrect memory pool size, header size={}, consumed={}",
                  in_header->memory_pool_size, consumed_input_size);
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    input += consumed_input_size;
@ -453,7 +453,7 @@ Result InfoUpdater::UpdatePerformanceBuffer(std::span<u8> performance_output,
        LOG_ERROR(Service_Audio,
                  "Consumed an incorrect performance size, header size={}, consumed={}",
                  in_header->performance_buffer_size, consumed_input_size);
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    input += consumed_input_size;
@ -467,18 +467,18 @@ Result InfoUpdater::UpdateBehaviorInfo(BehaviorInfo& behaviour_) {
    const auto in_params{reinterpret_cast<const BehaviorInfo::InParameter*>(input)};

    if (!CheckValidRevision(in_params->revision)) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    if (in_params->revision != behaviour_.GetUserRevision()) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    behaviour_.ClearError();
    behaviour_.UpdateFlags(in_params->flags);

    if (in_header->behaviour_size != sizeof(BehaviorInfo::InParameter)) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    input += sizeof(BehaviorInfo::InParameter);
@ -500,7 +500,7 @@ Result InfoUpdater::UpdateErrorInfo(const BehaviorInfo& behaviour_) {
 Result InfoUpdater::UpdateSplitterInfo(SplitterContext& splitter_context) {
    u32 consumed_size{0};
    if (!splitter_context.Update(input, consumed_size)) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }

    input += consumed_size;
@ -529,9 +529,9 @@ Result InfoUpdater::UpdateRendererInfo(const u64 elapsed_frames) {

 Result InfoUpdater::CheckConsumedSize() {
    if (CpuAddr(input) - CpuAddr(input_origin.data()) != expected_input_size) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    } else if (CpuAddr(output) - CpuAddr(output_origin.data()) != expected_output_size) {
-        return Service::Audio::ERR_INVALID_UPDATE_DATA;
+        return Service::Audio::ResultInvalidUpdateInfo;
    }
    return ResultSuccess;
 }
--- a/src/audio_core/renderer/memory/pool_mapper.cpp
+++ b/src/audio_core/renderer/memory/pool_mapper.cpp
@ -92,7 +92,7 @@ bool PoolMapper::TryAttachBuffer(BehaviorInfo::ErrorInfo& error_info, AddressInf
    address_info.Setup(address, size);

    if (!FillDspAddr(address_info)) {
-        error_info.error_code = Service::Audio::ERR_POOL_MAPPING_FAILED;
+        error_info.error_code = Service::Audio::ResultInvalidAddressInfo;
        error_info.address = address;
        return force_map;
    }
--- a/src/audio_core/renderer/system.cpp
+++ b/src/audio_core/renderer/system.cpp
@ -101,15 +101,15 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
                          Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                          u32 process_handle_, u64 applet_resource_user_id_, s32 session_id_) {
    if (!CheckValidRevision(params.revision)) {
-        return Service::Audio::ERR_INVALID_REVISION;
+        return Service::Audio::ResultInvalidRevision;
    }

    if (GetWorkBufferSize(params) > transfer_memory_size) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    if (process_handle_ == 0) {
-        return Service::Audio::ERR_INVALID_PROCESS_HANDLE;
+        return Service::Audio::ResultInvalidHandle;
    }

    behavior.SetUserLibRevision(params.revision);
@ -143,19 +143,19 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    samples_workbuffer =
        allocator.Allocate<s32>((voice_channels + mix_buffer_count) * sample_count, 0x10);
    if (samples_workbuffer.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    auto upsampler_workbuffer{allocator.Allocate<s32>(
        (voice_channels + mix_buffer_count) * TargetSampleCount * upsampler_count, 0x10)};
    if (upsampler_workbuffer.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    depop_buffer =
        allocator.Allocate<s32>(Common::AlignUp(static_cast<u32>(mix_buffer_count), 0x40), 0x40);
    if (depop_buffer.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    // invalidate samples_workbuffer DSP cache
@ -166,12 +166,12 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (voice_infos.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    auto sorted_voice_infos{allocator.Allocate<VoiceInfo*>(params.voices, 0x10)};
    if (sorted_voice_infos.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    std::memset(sorted_voice_infos.data(), 0, sorted_voice_infos.size_bytes());
@ -183,12 +183,12 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (voice_channel_resources.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    auto voice_cpu_states{allocator.Allocate<VoiceState>(params.voices, 0x10)};
    if (voice_cpu_states.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    for (auto& voice_state : voice_cpu_states) {
@ -198,7 +198,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    auto mix_infos{allocator.Allocate<MixInfo>(params.sub_mixes + 1, 0x10)};

    if (mix_infos.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    u32 effect_process_order_count{0};
@ -208,7 +208,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
        effect_process_order_count = params.effects * (params.sub_mixes + 1);
        effect_process_order_buffer = allocator.Allocate<s32>(effect_process_order_count, 0x10);
        if (effect_process_order_buffer.empty()) {
-            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }
    }

@ -222,7 +222,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,

    auto sorted_mix_infos{allocator.Allocate<MixInfo*>(params.sub_mixes + 1, 0x10)};
    if (sorted_mix_infos.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    std::memset(sorted_mix_infos.data(), 0, sorted_mix_infos.size_bytes());
@ -235,7 +235,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
        auto edge_matrix_workbuffer{allocator.Allocate<u8>(edge_matrix_size, 1)};

        if (node_states_workbuffer.empty() || edge_matrix_workbuffer.size() == 0) {
-            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }

        mix_context.Initialize(sorted_mix_infos, mix_infos, params.sub_mixes + 1,
@ -250,7 +250,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,

    upsampler_manager = allocator.Allocate<UpsamplerManager>(1, 0x10).data();
    if (upsampler_manager == nullptr) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    memory_pool_workbuffer = allocator.Allocate<MemoryPoolInfo>(memory_pool_count, 0x10);
@ -259,18 +259,18 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (memory_pool_workbuffer.empty() && memory_pool_count > 0) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    if (!splitter_context.Initialize(behavior, params, allocator)) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    std::span<EffectResultState> effect_result_states_cpu{};
    if (behavior.IsEffectInfoVersion2Supported() && params.effects > 0) {
        effect_result_states_cpu = allocator.Allocate<EffectResultState>(params.effects, 0x10);
        if (effect_result_states_cpu.empty()) {
-            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }
        std::memset(effect_result_states_cpu.data(), 0, effect_result_states_cpu.size_bytes());
    }
@ -289,7 +289,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
                                        upsampler_workbuffer);

    if (upsampler_infos.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    auto effect_infos{allocator.Allocate<EffectInfoBase>(params.effects, 0x40)};
@ -298,14 +298,14 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (effect_infos.empty() && params.effects > 0) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    std::span<EffectResultState> effect_result_states_dsp{};
    if (behavior.IsEffectInfoVersion2Supported() && params.effects > 0) {
        effect_result_states_dsp = allocator.Allocate<EffectResultState>(params.effects, 0x40);
        if (effect_result_states_dsp.empty()) {
-            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }
        std::memset(effect_result_states_dsp.data(), 0, effect_result_states_dsp.size_bytes());
    }
@ -319,14 +319,14 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    }

    if (sinks.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    sink_context.Initialize(sinks, params.sinks);

    auto voice_dsp_states{allocator.Allocate<VoiceState>(params.voices, 0x40)};
    if (voice_dsp_states.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    for (auto& voice_state : voice_dsp_states) {
@ -344,7 +344,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
            0xC};
        performance_workbuffer = allocator.Allocate<u8>(perf_workbuffer_size, 0x40);
        if (performance_workbuffer.empty()) {
-            return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+            return Service::Audio::ResultInsufficientBuffer;
        }
        std::memset(performance_workbuffer.data(), 0, performance_workbuffer.size_bytes());
        performance_manager.Initialize(performance_workbuffer, performance_workbuffer.size_bytes(),
@ -360,7 +360,7 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
    command_workbuffer_size = allocator.GetRemainingSize();
    command_workbuffer = allocator.Allocate<u8>(command_workbuffer_size, 0x40);
    if (command_workbuffer.empty()) {
-        return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+        return Service::Audio::ResultInsufficientBuffer;
    }

    command_buffer_size = 0;
--- a/src/audio_core/renderer/voice/voice_info.cpp
+++ b/src/audio_core/renderer/voice/voice_info.cpp
@ -181,7 +181,7 @@ void VoiceInfo::UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info,
        if (wave_buffer_internal.start_offset * byte_size > wave_buffer_internal.size ||
            wave_buffer_internal.end_offset * byte_size > wave_buffer_internal.size) {
            LOG_ERROR(Service_Audio, "Invalid PCM16 start/end wavebuffer sizes!");
-            error_info[0].error_code = Service::Audio::ERR_INVALID_UPDATE_DATA;
+            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
            error_info[0].address = wave_buffer_internal.address;
            return;
        }
@ -192,7 +192,7 @@ void VoiceInfo::UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info,
        if (wave_buffer_internal.start_offset * byte_size > wave_buffer_internal.size ||
            wave_buffer_internal.end_offset * byte_size > wave_buffer_internal.size) {
            LOG_ERROR(Service_Audio, "Invalid PCMFloat start/end wavebuffer sizes!");
-            error_info[0].error_code = Service::Audio::ERR_INVALID_UPDATE_DATA;
+            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
            error_info[0].address = wave_buffer_internal.address;
            return;
        }
@ -216,7 +216,7 @@ void VoiceInfo::UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info,
        if (start > static_cast<s64>(wave_buffer_internal.size) ||
            end > static_cast<s64>(wave_buffer_internal.size)) {
            LOG_ERROR(Service_Audio, "Invalid ADPCM start/end wavebuffer sizes!");
-            error_info[0].error_code = Service::Audio::ERR_INVALID_UPDATE_DATA;
+            error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
            error_info[0].address = wave_buffer_internal.address;
            return;
        }
@ -228,7 +228,7 @@ void VoiceInfo::UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info,

    if (wave_buffer_internal.start_offset < 0 || wave_buffer_internal.end_offset < 0) {
        LOG_ERROR(Service_Audio, "Invalid input start/end wavebuffer sizes!");
-        error_info[0].error_code = Service::Audio::ERR_INVALID_UPDATE_DATA;
+        error_info[0].error_code = Service::Audio::ResultInvalidUpdateInfo;
        error_info[0].address = wave_buffer_internal.address;
        return;
    }
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@ -454,7 +454,6 @@ add_library(core STATIC
    hle/service/filesystem/fsp_srv.h
    hle/service/fgm/fgm.cpp
    hle/service/fgm/fgm.h
-    hle/service/friend/errors.h
    hle/service/friend/friend.cpp
    hle/service/friend/friend.h
    hle/service/friend/friend_interface.cpp
--- a/src/core/hle/kernel/k_process.h
+++ b/src/core/hle/kernel/k_process.h
@ -310,10 +310,10 @@ public:
    /// Clears the signaled state of the process if and only if it's signaled.
    ///
    /// @pre The process must not be already terminated. If this is called on a
-    ///      terminated process, then ERR_INVALID_STATE will be returned.
+    ///      terminated process, then ResultInvalidState will be returned.
    ///
    /// @pre The process must be in a signaled state. If this is called on a
-    ///      process instance that is not signaled, ERR_INVALID_STATE will be
+    ///      process instance that is not signaled, ResultInvalidState will be
    ///      returned.
    Result Reset();

--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@ -30,12 +30,6 @@

 namespace Service::Account {

-constexpr Result ERR_INVALID_USER_ID{ErrorModule::Account, 20};
-constexpr Result ERR_INVALID_APPLICATION_ID{ErrorModule::Account, 22};
-constexpr Result ERR_INVALID_BUFFER{ErrorModule::Account, 30};
-constexpr Result ERR_INVALID_BUFFER_SIZE{ErrorModule::Account, 31};
-constexpr Result ERR_FAILED_SAVE_DATA{ErrorModule::Account, 100};
-
 // Thumbnails are hard coded to be at least this size
 constexpr std::size_t THUMBNAIL_SIZE = 0x24000;

@ -384,7 +378,7 @@ protected:
        if (user_data.size() < sizeof(UserData)) {
            LOG_ERROR(Service_ACC, "UserData buffer too small!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_INVALID_BUFFER);
+            rb.Push(Account::ResultInvalidArrayLength);
            return;
        }

@ -394,7 +388,7 @@ protected:
        if (!profile_manager.SetProfileBaseAndData(user_id, base, data)) {
            LOG_ERROR(Service_ACC, "Failed to update user data and base!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_FAILED_SAVE_DATA);
+            rb.Push(Account::ResultAccountUpdateFailed);
            return;
        }

@ -417,7 +411,7 @@ protected:
        if (user_data.size() < sizeof(UserData)) {
            LOG_ERROR(Service_ACC, "UserData buffer too small!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_INVALID_BUFFER);
+            rb.Push(Account::ResultInvalidArrayLength);
            return;
        }

@ -432,7 +426,7 @@ protected:
            !profile_manager.SetProfileBaseAndData(user_id, base, data)) {
            LOG_ERROR(Service_ACC, "Failed to update profile data, base, and image!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_FAILED_SAVE_DATA);
+            rb.Push(Account::ResultAccountUpdateFailed);
            return;
        }

@ -764,7 +758,7 @@ void Module::Interface::InitializeApplicationInfoRestricted(HLERequestContext& c
 Result Module::Interface::InitializeApplicationInfoBase() {
    if (application_info) {
        LOG_ERROR(Service_ACC, "Application already initialized");
-        return ERR_ACCOUNTINFO_ALREADY_INITIALIZED;
+        return Account::ResultApplicationInfoAlreadyInitialized;
    }

    // TODO(ogniK): This should be changed to reflect the target process for when we have multiple
@ -775,7 +769,7 @@ Result Module::Interface::InitializeApplicationInfoBase() {

    if (launch_property.Failed()) {
        LOG_ERROR(Service_ACC, "Failed to get launch property");
-        return ERR_ACCOUNTINFO_BAD_APPLICATION;
+        return Account::ResultInvalidApplication;
    }

    switch (launch_property->base_game_storage_id) {
@ -791,7 +785,7 @@ Result Module::Interface::InitializeApplicationInfoBase() {
    default:
        LOG_ERROR(Service_ACC, "Invalid game storage ID! storage_id={}",
                  launch_property->base_game_storage_id);
-        return ERR_ACCOUNTINFO_BAD_APPLICATION;
+        return Account::ResultInvalidApplication;
    }

    LOG_WARNING(Service_ACC, "ApplicationInfo init required");
@ -899,20 +893,20 @@ void Module::Interface::StoreSaveDataThumbnail(HLERequestContext& ctx, const Com

    if (tid == 0) {
        LOG_ERROR(Service_ACC, "TitleID is not valid!");
-        rb.Push(ERR_INVALID_APPLICATION_ID);
+        rb.Push(Account::ResultInvalidApplication);
        return;
    }

    if (uuid.IsInvalid()) {
        LOG_ERROR(Service_ACC, "User ID is not valid!");
-        rb.Push(ERR_INVALID_USER_ID);
+        rb.Push(Account::ResultInvalidUserId);
        return;
    }
    const auto thumbnail_size = ctx.GetReadBufferSize();
    if (thumbnail_size != THUMBNAIL_SIZE) {
        LOG_ERROR(Service_ACC, "Buffer size is empty! size={:X} expecting {:X}", thumbnail_size,
                  THUMBNAIL_SIZE);
-        rb.Push(ERR_INVALID_BUFFER_SIZE);
+        rb.Push(Account::ResultInvalidArrayLength);
        return;
    }

--- a/src/core/hle/service/acc/errors.h
+++ b/src/core/hle/service/acc/errors.h
@ -7,7 +7,13 @@

 namespace Service::Account {

-constexpr Result ERR_ACCOUNTINFO_BAD_APPLICATION{ErrorModule::Account, 22};
-constexpr Result ERR_ACCOUNTINFO_ALREADY_INITIALIZED{ErrorModule::Account, 41};
+constexpr Result ResultCancelledByUser{ErrorModule::Account, 1};
+constexpr Result ResultNoNotifications{ErrorModule::Account, 15};
+constexpr Result ResultInvalidUserId{ErrorModule::Account, 20};
+constexpr Result ResultInvalidApplication{ErrorModule::Account, 22};
+constexpr Result ResultNullptr{ErrorModule::Account, 30};
+constexpr Result ResultInvalidArrayLength{ErrorModule::Account, 32};
+constexpr Result ResultApplicationInfoAlreadyInitialized{ErrorModule::Account, 41};
+constexpr Result ResultAccountUpdateFailed{ErrorModule::Account, 100};

 } // namespace Service::Account
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@ -39,9 +39,9 @@

 namespace Service::AM {

-constexpr Result ERR_NO_DATA_IN_CHANNEL{ErrorModule::AM, 2};
-constexpr Result ERR_NO_MESSAGES{ErrorModule::AM, 3};
-constexpr Result ERR_SIZE_OUT_OF_BOUNDS{ErrorModule::AM, 503};
+constexpr Result ResultNoDataInChannel{ErrorModule::AM, 2};
+constexpr Result ResultNoMessages{ErrorModule::AM, 3};
+constexpr Result ResultInvalidOffset{ErrorModule::AM, 503};

 enum class LaunchParameterKind : u32 {
    ApplicationSpecific = 1,
@ -758,7 +758,7 @@ void ICommonStateGetter::ReceiveMessage(HLERequestContext& ctx) {

    if (message == AppletMessageQueue::AppletMessage::None) {
        LOG_ERROR(Service_AM, "Message queue is empty");
-        rb.Push(ERR_NO_MESSAGES);
+        rb.Push(AM::ResultNoMessages);
        rb.PushEnum<AppletMessageQueue::AppletMessage>(message);
        return;
    }
@ -1028,7 +1028,7 @@ private:
            LOG_DEBUG(Service_AM,
                      "storage is a nullptr. There is no data in the current normal channel");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NO_DATA_IN_CHANNEL);
+            rb.Push(AM::ResultNoDataInChannel);
            return;
        }

@ -1059,7 +1059,7 @@ private:
            LOG_DEBUG(Service_AM,
                      "storage is a nullptr. There is no data in the current interactive channel");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NO_DATA_IN_CHANNEL);
+            rb.Push(AM::ResultNoDataInChannel);
            return;
        }

@ -1138,7 +1138,7 @@ void IStorageAccessor::Write(HLERequestContext& ctx) {
                  backing.GetSize(), size, offset);

        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_SIZE_OUT_OF_BOUNDS);
+        rb.Push(AM::ResultInvalidOffset);
        return;
    }

@ -1161,7 +1161,7 @@ void IStorageAccessor::Read(HLERequestContext& ctx) {
                  backing.GetSize(), size, offset);

        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_SIZE_OUT_OF_BOUNDS);
+        rb.Push(AM::ResultInvalidOffset);
        return;
    }

@ -1502,7 +1502,7 @@ void IApplicationFunctions::PopLaunchParameter(HLERequestContext& ctx) {

    LOG_ERROR(Service_AM, "Attempted to load launch parameter but none was found!");
    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ERR_NO_DATA_IN_CHANNEL);
+    rb.Push(AM::ResultNoDataInChannel);
 }

 void IApplicationFunctions::CreateApplicationAndRequestToStartForQuest(HLERequestContext& ctx) {
@ -1799,7 +1799,7 @@ void IApplicationFunctions::TryPopFromFriendInvitationStorageChannel(HLERequestC
    LOG_WARNING(Service_AM, "(STUBBED) called");

    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ERR_NO_DATA_IN_CHANNEL);
+    rb.Push(AM::ResultNoDataInChannel);
 }

 void IApplicationFunctions::GetNotificationStorageChannelEvent(HLERequestContext& ctx) {
--- a/src/core/hle/service/am/applets/applet_controller.cpp
+++ b/src/core/hle/service/am/applets/applet_controller.cpp
@ -19,10 +19,9 @@

 namespace Service::AM::Applets {

-// This error code (0x183ACA) is thrown when the applet fails to initialize.
-[[maybe_unused]] constexpr Result ERR_CONTROLLER_APPLET_3101{ErrorModule::HID, 3101};
-// This error code (0x183CCA) is thrown when the u32 result in ControllerSupportResultInfo is 2.
-[[maybe_unused]] constexpr Result ERR_CONTROLLER_APPLET_3102{ErrorModule::HID, 3102};
+[[maybe_unused]] constexpr Result ResultControllerSupportCanceled{ErrorModule::HID, 3101};
+[[maybe_unused]] constexpr Result ResultControllerSupportNotSupportedNpadStyle{ErrorModule::HID,
+                                                                               3102};

 static Core::Frontend::ControllerParameters ConvertToFrontendParameters(
    ControllerSupportArgPrivate private_arg, ControllerSupportArgHeader header, bool enable_text,
--- a/src/core/hle/service/am/applets/applet_profile_select.cpp
+++ b/src/core/hle/service/am/applets/applet_profile_select.cpp
@ -7,13 +7,12 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/profile_select.h"
+#include "core/hle/service/acc/errors.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applet_profile_select.h"

 namespace Service::AM::Applets {

-constexpr Result ERR_USER_CANCELLED_SELECTION{ErrorModule::Account, 1};
-
 ProfileSelect::ProfileSelect(Core::System& system_, LibraryAppletMode applet_mode_,
                             const Core::Frontend::ProfileSelectApplet& frontend_)
    : Applet{system_, applet_mode_}, frontend{frontend_}, system{system_} {}
@ -63,8 +62,8 @@ void ProfileSelect::SelectionComplete(std::optional<Common::UUID> uuid) {
        output.result = 0;
        output.uuid_selected = *uuid;
    } else {
-        status = ERR_USER_CANCELLED_SELECTION;
-        output.result = ERR_USER_CANCELLED_SELECTION.raw;
+        status = Account::ResultCancelledByUser;
+        output.result = Account::ResultCancelledByUser.raw;
        output.uuid_selected = Common::InvalidUUID;
    }

--- a/src/core/hle/service/audio/audren_u.cpp
+++ b/src/core/hle/service/audio/audren_u.cpp
@ -170,7 +170,7 @@ private:

        if (impl->GetSystem().GetExecutionMode() == AudioCore::ExecutionMode::Manual) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NOT_SUPPORTED);
+            rb.Push(Audio::ResultNotSupported);
            return;
        }

@ -448,7 +448,7 @@ void AudRenU::OpenAudioRenderer(HLERequestContext& ctx) {
    if (impl->GetSessionCount() + 1 > AudioCore::MaxRendererSessions) {
        LOG_ERROR(Service_Audio, "Too many AudioRenderer sessions open!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_MAXIMUM_SESSIONS_REACHED);
+        rb.Push(Audio::ResultOutOfSessions);
        return;
    }

@ -461,7 +461,7 @@ void AudRenU::OpenAudioRenderer(HLERequestContext& ctx) {
    if (session_id == -1) {
        LOG_ERROR(Service_Audio, "Tried to open a session that's already in use!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_MAXIMUM_SESSIONS_REACHED);
+        rb.Push(Audio::ResultOutOfSessions);
        return;
    }

--- a/src/core/hle/service/audio/errors.h
+++ b/src/core/hle/service/audio/errors.h
@ -7,17 +7,17 @@

 namespace Service::Audio {

-constexpr Result ERR_INVALID_DEVICE_NAME{ErrorModule::Audio, 1};
-constexpr Result ERR_OPERATION_FAILED{ErrorModule::Audio, 2};
-constexpr Result ERR_INVALID_SAMPLE_RATE{ErrorModule::Audio, 3};
-constexpr Result ERR_INSUFFICIENT_BUFFER_SIZE{ErrorModule::Audio, 4};
-constexpr Result ERR_MAXIMUM_SESSIONS_REACHED{ErrorModule::Audio, 5};
-constexpr Result ERR_BUFFER_COUNT_EXCEEDED{ErrorModule::Audio, 8};
-constexpr Result ERR_INVALID_CHANNEL_COUNT{ErrorModule::Audio, 10};
-constexpr Result ERR_INVALID_UPDATE_DATA{ErrorModule::Audio, 41};
-constexpr Result ERR_POOL_MAPPING_FAILED{ErrorModule::Audio, 42};
-constexpr Result ERR_NOT_SUPPORTED{ErrorModule::Audio, 513};
-constexpr Result ERR_INVALID_PROCESS_HANDLE{ErrorModule::Audio, 1536};
-constexpr Result ERR_INVALID_REVISION{ErrorModule::Audio, 1537};
+constexpr Result ResultNotFound{ErrorModule::Audio, 1};
+constexpr Result ResultOperationFailed{ErrorModule::Audio, 2};
+constexpr Result ResultInvalidSampleRate{ErrorModule::Audio, 3};
+constexpr Result ResultInsufficientBuffer{ErrorModule::Audio, 4};
+constexpr Result ResultOutOfSessions{ErrorModule::Audio, 5};
+constexpr Result ResultBufferCountReached{ErrorModule::Audio, 8};
+constexpr Result ResultInvalidChannelCount{ErrorModule::Audio, 10};
+constexpr Result ResultInvalidUpdateInfo{ErrorModule::Audio, 41};
+constexpr Result ResultInvalidAddressInfo{ErrorModule::Audio, 42};
+constexpr Result ResultNotSupported{ErrorModule::Audio, 513};
+constexpr Result ResultInvalidHandle{ErrorModule::Audio, 1536};
+constexpr Result ResultInvalidRevision{ErrorModule::Audio, 1537};

 } // namespace Service::Audio
--- a/src/core/hle/service/friend/errors.h
+++ b/src/core/hle/service/friend/errors.h
@ -1,11 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/result.h"
-
-namespace Service::Friend {
-
-constexpr Result ERR_NO_NOTIFICATIONS{ErrorModule::Account, 15};
-}
--- a/src/core/hle/service/friend/friend.cpp
+++ b/src/core/hle/service/friend/friend.cpp
@ -6,7 +6,7 @@
 #include "common/uuid.h"
 #include "core/core.h"
 #include "core/hle/kernel/k_event.h"
-#include "core/hle/service/friend/errors.h"
+#include "core/hle/service/acc/errors.h"
 #include "core/hle/service/friend/friend.h"
 #include "core/hle/service/friend/friend_interface.h"
 #include "core/hle/service/ipc_helpers.h"
@ -259,7 +259,7 @@ private:
        if (notifications.empty()) {
            LOG_ERROR(Service_Friend, "No notifications in queue!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_NO_NOTIFICATIONS);
+            rb.Push(Account::ResultNoNotifications);
            return;
        }

--- a/src/core/hle/service/glue/arp.cpp
+++ b/src/core/hle/service/glue/arp.cpp
@ -61,7 +61,7 @@ void ARP_R::GetApplicationLaunchProperty(HLERequestContext& ctx) {
    if (!title_id.has_value()) {
        LOG_ERROR(Service_ARP, "Failed to get title ID for process ID!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_NOT_REGISTERED);
+        rb.Push(Glue::ResultProcessIdNotRegistered);
        return;
    }

@ -109,7 +109,7 @@ void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) {
    if (!title_id.has_value()) {
        LOG_ERROR(Service_ARP, "Failed to get title ID for process ID!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_NOT_REGISTERED);
+        rb.Push(Glue::ResultProcessIdNotRegistered);
        return;
    }

@ -178,7 +178,7 @@ private:
        if (process_id == 0) {
            LOG_ERROR(Service_ARP, "Must have non-zero process ID!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_INVALID_PROCESS_ID);
+            rb.Push(Glue::ResultInvalidProcessId);
            return;
        }

@ -186,7 +186,7 @@ private:
            LOG_ERROR(Service_ARP,
                      "Attempted to issue registrar, but registrar is already issued!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_INVALID_ACCESS);
+            rb.Push(Glue::ResultAlreadyBound);
            return;
        }

@ -205,7 +205,7 @@ private:
                Service_ARP,
                "Attempted to set application launch property, but registrar is already issued!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_INVALID_ACCESS);
+            rb.Push(Glue::ResultAlreadyBound);
            return;
        }

@ -224,7 +224,7 @@ private:
                Service_ARP,
                "Attempted to set application control property, but registrar is already issued!");
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_INVALID_ACCESS);
+            rb.Push(Glue::ResultAlreadyBound);
            return;
        }

@ -263,7 +263,7 @@ void ARP_W::AcquireRegistrar(HLERequestContext& ctx) {
        system, [this](u64 process_id, ApplicationLaunchProperty launch, std::vector<u8> control) {
            const auto res = GetTitleIDForProcessID(system, process_id);
            if (!res.has_value()) {
-                return ERR_NOT_REGISTERED;
+                return Glue::ResultProcessIdNotRegistered;
            }

            return manager.Register(*res, launch, std::move(control));
@ -283,7 +283,7 @@ void ARP_W::UnregisterApplicationInstance(HLERequestContext& ctx) {
    if (process_id == 0) {
        LOG_ERROR(Service_ARP, "Must have non-zero process ID!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_INVALID_PROCESS_ID);
+        rb.Push(Glue::ResultInvalidProcessId);
        return;
    }

@ -292,7 +292,7 @@ void ARP_W::UnregisterApplicationInstance(HLERequestContext& ctx) {
    if (!title_id.has_value()) {
        LOG_ERROR(Service_ARP, "No title ID for process ID!");
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_NOT_REGISTERED);
+        rb.Push(Glue::ResultProcessIdNotRegistered);
        return;
    }

--- a/src/core/hle/service/glue/errors.h
+++ b/src/core/hle/service/glue/errors.h
@ -7,9 +7,8 @@

 namespace Service::Glue {

-constexpr Result ERR_INVALID_RESOURCE{ErrorModule::ARP, 30};
-constexpr Result ERR_INVALID_PROCESS_ID{ErrorModule::ARP, 31};
-constexpr Result ERR_INVALID_ACCESS{ErrorModule::ARP, 42};
-constexpr Result ERR_NOT_REGISTERED{ErrorModule::ARP, 102};
+constexpr Result ResultInvalidProcessId{ErrorModule::ARP, 31};
+constexpr Result ResultAlreadyBound{ErrorModule::ARP, 42};
+constexpr Result ResultProcessIdNotRegistered{ErrorModule::ARP, 102};

 } // namespace Service::Glue
--- a/src/core/hle/service/glue/glue_manager.cpp
+++ b/src/core/hle/service/glue/glue_manager.cpp
@ -17,12 +17,12 @@ ARPManager::~ARPManager() = default;

 ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id) const {
    if (title_id == 0) {
-        return ERR_INVALID_PROCESS_ID;
+        return Glue::ResultInvalidProcessId;
    }

    const auto iter = entries.find(title_id);
    if (iter == entries.end()) {
-        return ERR_NOT_REGISTERED;
+        return Glue::ResultProcessIdNotRegistered;
    }

    return iter->second.launch;
@ -30,12 +30,12 @@ ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id)

 ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
    if (title_id == 0) {
-        return ERR_INVALID_PROCESS_ID;
+        return Glue::ResultInvalidProcessId;
    }

    const auto iter = entries.find(title_id);
    if (iter == entries.end()) {
-        return ERR_NOT_REGISTERED;
+        return Glue::ResultProcessIdNotRegistered;
    }

    return iter->second.control;
@ -44,12 +44,12 @@ ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
 Result ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,
                            std::vector<u8> control) {
    if (title_id == 0) {
-        return ERR_INVALID_PROCESS_ID;
+        return Glue::ResultInvalidProcessId;
    }

    const auto iter = entries.find(title_id);
    if (iter != entries.end()) {
-        return ERR_INVALID_ACCESS;
+        return Glue::ResultAlreadyBound;
    }

    entries.insert_or_assign(title_id, MapEntry{launch, std::move(control)});
@ -58,12 +58,12 @@ Result ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,

 Result ARPManager::Unregister(u64 title_id) {
    if (title_id == 0) {
-        return ERR_INVALID_PROCESS_ID;
+        return Glue::ResultInvalidProcessId;
    }

    const auto iter = entries.find(title_id);
    if (iter == entries.end()) {
-        return ERR_NOT_REGISTERED;
+        return Glue::ResultProcessIdNotRegistered;
    }

    entries.erase(iter);
--- a/src/core/hle/service/glue/glue_manager.h
+++ b/src/core/hle/service/glue/glue_manager.h
@ -30,23 +30,23 @@ public:
    ~ARPManager();

    // Returns the ApplicationLaunchProperty corresponding to the provided title ID if it was
-    // previously registered, otherwise ERR_NOT_REGISTERED if it was never registered or
-    // ERR_INVALID_PROCESS_ID if the title ID is 0.
+    // previously registered, otherwise ResultProcessIdNotRegistered if it was never registered or
+    // ResultInvalidProcessId if the title ID is 0.
    ResultVal<ApplicationLaunchProperty> GetLaunchProperty(u64 title_id) const;

    // Returns a vector of the raw bytes of NACP data (necessarily 0x4000 in size) corresponding to
-    // the provided title ID if it was previously registered, otherwise ERR_NOT_REGISTERED if it was
-    // never registered or ERR_INVALID_PROCESS_ID if the title ID is 0.
+    // the provided title ID if it was previously registered, otherwise ResultProcessIdNotRegistered
+    // if it was never registered or ResultInvalidProcessId if the title ID is 0.
    ResultVal<std::vector<u8>> GetControlProperty(u64 title_id) const;

    // Adds a new entry to the internal database with the provided parameters, returning
-    // ERR_INVALID_ACCESS if attempting to re-register a title ID without an intermediate Unregister
-    // step, and ERR_INVALID_PROCESS_ID if the title ID is 0.
+    // ResultProcessIdNotRegistered if attempting to re-register a title ID without an intermediate
+    // Unregister step, and ResultInvalidProcessId if the title ID is 0.
    Result Register(u64 title_id, ApplicationLaunchProperty launch, std::vector<u8> control);

    // Removes the registration for the provided title ID from the database, returning
-    // ERR_NOT_REGISTERED if it doesn't exist in the database and ERR_INVALID_PROCESS_ID if the
-    // title ID is 0.
+    // ResultProcessIdNotRegistered if it doesn't exist in the database and ResultInvalidProcessId
+    // if the title ID is 0.
    Result Unregister(u64 title_id);

    // Removes all entries from the database, always succeeds. Should only be used when resetting
--- a/src/core/hle/service/ipc_helpers.h
+++ b/src/core/hle/service/ipc_helpers.h
@ -19,7 +19,7 @@

 namespace IPC {

-constexpr Result ERR_REMOTE_PROCESS_DEAD{ErrorModule::HIPC, 301};
+constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};

 class RequestHelperBase {
 protected:
--- a/src/core/hle/service/ns/errors.h
+++ b/src/core/hle/service/ns/errors.h
@ -7,5 +7,6 @@

 namespace Service::NS {

-constexpr Result ERR_APPLICATION_LANGUAGE_NOT_FOUND{ErrorModule::NS, 300};
+constexpr Result ResultApplicationLanguageNotFound{ErrorModule::NS, 300};
+
 }
--- a/src/core/hle/service/ns/ns.cpp
+++ b/src/core/hle/service/ns/ns.cpp
@ -416,14 +416,14 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
    if (application_language == std::nullopt) {
        LOG_ERROR(Service_NS, "Could not convert application language! language_code={}",
                  language_code);
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+        return Service::NS::ResultApplicationLanguageNotFound;
    }
    const auto priority_list = GetApplicationLanguagePriorityList(*application_language);
    if (!priority_list) {
        LOG_ERROR(Service_NS,
                  "Could not find application language priorities! application_language={}",
                  *application_language);
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+        return Service::NS::ResultApplicationLanguageNotFound;
    }

    // Try to find a valid language.
@ -436,7 +436,7 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(

    LOG_ERROR(Service_NS, "Could not find a valid language! supported_languages={:08X}",
              supported_languages);
-    return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+    return Service::NS::ResultApplicationLanguageNotFound;
 }

 void IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
@ -461,7 +461,7 @@ ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguag
        ConvertToLanguageCode(static_cast<ApplicationLanguage>(application_language));
    if (language_code == std::nullopt) {
        LOG_ERROR(Service_NS, "Language not found! application_language={}", application_language);
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+        return Service::NS::ResultApplicationLanguageNotFound;
    }

    return static_cast<u64>(*language_code);
--- a/src/core/hle/service/server_manager.cpp
+++ b/src/core/hle/service/server_manager.cpp
@ -404,7 +404,7 @@ Result ServerManager::CompleteSyncRequest(RequestState&& request) {
    rc = request.session->SendReplyHLE();

    // If the session has been closed, we're done.
-    if (rc == Kernel::ResultSessionClosed || service_rc == IPC::ERR_REMOTE_PROCESS_DEAD) {
+    if (rc == Kernel::ResultSessionClosed || service_rc == IPC::ResultSessionClosed) {
        // Close the session.
        request.session->Close();

--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@ -176,7 +176,7 @@ Result ServiceFrameworkBase::HandleSyncRequest(Kernel::KServerSession& session,
    case IPC::CommandType::TIPC_Close: {
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ResultSuccess);
-        result = IPC::ERR_REMOTE_PROCESS_DEAD;
+        result = IPC::ResultSessionClosed;
        break;
    }
    case IPC::CommandType::ControlWithContext:
--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@ -74,7 +74,7 @@ constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 18> language_to_la
 constexpr std::size_t PRE_4_0_0_MAX_ENTRIES = 0xF;
 constexpr std::size_t POST_4_0_0_MAX_ENTRIES = 0x40;

-constexpr Result ERR_INVALID_LANGUAGE{ErrorModule::Settings, 625};
+constexpr Result ResultInvalidLanguage{ErrorModule::Settings, 625};

 void PushResponseLanguageCode(HLERequestContext& ctx, std::size_t num_language_codes) {
    IPC::ResponseBuilder rb{ctx, 3};
@ -130,7 +130,7 @@ void SET::MakeLanguageCode(HLERequestContext& ctx) {
    if (index >= available_language_codes.size()) {
        LOG_ERROR(Service_SET, "Invalid language code index! index={}", index);
        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_INVALID_LANGUAGE);
+        rb.Push(Set::ResultInvalidLanguage);
        return;
    }

--- a/src/core/hle/service/sm/sm.cpp
+++ b/src/core/hle/service/sm/sm.cpp
@ -18,10 +18,10 @@

 namespace Service::SM {

-constexpr Result ERR_NOT_INITIALIZED(ErrorModule::SM, 2);
-constexpr Result ERR_ALREADY_REGISTERED(ErrorModule::SM, 4);
-constexpr Result ERR_INVALID_NAME(ErrorModule::SM, 6);
-constexpr Result ERR_SERVICE_NOT_REGISTERED(ErrorModule::SM, 7);
+constexpr Result ResultInvalidClient(ErrorModule::SM, 2);
+constexpr Result ResultAlreadyRegistered(ErrorModule::SM, 4);
+constexpr Result ResultInvalidServiceName(ErrorModule::SM, 6);
+constexpr Result ResultNotRegistered(ErrorModule::SM, 7);

 ServiceManager::ServiceManager(Kernel::KernelCore& kernel_) : kernel{kernel_} {
    controller_interface = std::make_unique<Controller>(kernel.System());
@ -45,7 +45,7 @@ void ServiceManager::InvokeControlRequest(HLERequestContext& context) {
 static Result ValidateServiceName(const std::string& name) {
    if (name.empty() || name.size() > 8) {
        LOG_ERROR(Service_SM, "Invalid service name! service={}", name);
-        return ERR_INVALID_NAME;
+        return Service::SM::ResultInvalidServiceName;
    }
    return ResultSuccess;
 }
@ -58,7 +58,7 @@ Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
    std::scoped_lock lk{lock};
    if (registered_services.find(name) != registered_services.end()) {
        LOG_ERROR(Service_SM, "Service is already registered! service={}", name);
-        return ERR_ALREADY_REGISTERED;
+        return Service::SM::ResultAlreadyRegistered;
    }

    auto* port = Kernel::KPort::Create(kernel);
@ -80,7 +80,7 @@ Result ServiceManager::UnregisterService(const std::string& name) {
    const auto iter = registered_services.find(name);
    if (iter == registered_services.end()) {
        LOG_ERROR(Service_SM, "Server is not registered! service={}", name);
-        return ERR_SERVICE_NOT_REGISTERED;
+        return Service::SM::ResultNotRegistered;
    }

    registered_services.erase(iter);
@ -96,7 +96,7 @@ ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name
    auto it = service_ports.find(name);
    if (it == service_ports.end()) {
        LOG_WARNING(Service_SM, "Server is not registered! service={}", name);
-        return ERR_SERVICE_NOT_REGISTERED;
+        return Service::SM::ResultNotRegistered;
    }

    return it->second;
@ -160,7 +160,7 @@ static std::string PopServiceName(IPC::RequestParser& rp) {

 ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
    if (!ctx.GetManager()->GetIsInitializedForSm()) {
-        return ERR_NOT_INITIALIZED;
+        return Service::SM::ResultInvalidClient;
    }

    IPC::RequestParser rp{ctx};
@ -168,15 +168,15 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {

    // Find the named port.
    auto port_result = service_manager.GetServicePort(name);
-    if (port_result.Code() == ERR_INVALID_NAME) {
+    if (port_result.Code() == Service::SM::ResultInvalidServiceName) {
        LOG_ERROR(Service_SM, "Invalid service name '{}'", name);
-        return ERR_INVALID_NAME;
+        return Service::SM::ResultInvalidServiceName;
    }

    if (port_result.Failed()) {
        LOG_INFO(Service_SM, "Waiting for service {} to become available", name);
        ctx.SetIsDeferred();
-        return ERR_SERVICE_NOT_REGISTERED;
+        return Service::SM::ResultNotRegistered;
    }
    auto& port = port_result.Unwrap();