General: Fix compilation for GCC

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

@@ -13,7 +13,8 @@
 using Core::Memory::YUZU_PAGESIZE;
 
 namespace Service::Nvidia::NvCore {
-NvMap::Handle::Handle(u64 size, Id id) : size(size), aligned_size(size), orig_size(size), id(id) {
+NvMap::Handle::Handle(u64 size_, Id id_)
+    : size(size_), aligned_size(size), orig_size(size), id(id_) {
     flags.raw = 0;
 }
 
@@ -21,19 +22,21 @@ NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress)
     std::scoped_lock lock(mutex);
 
     // Handles cannot be allocated twice
-    if (allocated)
+    if (allocated) {
         return NvResult::AccessDenied;
+    }
 
     flags = pFlags;
     kind = pKind;
     align = pAlign < YUZU_PAGESIZE ? YUZU_PAGESIZE : pAlign;
 
     // This flag is only applicable for handles with an address passed
-    if (pAddress)
-        flags.keep_uncached_after_free = 0;
-    else
+    if (pAddress) {
+        flags.keep_uncached_after_free.Assign(0);
+    } else {
         LOG_CRITICAL(Service_NVDRV,
                      "Mapping nvmap handles without a CPU side address is unimplemented!");
+    }
 
     size = Common::AlignUp(size, YUZU_PAGESIZE);
     aligned_size = Common::AlignUp(size, align);
@@ -48,17 +51,19 @@ NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress)
 
 NvResult NvMap::Handle::Duplicate(bool internal_session) {
     // Unallocated handles cannot be duplicated as duplication requires memory accounting (in HOS)
-    if (!allocated) [[unlikely]]
+    if (!allocated) [[unlikely]] {
         return NvResult::BadValue;
+    }
 
     std::scoped_lock lock(mutex);
 
     // If we internally use FromId the duplication tracking of handles won't work accurately due to
     // us not implementing per-process handle refs.
-    if (internal_session)
+    if (internal_session) {
         internal_dupes++;
-    else
+    } else {
         dupes++;
+    }
 
     return NvResult::Success;
 }
@@ -92,8 +97,9 @@ bool NvMap::TryRemoveHandle(const Handle& handle_description) {
         std::scoped_lock lock(handles_lock);
 
         auto it{handles.find(handle_description.id)};
-        if (it != handles.end())
+        if (it != handles.end()) {
             handles.erase(it);
+        }
 
         return true;
     } else {
@@ -102,8 +108,9 @@ bool NvMap::TryRemoveHandle(const Handle& handle_description) {
 }
 
 NvResult NvMap::CreateHandle(u64 size, std::shared_ptr<NvMap::Handle>& result_out) {
-    if (!size) [[unlikely]]
+    if (!size) [[unlikely]] {
         return NvResult::BadValue;
+    }
 
     u32 id{next_handle_id.fetch_add(HandleIdIncrement, std::memory_order_relaxed)};
     auto handle_description{std::make_shared<Handle>(size, id)};
@@ -133,8 +140,9 @@ VAddr NvMap::GetHandleAddress(Handle::Id handle) {
 
 u32 NvMap::PinHandle(NvMap::Handle::Id handle) {
     auto handle_description{GetHandle(handle)};
-    if (!handle_description) [[unlikely]]
+    if (!handle_description) [[unlikely]] {
         return 0;
+    }
 
     std::scoped_lock lock(handle_description->mutex);
     if (!handle_description->pins) {
@@ -183,8 +191,9 @@ u32 NvMap::PinHandle(NvMap::Handle::Id handle) {
 
 void NvMap::UnpinHandle(Handle::Id handle) {
     auto handle_description{GetHandle(handle)};
-    if (!handle_description)
+    if (!handle_description) {
         return;
+    }
 
     std::scoped_lock lock(handle_description->mutex);
     if (--handle_description->pins < 0) {
@@ -226,12 +235,13 @@ std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool interna
 
         // Try to remove the shared ptr to the handle from the map, if nothing else is using the
         // handle then it will now be freed when `handle_description` goes out of scope
-        if (TryRemoveHandle(*handle_description))
+        if (TryRemoveHandle(*handle_description)) {
             LOG_DEBUG(Service_NVDRV, "Removed nvmap handle: {}", handle);
-        else
+        } else {
             LOG_DEBUG(Service_NVDRV,
                       "Tried to free nvmap handle: {} but didn't as it still has duplicates",
                       handle);
+        }
 
         freeInfo = {
             .address = handle_description->address,

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

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include <atomic>
 #include <list>
 #include <memory>
 #include <mutex>

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

@@ -188,6 +188,7 @@ NvResult nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<
 
     allocation_map[params.offset] = {
         .size = size,
+        .mappings{},
         .page_size = params.page_size,
         .sparse = (params.flags & MappingFlags::Sparse) != MappingFlags::None,
         .big_pages = params.page_size != VM::YUZU_PAGESIZE,
@@ -474,11 +475,13 @@ void nvhost_as_gpu::GetVARegionsImpl(IoctlGetVaRegions& params) {
         VaRegion{
             .offset = vm.small_page_allocator->vaStart << VM::PAGE_SIZE_BITS,
             .page_size = VM::YUZU_PAGESIZE,
+            ._pad0_{},
             .pages = vm.small_page_allocator->vaLimit - vm.small_page_allocator->vaStart,
         },
         VaRegion{
             .offset = vm.big_page_allocator->vaStart << vm.big_page_size_bits,
             .page_size = vm.big_page_size,
+            ._pad0_{},
             .pages = vm.big_page_allocator->vaLimit - vm.big_page_allocator->vaStart,
         },
     };

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

@@ -204,12 +204,12 @@ NvResult nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector
 
     event.wait_handle =
         host1x_syncpoint_manager.RegisterHostAction(fence_id, target_value, [this, slot]() {
-            auto& event = events[slot];
-            if (event.status.exchange(EventState::Signalling, std::memory_order_acq_rel) ==
+            auto& event_ = events[slot];
+            if (event_.status.exchange(EventState::Signalling, std::memory_order_acq_rel) ==
                 EventState::Waiting) {
-                event.kevent->GetWritableEvent().Signal();
+                event_.kevent->GetWritableEvent().Signal();
             }
-            event.status.store(EventState::Signalled, std::memory_order_release);
+            event_.status.store(EventState::Signalled, std::memory_order_release);
         });
     return NvResult::Timeout;
 }

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

@@ -12,8 +12,8 @@ namespace Service::Nvidia::Devices {
 
 u32 nvhost_nvdec::next_id{};
 
-nvhost_nvdec::nvhost_nvdec(Core::System& system_, NvCore::Container& core)
-    : nvhost_nvdec_common{system_, core, NvCore::ChannelType::NvDec} {}
+nvhost_nvdec::nvhost_nvdec(Core::System& system_, NvCore::Container& core_)
+    : nvhost_nvdec_common{system_, core_, NvCore::ChannelType::NvDec} {}
 nvhost_nvdec::~nvhost_nvdec() = default;
 
 NvResult nvhost_nvdec::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,

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

@@ -11,8 +11,8 @@ namespace Service::Nvidia::Devices {
 
 u32 nvhost_vic::next_id{};
 
-nvhost_vic::nvhost_vic(Core::System& system_, NvCore::Container& core)
-    : nvhost_nvdec_common{system_, core, NvCore::ChannelType::VIC} {}
+nvhost_vic::nvhost_vic(Core::System& system_, NvCore::Container& core_)
+    : nvhost_nvdec_common{system_, core_, NvCore::ChannelType::VIC} {}
 
 nvhost_vic::~nvhost_vic() = default;
 

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

@@ -269,7 +269,7 @@ NvResult nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
         params.address = freeInfo->address;
         params.size = static_cast<u32>(freeInfo->size);
         params.flags.raw = 0;
-        params.flags.map_uncached = freeInfo->was_uncached;
+        params.flags.map_uncached.Assign(freeInfo->was_uncached);
     } else {
         // This is possible when there's internel dups or other duplicates.
     }

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

@@ -6,6 +6,7 @@
 #pragma once
 
 #include <functional>
+#include <list>
 #include <memory>
 #include <string>
 #include <unordered_map>

src/core/hle/service/vi/vi.cpp

@@ -58,6 +58,7 @@ static_assert(sizeof(DisplayInfo) == 0x60, "DisplayInfo has wrong size");
 class NativeWindow final {
 public:
     constexpr explicit NativeWindow(u32 id_) : id{id_} {}
+    constexpr explicit NativeWindow(const NativeWindow& other) = default;
 
 private:
     const u32 magic = 2;