early-access version 1532

README.md

@@ -1,7 +1,7 @@
 yuzu emulator early access
 =============
 
-This is the source code for early-access 1530.
+This is the source code for early-access 1532.
 
 ## Legal Notice
 

src/common/common_sizes.h

@@ -8,6 +8,8 @@
 
 #include "common/common_types.h"
 
+namespace Common {
+
 enum : u64 {
     Size_1_KB = 0x400ULL,
     Size_64_KB = 64ULL * Size_1_KB,
@@ -37,3 +39,5 @@ enum : u64 {
     Size_512_GB = 512ULL * Size_1_GB,
     Size_Invalid = std::numeric_limits<u64>::max(),
 };
+
+} // namespace Common

src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp

@@ -13,13 +13,13 @@ namespace Kernel::Board::Nintendo::Nx {
 
 namespace impl {
 
-constexpr inline const std::size_t RequiredNonSecureSystemMemorySizeVi = 0x2238 * 4 * 1024;
+constexpr const std::size_t RequiredNonSecureSystemMemorySizeVi = 0x2238 * 4 * 1024;
-constexpr inline const std::size_t RequiredNonSecureSystemMemorySizeNvservices = 0x710 * 4 * 1024;
+constexpr const std::size_t RequiredNonSecureSystemMemorySizeNvservices = 0x710 * 4 * 1024;
-constexpr inline const std::size_t RequiredNonSecureSystemMemorySizeMisc = 0x80 * 4 * 1024;
+constexpr const std::size_t RequiredNonSecureSystemMemorySizeMisc = 0x80 * 4 * 1024;
 
 } // namespace impl
 
-constexpr inline const std::size_t RequiredNonSecureSystemMemorySize =
+constexpr const std::size_t RequiredNonSecureSystemMemorySize =
     impl::RequiredNonSecureSystemMemorySizeVi + impl::RequiredNonSecureSystemMemorySizeNvservices +
     impl::RequiredNonSecureSystemMemorySizeMisc;
 
@@ -57,11 +57,11 @@ size_t KSystemControl::Init::GetIntendedMemorySize() {
     switch (GetMemorySizeForInit()) {
     case Smc::MemorySize_4GB:
     default: // All invalid modes should go to 4GB.
-        return Size_4_GB;
+        return Common::Size_4_GB;
     case Smc::MemorySize_6GB:
-        return Size_6_GB;
+        return Common::Size_6_GB;
     case Smc::MemorySize_8GB:
-        return Size_8_GB;
+        return Common::Size_8_GB;
     }
 }
 
@@ -79,17 +79,17 @@ std::size_t KSystemControl::Init::GetApplicationPoolSize() {
         switch (GetMemoryArrangeForInit()) {
         case Smc::MemoryArrangement_4GB:
         default:
-            return Size_3285_MB;
+            return Common::Size_3285_MB;
         case Smc::MemoryArrangement_4GBForAppletDev:
-            return Size_2048_MB;
+            return Common::Size_2048_MB;
         case Smc::MemoryArrangement_4GBForSystemDev:
-            return Size_3285_MB;
+            return Common::Size_3285_MB;
         case Smc::MemoryArrangement_6GB:
-            return Size_4916_MB;
+            return Common::Size_4916_MB;
         case Smc::MemoryArrangement_6GBForAppletDev:
-            return Size_3285_MB;
+            return Common::Size_3285_MB;
         case Smc::MemoryArrangement_8GB:
-            return Size_4916_MB;
+            return Common::Size_4916_MB;
         }
     }();
 
@@ -103,22 +103,22 @@ size_t KSystemControl::Init::GetAppletPoolSize() {
         switch (GetMemoryArrangeForInit()) {
         case Smc::MemoryArrangement_4GB:
         default:
-            return Size_507_MB;
+            return Common::Size_507_MB;
         case Smc::MemoryArrangement_4GBForAppletDev:
-            return Size_1554_MB;
+            return Common::Size_1554_MB;
         case Smc::MemoryArrangement_4GBForSystemDev:
-            return Size_448_MB;
+            return Common::Size_448_MB;
         case Smc::MemoryArrangement_6GB:
-            return Size_562_MB;
+            return Common::Size_562_MB;
         case Smc::MemoryArrangement_6GBForAppletDev:
-            return Size_2193_MB;
+            return Common::Size_2193_MB;
         case Smc::MemoryArrangement_8GB:
-            return Size_2193_MB;
+            return Common::Size_2193_MB;
         }
     }();
 
     // Return (possibly) adjusted size.
-    constexpr size_t ExtraSystemMemoryForAtmosphere = Size_33_MB;
+    constexpr size_t ExtraSystemMemoryForAtmosphere = Common::Size_33_MB;
     return base_pool_size - ExtraSystemMemoryForAtmosphere - KTraceBufferSize;
 }
 

src/core/hle/kernel/k_address_space_info.cpp

@@ -14,24 +14,25 @@ namespace {
 
 // clang-format off
 constexpr std::array<KAddressSpaceInfo, 13> AddressSpaceInfos{{
-   { .bit_width = 32, .address = Size_2_MB   , .size = Size_1_GB   - Size_2_MB  , .type = KAddressSpaceInfo::Type::MapSmall, },
+   { .bit_width = 32, .address = Common::Size_2_MB   , .size = Common::Size_1_GB   - Common::Size_2_MB  , .type = KAddressSpaceInfo::Type::MapSmall, },
-   { .bit_width = 32, .address = Size_1_GB   , .size = Size_4_GB   - Size_1_GB  , .type = KAddressSpaceInfo::Type::MapLarge, },
+   { .bit_width = 32, .address = Common::Size_1_GB   , .size = Common::Size_4_GB   - Common::Size_1_GB  , .type = KAddressSpaceInfo::Type::MapLarge, },
-   { .bit_width = 32, .address = Size_Invalid, .size = Size_1_GB                , .type = KAddressSpaceInfo::Type::Heap,     },
+   { .bit_width = 32, .address = Common::Size_Invalid, .size = Common::Size_1_GB                        , .type = KAddressSpaceInfo::Type::Alias,    },
-   { .bit_width = 32, .address = Size_Invalid, .size = Size_1_GB                , .type = KAddressSpaceInfo::Type::Alias,    },
+   { .bit_width = 32, .address = Common::Size_Invalid, .size = Common::Size_1_GB                        , .type = KAddressSpaceInfo::Type::Heap,     },
-   { .bit_width = 36, .address = Size_128_MB , .size = Size_2_GB   - Size_128_MB, .type = KAddressSpaceInfo::Type::MapSmall, },
+   { .bit_width = 36, .address = Common::Size_128_MB , .size = Common::Size_2_GB   - Common::Size_128_MB, .type = KAddressSpaceInfo::Type::MapSmall, },
-   { .bit_width = 36, .address = Size_2_GB   , .size = Size_64_GB  - Size_2_GB  , .type = KAddressSpaceInfo::Type::MapLarge, },
+   { .bit_width = 36, .address = Common::Size_2_GB   , .size = Common::Size_64_GB  - Common::Size_2_GB  , .type = KAddressSpaceInfo::Type::MapLarge, },
-   { .bit_width = 36, .address = Size_Invalid, .size = Size_6_GB                , .type = KAddressSpaceInfo::Type::Heap,     },
+   { .bit_width = 36, .address = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Heap,     },
-   { .bit_width = 36, .address = Size_Invalid, .size = Size_6_GB                , .type = KAddressSpaceInfo::Type::Alias,    },
+   { .bit_width = 36, .address = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Alias,    },
-   { .bit_width = 39, .address = Size_128_MB , .size = Size_512_GB - Size_128_MB, .type = KAddressSpaceInfo::Type::Map39Bit, },
+   { .bit_width = 39, .address = Common::Size_128_MB , .size = Common::Size_512_GB - Common::Size_128_MB, .type = KAddressSpaceInfo::Type::Map39Bit, },
-   { .bit_width = 39, .address = Size_Invalid, .size = Size_64_GB               , .type = KAddressSpaceInfo::Type::MapSmall  },
+   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_64_GB                       , .type = KAddressSpaceInfo::Type::MapSmall  },
-   { .bit_width = 39, .address = Size_Invalid, .size = Size_6_GB                , .type = KAddressSpaceInfo::Type::Heap,     },
+   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Heap,     },
-   { .bit_width = 39, .address = Size_Invalid, .size = Size_64_GB               , .type = KAddressSpaceInfo::Type::Alias,    },
+   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_64_GB                       , .type = KAddressSpaceInfo::Type::Alias,    },
-   { .bit_width = 39, .address = Size_Invalid, .size = Size_2_GB                , .type = KAddressSpaceInfo::Type::Stack,    },
+   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_2_GB                        , .type = KAddressSpaceInfo::Type::Stack,    },
 }};
 // clang-format on
 
 constexpr bool IsAllowedIndexForAddress(std::size_t index) {
-    return index < AddressSpaceInfos.size() && AddressSpaceInfos[index].address != Size_Invalid;
+    return index < AddressSpaceInfos.size() &&
+           AddressSpaceInfos[index].address != Common::Size_Invalid;
 }
 
 using IndexArray =

src/core/hle/kernel/k_memory_layout.h

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include <utility>
+
 #include "common/alignment.h"
 #include "common/common_sizes.h"
 #include "common/common_types.h"
@@ -14,20 +16,20 @@
 
 namespace Kernel {
 
-constexpr std::size_t L1BlockSize = Size_1_GB;
+constexpr std::size_t L1BlockSize = Common::Size_1_GB;
-constexpr std::size_t L2BlockSize = Size_2_MB;
+constexpr std::size_t L2BlockSize = Common::Size_2_MB;
 
 constexpr std::size_t GetMaximumOverheadSize(std::size_t size) {
     return (Common::DivideUp(size, L1BlockSize) + Common::DivideUp(size, L2BlockSize)) * PageSize;
 }
 
-constexpr std::size_t MainMemorySize = Size_4_GB;
+constexpr std::size_t MainMemorySize = Common::Size_4_GB;
-constexpr std::size_t MainMemorySizeMax = Size_8_GB;
+constexpr std::size_t MainMemorySizeMax = Common::Size_8_GB;
 
 constexpr std::size_t ReservedEarlyDramSize = 0x60000;
 constexpr std::size_t DramPhysicalAddress = 0x80000000;
 
-constexpr std::size_t KernelAslrAlignment = Size_2_MB;
+constexpr std::size_t KernelAslrAlignment = Common::Size_2_MB;
 constexpr std::size_t KernelVirtualAddressSpaceWidth = 1ULL << 39;
 constexpr std::size_t KernelPhysicalAddressSpaceWidth = 1ULL << 48;
 
@@ -51,10 +53,10 @@ constexpr std::size_t KernelPhysicalAddressSpaceSize =
 constexpr std::size_t KernelPhysicalAddressCodeBase = DramPhysicalAddress + ReservedEarlyDramSize;
 
 constexpr std::size_t KernelPageTableHeapSize = GetMaximumOverheadSize(MainMemorySizeMax);
-constexpr std::size_t KernelInitialPageHeapSize = Size_128_KB;
+constexpr std::size_t KernelInitialPageHeapSize = Common::Size_128_KB;
 
-constexpr std::size_t KernelSlabHeapDataSize = Size_5_MB;
+constexpr std::size_t KernelSlabHeapDataSize = Common::Size_5_MB;
-constexpr std::size_t KernelSlabHeapGapsSize = Size_2_MB - Size_64_KB;
+constexpr std::size_t KernelSlabHeapGapsSize = Common::Size_2_MB - Common::Size_64_KB;
 constexpr std::size_t KernelSlabHeapSize = KernelSlabHeapDataSize + KernelSlabHeapGapsSize;
 
 // NOTE: This is calculated from KThread slab counts, assuming KThread size <= 0x860.
@@ -208,7 +210,7 @@ public:
                               static_cast<KMemoryRegionType>(KMemoryRegionAttr_LinearMapped));
     }
 
-    std::tuple<size_t, size_t> GetTotalAndKernelMemorySizes() const {
+    std::pair<size_t, size_t> GetTotalAndKernelMemorySizes() const {
         size_t total_size = 0, kernel_size = 0;
         for (const auto& region : GetPhysicalMemoryRegionTree()) {
             if (region.IsDerivedFrom(KMemoryRegionType_Dram)) {
@@ -218,7 +220,7 @@ public:
                 }
             }
         }
-        return std::make_tuple(total_size, kernel_size);
+        return std::make_pair(total_size, kernel_size);
     }
 
     void InitializeLinearMemoryRegionTrees(PAddr aligned_linear_phys_start,

src/core/hle/kernel/k_memory_region.h

@@ -160,7 +160,7 @@ private:
     KMemoryRegionAllocator& memory_region_allocator;
 
 public:
-    KMemoryRegionTree(KMemoryRegionAllocator& memory_region_allocator_);
+    explicit KMemoryRegionTree(KMemoryRegionAllocator& memory_region_allocator_);
 
 public:
     KMemoryRegion* FindModifiable(u64 address) {
@@ -328,14 +328,8 @@ class KMemoryRegionAllocator final : NonCopyable {
 public:
     static constexpr size_t MaxMemoryRegions = 200;
 
-private:
-    std::array<KMemoryRegion, MaxMemoryRegions> region_heap{};
-    size_t num_regions{};
-
-public:
     constexpr KMemoryRegionAllocator() = default;
 
-public:
     template <typename... Args>
     KMemoryRegion* Allocate(Args&&... args) {
         // Ensure we stay within the bounds of our heap.
@@ -347,6 +341,10 @@ public:
 
         return region;
     }
+
+private:
+    std::array<KMemoryRegion, MaxMemoryRegions> region_heap{};
+    size_t num_regions{};
 };
 
 } // namespace Kernel

src/core/hle/kernel/k_memory_region_type.h

@@ -41,20 +41,9 @@ constexpr size_t BitsForDeriveDense(size_t n) {
 }
 
 class KMemoryRegionTypeValue {
-private:
-    using ValueType = typename std::underlying_type<KMemoryRegionType>::type;
-
-private:
-    ValueType m_value{};
-    size_t m_next_bit{};
-    bool m_finalized{};
-    bool m_sparse_only{};
-    bool m_dense_only{};
-
-private:
-    constexpr KMemoryRegionTypeValue(ValueType v) : m_value(v) {}
-
 public:
+    using ValueType = std::underlying_type_t<KMemoryRegionType>;
+
     constexpr KMemoryRegionTypeValue() = default;
 
     constexpr operator KMemoryRegionType() const {
@@ -139,6 +128,16 @@ public:
     constexpr bool IsAncestorOf(ValueType v) const {
         return (m_value | v) == v;
     }
+
+private:
+    constexpr KMemoryRegionTypeValue(ValueType v) : m_value(v) {}
+
+private:
+    ValueType m_value{};
+    size_t m_next_bit{};
+    bool m_finalized{};
+    bool m_sparse_only{};
+    bool m_dense_only{};
 };
 
 } // namespace impl

src/core/hle/kernel/kernel.cpp

@@ -269,9 +269,7 @@ struct KernelCore::Impl {
         return schedulers[thread_id]->GetCurrentThread();
     }
 
-    void InitializeMemoryLayout() {
+    void DeriveInitialMemoryLayout(KMemoryLayout& memory_layout) {
-        KMemoryLayout memory_layout;
-
         // Insert the root region for the virtual memory tree, from which all other regions will
         // derive.
         memory_layout.GetVirtualMemoryRegionTree().InsertDirectly(
@@ -289,8 +287,8 @@ struct KernelCore::Impl {
         const VAddr code_end_virt_addr = KernelVirtualAddressCodeEnd;
 
         // Setup the containing kernel region.
-        constexpr size_t KernelRegionSize = Size_1_GB;
+        constexpr size_t KernelRegionSize = Common::Size_1_GB;
-        constexpr size_t KernelRegionAlign = Size_1_GB;
+        constexpr size_t KernelRegionAlign = Common::Size_1_GB;
         constexpr VAddr kernel_region_start =
             Common::AlignDown(code_start_virt_addr, KernelRegionAlign);
         size_t kernel_region_size = KernelRegionSize;
@@ -337,7 +335,7 @@ struct KernelCore::Impl {
 
         // Decide on the actual size for the misc region.
         constexpr size_t MiscRegionAlign = KernelAslrAlignment;
-        constexpr size_t MiscRegionMinimumSize = Size_32_MB;
+        constexpr size_t MiscRegionMinimumSize = Common::Size_32_MB;
         const size_t misc_region_size = Common::AlignUp(
             std::max(misc_region_needed_size, MiscRegionMinimumSize), MiscRegionAlign);
         ASSERT(misc_region_size > 0);
@@ -350,7 +348,7 @@ struct KernelCore::Impl {
             misc_region_start, misc_region_size, KMemoryRegionType_KernelMisc));
 
         // Setup the stack region.
-        constexpr size_t StackRegionSize = Size_14_MB;
+        constexpr size_t StackRegionSize = Common::Size_14_MB;
         constexpr size_t StackRegionAlign = KernelAslrAlignment;
         const VAddr stack_region_start =
             memory_layout.GetVirtualMemoryRegionTree().GetRandomAlignedRegion(
@@ -382,7 +380,7 @@ struct KernelCore::Impl {
             slab_region_start, slab_region_size, KMemoryRegionType_KernelSlab));
 
         // Setup the temp region.
-        constexpr size_t TempRegionSize = Size_128_MB;
+        constexpr size_t TempRegionSize = Common::Size_128_MB;
         constexpr size_t TempRegionAlign = KernelAslrAlignment;
         const VAddr temp_region_start =
             memory_layout.GetVirtualMemoryRegionTree().GetRandomAlignedRegion(
@@ -438,7 +436,7 @@ struct KernelCore::Impl {
         // Determine size available for kernel page table heaps, requiring > 8 MB.
         const PAddr resource_end_phys_addr = slab_start_phys_addr + resource_region_size;
         const size_t page_table_heap_size = resource_end_phys_addr - slab_end_phys_addr;
-        ASSERT(page_table_heap_size / Size_4_MB > 2);
+        ASSERT(page_table_heap_size / Common::Size_4_MB > 2);
 
         // Insert a physical region for the kernel page table heap region
         ASSERT(memory_layout.GetPhysicalMemoryRegionTree().Insert(
@@ -463,7 +461,7 @@ struct KernelCore::Impl {
         ASSERT(linear_extents.GetEndAddress() != 0);
 
         // Setup the linear mapping region.
-        constexpr size_t LinearRegionAlign = Size_1_GB;
+        constexpr size_t LinearRegionAlign = Common::Size_1_GB;
         const PAddr aligned_linear_phys_start =
             Common::AlignDown(linear_extents.GetAddress(), LinearRegionAlign);
         const size_t linear_region_size =
@@ -531,6 +529,12 @@ struct KernelCore::Impl {
         // Cache all linear regions in their own trees for faster access, later.
         memory_layout.InitializeLinearMemoryRegionTrees(aligned_linear_phys_start,
                                                         linear_region_start);
+    }
+
+    void InitializeMemoryLayout() {
+        // Derive the initial memory layout from the emulated board
+        KMemoryLayout memory_layout;
+        DeriveInitialMemoryLayout(memory_layout);
 
         const auto system_pool = memory_layout.GetKernelSystemPoolRegionPhysicalExtents();
         const auto applet_pool = memory_layout.GetKernelAppletPoolRegionPhysicalExtents();

src/video_core/renderer_opengl/gl_device.cpp

@@ -210,7 +210,7 @@ Device::Device() {
     const bool is_amd = vendor == "ATI Technologies Inc.";
     const bool is_intel = vendor == "Intel";
 
-#ifdef __linux__
+#ifdef __unix__
     const bool is_linux = true;
 #else
     const bool is_linux = false;