diff --git a/src/core/device_memory.h b/src/core/device_memory.h
index ff66e202d6..9efa088d00 100644
--- a/src/core/device_memory.h
+++ b/src/core/device_memory.h
@@ -13,13 +13,15 @@ namespace Core {
class System;
namespace DramMemoryMap {
-constexpr u64 Base = 0x80000000ULL;
-constexpr u64 Size = 0x100000000ULL;
-constexpr u64 End = Base + Size;
-constexpr u64 KernelReserveBase = Base + 0x60000;
-constexpr u64 SlabHeapBase = KernelReserveBase + 0x85000;
-constexpr u64 SlapHeapSize = 0xa21000;
-constexpr u64 SlabHeapEnd = SlabHeapBase + SlapHeapSize;
+enum : u64 {
+ Base = 0x80000000ULL,
+ Size = 0x100000000ULL,
+ End = Base + Size,
+ KernelReserveBase = Base + 0x60000,
+ SlabHeapBase = KernelReserveBase + 0x85000,
+ SlapHeapSize = 0xa21000,
+ SlabHeapEnd = SlabHeapBase + SlapHeapSize,
+};
}; // namespace DramMemoryMap
class DeviceMemory : NonCopyable {
diff --git a/src/core/hle/kernel/memory/address_space_info.cpp b/src/core/hle/kernel/memory/address_space_info.cpp
index 6a267c951b..27fae05e71 100644
--- a/src/core/hle/kernel/memory/address_space_info.cpp
+++ b/src/core/hle/kernel/memory/address_space_info.cpp
@@ -14,16 +14,18 @@ namespace Kernel::Memory {
namespace {
-constexpr std::size_t Size_1_MB{0x100000};
-constexpr std::size_t Size_2_MB{2 * Size_1_MB};
-constexpr std::size_t Size_128_MB{128 * Size_1_MB};
-constexpr std::size_t Size_1_GB{0x40000000};
-constexpr std::size_t Size_2_GB{2 * Size_1_GB};
-constexpr std::size_t Size_4_GB{4 * Size_1_GB};
-constexpr std::size_t Size_6_GB{6 * Size_1_GB};
-constexpr std::size_t Size_64_GB{64 * Size_1_GB};
-constexpr std::size_t Size_512_GB{512 * Size_1_GB};
-constexpr u64 Invalid{std::numeric_limits<u64>::max()};
+enum : u64 {
+ Size_1_MB = 0x100000,
+ Size_2_MB = 2 * Size_1_MB,
+ Size_128_MB = 128 * Size_1_MB,
+ Size_1_GB = 0x40000000,
+ Size_2_GB = 2 * Size_1_GB,
+ Size_4_GB = 4 * Size_1_GB,
+ Size_6_GB = 6 * Size_1_GB,
+ Size_64_GB = 64 * Size_1_GB,
+ Size_512_GB = 512 * Size_1_GB,
+ Invalid = std::numeric_limits<u64>::max(),
+};
// clang-format off
constexpr std::array<AddressSpaceInfo, 13> AddressSpaceInfos{{
diff --git a/src/core/hle/kernel/memory/memory_block_manager.cpp b/src/core/hle/kernel/memory/memory_block_manager.cpp
index da009566f9..1ebc126c05 100644
--- a/src/core/hle/kernel/memory/memory_block_manager.cpp
+++ b/src/core/hle/kernel/memory/memory_block_manager.cpp
@@ -15,7 +15,7 @@ MemoryBlockManager::MemoryBlockManager(VAddr start_addr, VAddr end_addr)
}
MemoryBlockManager::iterator MemoryBlockManager::FindIterator(VAddr addr) {
- iterator node{memory_block_tree.begin()};
+ auto node{memory_block_tree.begin()};
while (node != end()) {
const VAddr end_addr{node->GetNumPages() * PageSize + node->GetAddress()};
if (node->GetAddress() <= addr && end_addr - 1 >= addr) {
@@ -35,8 +35,8 @@ VAddr MemoryBlockManager::FindFreeArea(VAddr region_start, std::size_t region_nu
const VAddr region_end{region_start + region_num_pages * PageSize};
const VAddr region_last{region_end - 1};
- for (const_iterator it{FindIterator(region_start)}; it != memory_block_tree.cend(); it++) {
- const MemoryInfo info{it->GetMemoryInfo()};
+ for (auto it{FindIterator(region_start)}; it != memory_block_tree.cend(); it++) {
+ const auto info{it->GetMemoryInfo()};
if (region_last < info.GetAddress()) {
break;
}
diff --git a/src/core/hle/kernel/memory/memory_manager.cpp b/src/core/hle/kernel/memory/memory_manager.cpp
index 9c1bb981b0..3cd4f9e85c 100644
--- a/src/core/hle/kernel/memory/memory_manager.cpp
+++ b/src/core/hle/kernel/memory/memory_manager.cpp
@@ -15,15 +15,14 @@
namespace Kernel::Memory {
std::size_t MemoryManager::Impl::Initialize(Pool new_pool, u64 start_address, u64 end_address) {
- const std::size_t size{end_address - start_address};
+ const auto size{end_address - start_address};
// Calculate metadata sizes
- const std::size_t ref_count_size{(size / PageSize) * sizeof(u16)};
- const std::size_t optimize_map_size{(Common::AlignUp((size / PageSize), 64) / 64) *
- sizeof(u64)};
- const std::size_t manager_size{Common::AlignUp(optimize_map_size + ref_count_size, PageSize)};
- const std::size_t page_heap_size{PageHeap::CalculateMetadataOverheadSize(size)};
- const std::size_t total_metadata_size{manager_size + page_heap_size};
+ const auto ref_count_size{(size / PageSize) * sizeof(u16)};
+ const auto optimize_map_size{(Common::AlignUp((size / PageSize), 64) / 64) * sizeof(u64)};
+ const auto manager_size{Common::AlignUp(optimize_map_size + ref_count_size, PageSize)};
+ const auto page_heap_size{PageHeap::CalculateMetadataOverheadSize(size)};
+ const auto total_metadata_size{manager_size + page_heap_size};
ASSERT(manager_size <= total_metadata_size);
ASSERT(Common::IsAligned(total_metadata_size, PageSize));
@@ -55,7 +54,7 @@ VAddr MemoryManager::AllocateContinuous(std::size_t num_pages, std::size_t align
}
// Lock the pool that we're allocating from
- const std::size_t pool_index{static_cast<std::size_t>(pool)};
+ const auto pool_index{static_cast<std::size_t>(pool)};
std::lock_guard lock{pool_locks[pool_index]};
// Choose a heap based on our page size request
@@ -72,7 +71,7 @@ VAddr MemoryManager::AllocateContinuous(std::size_t num_pages, std::size_t align
}
// If we allocated more than we need, free some
- const std::size_t allocated_pages{PageHeap::GetBlockNumPages(heap_index)};
+ const auto allocated_pages{PageHeap::GetBlockNumPages(heap_index)};
if (allocated_pages > num_pages) {
chosen_manager.Free(allocated_block + num_pages * PageSize, allocated_pages - num_pages);
}
@@ -90,7 +89,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
}
// Lock the pool that we're allocating from
- const std::size_t pool_index{static_cast<std::size_t>(pool)};
+ const auto pool_index{static_cast<std::size_t>(pool)};
std::lock_guard lock{pool_locks[pool_index]};
// Choose a heap based on our page size request
@@ -105,7 +104,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
// Ensure that we don't leave anything un-freed
auto group_guard = detail::ScopeExit([&] {
for (const auto& it : page_list.Nodes()) {
- const std::size_t num_pages{std::min(
+ const auto num_pages{std::min(
it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
chosen_manager.Free(it.GetAddress(), num_pages);
}
@@ -113,12 +112,12 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
// Keep allocating until we've allocated all our pages
for (s32 index{heap_index}; index >= 0 && num_pages > 0; index--) {
- const std::size_t pages_per_alloc{PageHeap::GetBlockNumPages(index)};
+ const auto pages_per_alloc{PageHeap::GetBlockNumPages(index)};
while (num_pages >= pages_per_alloc) {
// Allocate a block
VAddr allocated_block{chosen_manager.AllocateBlock(index)};
- if (allocated_block == 0) {
+ if (!allocated_block) {
break;
}
@@ -158,7 +157,7 @@ ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages,
}
// Lock the pool that we're freeing from
- const std::size_t pool_index{static_cast<std::size_t>(pool)};
+ const auto pool_index{static_cast<std::size_t>(pool)};
std::lock_guard lock{pool_locks[pool_index]};
// TODO (bunnei): Support multiple managers
@@ -166,7 +165,7 @@ ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages,
// Free all of the pages
for (const auto& it : page_list.Nodes()) {
- const std::size_t num_pages{std::min(
+ const auto num_pages{std::min(
it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
chosen_manager.Free(it.GetAddress(), num_pages);
}
diff --git a/src/core/hle/kernel/memory/page_heap.h b/src/core/hle/kernel/memory/page_heap.h
index 39ca45ab12..380c3f5a19 100644
--- a/src/core/hle/kernel/memory/page_heap.h
+++ b/src/core/hle/kernel/memory/page_heap.h
@@ -22,9 +22,10 @@ namespace Kernel::Memory {
class PageHeap final : NonCopyable {
public:
static constexpr s32 GetAlignedBlockIndex(std::size_t num_pages, std::size_t align_pages) {
- const std::size_t target_pages{std::max(num_pages, align_pages)};
+ const auto target_pages{std::max(num_pages, align_pages)};
for (std::size_t i = 0; i < NumMemoryBlockPageShifts; i++) {
- if (target_pages <= (std::size_t(1) << MemoryBlockPageShifts[i]) / PageSize) {
+ if (target_pages <=
+ (static_cast<std::size_t>(1) << MemoryBlockPageShifts[i]) / PageSize) {
return static_cast<s32>(i);
}
}
@@ -33,7 +34,7 @@ public:
static constexpr s32 GetBlockIndex(std::size_t num_pages) {
for (s32 i{static_cast<s32>(NumMemoryBlockPageShifts) - 1}; i >= 0; i--) {
- if (num_pages >= (std::size_t(1) << MemoryBlockPageShifts[i]) / PageSize) {
+ if (num_pages >= (static_cast<std::size_t>(1) << MemoryBlockPageShifts[i]) / PageSize) {
return i;
}
}
@@ -41,7 +42,7 @@ public:
}
static constexpr std::size_t GetBlockSize(std::size_t index) {
- return std::size_t(1) << MemoryBlockPageShifts[index];
+ return static_cast<std::size_t>(1) << MemoryBlockPageShifts[index];
}
static constexpr std::size_t GetBlockNumPages(std::size_t index) {
@@ -51,7 +52,8 @@ public:
private:
static constexpr std::size_t NumMemoryBlockPageShifts{7};
static constexpr std::array<std::size_t, NumMemoryBlockPageShifts> MemoryBlockPageShifts{
- 0xC, 0x10, 0x15, 0x16, 0x19, 0x1D, 0x1E};
+ 0xC, 0x10, 0x15, 0x16, 0x19, 0x1D, 0x1E,
+ };
class Block final : NonCopyable {
private:
@@ -122,13 +124,13 @@ private:
constexpr bool ClearRange(std::size_t offset, std::size_t count) {
const s32 depth{GetHighestDepthIndex()};
- const std::size_t bit_ind{offset / 64};
+ const auto bit_ind{offset / 64};
u64* bits{bit_storages[depth]};
if (count < 64) {
- const std::size_t shift{offset % 64};
+ const auto shift{offset % 64};
ASSERT(shift + count <= 64);
// Check that all the bits are set
- const u64 mask{((u64(1) << count) - 1) << shift};
+ const u64 mask{((1ULL << count) - 1) << shift};
u64 v{bits[bit_ind]};
if ((v & mask) != mask) {
return false;
@@ -171,9 +173,9 @@ private:
private:
constexpr void SetBit(s32 depth, std::size_t offset) {
while (depth >= 0) {
- const std::size_t ind{offset / 64};
- const std::size_t which{offset % 64};
- const u64 mask{u64(1) << which};
+ const auto ind{offset / 64};
+ const auto which{offset % 64};
+ const u64 mask{1ULL << which};
u64* bit{std::addressof(bit_storages[depth][ind])};
const u64 v{*bit};
@@ -189,9 +191,9 @@ private:
constexpr void ClearBit(s32 depth, std::size_t offset) {
while (depth >= 0) {
- const std::size_t ind{offset / 64};
- const std::size_t which{offset % 64};
- const u64 mask{u64(1) << which};
+ const auto ind{offset / 64};
+ const auto which{offset % 64};
+ const u64 mask{1ULL << which};
u64* bit{std::addressof(bit_storages[depth][ind])};
u64 v{*bit};
@@ -246,7 +248,7 @@ private:
return next_block_shift;
}
constexpr std::size_t GetSize() const {
- return std::size_t(1) << GetShift();
+ return static_cast<std::size_t>(1) << GetShift();
}
constexpr std::size_t GetNumPages() const {
return GetSize() / PageSize;
@@ -266,13 +268,13 @@ private:
// Align up the address
VAddr end{addr + size};
- const std::size_t align{(next_block_shift != 0) ? (u64(1) << next_block_shift)
- : (u64(1) << block_shift)};
+ const auto align{(next_block_shift != 0) ? (1ULL << next_block_shift)
+ : (1ULL << block_shift)};
addr = Common::AlignDown((addr), align);
end = Common::AlignUp((end), align);
heap_address = addr;
- end_offset = (end - addr) / (u64(1) << block_shift);
+ end_offset = (end - addr) / (1ULL << block_shift);
return bitmap.Initialize(bit_storage, end_offset);
}
@@ -283,7 +285,7 @@ private:
// If we have a next shift, try to clear the blocks below and return the address
if (GetNextShift()) {
- const std::size_t diff{u64(1) << (GetNextShift() - GetShift())};
+ const auto diff{1ULL << (GetNextShift() - GetShift())};
offset = Common::AlignDown(offset, diff);
if (bitmap.ClearRange(offset, diff)) {
return heap_address + (offset << GetShift());
@@ -300,7 +302,7 @@ private:
if (soffset < 0) {
return 0;
}
- const std::size_t offset{static_cast<std::size_t>(soffset)};
+ const auto offset{static_cast<std::size_t>(soffset)};
// Update our tracking and return it
bitmap.ClearBit(offset);
@@ -311,9 +313,9 @@ private:
static constexpr std::size_t CalculateMetadataOverheadSize(std::size_t region_size,
std::size_t cur_block_shift,
std::size_t next_block_shift) {
- const std::size_t cur_block_size{(u64(1) << cur_block_shift)};
- const std::size_t next_block_size{(u64(1) << next_block_shift)};
- const std::size_t align{(next_block_shift != 0) ? next_block_size : cur_block_size};
+ const auto cur_block_size{(1ULL << cur_block_shift)};
+ const auto next_block_size{(1ULL << next_block_shift)};
+ const auto align{(next_block_shift != 0) ? next_block_size : cur_block_size};
return Bitmap::CalculateMetadataOverheadSize(
(align * 2 + Common::AlignUp(region_size, align)) / cur_block_size);
}
diff --git a/src/core/hle/kernel/memory/page_table.cpp b/src/core/hle/kernel/memory/page_table.cpp
index 941ecda212..091e52ca47 100644
--- a/src/core/hle/kernel/memory/page_table.cpp
+++ b/src/core/hle/kernel/memory/page_table.cpp
@@ -64,10 +64,10 @@ ResultCode PageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_t
bool enable_aslr, VAddr code_addr, std::size_t code_size,
Memory::MemoryManager::Pool pool) {
- const auto GetSpaceStart = [&](AddressSpaceInfo::Type type) {
+ const auto GetSpaceStart = [this](AddressSpaceInfo::Type type) {
return AddressSpaceInfo::GetAddressSpaceStart(address_space_width, type);
};
- const auto GetSpaceSize = [&](AddressSpaceInfo::Type type) {
+ const auto GetSpaceSize = [this](AddressSpaceInfo::Type type) {
return AddressSpaceInfo::GetAddressSpaceSize(address_space_width, type);
};
@@ -286,17 +286,9 @@ ResultCode PageTable::MapProcessCode(VAddr addr, std::size_t num_pages, MemorySt
}
PageLinkedList page_linked_list;
- if (const ResultCode result{
- system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool)};
- result.IsError()) {
- return result;
- }
-
- if (const ResultCode result{
- Operate(addr, num_pages, page_linked_list, OperationType::MapGroup)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(
+ system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool));
+ CASCADE_CODE(Operate(addr, num_pages, page_linked_list, OperationType::MapGroup));
block_manager->Update(addr, num_pages, state, perm);
@@ -310,13 +302,10 @@ ResultCode PageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::
MemoryState state{};
MemoryPermission perm{};
- if (const ResultCode result{CheckMemoryState(
- &state, &perm, nullptr, src_addr, size, MemoryState::All, MemoryState::Normal,
- MemoryPermission::Mask, MemoryPermission::ReadAndWrite, MemoryAttribute::Mask,
- MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(&state, &perm, nullptr, src_addr, size, MemoryState::All,
+ MemoryState::Normal, MemoryPermission::Mask,
+ MemoryPermission::ReadAndWrite, MemoryAttribute::Mask,
+ MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
if (IsRegionMapped(dst_addr, size)) {
return ERR_INVALID_ADDRESS_STATE;
@@ -329,16 +318,9 @@ ResultCode PageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::
auto block_guard = detail::ScopeExit(
[&] { Operate(src_addr, num_pages, perm, OperationType::ChangePermissions); });
- if (const ResultCode result{Operate(src_addr, num_pages, MemoryPermission::None,
- OperationType::ChangePermissions)};
- result.IsError()) {
- return result;
- }
-
- if (const ResultCode result{MapPages(dst_addr, page_linked_list, MemoryPermission::None)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(
+ Operate(src_addr, num_pages, MemoryPermission::None, OperationType::ChangePermissions));
+ CASCADE_CODE(MapPages(dst_addr, page_linked_list, MemoryPermission::None));
block_guard.Cancel();
}
@@ -359,35 +341,20 @@ ResultCode PageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std
const std::size_t num_pages{size / PageSize};
- if (const ResultCode result{CheckMemoryState(
- nullptr, nullptr, nullptr, src_addr, size, MemoryState::All, MemoryState::Normal,
- MemoryPermission::None, MemoryPermission::None, MemoryAttribute::Mask,
- MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(nullptr, nullptr, nullptr, src_addr, size, MemoryState::All,
+ MemoryState::Normal, MemoryPermission::None,
+ MemoryPermission::None, MemoryAttribute::Mask,
+ MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped));
MemoryState state{};
- if (const ResultCode result{CheckMemoryState(
- &state, nullptr, nullptr, dst_addr, PageSize, MemoryState::FlagCanCodeAlias,
- MemoryState::FlagCanCodeAlias, MemoryPermission::None, MemoryPermission::None,
- MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
-
- if (const ResultCode result{CheckMemoryState(dst_addr, size, MemoryState::All, state,
- MemoryPermission::None, MemoryPermission::None,
- MemoryAttribute::Mask, MemoryAttribute::None)};
- result.IsError()) {
- return result;
- }
-
- if (const ResultCode result{
- Operate(dst_addr, num_pages, MemoryPermission::None, OperationType::Unmap)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(
+ &state, nullptr, nullptr, dst_addr, PageSize, MemoryState::FlagCanCodeAlias,
+ MemoryState::FlagCanCodeAlias, MemoryPermission::None, MemoryPermission::None,
+ MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
+ CASCADE_CODE(CheckMemoryState(dst_addr, size, MemoryState::All, state, MemoryPermission::None,
+ MemoryPermission::None, MemoryAttribute::Mask,
+ MemoryAttribute::None));
+ CASCADE_CODE(Operate(dst_addr, num_pages, MemoryPermission::None, OperationType::Unmap));
block_manager->Update(dst_addr, num_pages, MemoryState::Free);
block_manager->Update(src_addr, num_pages, MemoryState::Normal, MemoryPermission::ReadAndWrite);
@@ -459,11 +426,8 @@ ResultCode PageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
process->GetResourceLimit()->Release(ResourceType::PhysicalMemory, remaining_size);
});
- if (const ResultCode result{system.Kernel().MemoryManager().Allocate(
- page_linked_list, remaining_pages, memory_pool)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_linked_list, remaining_pages,
+ memory_pool));
block_guard.Cancel();
}
@@ -508,9 +472,7 @@ ResultCode PageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
return RESULT_SUCCESS;
}
- if (const ResultCode result{UnmapMemory(addr, size)}; result.IsError()) {
- return result;
- }
+ CASCADE_CODE(UnmapMemory(addr, size));
auto process{system.Kernel().CurrentProcess()};
process->GetResourceLimit()->Release(ResourceType::PhysicalMemory, mapped_size);
@@ -559,13 +521,10 @@ ResultCode PageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
std::lock_guard lock{page_table_lock};
MemoryState src_state{};
- if (const ResultCode result{CheckMemoryState(
- &src_state, nullptr, nullptr, src_addr, size, MemoryState::FlagCanAlias,
- MemoryState::FlagCanAlias, MemoryPermission::Mask, MemoryPermission::ReadAndWrite,
- MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(
+ &src_state, nullptr, nullptr, src_addr, size, MemoryState::FlagCanAlias,
+ MemoryState::FlagCanAlias, MemoryPermission::Mask, MemoryPermission::ReadAndWrite,
+ MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
if (IsRegionMapped(dst_addr, size)) {
return ERR_INVALID_ADDRESS_STATE;
@@ -582,17 +541,9 @@ ResultCode PageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
OperationType::ChangePermissions);
});
- if (const ResultCode result{Operate(src_addr, num_pages, MemoryPermission::None,
- OperationType::ChangePermissions)};
- result.IsError()) {
- return result;
- }
-
- if (const ResultCode result{
- MapPages(dst_addr, page_linked_list, MemoryPermission::ReadAndWrite)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(
+ Operate(src_addr, num_pages, MemoryPermission::None, OperationType::ChangePermissions));
+ CASCADE_CODE(MapPages(dst_addr, page_linked_list, MemoryPermission::ReadAndWrite));
block_guard.Cancel();
}
@@ -608,22 +559,16 @@ ResultCode PageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
std::lock_guard lock{page_table_lock};
MemoryState src_state{};
- if (const ResultCode result{CheckMemoryState(
- &src_state, nullptr, nullptr, src_addr, size, MemoryState::FlagCanAlias,
- MemoryState::FlagCanAlias, MemoryPermission::Mask, MemoryPermission::None,
- MemoryAttribute::Mask, MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(
+ &src_state, nullptr, nullptr, src_addr, size, MemoryState::FlagCanAlias,
+ MemoryState::FlagCanAlias, MemoryPermission::Mask, MemoryPermission::None,
+ MemoryAttribute::Mask, MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped));
MemoryPermission dst_perm{};
- if (const ResultCode result{CheckMemoryState(
- nullptr, &dst_perm, nullptr, dst_addr, size, MemoryState::All, MemoryState::Stack,
- MemoryPermission::None, MemoryPermission::None, MemoryAttribute::Mask,
- MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(nullptr, &dst_perm, nullptr, dst_addr, size, MemoryState::All,
+ MemoryState::Stack, MemoryPermission::None,
+ MemoryPermission::None, MemoryAttribute::Mask,
+ MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
PageLinkedList src_pages;
PageLinkedList dst_pages;
@@ -639,17 +584,9 @@ ResultCode PageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
{
auto block_guard = detail::ScopeExit([&] { MapPages(dst_addr, dst_pages, dst_perm); });
- if (const ResultCode result{
- Operate(dst_addr, num_pages, MemoryPermission::None, OperationType::Unmap)};
- result.IsError()) {
- return result;
- }
-
- if (const ResultCode result{Operate(src_addr, num_pages, MemoryPermission::ReadAndWrite,
- OperationType::ChangePermissions)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(Operate(dst_addr, num_pages, MemoryPermission::None, OperationType::Unmap));
+ CASCADE_CODE(Operate(src_addr, num_pages, MemoryPermission::ReadAndWrite,
+ OperationType::ChangePermissions));
block_guard.Cancel();
}
@@ -665,7 +602,7 @@ ResultCode PageTable::MapPages(VAddr addr, const PageLinkedList& page_linked_lis
VAddr cur_addr{addr};
for (const auto& node : page_linked_list.Nodes()) {
- if (const ResultCode result{
+ if (const auto result{
Operate(cur_addr, node.GetNumPages(), perm, OperationType::Map, node.GetAddress())};
result.IsError()) {
const MemoryInfo info{block_manager->FindBlock(cur_addr).GetMemoryInfo()};
@@ -698,9 +635,7 @@ ResultCode PageTable::MapPages(VAddr addr, PageLinkedList& page_linked_list, Mem
return ERR_INVALID_ADDRESS_STATE;
}
- if (const ResultCode result{MapPages(addr, page_linked_list, perm)}; result.IsError()) {
- return result;
- }
+ CASCADE_CODE(MapPages(addr, page_linked_list, perm));
block_manager->Update(addr, num_pages, state, perm);
@@ -714,13 +649,10 @@ ResultCode PageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size, Memo
MemoryState prev_state{};
MemoryPermission prev_perm{};
- if (const ResultCode result{CheckMemoryState(
- &prev_state, &prev_perm, nullptr, addr, size, MemoryState::FlagCode,
- MemoryState::FlagCode, MemoryPermission::None, MemoryPermission::None,
- MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(
+ &prev_state, &prev_perm, nullptr, addr, size, MemoryState::FlagCode, MemoryState::FlagCode,
+ MemoryPermission::None, MemoryPermission::None, MemoryAttribute::Mask,
+ MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
MemoryState state{prev_state};
@@ -745,9 +677,7 @@ ResultCode PageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size, Memo
? OperationType::ChangePermissionsAndRefresh
: OperationType::ChangePermissions};
- if (const ResultCode result{Operate(addr, num_pages, perm, operation)}; result.IsError()) {
- return result;
- }
+ CASCADE_CODE(Operate(addr, num_pages, perm, operation));
block_manager->Update(addr, num_pages, state, perm);
@@ -775,15 +705,12 @@ ResultCode PageTable::ReserveTransferMemory(VAddr addr, std::size_t size, Memory
MemoryState state{};
MemoryAttribute attribute{};
- if (const ResultCode result{CheckMemoryState(
- &state, nullptr, &attribute, addr, size,
- MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
- MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
- MemoryPermission::Mask, MemoryPermission::ReadAndWrite, MemoryAttribute::Mask,
- MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(&state, nullptr, &attribute, addr, size,
+ MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
+ MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
+ MemoryPermission::Mask, MemoryPermission::ReadAndWrite,
+ MemoryAttribute::Mask, MemoryAttribute::None,
+ MemoryAttribute::IpcAndDeviceMapped));
block_manager->Update(addr, size / PageSize, state, perm, attribute | MemoryAttribute::Locked);
@@ -795,15 +722,12 @@ ResultCode PageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
MemoryState state{};
- if (const ResultCode result{
- CheckMemoryState(&state, nullptr, nullptr, addr, size,
- MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
- MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
- MemoryPermission::None, MemoryPermission::None, MemoryAttribute::Mask,
- MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(&state, nullptr, nullptr, addr, size,
+ MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
+ MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
+ MemoryPermission::None, MemoryPermission::None,
+ MemoryAttribute::Mask, MemoryAttribute::Locked,
+ MemoryAttribute::IpcAndDeviceMapped));
block_manager->Update(addr, size / PageSize, state, MemoryPermission::ReadAndWrite);
@@ -818,14 +742,11 @@ ResultCode PageTable::SetMemoryAttribute(VAddr addr, std::size_t size, MemoryAtt
MemoryPermission perm{};
MemoryAttribute attribute{};
- if (const ResultCode result{CheckMemoryState(
- &state, &perm, &attribute, addr, size, MemoryState::FlagCanChangeAttribute,
- MemoryState::FlagCanChangeAttribute, MemoryPermission::None, MemoryPermission::None,
- MemoryAttribute::LockedAndIpcLocked, MemoryAttribute::None,
- MemoryAttribute::DeviceSharedAndUncached)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(&state, &perm, &attribute, addr, size,
+ MemoryState::FlagCanChangeAttribute,
+ MemoryState::FlagCanChangeAttribute, MemoryPermission::None,
+ MemoryPermission::None, MemoryAttribute::LockedAndIpcLocked,
+ MemoryAttribute::None, MemoryAttribute::DeviceSharedAndUncached));
attribute = attribute & ~mask;
attribute = attribute | (mask & value);
@@ -866,21 +787,15 @@ ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {
PageLinkedList page_linked_list;
const std::size_t num_pages{delta / PageSize};
- if (const ResultCode result{
- system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(
+ system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool));
if (IsRegionMapped(current_heap_addr, delta)) {
return ERR_INVALID_ADDRESS_STATE;
}
- if (const ResultCode result{
- Operate(current_heap_addr, num_pages, page_linked_list, OperationType::MapGroup)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(
+ Operate(current_heap_addr, num_pages, page_linked_list, OperationType::MapGroup));
block_manager->Update(current_heap_addr, num_pages, MemoryState::Normal,
MemoryPermission::ReadAndWrite);
@@ -912,23 +827,12 @@ ResultVal<VAddr> PageTable::AllocateAndMapMemory(std::size_t needed_num_pages, s
}
if (is_map_only) {
- if (const ResultCode result{
- Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
} else {
PageLinkedList page_group;
- if (const ResultCode result{system.Kernel().MemoryManager().Allocate(
- page_group, needed_num_pages, memory_pool)};
- result.IsError()) {
- return result;
- }
- if (const ResultCode result{
- Operate(addr, needed_num_pages, page_group, OperationType::MapGroup)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(
+ system.Kernel().MemoryManager().Allocate(page_group, needed_num_pages, memory_pool));
+ CASCADE_CODE(Operate(addr, needed_num_pages, page_group, OperationType::MapGroup));
}
block_manager->Update(addr, needed_num_pages, state, perm);
@@ -1196,11 +1100,7 @@ ResultCode PageTable::CheckMemoryState(MemoryState* out_state, MemoryPermission*
}
// Validate against the provided masks
- if (const ResultCode result{
- CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr)};
- result.IsError()) {
- return result;
- }
+ CASCADE_CODE(CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr));
// Break once we're done
if (last_addr <= info.GetLastAddress()) {
diff --git a/src/core/hle/kernel/memory/system_control.cpp b/src/core/hle/kernel/memory/system_control.cpp
index e61522dc01..9cae3c6cb0 100644
--- a/src/core/hle/kernel/memory/system_control.cpp
+++ b/src/core/hle/kernel/memory/system_control.cpp
@@ -11,9 +11,9 @@
namespace Kernel::Memory::SystemControl {
u64 GenerateRandomU64ForInit() {
- std::random_device device;
- std::mt19937 gen(device());
- std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
+ static std::random_device device;
+ static std::mt19937 gen(device());
+ static std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
return distribution(gen);
}
diff --git a/src/core/hle/kernel/shared_memory.cpp b/src/core/hle/kernel/shared_memory.cpp
index e28da68691..c676967574 100644
--- a/src/core/hle/kernel/shared_memory.cpp
+++ b/src/core/hle/kernel/shared_memory.cpp
@@ -40,14 +40,14 @@ ResultCode SharedMemory::Map(Process& target_process, VAddr address, std::size_t
const u64 page_count{(size + Memory::PageSize - 1) / Memory::PageSize};
if (page_list.GetNumPages() != page_count) {
- UNIMPLEMENTED();
+ UNIMPLEMENTED_MSG("Page count does not match");
}
Memory::MemoryPermission expected =
&target_process == owner_process ? owner_permission : user_permission;
if (permission != expected) {
- UNIMPLEMENTED();
+ UNIMPLEMENTED_MSG("Permission does not match");
}
return target_process.PageTable().MapPages(address, page_list, Memory::MemoryState::Shared,
diff --git a/src/core/hle/kernel/shared_memory.h b/src/core/hle/kernel/shared_memory.h
index 06fe693de4..cd16d64124 100644
--- a/src/core/hle/kernel/shared_memory.h
+++ b/src/core/hle/kernel/shared_memory.h
@@ -28,7 +28,7 @@ public:
KernelCore& kernel, Core::DeviceMemory& device_memory, Process* owner_process,
Memory::PageLinkedList&& page_list, Memory::MemoryPermission owner_permission,
Memory::MemoryPermission user_permission, PAddr physical_address, std::size_t size,
- std::string name = "Unknown");
+ std::string name);
std::string GetTypeName() const override {
return "SharedMemory";
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 5914b5d39a..4134acf656 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -1196,7 +1196,7 @@ static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_add
}
auto& memory{system.Memory()};
- const Svc::MemoryInfo memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()};
+ const auto memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()};
memory.Write64(memory_info_address + 0x00, memory_info.addr);
memory.Write64(memory_info_address + 0x08, memory_info.size);
diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp
index 73a2bc7707..0cde7a5578 100644
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@@ -298,9 +298,7 @@ public:
continue;
}
- if (result.IsError()) {
- return result;
- }
+ CASCADE_CODE(result);
if (ValidateRegionForMap(page_table, addr, size)) {
return MakeResult<VAddr>(addr);
@@ -470,16 +468,15 @@ public:
}
// Map memory for the NRO
- const ResultVal<VAddr> map_result{MapNro(system.CurrentProcess(), nro_address, nro_size,
- bss_address, bss_size, nro_size + bss_size)};
+ const auto map_result{MapNro(system.CurrentProcess(), nro_address, nro_size, bss_address,
+ bss_size, nro_size + bss_size)};
if (map_result.Failed()) {
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(map_result.Code());
}
// Load the NRO into the mapped memory
- if (const ResultCode result{
- LoadNro(system.CurrentProcess(), header, nro_address, *map_result)};
+ if (const auto result{LoadNro(system.CurrentProcess(), header, nro_address, *map_result)};
result.IsError()) {
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(map_result.Code());
@@ -551,7 +548,7 @@ public:
return;
}
- const ResultCode result{UnmapNro(iter->second)};
+ const auto result{UnmapNro(iter->second)};
system.InvalidateCpuInstructionCaches();