5 files changed, 50 insertions, 45 deletions

diff --git a/src/common/common_sizes.h b/src/common/common_sizes.h
index 5dc039c94..7e9fd968b 100644
--- a/src/common/common_sizes.h
+++ b/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
diff --git a/src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp b/src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp
index a48d0c11e..919a6b943 100644
--- a/src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp
+++ b/src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp
@@ -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;
 }
 
diff --git a/src/core/hle/kernel/k_address_space_info.cpp b/src/core/hle/kernel/k_address_space_info.cpp
index 89906954d..c7549f7a2 100644
--- a/src/core/hle/kernel/k_address_space_info.cpp
+++ b/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 = Size_1_GB   , .size = Size_4_GB   - 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 = Size_Invalid, .size = Size_1_GB                , .type = KAddressSpaceInfo::Type::Alias,    },
-   { .bit_width = 36, .address = Size_128_MB , .size = Size_2_GB   - 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 = Size_Invalid, .size = Size_6_GB                , .type = KAddressSpaceInfo::Type::Heap,     },
-   { .bit_width = 36, .address = Size_Invalid, .size = 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 = Size_Invalid, .size = 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 = Size_Invalid, .size = Size_64_GB               , .type = KAddressSpaceInfo::Type::Alias,    },
-   { .bit_width = 39, .address = Size_Invalid, .size = Size_2_GB                , .type = KAddressSpaceInfo::Type::Stack,    },
+   { .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 = Common::Size_1_GB   , .size = Common::Size_4_GB   - Common::Size_1_GB  , .type = KAddressSpaceInfo::Type::MapLarge, },
+   { .bit_width = 32, .address = Common::Size_Invalid, .size = Common::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 = Common::Size_128_MB , .size = Common::Size_2_GB   - Common::Size_128_MB, .type = KAddressSpaceInfo::Type::MapSmall, },
+   { .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 = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Heap,     },
+   { .bit_width = 36, .address = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Alias,    },
+   { .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 = Common::Size_Invalid, .size = Common::Size_64_GB                       , .type = KAddressSpaceInfo::Type::MapSmall  },
+   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_6_GB                        , .type = KAddressSpaceInfo::Type::Heap,     },
+   { .bit_width = 39, .address = Common::Size_Invalid, .size = Common::Size_64_GB                       , .type = KAddressSpaceInfo::Type::Alias,    },
+   { .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 =
diff --git a/src/core/hle/kernel/k_memory_layout.h b/src/core/hle/kernel/k_memory_layout.h
index b3e057326..590dc449a 100644
--- a/src/core/hle/kernel/k_memory_layout.h
+++ b/src/core/hle/kernel/k_memory_layout.h
@@ -14,20 +14,20 @@
 
 namespace Kernel {
 
-constexpr std::size_t L1BlockSize = Size_1_GB;
-constexpr std::size_t L2BlockSize = Size_2_MB;
+constexpr std::size_t L1BlockSize = Common::Size_1_GB;
+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 MainMemorySizeMax = Size_8_GB;
+constexpr std::size_t MainMemorySize = Common::Size_4_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 +51,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 KernelSlabHeapGapsSize = Size_2_MB - Size_64_KB;
+constexpr std::size_t KernelSlabHeapDataSize = Common::Size_5_MB;
+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.
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 9360710de..e994e8bed 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -289,8 +289,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 KernelRegionAlign = Size_1_GB;
+        constexpr size_t KernelRegionSize = Common::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 +337,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 +350,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 +382,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 +438,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 +463,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 =