nintendo-back-up/yuzu-mainline
1
0
Fork 0
mirror of https://git.zaroz.cloud/nintendo-back-up/yuzu/yuzu-mainline.git synced 2025-03-21 01:53:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #4327 from lioncash/desig2

Browse Source 
address_space_info: Make use of designated initializers
This commit is contained in:
Rodrigo Locatti 2020-07-16 17:41:55 -03:00 committed by GitHub
commit 104c523d3d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 38 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
src/core/hle/kernel/memory/address_space_info.cpp
View File

@ -29,38 +29,37 @@ enum : u64 {
// clang-format off // clang-format off
constexpr std::array<AddressSpaceInfo, 13> AddressSpaceInfos{{ constexpr std::array<AddressSpaceInfo, 13> AddressSpaceInfos{{
{ 32 /*bit_width*/, Size_2_MB /*addr*/, Size_1_GB - Size_2_MB /*size*/, AddressSpaceInfo::Type::Is32Bit, }, { .bit_width = 32, .address = Size_2_MB , .size = Size_1_GB - Size_2_MB , .type = AddressSpaceInfo::Type::Is32Bit, },
{ 32 /*bit_width*/, Size_1_GB /*addr*/, Size_4_GB - Size_1_GB /*size*/, AddressSpaceInfo::Type::Small64Bit, }, { .bit_width = 32, .address = Size_1_GB , .size = Size_4_GB - Size_1_GB , .type = AddressSpaceInfo::Type::Small64Bit, },
{ 32 /*bit_width*/, Invalid /*addr*/, Size_1_GB /*size*/, AddressSpaceInfo::Type::Heap, }, { .bit_width = 32, .address = Invalid , .size = Size_1_GB , .type = AddressSpaceInfo::Type::Heap, },
{ 32 /*bit_width*/, Invalid /*addr*/, Size_1_GB /*size*/, AddressSpaceInfo::Type::Alias, }, { .bit_width = 32, .address = Invalid , .size = Size_1_GB , .type = AddressSpaceInfo::Type::Alias, },
{ 36 /*bit_width*/, Size_128_MB /*addr*/, Size_2_GB - Size_128_MB /*size*/, AddressSpaceInfo::Type::Is32Bit, }, { .bit_width = 36, .address = Size_128_MB, .size = Size_2_GB - Size_128_MB, .type = AddressSpaceInfo::Type::Is32Bit, },
{ 36 /*bit_width*/, Size_2_GB /*addr*/, Size_64_GB - Size_2_GB /*size*/, AddressSpaceInfo::Type::Small64Bit, }, { .bit_width = 36, .address = Size_2_GB , .size = Size_64_GB - Size_2_GB , .type = AddressSpaceInfo::Type::Small64Bit, },
{ 36 /*bit_width*/, Invalid /*addr*/, Size_6_GB /*size*/, AddressSpaceInfo::Type::Heap, }, { .bit_width = 36, .address = Invalid , .size = Size_6_GB , .type = AddressSpaceInfo::Type::Heap, },
{ 36 /*bit_width*/, Invalid /*addr*/, Size_6_GB /*size*/, AddressSpaceInfo::Type::Alias, }, { .bit_width = 36, .address = Invalid , .size = Size_6_GB , .type = AddressSpaceInfo::Type::Alias, },
{ 39 /*bit_width*/, Size_128_MB /*addr*/, Size_512_GB - Size_128_MB /*size*/, AddressSpaceInfo::Type::Large64Bit, }, { .bit_width = 39, .address = Size_128_MB, .size = Size_512_GB - Size_128_MB, .type = AddressSpaceInfo::Type::Large64Bit, },
{ 39 /*bit_width*/, Invalid /*addr*/, Size_64_GB /*size*/, AddressSpaceInfo::Type::Is32Bit }, { .bit_width = 39, .address = Invalid , .size = Size_64_GB , .type = AddressSpaceInfo::Type::Is32Bit },
{ 39 /*bit_width*/, Invalid /*addr*/, Size_6_GB /*size*/, AddressSpaceInfo::Type::Heap, }, { .bit_width = 39, .address = Invalid , .size = Size_6_GB , .type = AddressSpaceInfo::Type::Heap, },
{ 39 /*bit_width*/, Invalid /*addr*/, Size_64_GB /*size*/, AddressSpaceInfo::Type::Alias, }, { .bit_width = 39, .address = Invalid , .size = Size_64_GB , .type = AddressSpaceInfo::Type::Alias, },
{ 39 /*bit_width*/, Invalid /*addr*/, Size_2_GB /*size*/, AddressSpaceInfo::Type::Stack, }, { .bit_width = 39, .address = Invalid , .size = Size_2_GB , .type = AddressSpaceInfo::Type::Stack, },
}}; }};
// clang-format on // clang-format on
constexpr bool IsAllowedIndexForAddress(std::size_t index) { constexpr bool IsAllowedIndexForAddress(std::size_t index) {
return index < std::size(AddressSpaceInfos) && AddressSpaceInfos[index].GetAddress() != Invalid; return index < AddressSpaceInfos.size() && AddressSpaceInfos[index].address != Invalid;
} }
constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)> using IndexArray = std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>;
AddressSpaceIndices32Bit{
constexpr IndexArray AddressSpaceIndices32Bit{
0, 1, 0, 2, 0, 3, 0, 1, 0, 2, 0, 3,
}; };
constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)> constexpr IndexArray AddressSpaceIndices36Bit{
AddressSpaceIndices36Bit{
4, 5, 4, 6, 4, 7, 4, 5, 4, 6, 4, 7,
}; };
constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)> constexpr IndexArray AddressSpaceIndices39Bit{
AddressSpaceIndices39Bit{
9, 8, 8, 10, 12, 11, 9, 8, 8, 10, 12, 11,
}; };
@ -80,37 +79,37 @@ constexpr bool IsAllowed39BitType(AddressSpaceInfo::Type type) {
} // namespace } // namespace
u64 AddressSpaceInfo::GetAddressSpaceStart(std::size_t width, AddressSpaceInfo::Type type) { u64 AddressSpaceInfo::GetAddressSpaceStart(std::size_t width, Type type) {
const std::size_t index{static_cast<std::size_t>(type)}; const std::size_t index{static_cast<std::size_t>(type)};
switch (width) { switch (width) {
case 32: case 32:
ASSERT(IsAllowed32BitType(type)); ASSERT(IsAllowed32BitType(type));
ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices32Bit[index])); ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices32Bit[index]));
return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].GetAddress(); return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].address;
case 36: case 36:
ASSERT(IsAllowed36BitType(type)); ASSERT(IsAllowed36BitType(type));
ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices36Bit[index])); ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices36Bit[index]));
return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].GetAddress(); return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].address;
case 39: case 39:
ASSERT(IsAllowed39BitType(type)); ASSERT(IsAllowed39BitType(type));
ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices39Bit[index])); ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices39Bit[index]));
return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].GetAddress(); return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].address;
} }
UNREACHABLE(); UNREACHABLE();
} }
std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, AddressSpaceInfo::Type type) { std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, Type type) {
const std::size_t index{static_cast<std::size_t>(type)}; const std::size_t index{static_cast<std::size_t>(type)};
switch (width) { switch (width) {
case 32: case 32:
ASSERT(IsAllowed32BitType(type)); ASSERT(IsAllowed32BitType(type));
return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].GetSize(); return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].size;
case 36: case 36:
ASSERT(IsAllowed36BitType(type)); ASSERT(IsAllowed36BitType(type));
return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].GetSize(); return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].size;
case 39: case 39:
ASSERT(IsAllowed39BitType(type)); ASSERT(IsAllowed39BitType(type));
return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].GetSize(); return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].size;
} }
UNREACHABLE(); UNREACHABLE();
} }

29
src/core/hle/kernel/memory/address_space_info.h
View File

@ -11,8 +11,7 @@
namespace Kernel::Memory { namespace Kernel::Memory {
class AddressSpaceInfo final : NonCopyable { struct AddressSpaceInfo final {
public:
enum class Type : u32 { enum class Type : u32 {
Is32Bit = 0, Is32Bit = 0,
Small64Bit = 1, Small64Bit = 1,
@ -23,31 +22,13 @@ public:
Count, Count,
}; };
private:
std::size_t bit_width{};
std::size_t addr{};
std::size_t size{};
Type type{};
public:
static u64 GetAddressSpaceStart(std::size_t width, Type type); static u64 GetAddressSpaceStart(std::size_t width, Type type);
static std::size_t GetAddressSpaceSize(std::size_t width, Type type); static std::size_t GetAddressSpaceSize(std::size_t width, Type type);
constexpr AddressSpaceInfo(std::size_t bit_width, std::size_t addr, std::size_t size, Type type) const std::size_t bit_width{};
: bit_width{bit_width}, addr{addr}, size{size}, type{type} {} const std::size_t address{};
const std::size_t size{};
constexpr std::size_t GetWidth() const { const Type type{};
return bit_width;
}
constexpr std::size_t GetAddress() const {
return addr;
}
constexpr std::size_t GetSize() const {
return size;
}
constexpr Type GetType() const {
return type;
}
}; };
} // namespace Kernel::Memory } // namespace Kernel::Memory