fix: Clang fix part 2: Electric bogaloo

This commit is contained in:
Akatsuki Levi 2024-03-15 21:05:43 -03:00
parent 94a84f5943
commit 70d0df5e55
No known key found for this signature in database
GPG key ID: BB4057BB9E0F1C7A
93 changed files with 253 additions and 254 deletions

View file

@ -8,8 +8,8 @@
namespace AudioCore::AudioIn { namespace AudioCore::AudioIn {
In::In(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_) In::In(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
: manager{manager_}, parent_mutex{manager.mutex}, event{event_}, : manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
system{system_, event, session_id_} {} session_id_} {}
void In::Free() { void In::Free() {
std::scoped_lock l{parent_mutex}; std::scoped_lock l{parent_mutex};

View file

@ -14,8 +14,8 @@
namespace AudioCore::AudioIn { namespace AudioCore::AudioIn {
System::System(Core::System& system_, Kernel::KEvent* event_, const size_t session_id_) System::System(Core::System& system_, Kernel::KEvent* event_, const size_t session_id_)
: system{system_}, buffer_event{event_}, session_id{session_id_}, : system{system_}, buffer_event{event_},
session{std::make_unique<DeviceSession>(system_)} {} session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
System::~System() { System::~System() {
Finalize(); Finalize();

View file

@ -8,8 +8,8 @@
namespace AudioCore::AudioOut { namespace AudioCore::AudioOut {
Out::Out(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_) Out::Out(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
: manager{manager_}, parent_mutex{manager.mutex}, event{event_}, : manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
system{system_, event, session_id_} {} session_id_} {}
void Out::Free() { void Out::Free() {
std::scoped_lock l{parent_mutex}; std::scoped_lock l{parent_mutex};

View file

@ -14,8 +14,8 @@
namespace AudioCore::AudioOut { namespace AudioCore::AudioOut {
System::System(Core::System& system_, Kernel::KEvent* event_, size_t session_id_) System::System(Core::System& system_, Kernel::KEvent* event_, size_t session_id_)
: system{system_}, buffer_event{event_}, session_id{session_id_}, : system{system_}, buffer_event{event_},
session{std::make_unique<DeviceSession>(system_)} {} session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
System::~System() { System::~System() {
Finalize(); Finalize();

View file

@ -19,9 +19,10 @@ namespace AudioCore::Renderer {
InfoUpdater::InfoUpdater(std::span<const u8> input_, std::span<u8> output_, InfoUpdater::InfoUpdater(std::span<const u8> input_, std::span<u8> output_,
Kernel::KProcess* process_handle_, BehaviorInfo& behaviour_) Kernel::KProcess* process_handle_, BehaviorInfo& behaviour_)
: input{input_.data() + sizeof(UpdateDataHeader)}, input_origin{input_}, : input{input_.data() + sizeof(UpdateDataHeader)},
output{output_.data() + sizeof(UpdateDataHeader)}, output_origin{output_}, input_origin{input_}, output{output_.data() + sizeof(UpdateDataHeader)},
in_header{reinterpret_cast<const UpdateDataHeader*>(input_origin.data())}, output_origin{output_}, in_header{reinterpret_cast<const UpdateDataHeader*>(
input_origin.data())},
out_header{reinterpret_cast<UpdateDataHeader*>(output_origin.data())}, out_header{reinterpret_cast<UpdateDataHeader*>(output_origin.data())},
expected_input_size{input_.size()}, expected_output_size{output_.size()}, expected_input_size{input_.size()}, expected_output_size{output_.size()},
process_handle{process_handle_}, behaviour{behaviour_} { process_handle{process_handle_}, behaviour{behaviour_} {

View file

@ -13,8 +13,8 @@ PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, bool force_map_)
PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, std::span<MemoryPoolInfo> pool_infos_, PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, std::span<MemoryPoolInfo> pool_infos_,
u32 pool_count_, bool force_map_) u32 pool_count_, bool force_map_)
: process_handle{process_handle_}, pool_infos{pool_infos_.data()}, pool_count{pool_count_}, : process_handle{process_handle_}, pool_infos{pool_infos_.data()},
force_map{force_map_} {} pool_count{pool_count_}, force_map{force_map_} {}
void PoolMapper::ClearUseState(std::span<MemoryPoolInfo> pools, const u32 count) { void PoolMapper::ClearUseState(std::span<MemoryPoolInfo> pools, const u32 count) {
for (u32 i = 0; i < count; i++) { for (u32 i = 0; i < count; i++) {

View file

@ -12,7 +12,8 @@
namespace Common { namespace Common {
template <typename VaType, size_t AddressSpaceBits> template <typename VaType, size_t AddressSpaceBits>
concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >= AddressSpaceBits; concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >=
AddressSpaceBits;
struct EmptyStruct {}; struct EmptyStruct {};

View file

@ -598,14 +598,14 @@ public:
template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr, template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr> std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>) constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
: impl_base{unexpect_t{}, std::move(e.value())}, : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
ctor_base{detail::default_constructor_tag{}} {} detail::default_constructor_tag{}} {}
template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr, template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr> std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>) constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
: impl_base{unexpect_t{}, std::move(e.value())}, : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
ctor_base{detail::default_constructor_tag{}} {} detail::default_constructor_tag{}} {}
template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr> template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
constexpr explicit Expected(unexpect_t, Args&&... args) constexpr explicit Expected(unexpect_t, Args&&... args)

View file

@ -238,7 +238,9 @@ public:
template <typename T> template <typename T>
concept HasRedBlackKeyType = requires { concept HasRedBlackKeyType = requires {
{ std::is_same<typename T::RedBlackKeyType, void>::value } -> std::convertible_to<bool>; {
std::is_same<typename T::RedBlackKeyType, void>::value
} -> std::convertible_to<bool>;
}; };
namespace impl { namespace impl {

View file

@ -25,12 +25,12 @@ public:
MultiLevelPageTable(MultiLevelPageTable&& other) noexcept MultiLevelPageTable(MultiLevelPageTable&& other) noexcept
: address_space_bits{std::exchange(other.address_space_bits, 0)}, : address_space_bits{std::exchange(other.address_space_bits, 0)},
first_level_bits{std::exchange(other.first_level_bits, 0)}, first_level_bits{std::exchange(other.first_level_bits, 0)}, page_bits{std::exchange(
page_bits{std::exchange(other.page_bits, 0)}, other.page_bits, 0)},
first_level_shift{std::exchange(other.first_level_shift, 0)}, first_level_shift{std::exchange(other.first_level_shift, 0)},
first_level_chunk_size{std::exchange(other.first_level_chunk_size, 0)}, first_level_chunk_size{std::exchange(other.first_level_chunk_size, 0)},
first_level_map{std::move(other.first_level_map)}, first_level_map{std::move(other.first_level_map)}, base_ptr{std::exchange(other.base_ptr,
base_ptr{std::exchange(other.base_ptr, nullptr)} {} nullptr)} {}
MultiLevelPageTable& operator=(MultiLevelPageTable&& other) noexcept { MultiLevelPageTable& operator=(MultiLevelPageTable&& other) noexcept {
address_space_bits = std::exchange(other.address_space_bits, 0); address_space_bits = std::exchange(other.address_space_bits, 0);

View file

@ -362,9 +362,7 @@ public:
// _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all // _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all
// component names (x<->r) and permutations (xy<->yx) // component names (x<->r) and permutations (xy<->yx)
#define _DEFINE_SWIZZLER2(a, b, name) \ #define _DEFINE_SWIZZLER2(a, b, name) \
[[nodiscard]] constexpr Vec2<T> name() const { \ [[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
return Vec2<T>(a, b); \
}
#define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4) \ #define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4) \
_DEFINE_SWIZZLER2(a, b, a##b); \ _DEFINE_SWIZZLER2(a, b, a##b); \
_DEFINE_SWIZZLER2(a, b, a2##b2); \ _DEFINE_SWIZZLER2(a, b, a2##b2); \
@ -557,9 +555,7 @@ public:
// DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and // DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and
// permutations (xy<->yx) // permutations (xy<->yx)
#define _DEFINE_SWIZZLER2(a, b, name) \ #define _DEFINE_SWIZZLER2(a, b, name) \
[[nodiscard]] constexpr Vec2<T> name() const { \ [[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
return Vec2<T>(a, b); \
}
#define DEFINE_SWIZZLER2_COMP1(a, a2) \ #define DEFINE_SWIZZLER2_COMP1(a, a2) \
_DEFINE_SWIZZLER2(a, a, a##a); \ _DEFINE_SWIZZLER2(a, a, a##a); \
_DEFINE_SWIZZLER2(a, a, a2##a2) _DEFINE_SWIZZLER2(a, a, a2##a2)
@ -584,9 +580,7 @@ public:
#undef _DEFINE_SWIZZLER2 #undef _DEFINE_SWIZZLER2
#define _DEFINE_SWIZZLER3(a, b, c, name) \ #define _DEFINE_SWIZZLER3(a, b, c, name) \
[[nodiscard]] constexpr Vec3<T> name() const { \ [[nodiscard]] constexpr Vec3<T> name() const { return Vec3<T>(a, b, c); }
return Vec3<T>(a, b, c); \
}
#define DEFINE_SWIZZLER3_COMP1(a, a2) \ #define DEFINE_SWIZZLER3_COMP1(a, a2) \
_DEFINE_SWIZZLER3(a, a, a, a##a##a); \ _DEFINE_SWIZZLER3(a, a, a, a##a##a); \
_DEFINE_SWIZZLER3(a, a, a, a2##a2##a2) _DEFINE_SWIZZLER3(a, a, a, a2##a2##a2)

View file

@ -33,8 +33,8 @@ public:
VirtualBuffer& operator=(const VirtualBuffer&) = delete; VirtualBuffer& operator=(const VirtualBuffer&) = delete;
VirtualBuffer(VirtualBuffer&& other) noexcept VirtualBuffer(VirtualBuffer&& other) noexcept
: alloc_size{std::exchange(other.alloc_size, 0)}, : alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
base_ptr{std::exchange(other.base_ptr), nullptr} {} nullptr} {}
VirtualBuffer& operator=(VirtualBuffer&& other) noexcept { VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
alloc_size = std::exchange(other.alloc_size, 0); alloc_size = std::exchange(other.alloc_size, 0);

View file

@ -8,8 +8,8 @@
namespace Common::X64 { namespace Common::X64 {
NativeClock::NativeClock(u64 rdtsc_frequency_) NativeClock::NativeClock(u64 rdtsc_frequency_)
: rdtsc_frequency{rdtsc_frequency_}, : rdtsc_frequency{rdtsc_frequency_}, ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den,
ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency)}, rdtsc_frequency)},
us_rdtsc_factor{GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency)}, us_rdtsc_factor{GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency)},
ms_rdtsc_factor{GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency)}, ms_rdtsc_factor{GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency)},
cntpct_rdtsc_factor{GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency)}, cntpct_rdtsc_factor{GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency)},

View file

@ -16,8 +16,8 @@ using namespace Common::Literals;
class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks { class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
public: public:
explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process) explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process)
: m_parent{parent}, m_memory(process->GetMemory()), m_process(process), : m_parent{parent}, m_memory(process->GetMemory()),
m_debugger_enabled{parent.m_system.DebuggerEnabled()}, m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()},
m_check_memory_access{m_debugger_enabled || m_check_memory_access{m_debugger_enabled ||
!Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {} !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}

View file

@ -16,8 +16,8 @@ using namespace Common::Literals;
class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks { class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
public: public:
explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process) explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process)
: m_parent{parent}, m_memory(process->GetMemory()), m_process(process), : m_parent{parent}, m_memory(process->GetMemory()),
m_debugger_enabled{parent.m_system.DebuggerEnabled()}, m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()},
m_check_memory_access{m_debugger_enabled || m_check_memory_access{m_debugger_enabled ||
!Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {} !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}

View file

@ -29,8 +29,8 @@ constexpr std::array partition_names{
XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index) XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index)
: file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA}, : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
partitions(partition_names.size()), partitions_raw(partition_names.size()), partitions(partition_names.size()),
keys{Core::Crypto::KeyManager::Instance()} { partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
const auto header_status = TryReadHeader(); const auto header_status = TryReadHeader();
if (header_status != Loader::ResultStatus::Success) { if (header_status != Loader::ResultStatus::Success) {
status = header_status; status = header_status;

View file

@ -91,12 +91,8 @@ public:
} }
#define DECLARE_PATH_FLAG_HANDLER(__WHICH__) \ #define DECLARE_PATH_FLAG_HANDLER(__WHICH__) \
constexpr bool Is##__WHICH__##Allowed() const { \ constexpr bool Is##__WHICH__##Allowed() const { return (m_value & __WHICH__##Flag) != 0; } \
return (m_value & __WHICH__##Flag) != 0; \ constexpr void Allow##__WHICH__() { m_value |= __WHICH__##Flag; }
} \
constexpr void Allow##__WHICH__() { \
m_value |= __WHICH__##Flag; \
}
DECLARE_PATH_FLAG_HANDLER(WindowsPath) DECLARE_PATH_FLAG_HANDLER(WindowsPath)
DECLARE_PATH_FLAG_HANDLER(RelativePath) DECLARE_PATH_FLAG_HANDLER(RelativePath)

View file

@ -19,9 +19,9 @@
namespace FileSys { namespace FileSys {
NSP::NSP(VirtualFile file_, u64 title_id_, std::size_t program_index_) NSP::NSP(VirtualFile file_, u64 title_id_, std::size_t program_index_)
: file(std::move(file_)), expected_program_id(title_id_), program_index(program_index_), : file(std::move(file_)), expected_program_id(title_id_),
status{Loader::ResultStatus::Success}, pfs(std::make_shared<PartitionFilesystem>(file)), program_index(program_index_), status{Loader::ResultStatus::Success},
keys{Core::Crypto::KeyManager::Instance()} { pfs(std::make_shared<PartitionFilesystem>(file)), keys{Core::Crypto::KeyManager::Instance()} {
if (pfs->GetStatus() != Loader::ResultStatus::Success) { if (pfs->GetStatus() != Loader::ResultStatus::Success) {
status = pfs->GetStatus(); status = pfs->GetStatus();
return; return;

View file

@ -44,8 +44,8 @@ static bool CalculateHMAC256(Destination* out, const SourceKey* key, std::size_t
} }
NAX::NAX(VirtualFile file_) NAX::NAX(VirtualFile file_)
: header(std::make_unique<NAXHeader>()), file(std::move(file_)), : header(std::make_unique<NAXHeader>()),
keys{Core::Crypto::KeyManager::Instance()} { file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
std::string path = Common::FS::SanitizePath(file->GetFullPath()); std::string path = Common::FS::SanitizePath(file->GetFullPath());
static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca", static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca",
std::regex_constants::ECMAScript | std::regex_constants::ECMAScript |
@ -62,8 +62,8 @@ NAX::NAX(VirtualFile file_)
} }
NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id) NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
: header(std::make_unique<NAXHeader>()), file(std::move(file_)), : header(std::make_unique<NAXHeader>()),
keys{Core::Crypto::KeyManager::Instance()} { file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
Core::Crypto::SHA256Hash hash{}; Core::Crypto::SHA256Hash hash{};
mbedtls_sha256_ret(nca_id.data(), nca_id.size(), hash.data(), 0); mbedtls_sha256_ret(nca_id.data(), nca_id.size(), hash.data(), 0);
status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0], status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],

View file

@ -24,9 +24,7 @@ private:
friend class ::Kernel::KClassTokenGenerator; \ friend class ::Kernel::KClassTokenGenerator; \
static constexpr inline auto ObjectType = ::Kernel::KClassTokenGenerator::ObjectType::CLASS; \ static constexpr inline auto ObjectType = ::Kernel::KClassTokenGenerator::ObjectType::CLASS; \
static constexpr inline const char* const TypeName = #CLASS; \ static constexpr inline const char* const TypeName = #CLASS; \
static constexpr inline ClassTokenType ClassToken() { \ static constexpr inline ClassTokenType ClassToken() { return ::Kernel::ClassToken<CLASS>; } \
return ::Kernel::ClassToken<CLASS>; \
} \
\ \
public: \ public: \
SUYU_NON_COPYABLE(CLASS); \ SUYU_NON_COPYABLE(CLASS); \
@ -37,15 +35,9 @@ public:
constexpr ClassTokenType Token = ClassToken(); \ constexpr ClassTokenType Token = ClassToken(); \
return TypeObj(TypeName, Token); \ return TypeObj(TypeName, Token); \
} \ } \
static constexpr const char* GetStaticTypeName() { \ static constexpr const char* GetStaticTypeName() { return TypeName; } \
return TypeName; \ virtual TypeObj GetTypeObj() ATTRIBUTE { return GetStaticTypeObj(); } \
} \ virtual const char* GetTypeName() ATTRIBUTE { return GetStaticTypeName(); } \
virtual TypeObj GetTypeObj() ATTRIBUTE { \
return GetStaticTypeObj(); \
} \
virtual const char* GetTypeName() ATTRIBUTE { \
return GetStaticTypeName(); \
} \
\ \
private: \ private: \
constexpr bool operator!=(const TypeObj& rhs) constexpr bool operator!=(const TypeObj& rhs)

View file

@ -128,8 +128,8 @@ KVirtualAddress KMemoryRegionTree::GetRandomAlignedRegion(size_t size, size_t al
KMemoryLayout::KMemoryLayout() KMemoryLayout::KMemoryLayout()
: m_virtual_tree{m_memory_region_allocator}, m_physical_tree{m_memory_region_allocator}, : m_virtual_tree{m_memory_region_allocator}, m_physical_tree{m_memory_region_allocator},
m_virtual_linear_tree{m_memory_region_allocator}, m_virtual_linear_tree{m_memory_region_allocator}, m_physical_linear_tree{
m_physical_linear_tree{m_memory_region_allocator} {} m_memory_region_allocator} {}
void KMemoryLayout::InitializeLinearMemoryRegionTrees(KPhysicalAddress aligned_linear_phys_start, void KMemoryLayout::InitializeLinearMemoryRegionTrees(KPhysicalAddress aligned_linear_phys_start,
KVirtualAddress linear_virtual_start) { KVirtualAddress linear_virtual_start) {

View file

@ -17,7 +17,8 @@ namespace Kernel {
class KThread; class KThread;
template <typename T> template <typename T>
concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T& t) { concept KPriorityQueueAffinityMask = !
std::is_reference_v<T>&& requires(T& t) {
{ t.GetAffinityMask() } -> Common::ConvertibleTo<u64>; { t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
{ t.SetAffinityMask(0) }; { t.SetAffinityMask(0) };
@ -27,17 +28,22 @@ concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T& t) {
}; };
template <typename T> template <typename T>
concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T& t) { concept KPriorityQueueMember = !
std::is_reference_v<T>&& requires(T& t) {
{ typename T::QueueEntry() }; { typename T::QueueEntry() };
{ (typename T::QueueEntry()).Initialize() }; { (typename T::QueueEntry()).Initialize() };
{ (typename T::QueueEntry()).SetPrev(std::addressof(t)) }; { (typename T::QueueEntry()).SetPrev(std::addressof(t)) };
{ (typename T::QueueEntry()).SetNext(std::addressof(t)) }; { (typename T::QueueEntry()).SetNext(std::addressof(t)) };
{ (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>; { (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
{ (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>; { (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
{ t.GetPriorityQueueEntry(0) } -> std::same_as<typename T::QueueEntry&>; {
t.GetPriorityQueueEntry(0)
} -> std::same_as<typename T::QueueEntry&>;
{ t.GetAffinityMask() }; { t.GetAffinityMask() };
{ std::remove_cvref_t<decltype(t.GetAffinityMask())>() } -> KPriorityQueueAffinityMask; {
std::remove_cvref_t<decltype(t.GetAffinityMask())>()
} -> KPriorityQueueAffinityMask;
{ t.GetActiveCore() } -> Common::ConvertibleTo<s32>; { t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
{ t.GetPriority() } -> Common::ConvertibleTo<s32>; { t.GetPriority() } -> Common::ConvertibleTo<s32>;

View file

@ -10,7 +10,8 @@
namespace Kernel { namespace Kernel {
template <typename T> template <typename T>
concept KLockable = !std::is_reference_v<T> && requires(T& t) { concept KLockable = !
std::is_reference_v<T>&& requires(T& t) {
{ t.Lock() } -> std::same_as<void>; { t.Lock() } -> std::same_as<void>;
{ t.Unlock() } -> std::same_as<void>; { t.Unlock() } -> std::same_as<void>;
}; };

View file

@ -458,13 +458,9 @@ constexpr inline Result __TmpCurrentResultReference = ResultSuccess;
if (true) if (true)
#define R_CONVERT(catch_type, convert_type) \ #define R_CONVERT(catch_type, convert_type) \
R_CATCH(catch_type) { \ R_CATCH(catch_type) { R_THROW(static_cast<Result>(convert_type)); }
R_THROW(static_cast<Result>(convert_type)); \
}
#define R_CONVERT_ALL(convert_type) \ #define R_CONVERT_ALL(convert_type) \
R_CATCH_ALL() { \ R_CATCH_ALL() { R_THROW(static_cast<Result>(convert_type)); }
R_THROW(static_cast<Result>(convert_type)); \
}
#define R_ASSERT(res_expr) ASSERT(R_SUCCEEDED(res_expr)) #define R_ASSERT(res_expr) ASSERT(R_SUCCEEDED(res_expr))

View file

@ -1028,8 +1028,8 @@ void Module::Interface::TrySelectUserWithoutInteraction(HLERequestContext& ctx)
Module::Interface::Interface(std::shared_ptr<Module> module_, Module::Interface::Interface(std::shared_ptr<Module> module_,
std::shared_ptr<ProfileManager> profile_manager_, std::shared_ptr<ProfileManager> profile_manager_,
Core::System& system_, const char* name) Core::System& system_, const char* name)
: ServiceFramework{system_, name}, module{std::move(module_)}, : ServiceFramework{system_, name}, module{std::move(module_)}, profile_manager{std::move(
profile_manager{std::move(profile_manager_)} {} profile_manager_)} {}
Module::Interface::~Interface() = default; Module::Interface::~Interface() = default;

View file

@ -18,8 +18,9 @@ namespace Service::AM::Frontend {
Cabinet::Cabinet(Core::System& system_, std::shared_ptr<Applet> applet_, Cabinet::Cabinet(Core::System& system_, std::shared_ptr<Applet> applet_,
LibraryAppletMode applet_mode_, const Core::Frontend::CabinetApplet& frontend_) LibraryAppletMode applet_mode_, const Core::Frontend::CabinetApplet& frontend_)
: FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_}, : FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_}, service_context{
service_context{system_, "CabinetApplet"} { system_,
"CabinetApplet"} {
availability_change_event = availability_change_event =
service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent"); service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent");

View file

@ -18,8 +18,8 @@ namespace Service::AM {
IApplicationProxy::IApplicationProxy(Core::System& system_, std::shared_ptr<Applet> applet, IApplicationProxy::IApplicationProxy(Core::System& system_, std::shared_ptr<Applet> applet,
Kernel::KProcess* process, WindowSystem& window_system) Kernel::KProcess* process, WindowSystem& window_system)
: ServiceFramework{system_, "IApplicationProxy"}, m_window_system{window_system}, : ServiceFramework{system_, "IApplicationProxy"},
m_process{process}, m_applet{std::move(applet)} { m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IApplicationProxy::GetCommonStateGetter>, "GetCommonStateGetter"}, {0, D<&IApplicationProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

View file

@ -165,8 +165,8 @@ std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& syste
ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_, std::shared_ptr<Applet> applet, ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_, std::shared_ptr<Applet> applet,
WindowSystem& window_system) WindowSystem& window_system)
: ServiceFramework{system_, "ILibraryAppletCreator"}, m_window_system{window_system}, : ServiceFramework{system_, "ILibraryAppletCreator"},
m_applet{std::move(applet)} { m_window_system{window_system}, m_applet{std::move(applet)} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&ILibraryAppletCreator::CreateLibraryApplet>, "CreateLibraryApplet"}, {0, D<&ILibraryAppletCreator::CreateLibraryApplet>, "CreateLibraryApplet"},
{1, nullptr, "TerminateAllLibraryApplets"}, {1, nullptr, "TerminateAllLibraryApplets"},

View file

@ -20,8 +20,8 @@ namespace Service::AM {
ILibraryAppletProxy::ILibraryAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet, ILibraryAppletProxy::ILibraryAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
Kernel::KProcess* process, WindowSystem& window_system) Kernel::KProcess* process, WindowSystem& window_system)
: ServiceFramework{system_, "ILibraryAppletProxy"}, m_window_system{window_system}, : ServiceFramework{system_, "ILibraryAppletProxy"},
m_process{process}, m_applet{std::move(applet)} { m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&ILibraryAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"}, {0, D<&ILibraryAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

View file

@ -16,8 +16,8 @@ namespace Service::AM {
ISelfController::ISelfController(Core::System& system_, std::shared_ptr<Applet> applet, ISelfController::ISelfController(Core::System& system_, std::shared_ptr<Applet> applet,
Kernel::KProcess* process) Kernel::KProcess* process)
: ServiceFramework{system_, "ISelfController"}, m_process{process}, : ServiceFramework{system_, "ISelfController"}, m_process{process}, m_applet{
m_applet{std::move(applet)} { std::move(applet)} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&ISelfController::Exit>, "Exit"}, {0, D<&ISelfController::Exit>, "Exit"},

View file

@ -20,8 +20,8 @@ namespace Service::AM {
ISystemAppletProxy::ISystemAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet, ISystemAppletProxy::ISystemAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
Kernel::KProcess* process, WindowSystem& window_system) Kernel::KProcess* process, WindowSystem& window_system)
: ServiceFramework{system_, "ISystemAppletProxy"}, m_window_system{window_system}, : ServiceFramework{system_, "ISystemAppletProxy"},
m_process{process}, m_applet{std::move(applet)} { m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&ISystemAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"}, {0, D<&ISystemAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

View file

@ -11,8 +11,8 @@ namespace Service::AM {
IWindowController::IWindowController(Core::System& system_, std::shared_ptr<Applet> applet, IWindowController::IWindowController(Core::System& system_, std::shared_ptr<Applet> applet,
WindowSystem& window_system) WindowSystem& window_system)
: ServiceFramework{system_, "IWindowController"}, m_window_system{window_system}, : ServiceFramework{system_, "IWindowController"},
m_applet{std::move(applet)} { m_window_system{window_system}, m_applet{std::move(applet)} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, nullptr, "CreateWindow"}, {0, nullptr, "CreateWindow"},

View file

@ -9,8 +9,8 @@ namespace Service::AOC {
constexpr Result ResultNoPurchasedProductInfoAvailable{ErrorModule::NIMShop, 400}; constexpr Result ResultNoPurchasedProductInfoAvailable{ErrorModule::NIMShop, 400};
IPurchaseEventManager::IPurchaseEventManager(Core::System& system_) IPurchaseEventManager::IPurchaseEventManager(Core::System& system_)
: ServiceFramework{system_, "IPurchaseEventManager"}, : ServiceFramework{system_, "IPurchaseEventManager"}, service_context{system,
service_context{system, "IPurchaseEventManager"} { "IPurchaseEventManager"} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"}, {0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},

View file

@ -12,8 +12,9 @@ IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
const std::string& device_name, const AudioInParameter& in_params, const std::string& device_name, const AudioInParameter& in_params,
Kernel::KProcess* handle, u64 applet_resource_user_id) Kernel::KProcess* handle, u64 applet_resource_user_id)
: ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"}, : ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"},
event{service_context.CreateEvent("AudioInEvent")}, event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_,
impl{std::make_shared<In>(system_, manager, event, session_id)} { manager, event,
session_id)} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"}, {0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"},

View file

@ -10,8 +10,8 @@ namespace Service::Audio {
using namespace AudioCore::AudioIn; using namespace AudioCore::AudioIn;
IAudioInManager::IAudioInManager(Core::System& system_) IAudioInManager::IAudioInManager(Core::System& system_)
: ServiceFramework{system_, "audin:u"}, : ServiceFramework{system_, "audin:u"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)} { system_)} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IAudioInManager::ListAudioIns>, "ListAudioIns"}, {0, D<&IAudioInManager::ListAudioIns>, "ListAudioIns"},

View file

@ -14,8 +14,8 @@ IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
s32 session_id) s32 session_id)
: ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"}, : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_}, rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
impl{std::make_unique<Renderer>(system_, manager, rendered_event)}, impl{std::make_unique<Renderer>(system_, manager, rendered_event)}, process_handle{
process_handle{process_handle_} { process_handle_} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"}, {0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"},

View file

@ -7,8 +7,9 @@
namespace Service::News { namespace Service::News {
INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_) INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
: ServiceFramework{system_, "INewlyArrivedEventHolder"}, : ServiceFramework{system_, "INewlyArrivedEventHolder"}, service_context{
service_context{system_, "INewlyArrivedEventHolder"} { system_,
"INewlyArrivedEventHolder"} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&INewlyArrivedEventHolder::Get>, "Get"}, {0, D<&INewlyArrivedEventHolder::Get>, "Get"},

View file

@ -7,8 +7,8 @@
namespace Service::News { namespace Service::News {
IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_) IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
: ServiceFramework{system_, "IOverwriteEventHolder"}, : ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
service_context{system_, "IOverwriteEventHolder"} { "IOverwriteEventHolder"} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IOverwriteEventHolder::Get>, "Get"}, {0, D<&IOverwriteEventHolder::Get>, "Get"},

View file

@ -11,8 +11,8 @@
namespace Service::FileSystem { namespace Service::FileSystem {
IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_getter_) IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_getter_)
: ServiceFramework{system_, "IFileSystem"}, : ServiceFramework{system_, "IFileSystem"}, backend{std::make_unique<FileSys::Fsa::IFileSystem>(
backend{std::make_unique<FileSys::Fsa::IFileSystem>(dir_)}, dir_)},
size_getter{std::move(size_getter_)} { size_getter{std::move(size_getter_)} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IFileSystem::CreateFile>, "CreateFile"}, {0, D<&IFileSystem::CreateFile>, "CreateFile"},

View file

@ -12,8 +12,8 @@ namespace Service::FileSystem {
ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_, ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_,
std::shared_ptr<SaveDataController> save_data_controller_, std::shared_ptr<SaveDataController> save_data_controller_,
FileSys::SaveDataSpaceId space) FileSys::SaveDataSpaceId space)
: ServiceFramework{system_, "ISaveDataInfoReader"}, : ServiceFramework{system_, "ISaveDataInfoReader"}, save_data_controller{
save_data_controller{save_data_controller_} { save_data_controller_} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&ISaveDataInfoReader::ReadSaveDataInfo>, "ReadSaveDataInfo"}, {0, D<&ISaveDataInfoReader::ReadSaveDataInfo>, "ReadSaveDataInfo"},
}; };

View file

@ -11,8 +11,8 @@
namespace Service::Glue::Time { namespace Service::Glue::Time {
AlarmWorker::AlarmWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource) AlarmWorker::AlarmWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource)
: m_system{system}, m_ctx{system, "Glue:AlarmWorker"}, : m_system{system}, m_ctx{system, "Glue:AlarmWorker"}, m_steady_clock_resource{
m_steady_clock_resource{steady_clock_resource} {} steady_clock_resource} {}
AlarmWorker::~AlarmWorker() { AlarmWorker::~AlarmWorker() {
m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event); m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);

View file

@ -87,8 +87,10 @@ static Service::PSC::Time::LocationName GetTimeZoneString(
} }
TimeManager::TimeManager(Core::System& system) TimeManager::TimeManager(Core::System& system)
: m_steady_clock_resource{system}, m_time_zone_binary{system}, : m_steady_clock_resource{system}, m_time_zone_binary{system}, m_worker{
m_worker{system, m_steady_clock_resource, m_file_timestamp_worker} { system,
m_steady_clock_resource,
m_file_timestamp_worker} {
m_time_m = m_time_m =
system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true); system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);

View file

@ -22,9 +22,9 @@ TimeZoneService::TimeZoneService(
std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service) std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service)
: ServiceFramework{system_, "ITimeZoneService"}, m_system{system}, : ServiceFramework{system_, "ITimeZoneService"}, m_system{system},
m_can_write_timezone_device_location{can_write_timezone_device_location}, m_can_write_timezone_device_location{can_write_timezone_device_location},
m_file_timestamp_worker{file_timestamp_worker}, m_file_timestamp_worker{file_timestamp_worker}, m_wrapped_service{std::move(
m_wrapped_service{std::move(time_zone_service)}, m_operation_event{m_system}, time_zone_service)},
m_time_zone_binary{time_zone_binary} { m_operation_event{m_system}, m_time_zone_binary{time_zone_binary} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"}, {0, D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},

View file

@ -19,11 +19,11 @@ namespace Service::Glue::Time {
TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource, TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
FileTimestampWorker& file_timestamp_worker) FileTimestampWorker& file_timestamp_worker)
: m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, : m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, m_event{m_ctx.CreateEvent(
m_event{m_ctx.CreateEvent("Glue:TimeWorker:Event")}, "Glue:TimeWorker:Event")},
m_steady_clock_resource{steady_clock_resource}, m_steady_clock_resource{steady_clock_resource},
m_file_timestamp_worker{file_timestamp_worker}, m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent(
m_timer_steady_clock{m_ctx.CreateEvent("Glue:TimeWorker:SteadyClockTimerEvent")}, "Glue:TimeWorker:SteadyClockTimerEvent")},
m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")}, m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")},
m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} { m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
m_timer_steady_clock_timing_event = Core::Timing::CreateEvent( m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(

View file

@ -17,8 +17,8 @@ namespace Service::HID {
IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<ResourceManager> resource, IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<ResourceManager> resource,
std::shared_ptr<HidFirmwareSettings> settings) std::shared_ptr<HidFirmwareSettings> settings)
: ServiceFramework{system_, "hid:dbg"}, resource_manager{resource}, : ServiceFramework{system_, "hid:dbg"}, resource_manager{resource}, firmware_settings{
firmware_settings{settings} { settings} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, nullptr, "DeactivateDebugPad"}, {0, nullptr, "DeactivateDebugPad"},

View file

@ -72,8 +72,8 @@ public:
u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0, u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0,
Flags flags = Flags::None) Flags flags = Flags::None)
: RequestHelperBase(ctx), normal_params_size(normal_params_size_), : RequestHelperBase(ctx), normal_params_size(normal_params_size_),
num_handles_to_copy(num_handles_to_copy_), num_objects_to_move(num_objects_to_move_), num_handles_to_copy(num_handles_to_copy_),
kernel{ctx.kernel} { num_objects_to_move(num_objects_to_move_), kernel{ctx.kernel} {
memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH); memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);

View file

@ -40,8 +40,8 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
public: public:
explicit DynarmicCallbacks64(Core::Memory::Memory& memory_, std::vector<u8>& local_memory_, explicit DynarmicCallbacks64(Core::Memory::Memory& memory_, std::vector<u8>& local_memory_,
IntervalSet& mapped_ranges_, JITContextImpl& parent_) IntervalSet& mapped_ranges_, JITContextImpl& parent_)
: memory{memory_}, local_memory{local_memory_}, mapped_ranges{mapped_ranges_}, : memory{memory_}, local_memory{local_memory_},
parent{parent_} {} mapped_ranges{mapped_ranges_}, parent{parent_} {}
u8 MemoryRead8(u64 vaddr) override { u8 MemoryRead8(u64 vaddr) override {
return ReadMemory<u8>(vaddr); return ReadMemory<u8>(vaddr);

View file

@ -23,8 +23,8 @@ class IDatabaseService final : public ServiceFramework<IDatabaseService> {
public: public:
explicit IDatabaseService(Core::System& system_, std::shared_ptr<MiiManager> mii_manager, explicit IDatabaseService(Core::System& system_, std::shared_ptr<MiiManager> mii_manager,
bool is_system_) bool is_system_)
: ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager}, : ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager}, is_system{
is_system{is_system_} { is_system_} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IDatabaseService::IsUpdated>, "IsUpdated"}, {0, D<&IDatabaseService::IsUpdated>, "IsUpdated"},

View file

@ -30,8 +30,8 @@ Alarm::~Alarm() {
Alarms::Alarms(Core::System& system, StandardSteadyClockCore& steady_clock, Alarms::Alarms(Core::System& system, StandardSteadyClockCore& steady_clock,
PowerStateRequestManager& power_state_request_manager) PowerStateRequestManager& power_state_request_manager)
: m_system{system}, m_ctx{system, "Psc:Alarms"}, m_steady_clock{steady_clock}, : m_system{system}, m_ctx{system, "Psc:Alarms"}, m_steady_clock{steady_clock},
m_power_state_request_manager{power_state_request_manager}, m_power_state_request_manager{power_state_request_manager}, m_event{m_ctx.CreateEvent(
m_event{m_ctx.CreateEvent("Psc:Alarms:Event")} {} "Psc:Alarms:Event")} {}
Alarms::~Alarms() { Alarms::~Alarms() {
m_ctx.CloseEvent(m_event); m_ctx.CloseEvent(m_event);

View file

@ -11,8 +11,8 @@ StandardUserSystemClockCore::StandardUserSystemClockCore(
StandardNetworkSystemClockCore& network_clock) StandardNetworkSystemClockCore& network_clock)
: SystemClockCore{local_clock.GetSteadyClock()}, m_system{system}, : SystemClockCore{local_clock.GetSteadyClock()}, m_system{system},
m_ctx{m_system, "Psc:StandardUserSystemClockCore"}, m_local_system_clock{local_clock}, m_ctx{m_system, "Psc:StandardUserSystemClockCore"}, m_local_system_clock{local_clock},
m_network_system_clock{network_clock}, m_network_system_clock{network_clock}, m_event{m_ctx.CreateEvent(
m_event{m_ctx.CreateEvent("Psc:StandardUserSystemClockCore:Event")} {} "Psc:StandardUserSystemClockCore:Event")} {}
StandardUserSystemClockCore::~StandardUserSystemClockCore() { StandardUserSystemClockCore::~StandardUserSystemClockCore() {
m_ctx.CloseEvent(m_event); m_ctx.CloseEvent(m_event);

View file

@ -6,8 +6,8 @@
namespace Service::PSC::Time { namespace Service::PSC::Time {
OperationEvent::OperationEvent(Core::System& system) OperationEvent::OperationEvent(Core::System& system)
: m_ctx{system, "Time:OperationEvent"}, : m_ctx{system, "Time:OperationEvent"}, m_event{
m_event{m_ctx.CreateEvent("Time:OperationEvent:Event")} {} m_ctx.CreateEvent("Time:OperationEvent:Event")} {}
OperationEvent::~OperationEvent() { OperationEvent::~OperationEvent() {
m_ctx.CloseEvent(m_event); m_ctx.CloseEvent(m_event);

View file

@ -29,8 +29,8 @@ public:
m_standard_user_system_clock{m_system, m_standard_local_system_clock, m_standard_user_system_clock{m_system, m_standard_local_system_clock,
m_standard_network_system_clock}, m_standard_network_system_clock},
m_ephemeral_network_clock{m_tick_based_steady_clock}, m_shared_memory{m_system}, m_ephemeral_network_clock{m_tick_based_steady_clock}, m_shared_memory{m_system},
m_power_state_request_manager{m_system}, m_power_state_request_manager{m_system}, m_alarms{m_system, m_standard_steady_clock,
m_alarms{m_system, m_standard_steady_clock, m_power_state_request_manager}, m_power_state_request_manager},
m_local_system_clock_context_writer{m_system, m_shared_memory}, m_local_system_clock_context_writer{m_system, m_shared_memory},
m_network_system_clock_context_writer{m_system, m_shared_memory, m_network_system_clock_context_writer{m_system, m_shared_memory,
m_standard_user_system_clock}, m_standard_user_system_clock},

View file

@ -8,8 +8,8 @@ namespace Service::PSC::Time {
IPowerStateRequestHandler::IPowerStateRequestHandler( IPowerStateRequestHandler::IPowerStateRequestHandler(
Core::System& system_, PowerStateRequestManager& power_state_request_manager) Core::System& system_, PowerStateRequestManager& power_state_request_manager)
: ServiceFramework{system_, "time:p"}, m_system{system}, : ServiceFramework{system_, "time:p"}, m_system{system}, m_power_state_request_manager{
m_power_state_request_manager{power_state_request_manager} { power_state_request_manager} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"}, {0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"},

View file

@ -37,8 +37,8 @@ StaticService::StaticService(Core::System& system_, StaticServiceSetupInfo setup
m_user_system_clock{m_time->m_standard_user_system_clock}, m_user_system_clock{m_time->m_standard_user_system_clock},
m_network_system_clock{m_time->m_standard_network_system_clock}, m_network_system_clock{m_time->m_standard_network_system_clock},
m_time_zone{m_time->m_time_zone}, m_time_zone{m_time->m_time_zone},
m_ephemeral_network_clock{m_time->m_ephemeral_network_clock}, m_ephemeral_network_clock{m_time->m_ephemeral_network_clock}, m_shared_memory{
m_shared_memory{m_time->m_shared_memory} { m_time->m_shared_memory} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"}, {0, D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"},

View file

@ -12,8 +12,8 @@ SteadyClock::SteadyClock(Core::System& system_, std::shared_ptr<TimeManager> man
bool can_write_steady_clock, bool can_write_uninitialized_clock) bool can_write_steady_clock, bool can_write_uninitialized_clock)
: ServiceFramework{system_, "ISteadyClock"}, m_system{system}, : ServiceFramework{system_, "ISteadyClock"}, m_system{system},
m_clock_core{manager->m_standard_steady_clock}, m_clock_core{manager->m_standard_steady_clock},
m_can_write_steady_clock{can_write_steady_clock}, m_can_write_steady_clock{can_write_steady_clock}, m_can_write_uninitialized_clock{
m_can_write_uninitialized_clock{can_write_uninitialized_clock} { can_write_uninitialized_clock} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&SteadyClock::GetCurrentTimePoint>, "GetCurrentTimePoint"}, {0, D<&SteadyClock::GetCurrentTimePoint>, "GetCurrentTimePoint"},

View file

@ -11,8 +11,8 @@ namespace Service::PSC::Time {
SystemClock::SystemClock(Core::System& system_, SystemClockCore& clock_core, bool can_write_clock, SystemClock::SystemClock(Core::System& system_, SystemClockCore& clock_core, bool can_write_clock,
bool can_write_uninitialized_clock) bool can_write_uninitialized_clock)
: ServiceFramework{system_, "ISystemClock"}, m_system{system}, m_clock_core{clock_core}, : ServiceFramework{system_, "ISystemClock"}, m_system{system}, m_clock_core{clock_core},
m_can_write_clock{can_write_clock}, m_can_write_clock{can_write_clock}, m_can_write_uninitialized_clock{
m_can_write_uninitialized_clock{can_write_uninitialized_clock} { can_write_uninitialized_clock} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&SystemClock::GetCurrentTime>, "GetCurrentTime"}, {0, D<&SystemClock::GetCurrentTime>, "GetCurrentTime"},

View file

@ -13,8 +13,8 @@ namespace Service::PSC::Time {
TimeZoneService::TimeZoneService(Core::System& system_, StandardSteadyClockCore& clock_core, TimeZoneService::TimeZoneService(Core::System& system_, StandardSteadyClockCore& clock_core,
TimeZone& time_zone, bool can_write_timezone_device_location) TimeZone& time_zone, bool can_write_timezone_device_location)
: ServiceFramework{system_, "ITimeZoneService"}, m_system{system}, m_clock_core{clock_core}, : ServiceFramework{system_, "ITimeZoneService"}, m_system{system}, m_clock_core{clock_core},
m_time_zone{time_zone}, m_time_zone{time_zone}, m_can_write_timezone_device_location{
m_can_write_timezone_device_location{can_write_timezone_device_location} { can_write_timezone_device_location} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"}, {0, D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},

View file

@ -251,8 +251,8 @@ void SM::UnregisterService(HLERequestContext& ctx) {
} }
SM::SM(ServiceManager& service_manager_, Core::System& system_) SM::SM(ServiceManager& service_manager_, Core::System& system_)
: ServiceFramework{system_, "sm:", 4}, service_manager{service_manager_}, : ServiceFramework{system_, "sm:", 4},
kernel{system_.Kernel()} { service_manager{service_manager_}, kernel{system_.Kernel()} {
RegisterHandlers({ RegisterHandlers({
{0, &SM::Initialize, "Initialize"}, {0, &SM::Initialize, "Initialize"},
{1, &SM::GetServiceCmif, "GetService"}, {1, &SM::GetServiceCmif, "GetService"},

View file

@ -15,8 +15,8 @@ namespace Service::VI {
IApplicationDisplayService::IApplicationDisplayService(Core::System& system_, IApplicationDisplayService::IApplicationDisplayService(Core::System& system_,
std::shared_ptr<Container> container) std::shared_ptr<Container> container)
: ServiceFramework{system_, "IApplicationDisplayService"}, m_container{std::move(container)}, : ServiceFramework{system_, "IApplicationDisplayService"},
m_context{system, "IApplicationDisplayService"} { m_container{std::move(container)}, m_context{system, "IApplicationDisplayService"} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{100, C<&IApplicationDisplayService::GetRelayService>, "GetRelayService"}, {100, C<&IApplicationDisplayService::GetRelayService>, "GetRelayService"},

View file

@ -218,8 +218,8 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
CheatEngine::CheatEngine(System& system_, std::vector<CheatEntry> cheats_, CheatEngine::CheatEngine(System& system_, std::vector<CheatEntry> cheats_,
const std::array<u8, 0x20>& build_id_) const std::array<u8, 0x20>& build_id_)
: vm{std::make_unique<StandardVmCallbacks>(system_, metadata)}, cheats(std::move(cheats_)), : vm{std::make_unique<StandardVmCallbacks>(system_, metadata)},
core_timing{system_.CoreTiming()}, system{system_} { cheats(std::move(cheats_)), core_timing{system_.CoreTiming()}, system{system_} {
metadata.main_nso_build_id = build_id_; metadata.main_nso_build_id = build_id_;
} }

View file

@ -148,8 +148,8 @@ public:
Common::Input::AnalogProperties properties_y_, Common::Input::AnalogProperties properties_y_,
InputEngine* input_engine_) InputEngine* input_engine_)
: identifier(identifier_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_), : identifier(identifier_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
properties_y(properties_y_), input_engine(input_engine_), properties_y(properties_y_),
invert_axis_y{input_engine_->GetEngineName() == "sdl"} { input_engine(input_engine_), invert_axis_y{input_engine_->GetEngineName() == "sdl"} {
UpdateCallback engine_callback{[this]() { OnChange(); }}; UpdateCallback engine_callback{[this]() { OnChange(); }};
const InputIdentifier x_input_identifier{ const InputIdentifier x_input_identifier{
.identifier = identifier, .identifier = identifier,

View file

@ -186,8 +186,8 @@ Function::Function(ObjectPool<Block>& block_pool, Location start_address)
CFG::CFG(Environment& env_, ObjectPool<Block>& block_pool_, Location start_address, CFG::CFG(Environment& env_, ObjectPool<Block>& block_pool_, Location start_address,
bool exits_to_dispatcher_) bool exits_to_dispatcher_)
: env{env_}, block_pool{block_pool_}, program_start{start_address}, : env{env_}, block_pool{block_pool_}, program_start{start_address}, exits_to_dispatcher{
exits_to_dispatcher{exits_to_dispatcher_} { exits_to_dispatcher_} {
if (exits_to_dispatcher) { if (exits_to_dispatcher) {
dispatch_block = block_pool.Create(Block{}); dispatch_block = block_pool.Create(Block{});
dispatch_block->begin = {}; dispatch_block->begin = {};

View file

@ -112,8 +112,8 @@ struct Statement : ListBaseHook {
Statement(SetVariable, u32 id_, Statement* op_, Statement* up_) Statement(SetVariable, u32 id_, Statement* op_, Statement* up_)
: op{op_}, id{id_}, up{up_}, type{StatementType::SetVariable} {} : op{op_}, id{id_}, up{up_}, type{StatementType::SetVariable} {}
Statement(SetIndirectBranchVariable, IR::Reg branch_reg_, s32 branch_offset_, Statement* up_) Statement(SetIndirectBranchVariable, IR::Reg branch_reg_, s32 branch_offset_, Statement* up_)
: branch_offset{branch_offset_}, branch_reg{branch_reg_}, up{up_}, : branch_offset{branch_offset_},
type{StatementType::SetIndirectBranchVariable} {} branch_reg{branch_reg_}, up{up_}, type{StatementType::SetIndirectBranchVariable} {}
Statement(Variable, u32 id_, Statement* up_) Statement(Variable, u32 id_, Statement* up_)
: id{id_}, up{up_}, type{StatementType::Variable} {} : id{id_}, up{up_}, type{StatementType::Variable} {}
Statement(IndirectBranchCond, u32 location_, Statement* up_) Statement(IndirectBranchCond, u32 location_, Statement* up_)

View file

@ -54,8 +54,8 @@ QtNXWebEngineView::QtNXWebEngineView(QWidget* parent, Core::System& system,
: QWebEngineView(parent), input_subsystem{input_subsystem_}, : QWebEngineView(parent), input_subsystem{input_subsystem_},
url_interceptor(std::make_unique<UrlRequestInterceptor>()), url_interceptor(std::make_unique<UrlRequestInterceptor>()),
input_interpreter(std::make_unique<InputInterpreter>(system)), input_interpreter(std::make_unique<InputInterpreter>(system)),
default_profile{QWebEngineProfile::defaultProfile()}, default_profile{QWebEngineProfile::defaultProfile()}, global_settings{
global_settings{default_profile->settings()} { default_profile->settings()} {
default_profile->setPersistentStoragePath(QString::fromStdString(Common::FS::PathToUTF8String( default_profile->setPersistentStoragePath(QString::fromStdString(Common::FS::PathToUTF8String(
Common::FS::GetSuyuPath(Common::FS::SuyuPath::SuyuDir) / "qtwebengine"))); Common::FS::GetSuyuPath(Common::FS::SuyuPath::SuyuDir) / "qtwebengine")));

View file

@ -284,8 +284,8 @@ struct NullRenderWidget : public RenderWidget {
GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread_, GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread_,
std::shared_ptr<InputCommon::InputSubsystem> input_subsystem_, std::shared_ptr<InputCommon::InputSubsystem> input_subsystem_,
Core::System& system_) Core::System& system_)
: QWidget(parent), emu_thread(emu_thread_), input_subsystem{std::move(input_subsystem_)}, : QWidget(parent),
system{system_} { emu_thread(emu_thread_), input_subsystem{std::move(input_subsystem_)}, system{system_} {
setWindowTitle(QStringLiteral("suyu %1 | %2-%3") setWindowTitle(QStringLiteral("suyu %1 | %2-%3")
.arg(QString::fromUtf8(Common::g_build_name), .arg(QString::fromUtf8(Common::g_build_name),
QString::fromUtf8(Common::g_scm_branch), QString::fromUtf8(Common::g_scm_branch),

View file

@ -32,9 +32,9 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
InputCommon::InputSubsystem* input_subsystem, InputCommon::InputSubsystem* input_subsystem,
std::vector<VkDeviceInfo::Record>& vk_device_records, std::vector<VkDeviceInfo::Record>& vk_device_records,
Core::System& system_, bool enable_web_config) Core::System& system_, bool enable_web_config)
: QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()}, registry(registry_), : QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()},
system{system_}, registry(registry_), system{system_}, builder{std::make_unique<ConfigurationShared::Builder>(
builder{std::make_unique<ConfigurationShared::Builder>(this, !system_.IsPoweredOn())}, this, !system_.IsPoweredOn())},
applets_tab{std::make_unique<ConfigureApplets>(system_, nullptr, *builder, this)}, applets_tab{std::make_unique<ConfigureApplets>(system_, nullptr, *builder, this)},
audio_tab{std::make_unique<ConfigureAudio>(system_, nullptr, *builder, this)}, audio_tab{std::make_unique<ConfigureAudio>(system_, nullptr, *builder, this)},
cpu_tab{std::make_unique<ConfigureCpu>(system_, nullptr, *builder, this)}, cpu_tab{std::make_unique<ConfigureCpu>(system_, nullptr, *builder, this)},

View file

@ -293,11 +293,11 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
InputCommon::InputSubsystem* input_subsystem_, InputCommon::InputSubsystem* input_subsystem_,
InputProfiles* profiles_, Core::HID::HIDCore& hid_core_, InputProfiles* profiles_, Core::HID::HIDCore& hid_core_,
bool is_powered_on_, bool debug_) bool is_powered_on_, bool debug_)
: QWidget(parent), ui(std::make_unique<Ui::ConfigureInputPlayer>()), : QWidget(parent),
player_index{player_index_}, debug{debug_}, is_powered_on{is_powered_on_}, ui(std::make_unique<Ui::ConfigureInputPlayer>()), player_index{player_index_}, debug{debug_},
input_subsystem{input_subsystem_}, profiles(profiles_), is_powered_on{is_powered_on_}, input_subsystem{input_subsystem_}, profiles(profiles_),
timeout_timer(std::make_unique<QTimer>()), poll_timer(std::make_unique<QTimer>()), timeout_timer(std::make_unique<QTimer>()),
bottom_row{bottom_row_}, hid_core{hid_core_} { poll_timer(std::make_unique<QTimer>()), bottom_row{bottom_row_}, hid_core{hid_core_} {
if (player_index == 0) { if (player_index == 0) {
auto* emulated_controller_p1 = auto* emulated_controller_p1 =
hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1); hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1);

View file

@ -766,8 +766,8 @@ Widget::Widget(Settings::BasicSetting* setting_, const TranslationMap& translati
Builder::Builder(QWidget* parent_, bool runtime_lock_) Builder::Builder(QWidget* parent_, bool runtime_lock_)
: translations{InitializeTranslations(parent_)}, : translations{InitializeTranslations(parent_)},
combobox_translations{ComboboxEnumeration(parent_)}, parent{parent_}, combobox_translations{ComboboxEnumeration(parent_)}, parent{parent_}, runtime_lock{
runtime_lock{runtime_lock_} {} runtime_lock_} {}
Builder::~Builder() = default; Builder::~Builder() = default;

View file

@ -24,8 +24,8 @@ enum class ConnectionType : u8 { TraversalServer, IP };
DirectConnectWindow::DirectConnectWindow(Core::System& system_, QWidget* parent) DirectConnectWindow::DirectConnectWindow(Core::System& system_, QWidget* parent)
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint), : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
ui(std::make_unique<Ui::DirectConnect>()), system{system_}, ui(std::make_unique<Ui::DirectConnect>()), system{system_}, room_network{
room_network{system.GetRoomNetwork()} { system.GetRoomNetwork()} {
ui->setupUi(this); ui->setupUi(this);

View file

@ -31,8 +31,9 @@ HostRoomWindow::HostRoomWindow(QWidget* parent, QStandardItemModel* list,
std::shared_ptr<Core::AnnounceMultiplayerSession> session, std::shared_ptr<Core::AnnounceMultiplayerSession> session,
Core::System& system_) Core::System& system_)
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint), : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
ui(std::make_unique<Ui::HostRoom>()), announce_multiplayer_session(session), system{system_}, ui(std::make_unique<Ui::HostRoom>()),
room_network{system.GetRoomNetwork()} { announce_multiplayer_session(session), system{system_}, room_network{
system.GetRoomNetwork()} {
ui->setupUi(this); ui->setupUi(this);
// set up validation for all of the fields // set up validation for all of the fields

View file

@ -27,8 +27,9 @@
Lobby::Lobby(QWidget* parent, QStandardItemModel* list, Lobby::Lobby(QWidget* parent, QStandardItemModel* list,
std::shared_ptr<Core::AnnounceMultiplayerSession> session, Core::System& system_) std::shared_ptr<Core::AnnounceMultiplayerSession> session, Core::System& system_)
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint), : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
ui(std::make_unique<Ui::Lobby>()), announce_multiplayer_session(session), system{system_}, ui(std::make_unique<Ui::Lobby>()),
room_network{system.GetRoomNetwork()} { announce_multiplayer_session(session), system{system_}, room_network{
system.GetRoomNetwork()} {
ui->setupUi(this); ui->setupUi(this);
// setup the watcher for background connections // setup the watcher for background connections

View file

@ -18,8 +18,8 @@ namespace Tegra {
CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id) CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
: host1x{host1x_}, memory_manager{host1x.GMMU()}, : host1x{host1x_}, memory_manager{host1x.GMMU()},
host_processor{std::make_unique<Host1x::Control>(host1x_)}, host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
current_class{static_cast<ChClassId>(id)} { static_cast<ChClassId>(id)} {
thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); }); thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
} }

View file

@ -18,8 +18,8 @@ constexpr u32 ComputeInline = 0x6D;
DmaPusher::DmaPusher(Core::System& system_, GPU& gpu_, MemoryManager& memory_manager_, DmaPusher::DmaPusher(Core::System& system_, GPU& gpu_, MemoryManager& memory_manager_,
Control::ChannelState& channel_state_) Control::ChannelState& channel_state_)
: gpu{gpu_}, system{system_}, memory_manager{memory_manager_}, : gpu{gpu_}, system{system_}, memory_manager{memory_manager_}, puller{gpu_, memory_manager_,
puller{gpu_, memory_manager_, *this, channel_state_} {} *this, channel_state_} {}
DmaPusher::~DmaPusher() = default; DmaPusher::~DmaPusher() = default;

View file

@ -24,8 +24,9 @@ constexpr u32 MacroRegistersStart = 0xE00;
Maxwell3D::Maxwell3D(Core::System& system_, MemoryManager& memory_manager_) Maxwell3D::Maxwell3D(Core::System& system_, MemoryManager& memory_manager_)
: draw_manager{std::make_unique<DrawManager>(this)}, system{system_}, : draw_manager{std::make_unique<DrawManager>(this)}, system{system_},
memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)}, memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)}, upload_state{
upload_state{memory_manager, regs.upload} { memory_manager,
regs.upload} {
dirty.flags.flip(); dirty.flags.flip();
InitializeRegisterDefaults(); InitializeRegisterDefaults();
execution_mask.reset(); execution_mask.reset();

View file

@ -21,8 +21,8 @@ namespace Tegra::Engines {
Puller::Puller(GPU& gpu_, MemoryManager& memory_manager_, DmaPusher& dma_pusher_, Puller::Puller(GPU& gpu_, MemoryManager& memory_manager_, DmaPusher& dma_pusher_,
Control::ChannelState& channel_state_) Control::ChannelState& channel_state_)
: gpu{gpu_}, memory_manager{memory_manager_}, dma_pusher{dma_pusher_}, : gpu{gpu_}, memory_manager{memory_manager_}, dma_pusher{dma_pusher_}, channel_state{
channel_state{channel_state_} {} channel_state_} {}
Puller::~Puller() = default; Puller::~Puller() = default;

View file

@ -11,8 +11,8 @@ namespace Tegra {
Decoder::Decoder(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::NvdecRegisters& regs_, Decoder::Decoder(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::NvdecRegisters& regs_,
Host1x::FrameQueue& frame_queue_) Host1x::FrameQueue& frame_queue_)
: host1x(host1x_), memory_manager{host1x.GMMU()}, regs{regs_}, id{id_}, : host1x(host1x_), memory_manager{host1x.GMMU()}, regs{regs_}, id{id_}, frame_queue{
frame_queue{frame_queue_} {} frame_queue_} {}
Decoder::~Decoder() = default; Decoder::~Decoder() = default;

View file

@ -9,8 +9,8 @@
namespace Tegra::Host1x { namespace Tegra::Host1x {
Host1x::Host1x(Core::System& system_) Host1x::Host1x(Core::System& system_)
: system{system_}, syncpoint_manager{}, memory_manager(system.DeviceMemory()), : system{system_}, syncpoint_manager{},
gmmu_manager{system, memory_manager, 32, 0, 12}, memory_manager(system.DeviceMemory()), gmmu_manager{system, memory_manager, 32, 0, 12},
allocator{std::make_unique<Common::FlatAllocator<u32, 0, 32>>(1 << 12)} {} allocator{std::make_unique<Common::FlatAllocator<u32, 0, 32>>(1 << 12)} {}
Host1x::~Host1x() = default; Host1x::~Host1x() = default;

View file

@ -94,8 +94,8 @@ void SwizzleSurface(std::span<u8> output, u32 out_stride, std::span<const u8> in
} // namespace } // namespace
Vic::Vic(Host1x& host1x_, s32 id_, u32 syncpt, FrameQueue& frame_queue_) Vic::Vic(Host1x& host1x_, s32 id_, u32 syncpt, FrameQueue& frame_queue_)
: CDmaPusher{host1x_, id_}, id{id_}, syncpoint{syncpt}, frame_queue{frame_queue_}, : CDmaPusher{host1x_, id_}, id{id_}, syncpoint{syncpt},
has_sse41{HasSSE41()} { frame_queue{frame_queue_}, has_sse41{HasSSE41()} {
LOG_INFO(HW_GPU, "Created vic {}", id); LOG_INFO(HW_GPU, "Created vic {}", id);
} }

View file

@ -28,8 +28,8 @@ MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager&
split_address{split_address_}, page_bits{page_bits_}, big_page_bits{big_page_bits_}, split_address{split_address_}, page_bits{page_bits_}, big_page_bits{big_page_bits_},
entries{}, big_entries{}, page_table{address_space_bits, address_space_bits + page_bits - 38, entries{}, big_entries{}, page_table{address_space_bits, address_space_bits + page_bits - 38,
page_bits != big_page_bits ? page_bits : 0}, page_bits != big_page_bits ? page_bits : 0},
kind_map{PTEKind::INVALID}, kind_map{PTEKind::INVALID}, unique_identifier{unique_identifier_generator.fetch_add(
unique_identifier{unique_identifier_generator.fetch_add(1, std::memory_order_acq_rel)}, 1, std::memory_order_acq_rel)},
accumulator{std::make_unique<VideoCommon::InvalidationAccumulator>()} { accumulator{std::make_unique<VideoCommon::InvalidationAccumulator>()} {
address_space_size = 1ULL << address_space_bits; address_space_size = 1ULL << address_space_bits;
page_size = 1ULL << page_bits; page_size = 1ULL << page_bits;

View file

@ -115,8 +115,8 @@ struct QueryCacheBase<Traits>::QueryCacheBaseImpl {
QueryCacheBaseImpl(QueryCacheBase<Traits>* owner_, VideoCore::RasterizerInterface& rasterizer_, QueryCacheBaseImpl(QueryCacheBase<Traits>* owner_, VideoCore::RasterizerInterface& rasterizer_,
Tegra::MaxwellDeviceMemoryManager& device_memory_, RuntimeType& runtime_, Tegra::MaxwellDeviceMemoryManager& device_memory_, RuntimeType& runtime_,
Tegra::GPU& gpu_) Tegra::GPU& gpu_)
: owner{owner_}, rasterizer{rasterizer_}, device_memory{device_memory_}, runtime{runtime_}, : owner{owner_}, rasterizer{rasterizer_},
gpu{gpu_} { device_memory{device_memory_}, runtime{runtime_}, gpu{gpu_} {
streamer_mask = 0; streamer_mask = 0;
for (size_t i = 0; i < static_cast<size_t>(QueryType::MaxQueryTypes); i++) { for (size_t i = 0; i < static_cast<size_t>(QueryType::MaxQueryTypes); i++) {
streamers[i] = runtime.GetStreamerInterface(static_cast<QueryType>(i)); streamers[i] = runtime.GetStreamerInterface(static_cast<QueryType>(i));

View file

@ -31,8 +31,8 @@ ComputePipeline::ComputePipeline(const Device& device, TextureCache& texture_cac
BufferCache& buffer_cache_, ProgramManager& program_manager_, BufferCache& buffer_cache_, ProgramManager& program_manager_,
const Shader::Info& info_, std::string code, const Shader::Info& info_, std::string code,
std::vector<u32> code_v, bool force_context_flush) std::vector<u32> code_v, bool force_context_flush)
: texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, program_manager{program_manager_}, : texture_cache{texture_cache_}, buffer_cache{buffer_cache_},
info{info_} { program_manager{program_manager_}, info{info_} {
switch (device.GetShaderBackend()) { switch (device.GetShaderBackend()) {
case Settings::ShaderBackend::Glsl: case Settings::ShaderBackend::Glsl:
source_program = CreateProgram(code, GL_COMPUTE_SHADER); source_program = CreateProgram(code, GL_COMPUTE_SHADER);

View file

@ -66,8 +66,9 @@ bool QueryCache::AnyCommandQueued() const noexcept {
HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency_, HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
VideoCore::QueryType type_) VideoCore::QueryType type_)
: HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_}, : HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_}, query{
query{cache.AllocateQuery(type)} { cache.AllocateQuery(
type)} {
glBeginQuery(GetTarget(type), query.handle); glBeginQuery(GetTarget(type), query.handle);
} }

View file

@ -24,8 +24,8 @@ using PushConstants = std::array<u32, 4 * 4>;
FSR::FSR(const Device& device, MemoryAllocator& memory_allocator, size_t image_count, FSR::FSR(const Device& device, MemoryAllocator& memory_allocator, size_t image_count,
VkExtent2D extent) VkExtent2D extent)
: m_device{device}, m_memory_allocator{memory_allocator}, m_image_count{image_count}, : m_device{device}, m_memory_allocator{memory_allocator},
m_extent{extent} { m_image_count{image_count}, m_extent{extent} {
CreateImages(); CreateImages();
CreateRenderPasses(); CreateRenderPasses();

View file

@ -531,8 +531,8 @@ ASTCDecoderPass::ASTCDecoderPass(const Device& device_, Scheduler& scheduler_,
ASTC_PASS_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY, ASTC_BANK_INFO, ASTC_PASS_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY, ASTC_BANK_INFO,
COMPUTE_PUSH_CONSTANT_RANGE<sizeof(AstcPushConstants)>, ASTC_DECODER_COMP_SPV), COMPUTE_PUSH_CONSTANT_RANGE<sizeof(AstcPushConstants)>, ASTC_DECODER_COMP_SPV),
scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_}, scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
compute_pass_descriptor_queue{compute_pass_descriptor_queue_}, compute_pass_descriptor_queue{compute_pass_descriptor_queue_}, memory_allocator{
memory_allocator{memory_allocator_} {} memory_allocator_} {}
ASTCDecoderPass::~ASTCDecoderPass() = default; ASTCDecoderPass::~ASTCDecoderPass() = default;

View file

@ -31,8 +31,8 @@ ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipel
PipelineStatistics* pipeline_statistics, PipelineStatistics* pipeline_statistics,
VideoCore::ShaderNotify* shader_notify, const Shader::Info& info_, VideoCore::ShaderNotify* shader_notify, const Shader::Info& info_,
vk::ShaderModule spv_module_) vk::ShaderModule spv_module_)
: device{device_}, pipeline_cache(pipeline_cache_), : device{device_},
guest_descriptor_queue{guest_descriptor_queue_}, info{info_}, pipeline_cache(pipeline_cache_), guest_descriptor_queue{guest_descriptor_queue_}, info{info_},
spv_module(std::move(spv_module_)) { spv_module(std::move(spv_module_)) {
if (shader_notify) { if (shader_notify) {
shader_notify->MarkShaderBuilding(); shader_notify->MarkShaderBuilding();

View file

@ -100,8 +100,8 @@ PresentManager::PresentManager(const vk::Instance& instance_,
Swapchain& swapchain_, vk::SurfaceKHR& surface_) Swapchain& swapchain_, vk::SurfaceKHR& surface_)
: instance{instance_}, render_window{render_window_}, device{device_}, : instance{instance_}, render_window{render_window_}, device{device_},
memory_allocator{memory_allocator_}, scheduler{scheduler_}, swapchain{swapchain_}, memory_allocator{memory_allocator_}, scheduler{scheduler_}, swapchain{swapchain_},
surface{surface_}, surface{surface_}, blit_supported{CanBlitToSwapchain(device.GetPhysical(),
blit_supported{CanBlitToSwapchain(device.GetPhysical(), swapchain.GetImageViewFormat())}, swapchain.GetImageViewFormat())},
use_present_thread{Settings::values.async_presentation.GetValue()} { use_present_thread{Settings::values.async_presentation.GetValue()} {
SetImageCount(); SetImageCount();

View file

@ -1161,9 +1161,10 @@ struct QueryCacheRuntimeImpl {
StagingBufferPool& staging_pool_, StagingBufferPool& staging_pool_,
ComputePassDescriptorQueue& compute_pass_descriptor_queue, ComputePassDescriptorQueue& compute_pass_descriptor_queue,
DescriptorPool& descriptor_pool) DescriptorPool& descriptor_pool)
: rasterizer{rasterizer_}, device_memory{device_memory_}, buffer_cache{buffer_cache_}, : rasterizer{rasterizer_}, device_memory{device_memory_},
device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_}, buffer_cache{buffer_cache_}, device{device_},
staging_pool{staging_pool_}, guest_streamer(0, runtime), memory_allocator{memory_allocator_}, scheduler{scheduler_}, staging_pool{staging_pool_},
guest_streamer(0, runtime),
sample_streamer(static_cast<size_t>(QueryType::ZPassPixelCount64), runtime, rasterizer, sample_streamer(static_cast<size_t>(QueryType::ZPassPixelCount64), runtime, rasterizer,
device, scheduler, memory_allocator, compute_pass_descriptor_queue, device, scheduler, memory_allocator, compute_pass_descriptor_queue,
descriptor_pool), descriptor_pool),

View file

@ -49,8 +49,8 @@ size_t GetStreamBufferSize(const Device& device) {
StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& memory_allocator_, StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& memory_allocator_,
Scheduler& scheduler_) Scheduler& scheduler_)
: device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_}, : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
stream_buffer_size{GetStreamBufferSize(device)}, stream_buffer_size{GetStreamBufferSize(device)}, region_size{stream_buffer_size /
region_size{stream_buffer_size / StagingBufferPool::NUM_SYNCS} { StagingBufferPool::NUM_SYNCS} {
VkBufferCreateInfo stream_ci = { VkBufferCreateInfo stream_ci = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,

View file

@ -398,8 +398,8 @@ u32 GraphicsEnvironment::ReadViewportTransformState() {
ComputeEnvironment::ComputeEnvironment(Tegra::Engines::KeplerCompute& kepler_compute_, ComputeEnvironment::ComputeEnvironment(Tegra::Engines::KeplerCompute& kepler_compute_,
Tegra::MemoryManager& gpu_memory_, GPUVAddr program_base_, Tegra::MemoryManager& gpu_memory_, GPUVAddr program_base_,
u32 start_address_) u32 start_address_)
: GenericEnvironment{gpu_memory_, program_base_, start_address_}, : GenericEnvironment{gpu_memory_, program_base_, start_address_}, kepler_compute{
kepler_compute{&kepler_compute_} { &kepler_compute_} {
const auto& qmd{kepler_compute->launch_description}; const auto& qmd{kepler_compute->launch_description};
stage = Shader::Stage::Compute; stage = Shader::Stage::Compute;
local_memory_size = qmd.local_pos_alloc + qmd.local_crs_alloc; local_memory_size = qmd.local_pos_alloc + qmd.local_crs_alloc;

View file

@ -625,8 +625,8 @@ class Image {
public: public:
explicit Image(VkImage handle_, VkDevice owner_, VmaAllocator allocator_, explicit Image(VkImage handle_, VkDevice owner_, VmaAllocator allocator_,
VmaAllocation allocation_, const DeviceDispatch& dld_) noexcept VmaAllocation allocation_, const DeviceDispatch& dld_) noexcept
: handle{handle_}, owner{owner_}, allocator{allocator_}, allocation{allocation_}, : handle{handle_}, owner{owner_}, allocator{allocator_},
dld{&dld_} {} allocation{allocation_}, dld{&dld_} {}
Image() = default; Image() = default;
Image(const Image&) = delete; Image(const Image&) = delete;
@ -680,8 +680,8 @@ public:
explicit Buffer(VkBuffer handle_, VkDevice owner_, VmaAllocator allocator_, explicit Buffer(VkBuffer handle_, VkDevice owner_, VmaAllocator allocator_,
VmaAllocation allocation_, std::span<u8> mapped_, bool is_coherent_, VmaAllocation allocation_, std::span<u8> mapped_, bool is_coherent_,
const DeviceDispatch& dld_) noexcept const DeviceDispatch& dld_) noexcept
: handle{handle_}, owner{owner_}, allocator{allocator_}, allocation{allocation_}, : handle{handle_}, owner{owner_}, allocator{allocator_},
mapped{mapped_}, is_coherent{is_coherent_}, dld{&dld_} {} allocation{allocation_}, mapped{mapped_}, is_coherent{is_coherent_}, dld{&dld_} {}
Buffer() = default; Buffer() = default;
Buffer(const Buffer&) = delete; Buffer(const Buffer&) = delete;
@ -689,8 +689,8 @@ public:
Buffer(Buffer&& rhs) noexcept Buffer(Buffer&& rhs) noexcept
: handle{std::exchange(rhs.handle, nullptr)}, owner{rhs.owner}, allocator{rhs.allocator}, : handle{std::exchange(rhs.handle, nullptr)}, owner{rhs.owner}, allocator{rhs.allocator},
allocation{rhs.allocation}, mapped{rhs.mapped}, is_coherent{rhs.is_coherent}, allocation{rhs.allocation}, mapped{rhs.mapped},
dld{rhs.dld} {} is_coherent{rhs.is_coherent}, dld{rhs.dld} {}
Buffer& operator=(Buffer&& rhs) noexcept { Buffer& operator=(Buffer&& rhs) noexcept {
Release(); Release();