Define SampleMask as an array

src/core/core.cpp

@@ -293,7 +293,6 @@ struct System::Impl {
         ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
                                             Kernel::KProcess::ProcessType::Userland, resource_limit)
                    .IsSuccess());
-        Kernel::KProcess::Register(system.Kernel(), main_process);
         kernel.MakeApplicationProcess(main_process);
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {

src/core/hle/kernel/k_auto_object.h

@@ -182,8 +182,8 @@ public:
     explicit KAutoObjectWithList(KernelCore& kernel) : KAutoObject(kernel) {}
 
     static int Compare(const KAutoObjectWithList& lhs, const KAutoObjectWithList& rhs) {
-        const uintptr_t lid = reinterpret_cast<uintptr_t>(std::addressof(lhs));
-        const uintptr_t rid = reinterpret_cast<uintptr_t>(std::addressof(rhs));
+        const u64 lid = lhs.GetId();
+        const u64 rid = rhs.GetId();
 
         if (lid < rid) {
             return -1;

src/core/hle/kernel/kernel.cpp

@@ -95,7 +95,7 @@ struct KernelCore::Impl {
                                        pt_heap_region.GetSize());
         }
 
-        InitializeHackSharedMemory(kernel);
+        InitializeHackSharedMemory();
         RegisterHostThread(nullptr);
     }
 
@@ -216,12 +216,10 @@ struct KernelCore::Impl {
             auto* main_thread{Kernel::KThread::Create(system.Kernel())};
             main_thread->SetCurrentCore(core);
             ASSERT(Kernel::KThread::InitializeMainThread(system, main_thread, core).IsSuccess());
-            KThread::Register(system.Kernel(), main_thread);
 
             auto* idle_thread{Kernel::KThread::Create(system.Kernel())};
             idle_thread->SetCurrentCore(core);
             ASSERT(Kernel::KThread::InitializeIdleThread(system, idle_thread, core).IsSuccess());
-            KThread::Register(system.Kernel(), idle_thread);
 
             schedulers[i]->Initialize(main_thread, idle_thread, core);
         }
@@ -232,7 +230,6 @@ struct KernelCore::Impl {
                                        const Core::Timing::CoreTiming& core_timing) {
         system_resource_limit = KResourceLimit::Create(system.Kernel());
         system_resource_limit->Initialize(&core_timing);
-        KResourceLimit::Register(kernel, system_resource_limit);
 
         const auto sizes{memory_layout->GetTotalAndKernelMemorySizes()};
         const auto total_size{sizes.first};
@@ -358,7 +355,6 @@ struct KernelCore::Impl {
             ASSERT(KThread::InitializeHighPriorityThread(system, shutdown_threads[core_id], {}, {},
                                                          core_id)
                        .IsSuccess());
-            KThread::Register(system.Kernel(), shutdown_threads[core_id]);
         }
     }
 
@@ -733,7 +729,7 @@ struct KernelCore::Impl {
         memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize());
     }
 
-    void InitializeHackSharedMemory(KernelCore& kernel) {
+    void InitializeHackSharedMemory() {
         // Setup memory regions for emulated processes
         // TODO(bunnei): These should not be hardcoded regions initialized within the kernel
         constexpr std::size_t hid_size{0x40000};
@@ -750,23 +746,14 @@ struct KernelCore::Impl {
 
         hid_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
                                    Svc::MemoryPermission::Read, hid_size);
-        KSharedMemory::Register(kernel, hid_shared_mem);
-
         font_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
                                     Svc::MemoryPermission::Read, font_size);
-        KSharedMemory::Register(kernel, font_shared_mem);
-
         irs_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
                                    Svc::MemoryPermission::Read, irs_size);
-        KSharedMemory::Register(kernel, irs_shared_mem);
-
         time_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
                                     Svc::MemoryPermission::Read, time_size);
-        KSharedMemory::Register(kernel, time_shared_mem);
-
         hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
                                       Svc::MemoryPermission::Read, hidbus_size);
-        KSharedMemory::Register(kernel, hidbus_shared_mem);
     }
 
     std::mutex registered_objects_lock;
@@ -1085,15 +1072,12 @@ static std::jthread RunHostThreadFunc(KernelCore& kernel, KProcess* process,
     // Commit the thread reservation.
     thread_reservation.Commit();
 
-    // Register the thread.
-    KThread::Register(kernel, thread);
-
     return std::jthread(
         [&kernel, thread, thread_name{std::move(thread_name)}, func{std::move(func)}] {
             // Set the thread name.
             Common::SetCurrentThreadName(thread_name.c_str());
 
-            // Set the thread as current.
+            // Register the thread.
             kernel.RegisterHostThread(thread);
 
             // Run the callback.
@@ -1115,9 +1099,6 @@ std::jthread KernelCore::RunOnHostCoreProcess(std::string&& process_name,
     // Ensure that we don't hold onto any extra references.
     SCOPE_EXIT({ process->Close(); });
 
-    // Register the new process.
-    KProcess::Register(*this, process);
-
     // Run the host thread.
     return RunHostThreadFunc(*this, process, std::move(process_name), std::move(func));
 }
@@ -1143,9 +1124,6 @@ void KernelCore::RunOnGuestCoreProcess(std::string&& process_name, std::function
     // Ensure that we don't hold onto any extra references.
     SCOPE_EXIT({ process->Close(); });
 
-    // Register the new process.
-    KProcess::Register(*this, process);
-
     // Reserve a new thread from the process resource limit.
     KScopedResourceReservation thread_reservation(process, LimitableResource::ThreadCountMax);
     ASSERT(thread_reservation.Succeeded());
@@ -1158,9 +1136,6 @@ void KernelCore::RunOnGuestCoreProcess(std::string&& process_name, std::function
     // Commit the thread reservation.
     thread_reservation.Commit();
 
-    // Register the new thread.
-    KThread::Register(*this, thread);
-
     // Begin running the thread.
     ASSERT(R_SUCCEEDED(thread->Run()));
 }

src/core/hle/service/ipc_helpers.h

@@ -156,7 +156,6 @@ public:
 
             auto* session = Kernel::KSession::Create(kernel);
             session->Initialize(nullptr, 0);
-            Kernel::KSession::Register(kernel, session);
 
             auto next_manager = std::make_shared<Service::SessionRequestManager>(
                 kernel, manager->GetServerManager());

src/core/hle/service/kernel_helpers.cpp

@@ -25,9 +25,6 @@ ServiceContext::ServiceContext(Core::System& system_, std::string name_)
                                         Kernel::KProcess::ProcessType::KernelInternal,
                                         kernel.GetSystemResourceLimit())
                .IsSuccess());
-
-    // Register the process.
-    Kernel::KProcess::Register(kernel, process);
     process_created = true;
 }
 

src/core/hle/service/mutex.cpp

@@ -12,9 +12,6 @@ Mutex::Mutex(Core::System& system) : m_system(system) {
     m_event = Kernel::KEvent::Create(system.Kernel());
     m_event->Initialize(nullptr);
 
-    // Register the event.
-    Kernel::KEvent::Register(system.Kernel(), m_event);
-
     ASSERT(R_SUCCEEDED(m_event->Signal()));
 }
 

src/core/hle/service/server_manager.cpp

@@ -33,9 +33,6 @@ ServerManager::ServerManager(Core::System& system) : m_system{system}, m_serve_m
     // Initialize event.
     m_event = Kernel::KEvent::Create(system.Kernel());
     m_event->Initialize(nullptr);
-
-    // Register event.
-    Kernel::KEvent::Register(system.Kernel(), m_event);
 }
 
 ServerManager::~ServerManager() {
@@ -163,9 +160,6 @@ Result ServerManager::ManageDeferral(Kernel::KEvent** out_event) {
     // Initialize the event.
     m_deferral_event->Initialize(nullptr);
 
-    // Register the event.
-    Kernel::KEvent::Register(m_system.Kernel(), m_deferral_event);
-
     // Set the output.
     *out_event = m_deferral_event;
 

src/core/hle/service/sm/sm.cpp

@@ -64,9 +64,6 @@ Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
     auto* port = Kernel::KPort::Create(kernel);
     port->Initialize(ServerSessionCountMax, false, 0);
 
-    // Register the port.
-    Kernel::KPort::Register(kernel, port);
-
     service_ports.emplace(name, port);
     registered_services.emplace(name, handler);
     if (deferral_event) {

src/core/hle/service/sm/sm_controller.cpp

@@ -49,9 +49,6 @@ void Controller::CloneCurrentObject(HLERequestContext& ctx) {
     // Commit the session reservation.
     session_reservation.Commit();
 
-    // Register the session.
-    Kernel::KSession::Register(system.Kernel(), session);
-
     // Register with server manager.
     session_manager->GetServerManager().RegisterSession(&session->GetServerSession(),
                                                         session_manager);

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -473,7 +473,8 @@ void EmitSetFragColor(EmitContext& ctx, u32 index, u32 component, Id value) {
 }
 
 void EmitSetSampleMask(EmitContext& ctx, Id value) {
-    ctx.OpStore(ctx.sample_mask, value);
+    const Id pointer{ctx.OpAccessChain(ctx.output_u32, ctx.sample_mask, ctx.u32_zero_value)};
+    ctx.OpStore(pointer, value);
 }
 
 void EmitSetFragDepth(EmitContext& ctx, Id value) {

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -1572,7 +1572,8 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
             Decorate(frag_depth, spv::Decoration::BuiltIn, spv::BuiltIn::FragDepth);
         }
         if (info.stores_sample_mask) {
-            sample_mask = DefineOutput(*this, U32[1], std::nullopt);
+            const Id array_type{TypeArray(U32[1], Const(1U))};
+            sample_mask = DefineOutput(*this, array_type, std::nullopt);
             Decorate(sample_mask, spv::Decoration::BuiltIn, spv::BuiltIn::SampleMask);
         }
         break;