[hle/kernel] assume all memory managers to be aligned to host page size

src/core/hle/kernel/k_memory_manager.cpp

@@ -455,7 +455,7 @@ size_t KMemoryManager::Impl::Initialize(KPhysicalAddress address, size_t size,
     const size_t page_heap_size = KPageHeap::CalculateManagementOverheadSize(size);
     const size_t total_management_size = manager_size + page_heap_size;
     ASSERT(manager_size <= total_management_size);
-    ASSERT(management + total_management_size <= management_end);
+    ASSERT(management + total_management_size <= Common::AlignUp(GetInteger(management_end), Common::HostPageSize));
     ASSERT(Common::IsAligned(total_management_size, PageSize));
 
     // Setup region.
@@ -557,7 +557,7 @@ size_t KMemoryManager::Impl::CalculateManagementOverheadSize(size_t region_size)
         sizeof(u64);
     const size_t manager_meta_size = Common::AlignUp(optimize_map_size + ref_count_size, PageSize);
     const size_t page_heap_size = KPageHeap::CalculateManagementOverheadSize(region_size);
-    return manager_meta_size + page_heap_size;
+    return Common::AlignUp(manager_meta_size + page_heap_size, Common::HostPageSize);
 }
 
 } // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -457,12 +457,12 @@ struct KernelCore::Impl {
             GetInteger(kernel_region_start), kernel_region_size, KMemoryRegionType_Kernel));
 
         // Setup the code region.
-        constexpr size_t CodeRegionAlign = PageSize;
-        constexpr KVirtualAddress code_region_start =
+        const size_t CodeRegionAlign = Common::HostPageSize;
+        const KVirtualAddress code_region_start =
             Common::AlignDown(GetInteger(code_start_virt_addr), CodeRegionAlign);
-        constexpr KVirtualAddress code_region_end =
+        const KVirtualAddress code_region_end =
             Common::AlignUp(GetInteger(code_end_virt_addr), CodeRegionAlign);
-        constexpr size_t code_region_size = code_region_end - code_region_start;
+        const size_t code_region_size = code_region_end - code_region_start;
         ASSERT(memory_layout->GetVirtualMemoryRegionTree().Insert(
             GetInteger(code_region_start), code_region_size, KMemoryRegionType_KernelCode));
 
@@ -524,7 +524,7 @@ struct KernelCore::Impl {
 
         // Determine the size of the slab region.
         const size_t slab_region_size =
-            Common::AlignUp(Init::CalculateTotalSlabHeapSize(system.Kernel()), PageSize);
+            Common::AlignUp(Init::CalculateTotalSlabHeapSize(system.Kernel()), Common::HostPageSize);
         ASSERT(slab_region_size <= resource_region_size);
 
         // Setup the slab region.
@@ -576,7 +576,7 @@ struct KernelCore::Impl {
             region.SetTypeAttribute(KMemoryRegionAttr_DidKernelMap);
 
             // Create a virtual pair region and insert it into the tree.
-            const KPhysicalAddress map_phys_addr = Common::AlignDown(region.GetAddress(), PageSize);
+            const KPhysicalAddress map_phys_addr = Common::AlignDown(region.GetAddress(), Common::HostPageSize);
             const size_t map_size =
                 Common::AlignUp(region.GetEndAddress(), PageSize) - GetInteger(map_phys_addr);
             const KVirtualAddress map_virt_addr =