Removed unused file.

This is a leftover from #1792

src/core/hle/kernel/svc.cpp

@@ -682,110 +682,37 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         ThreadTickCount = 0xF0000002,
     };
 
-    const auto info_id_type = static_cast<GetInfoType>(info_id);
+    const auto* current_process = Core::CurrentProcess();
+    const auto& vm_manager = current_process->VMManager();
 
-    switch (info_id_type) {
+    switch (static_cast<GetInfoType>(info_id)) {
     case GetInfoType::AllowedCpuIdBitmask:
+        *result = current_process->GetAllowedProcessorMask();
+        break;
     case GetInfoType::AllowedThreadPrioBitmask:
+        *result = current_process->GetAllowedThreadPriorityMask();
+        break;
     case GetInfoType::MapRegionBaseAddr:
+        *result = vm_manager.GetMapRegionBaseAddress();
+        break;
     case GetInfoType::MapRegionSize:
+        *result = vm_manager.GetMapRegionSize();
+        break;
     case GetInfoType::HeapRegionBaseAddr:
+        *result = vm_manager.GetHeapRegionBaseAddress();
+        break;
     case GetInfoType::HeapRegionSize:
-    case GetInfoType::ASLRRegionBaseAddr:
-    case GetInfoType::ASLRRegionSize:
-    case GetInfoType::NewMapRegionBaseAddr:
-    case GetInfoType::NewMapRegionSize:
+        *result = vm_manager.GetHeapRegionSize();
+        break;
     case GetInfoType::TotalMemoryUsage:
+        *result = vm_manager.GetTotalMemoryUsage();
+        break;
     case GetInfoType::TotalHeapUsage:
-    case GetInfoType::IsVirtualAddressMemoryEnabled:
-    case GetInfoType::PersonalMmHeapUsage:
-    case GetInfoType::TitleId:
-    case GetInfoType::UserExceptionContextAddr: {
-        if (info_sub_id != 0) {
-            return ERR_INVALID_ENUM_VALUE;
-        }
-
-        const auto& current_process_handle_table = Core::CurrentProcess()->GetHandleTable();
-        const auto process = current_process_handle_table.Get<Process>(static_cast<Handle>(handle));
-        if (!process) {
-            return ERR_INVALID_HANDLE;
-        }
-
-        switch (info_id_type) {
-        case GetInfoType::AllowedCpuIdBitmask:
-            *result = process->GetAllowedProcessorMask();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::AllowedThreadPrioBitmask:
-            *result = process->GetAllowedThreadPriorityMask();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::MapRegionBaseAddr:
-            *result = process->VMManager().GetMapRegionBaseAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::MapRegionSize:
-            *result = process->VMManager().GetMapRegionSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::HeapRegionBaseAddr:
-            *result = process->VMManager().GetHeapRegionBaseAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::HeapRegionSize:
-            *result = process->VMManager().GetHeapRegionSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::ASLRRegionBaseAddr:
-            *result = process->VMManager().GetASLRRegionBaseAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::ASLRRegionSize:
-            *result = process->VMManager().GetASLRRegionSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::NewMapRegionBaseAddr:
-            *result = process->VMManager().GetNewMapRegionBaseAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::NewMapRegionSize:
-            *result = process->VMManager().GetNewMapRegionSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TotalMemoryUsage:
-            *result = process->VMManager().GetTotalMemoryUsage();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TotalHeapUsage:
-            *result = process->VMManager().GetTotalHeapUsage();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::IsVirtualAddressMemoryEnabled:
-            *result = process->IsVirtualMemoryEnabled();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TitleId:
-            *result = process->GetTitleID();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::UserExceptionContextAddr:
-            LOG_WARNING(Kernel_SVC,
-                        "(STUBBED) Attempted to query user exception context address, returned 0");
-            *result = 0;
-            return RESULT_SUCCESS;
-
-        default:
-            break;
-        }
-
-        LOG_WARNING(Kernel_SVC, "(STUBBED) Unimplemented svcGetInfo id=0x{:016X}", info_id);
-        return ERR_INVALID_ENUM_VALUE;
-    }
-
+        *result = vm_manager.GetTotalHeapUsage();
+        break;
     case GetInfoType::IsCurrentProcessBeingDebugged:
         *result = 0;
-        return RESULT_SUCCESS;
-
+        break;
     case GetInfoType::RandomEntropy:
         if (handle != 0) {
             LOG_ERROR(Kernel_SVC, "Process Handle is non zero, expected 0 result but got {:016X}",
@@ -799,15 +726,37 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
             return ERR_INVALID_COMBINATION;
         }
 
-        *result = Core::CurrentProcess()->GetRandomEntropy(info_sub_id);
+        *result = current_process->GetRandomEntropy(info_sub_id);
         return RESULT_SUCCESS;
-
+        break;
+    case GetInfoType::ASLRRegionBaseAddr:
+        *result = vm_manager.GetASLRRegionBaseAddress();
+        break;
+    case GetInfoType::ASLRRegionSize:
+        *result = vm_manager.GetASLRRegionSize();
+        break;
+    case GetInfoType::NewMapRegionBaseAddr:
+        *result = vm_manager.GetNewMapRegionBaseAddress();
+        break;
+    case GetInfoType::NewMapRegionSize:
+        *result = vm_manager.GetNewMapRegionSize();
+        break;
+    case GetInfoType::IsVirtualAddressMemoryEnabled:
+        *result = current_process->IsVirtualMemoryEnabled();
+        break;
+    case GetInfoType::TitleId:
+        *result = current_process->GetTitleID();
+        break;
     case GetInfoType::PrivilegedProcessId:
         LOG_WARNING(Kernel_SVC,
                     "(STUBBED) Attempted to query privileged process id bounds, returned 0");
         *result = 0;
-        return RESULT_SUCCESS;
-
+        break;
+    case GetInfoType::UserExceptionContextAddr:
+        LOG_WARNING(Kernel_SVC,
+                    "(STUBBED) Attempted to query user exception context address, returned 0");
+        *result = 0;
+        break;
     case GetInfoType::ThreadTickCount: {
         constexpr u64 num_cpus = 4;
         if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
@@ -817,7 +766,7 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         }
 
         const auto thread =
-            Core::CurrentProcess()->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
+            current_process->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
         if (!thread) {
             LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
                       static_cast<Handle>(handle));
@@ -840,13 +789,14 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         }
 
         *result = out_ticks;
-        return RESULT_SUCCESS;
+        break;
     }
-
     default:
         LOG_WARNING(Kernel_SVC, "(STUBBED) Unimplemented svcGetInfo id=0x{:016X}", info_id);
         return ERR_INVALID_ENUM_VALUE;
     }
+
+    return RESULT_SUCCESS;
 }
 
 /// Sets the thread activity

src/video_core/command_processor.cpp

@@ -1,142 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <array>
-#include <cstddef>
-#include <memory>
-#include <utility>
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/microprofile.h"
-#include "common/vector_math.h"
-#include "core/memory.h"
-#include "core/tracer/recorder.h"
-#include "video_core/command_processor.h"
-#include "video_core/engines/fermi_2d.h"
-#include "video_core/engines/kepler_memory.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/engines/maxwell_compute.h"
-#include "video_core/engines/maxwell_dma.h"
-#include "video_core/gpu.h"
-#include "video_core/renderer_base.h"
-#include "video_core/video_core.h"
-
-namespace Tegra {
-
-enum class BufferMethods {
-    BindObject = 0,
-    CountBufferMethods = 0x40,
-};
-
-MICROPROFILE_DEFINE(ProcessCommandLists, "GPU", "Execute command buffer", MP_RGB(128, 128, 192));
-
-void GPU::ProcessCommandLists(const std::vector<CommandListHeader>& commands) {
-    MICROPROFILE_SCOPE(ProcessCommandLists);
-
-    // On entering GPU code, assume all memory may be touched by the ARM core.
-    maxwell_3d->dirty_flags.OnMemoryWrite();
-
-    auto WriteReg = [this](u32 method, u32 subchannel, u32 value, u32 remaining_params) {
-        LOG_TRACE(HW_GPU,
-                  "Processing method {:08X} on subchannel {} value "
-                  "{:08X} remaining params {}",
-                  method, subchannel, value, remaining_params);
-
-        ASSERT(subchannel < bound_engines.size());
-
-        if (method == static_cast<u32>(BufferMethods::BindObject)) {
-            // Bind the current subchannel to the desired engine id.
-            LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", subchannel, value);
-            bound_engines[subchannel] = static_cast<EngineID>(value);
-            return;
-        }
-
-        if (method < static_cast<u32>(BufferMethods::CountBufferMethods)) {
-            // TODO(Subv): Research and implement these methods.
-            LOG_ERROR(HW_GPU, "Special buffer methods other than Bind are not implemented");
-            return;
-        }
-
-        const EngineID engine = bound_engines[subchannel];
-
-        switch (engine) {
-        case EngineID::FERMI_TWOD_A:
-            fermi_2d->WriteReg(method, value);
-            break;
-        case EngineID::MAXWELL_B:
-            maxwell_3d->WriteReg(method, value, remaining_params);
-            break;
-        case EngineID::MAXWELL_COMPUTE_B:
-            maxwell_compute->WriteReg(method, value);
-            break;
-        case EngineID::MAXWELL_DMA_COPY_A:
-            maxwell_dma->WriteReg(method, value);
-            break;
-        case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-            kepler_memory->WriteReg(method, value);
-            break;
-        default:
-            UNIMPLEMENTED_MSG("Unimplemented engine");
-        }
-    };
-
-    for (auto entry : commands) {
-        Tegra::GPUVAddr address = entry.Address();
-        u32 size = entry.sz;
-        const std::optional<VAddr> head_address = memory_manager->GpuToCpuAddress(address);
-        VAddr current_addr = *head_address;
-        while (current_addr < *head_address + size * sizeof(CommandHeader)) {
-            const CommandHeader header = {Memory::Read32(current_addr)};
-            current_addr += sizeof(u32);
-
-            switch (header.mode.Value()) {
-            case SubmissionMode::IncreasingOld:
-            case SubmissionMode::Increasing: {
-                // Increase the method value with each argument.
-                for (unsigned i = 0; i < header.arg_count; ++i) {
-                    WriteReg(header.method + i, header.subchannel, Memory::Read32(current_addr),
-                             header.arg_count - i - 1);
-                    current_addr += sizeof(u32);
-                }
-                break;
-            }
-            case SubmissionMode::NonIncreasingOld:
-            case SubmissionMode::NonIncreasing: {
-                // Use the same method value for all arguments.
-                for (unsigned i = 0; i < header.arg_count; ++i) {
-                    WriteReg(header.method, header.subchannel, Memory::Read32(current_addr),
-                             header.arg_count - i - 1);
-                    current_addr += sizeof(u32);
-                }
-                break;
-            }
-            case SubmissionMode::IncreaseOnce: {
-                ASSERT(header.arg_count.Value() >= 1);
-
-                // Use the original method for the first argument and then the next method for all
-                // other arguments.
-                WriteReg(header.method, header.subchannel, Memory::Read32(current_addr),
-                         header.arg_count - 1);
-                current_addr += sizeof(u32);
-
-                for (unsigned i = 1; i < header.arg_count; ++i) {
-                    WriteReg(header.method + 1, header.subchannel, Memory::Read32(current_addr),
-                             header.arg_count - i - 1);
-                    current_addr += sizeof(u32);
-                }
-                break;
-            }
-            case SubmissionMode::Inline: {
-                // The register value is stored in the bits 16-28 as an immediate
-                WriteReg(header.method, header.subchannel, header.inline_data, 0);
-                break;
-            }
-            default:
-                UNIMPLEMENTED();
-            }
-        }
-    }
-}
-
-} // namespace Tegra

src/video_core/gpu.cpp

@@ -141,6 +141,12 @@ void GPU::CallMethod(const MethodCall& method_call) {
         return;
     }
 
+    if (method_call.method < static_cast<u32>(BufferMethods::CountBufferMethods)) {
+        // TODO(Subv): Research and implement these methods.
+        LOG_ERROR(HW_GPU, "Special buffer methods other than Bind are not implemented");
+        return;
+    }
+
     const EngineID engine = bound_engines[method_call.subchannel];
 
     switch (engine) {