weakboson/eden
1
0
Fork 0
forked from eden-emu/eden
Code Pull requests Activity

Ran clang-format. Fixed Qt6 deprecations.

Browse source
This commit is contained in:
weakboson 2025-07-23 18:07:16 +08:00
parent a538126eb7
commit 8cd0d78269
219 changed files with 2635 additions and 2845 deletions
Download patch file Download diff file Expand all files Collapse all files

8
externals/dynarmic/src/dynarmic/ir/basic_block.cpp vendored
View file

@ -7,7 +7,6 @@
#include <algorithm> #include <algorithm>
#include <initializer_list> #include <initializer_list>
#include <map>
#include <string> #include <string>
#include <fmt/format.h> #include <fmt/format.h>
@ -22,12 +21,7 @@
namespace Dynarmic::IR { namespace Dynarmic::IR {
Block::Block(const LocationDescriptor& location) Block::Block(const LocationDescriptor& location)
: location{location}, : location{location}, end_location{location}, cond{Cond::AL}, instruction_alloc_pool{std::make_unique<InstPool>()} {
end_location{location},
cond{Cond::AL},
instruction_alloc_pool{std::make_unique<std::remove_reference_t<decltype(*instruction_alloc_pool)>>()}
{
} }
/// Prepends a new instruction to this basic block before the insertion point, /// Prepends a new instruction to this basic block before the insertion point,

4
externals/dynarmic/src/dynarmic/ir/basic_block.h vendored
View file

@ -17,7 +17,6 @@
#include "dynarmic/ir/microinstruction.h" #include "dynarmic/ir/microinstruction.h"
#include "dynarmic/ir/terminal.h" #include "dynarmic/ir/terminal.h"
#include "dynarmic/ir/value.h" #include "dynarmic/ir/value.h"
#include "dynarmic/ir/dense_list.h"
#include "dynarmic/common/memory_pool.h" #include "dynarmic/common/memory_pool.h"
namespace Dynarmic::IR { namespace Dynarmic::IR {
@ -171,8 +170,9 @@ private:
LocationDescriptor end_location; LocationDescriptor end_location;
/// Conditional to pass in order to execute this block /// Conditional to pass in order to execute this block
Cond cond; Cond cond;
using InstPool = Common::Pool<sizeof(Inst), 0x200000UL / sizeof(Inst)>;
/// Memory pool for instruction list /// Memory pool for instruction list
std::unique_ptr<Common::Pool<sizeof(Inst), 2097152UL / sizeof(Inst)>> instruction_alloc_pool; std::unique_ptr<InstPool> instruction_alloc_pool;
/// Terminal instruction of this block. /// Terminal instruction of this block.
Terminal terminal = Term::Invalid{}; Terminal terminal = Term::Invalid{};
/// Number of cycles this block takes to execute if the conditional fails. /// Number of cycles this block takes to execute if the conditional fails.

12
externals/dynarmic/src/dynarmic/ir/microinstruction.h vendored
View file

@ -23,7 +23,7 @@ constexpr size_t max_arg_count = 4;
/// A representation of a microinstruction. A single ARM/Thumb instruction may be /// A representation of a microinstruction. A single ARM/Thumb instruction may be
/// converted into zero or more microinstructions. /// converted into zero or more microinstructions.
//class Inst final { //class Inst final {
class Inst final : public mcl::intrusive_list_node<Inst> { class alignas(64) Inst final : public mcl::intrusive_list_node<Inst> {
public: public:
explicit Inst(Opcode op) : op(op) {} explicit Inst(Opcode op) : op(op) {}
@ -74,12 +74,12 @@ private:
void UndoUse(const Value& value); void UndoUse(const Value& value);
// TODO: so much padding wasted with mcl::intrusive_node // TODO: so much padding wasted with mcl::intrusive_node
// 16 + 1, 24 // 17
Opcode op; //2 (6) Opcode op; // 20(4)
// Linked list of pseudooperations associated with this instruction. // Linked list of pseudooperations associated with this instruction.
Inst* next_pseudoop = nullptr; //8 (14) Inst* next_pseudoop = nullptr; // 24(8)
unsigned use_count = 0; //4 (0) unsigned use_count = 0; // 32(4)
unsigned name = 0; //4 (4) unsigned name = 0; // 36(4)
alignas(64) std::array<Value, max_arg_count> args; //16 * 4 = 64 (1 cache line) alignas(64) std::array<Value, max_arg_count> args; //16 * 4 = 64 (1 cache line)
}; };
static_assert(sizeof(Inst) == 128); static_assert(sizeof(Inst) == 128);

171
src/android/app/src/main/jni/android_settings.h
View file

@ -8,8 +8,8 @@
#include <common/settings_common.h> #include <common/settings_common.h>
#include "common/common_types.h" #include "common/common_types.h"
#include "common/settings_setting.h"
#include "common/settings_enums.h" #include "common/settings_enums.h"
#include "common/settings_setting.h"
namespace AndroidSettings { namespace AndroidSettings {
@ -64,114 +64,175 @@ namespace AndroidSettings {
// Input/performance overlay settings // Input/performance overlay settings
std::vector<OverlayControlData> overlay_control_data; std::vector<OverlayControlData> overlay_control_data;
Settings::Setting<s32> overlay_scale{linkage, 50, "control_scale", Settings::Setting<s32> overlay_scale{linkage, 50, "control_scale", Settings::Category::Overlay};
Settings::Category::Overlay};
Settings::Setting<s32> overlay_opacity{linkage, 100, "control_opacity", Settings::Setting<s32> overlay_opacity{linkage, 100, "control_opacity",
Settings::Category::Overlay}; Settings::Category::Overlay};
Settings::Setting<bool> joystick_rel_center{linkage, true, "joystick_rel_center", Settings::Setting<bool> joystick_rel_center{linkage, true, "joystick_rel_center",
Settings::Category::Overlay}; Settings::Category::Overlay};
Settings::Setting<bool> dpad_slide{linkage, true, "dpad_slide", Settings::Setting<bool> dpad_slide{linkage, true, "dpad_slide", Settings::Category::Overlay};
Settings::Category::Overlay};
Settings::Setting<bool> haptic_feedback{linkage, true, "haptic_feedback", Settings::Setting<bool> haptic_feedback{linkage, true, "haptic_feedback",
Settings::Category::Overlay}; Settings::Category::Overlay};
Settings::Setting<bool> show_performance_overlay{linkage, true, "show_performance_overlay", Settings::Setting<bool> show_performance_overlay{linkage,
true,
"show_performance_overlay",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Paired, true, Settings::Specialization::Paired,
true,
true}; true};
Settings::Setting<bool> perf_overlay_background{linkage, false, "perf_overlay_background", Settings::Setting<bool> perf_overlay_background{linkage,
false,
"perf_overlay_background",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, Settings::Specialization::Default,
true,
true, true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<s32> perf_overlay_position{linkage, 0, "perf_overlay_position", Settings::Setting<s32> perf_overlay_position{linkage,
0,
"perf_overlay_position",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_fps{linkage, true, "show_fps", Settings::Setting<bool> show_fps{linkage,
true,
"show_fps",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_frame_time{linkage, false, "show_frame_time", Settings::Setting<bool> show_frame_time{linkage,
false,
"show_frame_time",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_app_ram_usage{linkage, false, "show_app_ram_usage", Settings::Setting<bool> show_app_ram_usage{linkage,
false,
"show_app_ram_usage",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_system_ram_usage{linkage, false, "show_system_ram_usage", Settings::Setting<bool> show_system_ram_usage{linkage,
false,
"show_system_ram_usage",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_bat_temperature{linkage, false, "show_bat_temperature", Settings::Setting<bool> show_bat_temperature{linkage,
false,
"show_bat_temperature",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<Settings::TemperatureUnits> bat_temperature_unit{linkage, Settings::Setting<Settings::TemperatureUnits> bat_temperature_unit{
linkage,
Settings::TemperatureUnits::Celsius, Settings::TemperatureUnits::Celsius,
"bat_temperature_unit", "bat_temperature_unit",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, Settings::Specialization::Default,
true, true, true,
true,
&show_bat_temperature}; &show_bat_temperature};
Settings::Setting<bool> show_power_info{linkage, false, "show_power_info", Settings::Setting<bool> show_power_info{linkage,
false,
"show_power_info",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_shaders_building{linkage, true, "show_shaders_building", Settings::Setting<bool> show_shaders_building{linkage,
true,
"show_shaders_building",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_input_overlay{linkage, true, "show_input_overlay", Settings::Setting<bool> show_input_overlay{linkage, true, "show_input_overlay",
Settings::Category::Overlay}; Settings::Category::Overlay};
Settings::Setting<bool> touchscreen{linkage, true, "touchscreen", Settings::Setting<bool> touchscreen{linkage, true, "touchscreen", Settings::Category::Overlay};
Settings::Category::Overlay}; Settings::Setting<s32> lock_drawer{linkage, false, "lock_drawer", Settings::Category::Overlay};
Settings::Setting<s32> lock_drawer{linkage, false, "lock_drawer",
Settings::Category::Overlay};
/// DEVICE/SOC OVERLAY /// DEVICE/SOC OVERLAY
Settings::Setting<bool> show_soc_overlay{linkage, true, "show_soc_overlay", Settings::Setting<bool> show_soc_overlay{linkage,
true,
"show_soc_overlay",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Paired, true, true}; Settings::Specialization::Paired,
true,
true};
Settings::Setting<bool> show_device_model{linkage, true, "show_device_model", Settings::Setting<bool> show_device_model{linkage,
true,
"show_device_model",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_gpu_model{linkage, true, "show_gpu_model", Settings::Setting<bool> show_gpu_model{linkage,
true,
"show_gpu_model",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay}; &show_performance_overlay};
Settings::Setting<bool> show_soc_model{linkage, true, "show_soc_model", Settings::Setting<bool> show_soc_model{linkage,
true,
"show_soc_model",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
&show_soc_overlay}; true,
Settings::Setting<bool> show_fw_version{linkage, true, "show_firmware_version",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> soc_overlay_background{linkage, false, "soc_overlay_background",
Settings::Category::Overlay,
Settings::Specialization::Default, true,
true, true,
&show_soc_overlay}; &show_soc_overlay};
Settings::Setting<s32> soc_overlay_position{linkage, 2, "soc_overlay_position",
Settings::Setting<bool> show_fw_version{linkage,
true,
"show_firmware_version",
Settings::Category::Overlay, Settings::Category::Overlay,
Settings::Specialization::Default, true, true, Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> soc_overlay_background{linkage,
false,
"soc_overlay_background",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_soc_overlay};
Settings::Setting<s32> soc_overlay_position{linkage,
2,
"soc_overlay_position",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_soc_overlay}; &show_soc_overlay};
Settings::Setting<bool> dont_show_eden_veil_warning{linkage, false, Settings::Setting<bool> dont_show_eden_veil_warning{
"dont_show_eden_veil_warning", linkage, false, "dont_show_eden_veil_warning", Settings::Category::Miscellaneous};
Settings::Category::Miscellaneous};
}; };
extern Values values; extern Values values;

76
src/android/app/src/main/jni/native.cpp
View file

@ -4,7 +4,6 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include <codecvt> #include <codecvt>
#include <locale> #include <locale>
#include <string> #include <string>
@ -24,9 +23,9 @@
#include <frontend_common/content_manager.h> #include <frontend_common/content_manager.h>
#include <jni.h> #include <jni.h>
#include "common/android/multiplayer/multiplayer.h"
#include "common/android/android_common.h" #include "common/android/android_common.h"
#include "common/android/id_cache.h" #include "common/android/id_cache.h"
#include "common/android/multiplayer/multiplayer.h"
#include "common/detached_tasks.h" #include "common/detached_tasks.h"
#include "common/dynamic_library.h" #include "common/dynamic_library.h"
#include "common/fs/path_util.h" #include "common/fs/path_util.h"
@ -65,12 +64,12 @@
#include "hid_core/hid_core.h" #include "hid_core/hid_core.h"
#include "hid_core/hid_types.h" #include "hid_core/hid_types.h"
#include "jni/native.h" #include "jni/native.h"
#include "network/announce_multiplayer_session.h"
#include "video_core/renderer_base.h" #include "video_core/renderer_base.h"
#include "video_core/renderer_vulkan/renderer_vulkan.h" #include "video_core/renderer_vulkan/renderer_vulkan.h"
#include "video_core/shader_notify.h"
#include "video_core/vulkan_common/vulkan_instance.h" #include "video_core/vulkan_common/vulkan_instance.h"
#include "video_core/vulkan_common/vulkan_surface.h" #include "video_core/vulkan_common/vulkan_surface.h"
#include "video_core/shader_notify.h"
#include "network/announce_multiplayer_session.h"
#define jconst [[maybe_unused]] const auto #define jconst [[maybe_unused]] const auto
#define jauto [[maybe_unused]] auto #define jauto [[maybe_unused]] auto
@ -581,7 +580,9 @@ jobjectArray Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getSystemDriverInfo(
return j_driver_info; return j_driver_info;
} }
jstring Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getGpuModel(JNIEnv *env, jobject j_obj, jobject j_surf, jstring j_hook_lib_dir) { jstring Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getGpuModel(JNIEnv* env, jobject j_obj,
jobject j_surf,
jstring j_hook_lib_dir) {
const char* file_redirect_dir_{}; const char* file_redirect_dir_{};
int featureFlags{}; int featureFlags{};
std::string hook_lib_dir = Common::Android::GetJString(env, j_hook_lib_dir); std::string hook_lib_dir = Common::Android::GetJString(env, j_hook_lib_dir);
@ -791,16 +792,19 @@ jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_firmwareVersion(JNIEnv* env, jclas
} }
jint Java_org_yuzu_yuzu_1emu_NativeLibrary_verifyFirmware(JNIEnv* env, jclass clazz) { jint Java_org_yuzu_yuzu_1emu_NativeLibrary_verifyFirmware(JNIEnv* env, jclass clazz) {
return static_cast<int>(FirmwareManager::VerifyFirmware(EmulationSession::GetInstance().System())); return static_cast<int>(
FirmwareManager::VerifyFirmware(EmulationSession::GetInstance().System()));
} }
jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_gameRequiresFirmware(JNIEnv* env, jclass clazz, jstring jprogramId) { jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_gameRequiresFirmware(JNIEnv* env, jclass clazz,
jstring jprogramId) {
auto program_id = EmulationSession::GetProgramId(env, jprogramId); auto program_id = EmulationSession::GetProgramId(env, jprogramId);
return FirmwareManager::GameRequiresFirmware(program_id); return FirmwareManager::GameRequiresFirmware(program_id);
} }
jint Java_org_yuzu_yuzu_1emu_NativeLibrary_installKeys(JNIEnv* env, jclass clazz, jstring jpath, jstring jext) { jint Java_org_yuzu_yuzu_1emu_NativeLibrary_installKeys(JNIEnv* env, jclass clazz, jstring jpath,
jstring jext) {
const auto path = Common::Android::GetJString(env, jpath); const auto path = Common::Android::GetJString(env, jpath);
const auto ext = Common::Android::GetJString(env, jext); const auto ext = Common::Android::GetJString(env, jext);
@ -957,63 +961,59 @@ jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_areKeysPresent(JNIEnv* env, jobje
} }
JNIEXPORT void JNICALL JNIEXPORT void JNICALL
Java_org_yuzu_yuzu_1emu_NativeLibrary_initMultiplayer( Java_org_yuzu_yuzu_1emu_NativeLibrary_initMultiplayer(JNIEnv* env, [[maybe_unused]] jobject obj) {
JNIEnv* env, [[maybe_unused]] jobject obj) {
if (multiplayer) { if (multiplayer) {
return; return;
} }
announce_multiplayer_session = std::make_shared<Core::AnnounceMultiplayerSession>(); announce_multiplayer_session = std::make_shared<Core::AnnounceMultiplayerSession>();
multiplayer = std::make_unique<AndroidMultiplayer>(s_instance.System(), announce_multiplayer_session); multiplayer =
std::make_unique<AndroidMultiplayer>(s_instance.System(), announce_multiplayer_session);
multiplayer->NetworkInit(); multiplayer->NetworkInit();
} }
JNIEXPORT jobjectArray JNICALL JNIEXPORT jobjectArray JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayGetPublicRooms(
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayGetPublicRooms(
JNIEnv* env, [[maybe_unused]] jobject obj) { JNIEnv* env, [[maybe_unused]] jobject obj) {
return Common::Android::ToJStringArray(env, multiplayer->NetPlayGetPublicRooms()); return Common::Android::ToJStringArray(env, multiplayer->NetPlayGetPublicRooms());
} }
JNIEXPORT jint JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayCreateRoom( JNIEXPORT jint JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayCreateRoom(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring ipaddress, jint port, JNIEnv* env, [[maybe_unused]] jobject obj, jstring ipaddress, jint port, jstring username,
jstring username, jstring preferredGameName, jlong preferredGameId, jstring password, jstring preferredGameName, jlong preferredGameId, jstring password, jstring room_name,
jstring room_name, jint max_players, jboolean isPublic) { jint max_players, jboolean isPublic) {
return static_cast<jint>( return static_cast<jint>(multiplayer->NetPlayCreateRoom(
multiplayer->NetPlayCreateRoom(Common::Android::GetJString(env, ipaddress), port, Common::Android::GetJString(env, ipaddress), port,
Common::Android::GetJString(env, username), Common::Android::GetJString(env, preferredGameName), Common::Android::GetJString(env, username),
preferredGameId,Common::Android::GetJString(env, password), Common::Android::GetJString(env, preferredGameName), preferredGameId,
Common::Android::GetJString(env, room_name), max_players, isPublic)); Common::Android::GetJString(env, password), Common::Android::GetJString(env, room_name),
max_players, isPublic));
} }
JNIEXPORT jint JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayJoinRoom( JNIEXPORT jint JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayJoinRoom(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring ipaddress, jint port, JNIEnv* env, [[maybe_unused]] jobject obj, jstring ipaddress, jint port, jstring username,
jstring username, jstring password) { jstring password) {
return static_cast<jint>( return static_cast<jint>(multiplayer->NetPlayJoinRoom(
multiplayer->NetPlayJoinRoom(Common::Android::GetJString(env, ipaddress), port, Common::Android::GetJString(env, ipaddress), port,
Common::Android::GetJString(env, username), Common::Android::GetJString(env, password))); Common::Android::GetJString(env, username), Common::Android::GetJString(env, password)));
} }
JNIEXPORT jobjectArray JNICALL JNIEXPORT jobjectArray JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayRoomInfo(
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayRoomInfo(
JNIEnv* env, [[maybe_unused]] jobject obj) { JNIEnv* env, [[maybe_unused]] jobject obj) {
return Common::Android::ToJStringArray(env, multiplayer->NetPlayRoomInfo()); return Common::Android::ToJStringArray(env, multiplayer->NetPlayRoomInfo());
} }
JNIEXPORT jboolean JNICALL JNIEXPORT jboolean JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsJoined(
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsJoined(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) { [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
return multiplayer->NetPlayIsJoined(); return multiplayer->NetPlayIsJoined();
} }
JNIEXPORT jboolean JNICALL JNIEXPORT jboolean JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsHostedRoom(
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsHostedRoom(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) { [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
return multiplayer->NetPlayIsHostedRoom(); return multiplayer->NetPlayIsHostedRoom();
} }
JNIEXPORT void JNICALL JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlaySendMessage(
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlaySendMessage(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring msg) { JNIEnv* env, [[maybe_unused]] jobject obj, jstring msg) {
multiplayer->NetPlaySendMessage(Common::Android::GetJString(env, msg)); multiplayer->NetPlaySendMessage(Common::Android::GetJString(env, msg));
} }
@ -1028,14 +1028,12 @@ JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayLea
multiplayer->NetPlayLeaveRoom(); multiplayer->NetPlayLeaveRoom();
} }
JNIEXPORT jboolean JNICALL JNIEXPORT jboolean JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsModerator(
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsModerator(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) { [[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
return multiplayer->NetPlayIsModerator(); return multiplayer->NetPlayIsModerator();
} }
JNIEXPORT jobjectArray JNICALL JNIEXPORT jobjectArray JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayGetBanList(
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayGetBanList(
JNIEnv* env, [[maybe_unused]] jobject obj) { JNIEnv* env, [[maybe_unused]] jobject obj) {
return Common::Android::ToJStringArray(env, multiplayer->NetPlayGetBanList()); return Common::Android::ToJStringArray(env, multiplayer->NetPlayGetBanList());
} }
@ -1050,9 +1048,7 @@ JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayUnb
multiplayer->NetPlayUnbanUser(Common::Android::GetJString(env, username)); multiplayer->NetPlayUnbanUser(Common::Android::GetJString(env, username));
} }
JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_updatePowerState( JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_updatePowerState(JNIEnv* env, jobject,
JNIEnv* env,
jobject,
jint percentage, jint percentage,
jboolean isCharging, jboolean isCharging,
jboolean hasBattery) { jboolean hasBattery) {

4
src/audio_core/in/audio_in.cpp
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_}, system{system_, event, : manager{manager_}, parent_mutex{manager.mutex}, event{event_},
session_id_} {} system{system_, event, session_id_} {}
void In::Free() { void In::Free() {
std::scoped_lock l{parent_mutex}; std::scoped_lock l{parent_mutex};

4
src/audio_core/in/audio_in_system.cpp
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_}, : system{system_}, buffer_event{event_}, session_id{session_id_},
session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {} session{std::make_unique<DeviceSession>(system_)} {}
System::~System() { System::~System() {
Finalize(); Finalize();

4
src/audio_core/out/audio_out.cpp
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_}, system{system_, event, : manager{manager_}, parent_mutex{manager.mutex}, event{event_},
session_id_} {} system{system_, event, session_id_} {}
void Out::Free() { void Out::Free() {
std::scoped_lock l{parent_mutex}; std::scoped_lock l{parent_mutex};

4
src/audio_core/out/audio_out_system.cpp
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_}, : system{system_}, buffer_event{event_}, session_id{session_id_},
session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {} session{std::make_unique<DeviceSession>(system_)} {}
System::~System() { System::~System() {
Finalize(); Finalize();

7
src/audio_core/renderer/behavior/info_updater.cpp
View file

@ -19,10 +19,9 @@ 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{input_.data() + sizeof(UpdateDataHeader)}, input_origin{input_},
input_origin{input_}, output{output_.data() + sizeof(UpdateDataHeader)}, output{output_.data() + sizeof(UpdateDataHeader)}, output_origin{output_},
output_origin{output_}, in_header{reinterpret_cast<const UpdateDataHeader*>( in_header{reinterpret_cast<const UpdateDataHeader*>(input_origin.data())},
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_} {

4
src/audio_core/renderer/memory/pool_mapper.cpp
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()}, : process_handle{process_handle_}, pool_infos{pool_infos_.data()}, pool_count{pool_count_},
pool_count{pool_count_}, force_map{force_map_} {} 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++) {

4
src/audio_core/sink/sink_stream.cpp
View file

@ -240,7 +240,9 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
// Successfully dequeued a new buffer. // Successfully dequeued a new buffer.
queued_buffers--; queued_buffers--;
{ std::unique_lock lk{release_mutex}; } {
std::unique_lock lk{release_mutex};
}
release_cv.notify_one(); release_cv.notify_one();
} }

3
src/common/address_space.h
View file

@ -12,8 +12,7 @@
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 >= concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >= AddressSpaceBits;
AddressSpaceBits;
struct EmptyStruct {}; struct EmptyStruct {};

4
src/common/android/android_common.cpp
View file

@ -38,8 +38,8 @@ jstring ToJString(JNIEnv* env, std::string_view str) {
} }
jobjectArray ToJStringArray(JNIEnv* env, const std::vector<std::string>& strs) { jobjectArray ToJStringArray(JNIEnv* env, const std::vector<std::string>& strs) {
jobjectArray array = jobjectArray array = env->NewObjectArray(
env->NewObjectArray(static_cast<jsize>(strs.size()), env->FindClass("java/lang/String"), env->NewStringUTF("")); static_cast<jsize>(strs.size()), env->FindClass("java/lang/String"), env->NewStringUTF(""));
for (std::size_t i = 0; i < strs.size(); ++i) { for (std::size_t i = 0; i < strs.size(); ++i) {
env->SetObjectArrayElement(array, static_cast<jsize>(i), ToJString(env, strs[i])); env->SetObjectArrayElement(array, static_cast<jsize>(i), ToJString(env, strs[i]));
} }

19
src/common/android/id_cache.cpp
View file

@ -6,14 +6,13 @@
#include <jni.h> #include <jni.h>
#include <network/network.h>
#include "applets/software_keyboard.h" #include "applets/software_keyboard.h"
#include "common/android/id_cache.h" #include "common/android/id_cache.h"
#include "common/android/multiplayer/multiplayer.h"
#include "common/assert.h" #include "common/assert.h"
#include "common/fs/fs_android.h" #include "common/fs/fs_android.h"
#include "video_core/rasterizer_interface.h" #include "video_core/rasterizer_interface.h"
#include "common/android/multiplayer/multiplayer.h"
#include <network/network.h>
static JavaVM* s_java_vm; static JavaVM* s_java_vm;
static jclass s_native_library_class; static jclass s_native_library_class;
@ -441,8 +440,7 @@ namespace Common::Android {
const jclass game_dir_class = env->FindClass("org/yuzu/yuzu_emu/model/GameDir"); const jclass game_dir_class = env->FindClass("org/yuzu/yuzu_emu/model/GameDir");
s_game_dir_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_dir_class)); s_game_dir_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_dir_class));
s_game_dir_constructor = env->GetMethodID(game_dir_class, "<init>", s_game_dir_constructor = env->GetMethodID(game_dir_class, "<init>", "(Ljava/lang/String;Z)V");
"(Ljava/lang/String;Z)V");
env->DeleteLocalRef(game_dir_class); env->DeleteLocalRef(game_dir_class);
// Initialize methods // Initialize methods
@ -452,8 +450,8 @@ namespace Common::Android {
env->GetStaticMethodID(s_disk_cache_progress_class, "loadProgress", "(III)V"); env->GetStaticMethodID(s_disk_cache_progress_class, "loadProgress", "(III)V");
s_copy_to_storage = env->GetStaticMethodID(s_native_library_class, "copyFileToStorage", s_copy_to_storage = env->GetStaticMethodID(s_native_library_class, "copyFileToStorage",
"(Ljava/lang/String;Ljava/lang/String;)Z"); "(Ljava/lang/String;Ljava/lang/String;)Z");
s_file_exists = env->GetStaticMethodID(s_native_library_class, "exists", s_file_exists =
"(Ljava/lang/String;)Z"); env->GetStaticMethodID(s_native_library_class, "exists", "(Ljava/lang/String;)Z");
s_file_extension = env->GetStaticMethodID(s_native_library_class, "getFileExtension", s_file_extension = env->GetStaticMethodID(s_native_library_class, "getFileExtension",
"(Ljava/lang/String;)Ljava/lang/String;"); "(Ljava/lang/String;)Ljava/lang/String;");
s_on_emulation_started = s_on_emulation_started =
@ -577,12 +575,10 @@ namespace Common::Android {
env->GetMethodID(yuzu_input_device_interface, "getName", "()Ljava/lang/String;"); env->GetMethodID(yuzu_input_device_interface, "getName", "()Ljava/lang/String;");
s_yuzu_input_device_get_guid = s_yuzu_input_device_get_guid =
env->GetMethodID(yuzu_input_device_interface, "getGUID", "()Ljava/lang/String;"); env->GetMethodID(yuzu_input_device_interface, "getGUID", "()Ljava/lang/String;");
s_yuzu_input_device_get_port = env->GetMethodID(yuzu_input_device_interface, "getPort", s_yuzu_input_device_get_port = env->GetMethodID(yuzu_input_device_interface, "getPort", "()I");
"()I");
s_yuzu_input_device_get_supports_vibration = s_yuzu_input_device_get_supports_vibration =
env->GetMethodID(yuzu_input_device_interface, "getSupportsVibration", "()Z"); env->GetMethodID(yuzu_input_device_interface, "getSupportsVibration", "()Z");
s_yuzu_input_device_vibrate = env->GetMethodID(yuzu_input_device_interface, "vibrate", s_yuzu_input_device_vibrate = env->GetMethodID(yuzu_input_device_interface, "vibrate", "(F)V");
"(F)V");
s_yuzu_input_device_get_axes = s_yuzu_input_device_get_axes =
env->GetMethodID(yuzu_input_device_interface, "getAxes", "()[Ljava/lang/Integer;"); env->GetMethodID(yuzu_input_device_interface, "getAxes", "()[Ljava/lang/Integer;");
s_yuzu_input_device_has_keys = s_yuzu_input_device_has_keys =
@ -592,7 +588,6 @@ namespace Common::Android {
"(ILjava/lang/String;)V"); "(ILjava/lang/String;)V");
s_clear_chat = env->GetStaticMethodID(s_native_library_class, "clearChat", "()V"); s_clear_chat = env->GetStaticMethodID(s_native_library_class, "clearChat", "()V");
// Initialize Android Storage // Initialize Android Storage
Common::FS::Android::RegisterCallbacks(env, s_native_library_class); Common::FS::Android::RegisterCallbacks(env, s_native_library_class);

1
src/common/android/id_cache.h
View file

@ -118,5 +118,4 @@ jmethodID GetYuzuDeviceHasKeys();
jmethodID GetAddNetPlayMessage(); jmethodID GetAddNetPlayMessage();
jmethodID ClearChat(); jmethodID ClearChat();
} // namespace Common::Android } // namespace Common::Android

42
src/common/android/multiplayer/multiplayer.cpp
View file

@ -6,17 +6,17 @@
#include "common/android/android_common.h" #include "common/android/android_common.h"
#include "android/log.h"
#include "core/core.h" #include "core/core.h"
#include "network/network.h" #include "network/network.h"
#include "android/log.h"
#include "common/settings.h" #include "common/settings.h"
#include "web_service/web_backend.h"
#include "web_service/verify_user_jwt.h" #include "web_service/verify_user_jwt.h"
#include "web_service/web_backend.h"
#include "web_service/web_result.h" #include "web_service/web_result.h"
#include <thread>
#include <chrono> #include <chrono>
#include <thread>
namespace IDCache = Common::Android; namespace IDCache = Common::Android;
@ -146,13 +146,10 @@ bool AndroidMultiplayer::NetworkInit() {
return true; return true;
} }
NetPlayStatus AndroidMultiplayer::NetPlayCreateRoom(const std::string &ipaddress, int port, NetPlayStatus AndroidMultiplayer::NetPlayCreateRoom(
const std::string &username, const std::string& ipaddress, int port, const std::string& username,
const std::string &preferredGameName, const std::string& preferredGameName, const u64& preferredGameId, const std::string& password,
const u64 &preferredGameId, const std::string& room_name, int max_players, bool isPublic) {
const std::string &password,
const std::string &room_name, int max_players,
bool isPublic) {
auto member = Network::GetRoomMember().lock(); auto member = Network::GetRoomMember().lock();
if (!member) { if (!member) {
return NetPlayStatus::NETWORK_ERROR; return NetPlayStatus::NETWORK_ERROR;
@ -249,9 +246,7 @@ NetPlayStatus AndroidMultiplayer::NetPlayJoinRoom(const std::string &ipaddress,
return NetPlayStatus::NETWORK_ERROR; return NetPlayStatus::NETWORK_ERROR;
} }
port = port = (port == 0) ? Network::DefaultRoomPort : static_cast<u16>(port);
(port == 0) ? Network::DefaultRoomPort : static_cast<u16>(port);
if (member->GetState() == Network::RoomMember::State::Joining || member->IsConnected()) { if (member->GetState() == Network::RoomMember::State::Joining || member->IsConnected()) {
return NetPlayStatus::ALREADY_IN_ROOM; return NetPlayStatus::ALREADY_IN_ROOM;
@ -386,11 +381,9 @@ std::vector<std::string> AndroidMultiplayer::NetPlayGetPublicRooms() {
if (auto session = announce_multiplayer_session.lock()) { if (auto session = announce_multiplayer_session.lock()) {
auto rooms = session->GetRoomList(); auto rooms = session->GetRoomList();
for (const auto& room : rooms) { for (const auto& room : rooms) {
room_list.push_back(room.information.name + "|" + room_list.push_back(room.information.name + "|" + (room.has_password ? "1" : "0") +
(room.has_password ? "1" : "0") + "|" + "|" + std::to_string(room.information.member_slots) + "|" +
std::to_string(room.information.member_slots) + "|" + room.ip + "|" + std::to_string(room.information.port) + "|" +
room.ip + "|" +
std::to_string(room.information.port) + "|" +
room.information.description + "|" + room.information.description + "|" +
room.information.host_username + "|" + room.information.host_username + "|" +
std::to_string(room.information.preferred_game.id) + "|" + std::to_string(room.information.preferred_game.id) + "|" +
@ -398,17 +391,13 @@ std::vector<std::string> AndroidMultiplayer::NetPlayGetPublicRooms() {
room.information.preferred_game.version); room.information.preferred_game.version);
for (const auto& member : room.members) { for (const auto& member : room.members) {
room_list.push_back("MEMBER|" + room.information.name + "|" + room_list.push_back("MEMBER|" + room.information.name + "|" + member.username +
member.username + "|" + "|" + member.nickname + "|" + std::to_string(member.game.id) +
member.nickname + "|" + "|" + member.game.name);
std::to_string(member.game.id) + "|" +
member.game.name);
} }
} }
} }
return room_list; return room_list;
} }
std::vector<std::string> AndroidMultiplayer::NetPlayGetBanList() { std::vector<std::string> AndroidMultiplayer::NetPlayGetBanList() {
@ -429,7 +418,8 @@ std::vector<std::string> AndroidMultiplayer::NetPlayGetBanList() {
return ban_list; return ban_list;
} }
std::unique_ptr<Network::VerifyUser::Backend> AndroidMultiplayer::CreateVerifyBackend(bool use_validation) { std::unique_ptr<Network::VerifyUser::Backend> AndroidMultiplayer::CreateVerifyBackend(
bool use_validation) {
std::unique_ptr<Network::VerifyUser::Backend> verify_backend; std::unique_ptr<Network::VerifyUser::Backend> verify_backend;
if (use_validation) { if (use_validation) {
// #ifdef ENABLE_WEB_SERVICE // #ifdef ENABLE_WEB_SERVICE

7
src/common/android/multiplayer/multiplayer.h
View file

@ -7,13 +7,13 @@
#include <vector> #include <vector>
#include <common/common_types.h> #include <common/common_types.h>
#include <network/network.h>
#include <network/announce_multiplayer_session.h> #include <network/announce_multiplayer_session.h>
#include <network/network.h>
namespace Core { namespace Core {
class System; class System;
class AnnounceMultiplayerSession; class AnnounceMultiplayerSession;
} } // namespace Core
enum class NetPlayStatus : s32 { enum class NetPlayStatus : s32 {
NO_ERROR, NO_ERROR,
@ -64,7 +64,8 @@ public:
void ClearChat(); void ClearChat();
NetPlayStatus NetPlayCreateRoom(const std::string& ipaddress, int port, NetPlayStatus NetPlayCreateRoom(const std::string& ipaddress, int port,
const std::string &username, const std::string &preferredGameName, const std::string& username,
const std::string& preferredGameName,
const u64& preferredGameId, const std::string& password, const u64& preferredGameId, const std::string& password,
const std::string& room_name, int max_players, bool isPublic); const std::string& room_name, int max_players, bool isPublic);

11
src/common/device_power_state.cpp
View file

@ -27,8 +27,7 @@ extern std::atomic<bool> g_has_battery;
namespace Common { namespace Common {
PowerStatus GetPowerStatus() PowerStatus GetPowerStatus() {
{
PowerStatus info; PowerStatus info;
#if defined(_WIN32) #if defined(_WIN32)
@ -58,8 +57,7 @@ namespace Common {
CFNumberRef curNum = CFNumberRef curNum =
(CFNumberRef)CFDictionaryGetValue(battery, CFSTR(kIOPSCurrentCapacityKey)); (CFNumberRef)CFDictionaryGetValue(battery, CFSTR(kIOPSCurrentCapacityKey));
CFNumberRef maxNum = CFNumberRef maxNum = (CFNumberRef)CFDictionaryGetValue(battery, CFSTR(kIOPSMaxCapacityKey));
(CFNumberRef)CFDictionaryGetValue(battery, CFSTR(kIOPSMaxCapacityKey));
int cur = 0, max = 0; int cur = 0, max = 0;
CFNumberGetValue(curNum, kCFNumberIntType, &cur); CFNumberGetValue(curNum, kCFNumberIntType, &cur);
CFNumberGetValue(maxNum, kCFNumberIntType, &max); CFNumberGetValue(maxNum, kCFNumberIntType, &max);
@ -82,8 +80,7 @@ namespace Common {
std::ifstream capFile(std::string(battery_path) + "capacity"); std::ifstream capFile(std::string(battery_path) + "capacity");
if (capFile) { if (capFile) {
capFile >> info.percentage; capFile >> info.percentage;
} } else {
else {
info.has_battery = false; info.has_battery = false;
} }
@ -99,4 +96,4 @@ namespace Common {
return info; return info;
} }
} } // namespace Common

8
src/common/expected.h
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())}, ctor_base{ : impl_base{unexpect_t{}, std::move(e.value())},
detail::default_constructor_tag{}} {} ctor_base{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())}, ctor_base{ : impl_base{unexpect_t{}, std::move(e.value())},
detail::default_constructor_tag{}} {} ctor_base{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)

28
src/common/fs/path_util.cpp
View file

@ -88,9 +88,8 @@ public:
} }
void CreateEdenPaths() { void CreateEdenPaths() {
std::for_each(eden_paths.begin(), eden_paths.end(), [](auto &path) { std::for_each(eden_paths.begin(), eden_paths.end(),
void(FS::CreateDir(path.second)); [](auto& path) { void(FS::CreateDir(path.second)); });
});
} }
void SetEdenPathImpl(EdenPath eden_path, const fs::path& new_path) { void SetEdenPathImpl(EdenPath eden_path, const fs::path& new_path) {
@ -116,9 +115,13 @@ public:
eden_path_cache = eden_path / CACHE_DIR; eden_path_cache = eden_path / CACHE_DIR;
eden_path_config = eden_path / CONFIG_DIR; eden_path_config = eden_path / CONFIG_DIR;
#define LEGACY_PATH(titleName, upperName) GenerateLegacyPath(LegacyPath::titleName##Dir, GetAppDataRoamingDirectory() / upperName##_DIR); \ #define LEGACY_PATH(titleName, upperName) \
GenerateLegacyPath(LegacyPath::titleName##ConfigDir, GetAppDataRoamingDirectory() / upperName##_DIR / CONFIG_DIR); \ GenerateLegacyPath(LegacyPath::titleName##Dir, \
GenerateLegacyPath(LegacyPath::titleName##CacheDir, GetAppDataRoamingDirectory() / upperName##_DIR / CACHE_DIR); GetAppDataRoamingDirectory() / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##ConfigDir, \
GetAppDataRoamingDirectory() / upperName##_DIR / CONFIG_DIR); \
GenerateLegacyPath(LegacyPath::titleName##CacheDir, \
GetAppDataRoamingDirectory() / upperName##_DIR / CACHE_DIR);
LEGACY_PATH(Citron, CITRON) LEGACY_PATH(Citron, CITRON)
LEGACY_PATH(Sudachi, SUDACHI) LEGACY_PATH(Sudachi, SUDACHI)
@ -143,9 +146,13 @@ public:
eden_path_config = GetDataDirectory("XDG_CONFIG_HOME") / EDEN_DIR; eden_path_config = GetDataDirectory("XDG_CONFIG_HOME") / EDEN_DIR;
} }
#define LEGACY_PATH(titleName, upperName) GenerateLegacyPath(LegacyPath::titleName##Dir, GetDataDirectory("XDG_DATA_HOME") / upperName##_DIR); \ #define LEGACY_PATH(titleName, upperName) \
GenerateLegacyPath(LegacyPath::titleName##ConfigDir, GetDataDirectory("XDG_CONFIG_HOME") / upperName##_DIR); \ GenerateLegacyPath(LegacyPath::titleName##Dir, \
GenerateLegacyPath(LegacyPath::titleName##CacheDir, GetDataDirectory("XDG_CACHE_HOME") / upperName##_DIR); GetDataDirectory("XDG_DATA_HOME") / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##ConfigDir, \
GetDataDirectory("XDG_CONFIG_HOME") / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##CacheDir, \
GetDataDirectory("XDG_CACHE_HOME") / upperName##_DIR);
LEGACY_PATH(Citron, CITRON) LEGACY_PATH(Citron, CITRON)
LEGACY_PATH(Sudachi, SUDACHI) LEGACY_PATH(Sudachi, SUDACHI)
@ -301,8 +308,7 @@ void SetEdenPath(EdenPath eden_path, const fs::path& new_path) {
PathManagerImpl::GetInstance().SetEdenPathImpl(eden_path, new_path); PathManagerImpl::GetInstance().SetEdenPathImpl(eden_path, new_path);
} }
void CreateEdenPaths() void CreateEdenPaths() {
{
PathManagerImpl::GetInstance().CreateEdenPaths(); PathManagerImpl::GetInstance().CreateEdenPaths();
} }

4
src/common/intrusive_red_black_tree.h
View file

@ -238,9 +238,7 @@ 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 {

8
src/common/multi_level_page_table.h
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)}, page_bits{std::exchange( first_level_bits{std::exchange(other.first_level_bits, 0)},
other.page_bits, 0)}, page_bits{std::exchange(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)}, base_ptr{std::exchange(other.base_ptr, first_level_map{std::move(other.first_level_map)},
nullptr)} {} base_ptr{std::exchange(other.base_ptr, 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);

4
src/common/polyfill_thread.h
View file

@ -339,7 +339,9 @@ void CondvarWait(Condvar& cv, std::unique_lock<Lock>& lk, std::stop_token token,
} }
std::stop_callback callback(token, [&] { std::stop_callback callback(token, [&] {
{ std::scoped_lock lk2{*lk.mutex()}; } {
std::scoped_lock lk2{*lk.mutex()};
}
cv.notify_all(); cv.notify_all();
}); });

76
src/common/settings.h
View file

@ -217,7 +217,8 @@ struct Values {
true, true,
true, true,
&use_speed_limit}; &use_speed_limit};
SwitchableSetting<bool> sync_core_speed{linkage, false, "sync_core_speed", Category::Core, Specialization::Default}; SwitchableSetting<bool> sync_core_speed{linkage, false, "sync_core_speed", Category::Core,
Specialization::Default};
// Memory // Memory
#ifdef HAS_NCE #ifdef HAS_NCE
@ -243,29 +244,14 @@ struct Values {
CpuAccuracy::Auto, CpuAccuracy::Paranoid, CpuAccuracy::Auto, CpuAccuracy::Paranoid,
"cpu_accuracy", Category::Cpu}; "cpu_accuracy", Category::Cpu};
SwitchableSetting<bool> use_fast_cpu_time{linkage, SwitchableSetting<bool> use_fast_cpu_time{
false, linkage, false, "use_fast_cpu_time", Category::Cpu, Specialization::Paired, true, true};
"use_fast_cpu_time", SwitchableSetting<CpuClock> fast_cpu_time{
Category::Cpu, linkage, CpuClock::Boost, "fast_cpu_time", Category::Cpu, Specialization::Default, true,
Specialization::Paired, true, &use_fast_cpu_time};
true,
true};
SwitchableSetting<CpuClock> fast_cpu_time{linkage,
CpuClock::Boost,
"fast_cpu_time",
Category::Cpu,
Specialization::Default,
true,
true,
&use_fast_cpu_time};
SwitchableSetting<bool> use_custom_cpu_ticks{linkage, SwitchableSetting<bool> use_custom_cpu_ticks{
false, linkage, false, "use_custom_cpu_ticks", Category::Cpu, Specialization::Paired, true, true};
"use_custom_cpu_ticks",
Category::Cpu,
Specialization::Paired,
true,
true};
SwitchableSetting<u32, true> cpu_ticks{linkage, SwitchableSetting<u32, true> cpu_ticks{linkage,
16000, 16000,
@ -323,8 +309,8 @@ struct Values {
Specialization::RuntimeList}; Specialization::RuntimeList};
SwitchableSetting<bool> enable_raii{linkage, false, "enable_raii", Category::Renderer}; SwitchableSetting<bool> enable_raii{linkage, false, "enable_raii", Category::Renderer};
#ifdef __ANDROID__ #ifdef __ANDROID__
SwitchableSetting<bool> frame_interpolation{linkage, true, "frame_interpolation", Category::Renderer, SwitchableSetting<bool> frame_interpolation{linkage, true, "frame_interpolation",
Specialization::RuntimeList}; Category::Renderer, Specialization::RuntimeList};
SwitchableSetting<bool> frame_skipping{linkage, false, "frame_skipping", Category::Renderer, SwitchableSetting<bool> frame_skipping{linkage, false, "frame_skipping", Category::Renderer,
Specialization::RuntimeList}; Specialization::RuntimeList};
#endif #endif
@ -476,13 +462,9 @@ struct Values {
Category::RendererAdvanced}; Category::RendererAdvanced};
SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders", SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
Category::RendererAdvanced}; Category::RendererAdvanced};
SwitchableSetting<bool> use_fast_gpu_time{linkage, SwitchableSetting<bool> use_fast_gpu_time{
true, linkage, true, "use_fast_gpu_time", Category::RendererAdvanced, Specialization::Paired,
"use_fast_gpu_time", true, true};
Category::RendererAdvanced,
Specialization::Paired,
true,
true};
SwitchableSetting<GpuOverclock> fast_gpu_time{linkage, SwitchableSetting<GpuOverclock> fast_gpu_time{linkage,
GpuOverclock::Low, GpuOverclock::Low,
@ -507,17 +489,15 @@ struct Values {
SwitchableSetting<bool> barrier_feedback_loops{linkage, true, "barrier_feedback_loops", SwitchableSetting<bool> barrier_feedback_loops{linkage, true, "barrier_feedback_loops",
Category::RendererAdvanced}; Category::RendererAdvanced};
SwitchableSetting<u8, true> dyna_state{linkage, SwitchableSetting<u8, true> dyna_state{
0, linkage, 0, 0, 3, "dyna_state", Category::RendererExtensions, Specialization::Scalar};
0,
3,
"dyna_state",
Category::RendererExtensions,
Specialization::Scalar};
SwitchableSetting<bool> provoking_vertex{linkage, false, "provoking_vertex", Category::RendererExtensions}; SwitchableSetting<bool> provoking_vertex{linkage, false, "provoking_vertex",
SwitchableSetting<bool> descriptor_indexing{linkage, false, "descriptor_indexing", Category::RendererExtensions}; Category::RendererExtensions};
SwitchableSetting<bool> sample_shading{linkage, false, "sample_shading", Category::RendererExtensions}; SwitchableSetting<bool> descriptor_indexing{linkage, false, "descriptor_indexing",
Category::RendererExtensions};
SwitchableSetting<bool> sample_shading{linkage, false, "sample_shading",
Category::RendererExtensions};
Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug}; Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug};
Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback", Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback",
@ -532,12 +512,9 @@ struct Values {
Category::RendererDebug}; Category::RendererDebug};
// System // System
SwitchableSetting<Language, true> language_index{linkage, SwitchableSetting<Language, true> language_index{
Language::EnglishAmerican, linkage, Language::EnglishAmerican, Language::Japanese,
Language::Japanese, Language::Serbian, "language_index", Category::System};
Language::Serbian,
"language_index",
Category::System};
SwitchableSetting<Region, true> region_index{linkage, Region::Usa, Region::Japan, SwitchableSetting<Region, true> region_index{linkage, Region::Usa, Region::Japan,
Region::Taiwan, "region_index", Category::System}; Region::Taiwan, "region_index", Category::System};
SwitchableSetting<TimeZone, true> time_zone_index{linkage, TimeZone::Auto, SwitchableSetting<TimeZone, true> time_zone_index{linkage, TimeZone::Auto,
@ -687,8 +664,7 @@ struct Values {
Setting<bool> extended_logging{ Setting<bool> extended_logging{
linkage, false, "extended_logging", Category::Debugging, Specialization::Default, false}; linkage, false, "extended_logging", Category::Debugging, Specialization::Default, false};
Setting<bool> use_debug_asserts{linkage, false, "use_debug_asserts", Category::Debugging}; Setting<bool> use_debug_asserts{linkage, false, "use_debug_asserts", Category::Debugging};
Setting<bool> use_auto_stub{ Setting<bool> use_auto_stub{linkage, false, "use_auto_stub", Category::Debugging};
linkage, false, "use_auto_stub", Category::Debugging};
Setting<bool> enable_all_controllers{linkage, false, "enable_all_controllers", Setting<bool> enable_all_controllers{linkage, false, "enable_all_controllers",
Category::Debugging}; Category::Debugging};
Setting<bool> perform_vulkan_check{linkage, true, "perform_vulkan_check", Category::Debugging}; Setting<bool> perform_vulkan_check{linkage, true, "perform_vulkan_check", Category::Debugging};

15
src/common/settings_enums.h
View file

@ -150,19 +150,8 @@ ENUM(FullscreenMode, Borderless, Exclusive);
ENUM(NvdecEmulation, Off, Cpu, Gpu); ENUM(NvdecEmulation, Off, Cpu, Gpu);
ENUM(ResolutionSetup, ENUM(ResolutionSetup, Res1_4X, Res1_2X, Res3_4X, Res1X, Res3_2X, Res2X, Res3X, Res4X, Res5X, Res6X,
Res1_4X, Res7X, Res8X);
Res1_2X,
Res3_4X,
Res1X,
Res3_2X,
Res2X,
Res3X,
Res4X,
Res5X,
Res6X,
Res7X,
Res8X);
ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, ScaleForce, Fsr, Area, MaxEnum); ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, ScaleForce, Fsr, Area, MaxEnum);

12
src/common/string_util.cpp
View file

@ -4,9 +4,8 @@
#include <algorithm> #include <algorithm>
#include <cctype> #include <cctype>
#include <codecvt>
#include <locale>
#include <sstream> #include <sstream>
#include <boost/locale.hpp>
#include "common/string_util.h" #include "common/string_util.h"
@ -142,18 +141,15 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
} }
std::string UTF16ToUTF8(std::u16string_view input) { std::string UTF16ToUTF8(std::u16string_view input) {
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert; return boost::locale::conv::utf_to_utf<char>(input.data(), input.data() + input.size());
return convert.to_bytes(input.data(), input.data() + input.size());
} }
std::u16string UTF8ToUTF16(std::string_view input) { std::u16string UTF8ToUTF16(std::string_view input) {
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert; return boost::locale::conv::utf_to_utf<char16_t>(input.data(), input.data() + input.size());
return convert.from_bytes(input.data(), input.data() + input.size());
} }
std::u32string UTF8ToUTF32(std::string_view input) { std::u32string UTF8ToUTF32(std::string_view input) {
std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert; return boost::locale::conv::utf_to_utf<char32_t>(input.data(), input.data() + input.size());
return convert.from_bytes(input.data(), input.data() + input.size());
} }
#ifdef _WIN32 #ifdef _WIN32

12
src/common/vector_math.h
View file

@ -362,7 +362,9 @@ 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 { return Vec2<T>(a, b); } [[nodiscard]] constexpr Vec2<T> name() const { \
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); \
@ -555,7 +557,9 @@ 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 { return Vec2<T>(a, b); } [[nodiscard]] constexpr Vec2<T> name() const { \
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)
@ -580,7 +584,9 @@ 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 { return Vec3<T>(a, b, c); } [[nodiscard]] constexpr Vec3<T> name() const { \
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)

4
src/common/virtual_buffer.h
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)}, base_ptr{std::exchange(other.base_ptr), : alloc_size{std::exchange(other.alloc_size, 0)},
nullptr} {} base_ptr{std::exchange(other.base_ptr), 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);

4
src/common/x64/native_clock.cpp
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_}, ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den, : rdtsc_frequency{rdtsc_frequency_},
rdtsc_frequency)}, ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den, 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)},

3
src/core/arm/arm_interface.cpp
View file

@ -14,7 +14,8 @@ void ArmInterface::LogBacktrace(Kernel::KProcess* process) const {
this->GetContext(ctx); this->GetContext(ctx);
LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", ctx.sp, ctx.pc); LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", ctx.sp, ctx.pc);
LOG_ERROR(Core_ARM, "{:20}{:20}{:20}{:20}{}", "Module Name", "Address", "Original Address", "Offset", "Symbol"); LOG_ERROR(Core_ARM, "{:20}{:20}{:20}{:20}{}", "Module Name", "Address", "Original Address",
"Offset", "Symbol");
LOG_ERROR(Core_ARM, ""); LOG_ERROR(Core_ARM, "");
const auto backtrace = GetBacktraceFromContext(process, ctx); const auto backtrace = GetBacktraceFromContext(process, ctx);

11
src/core/arm/dynarmic/arm_dynarmic_32.cpp
View file

@ -19,8 +19,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_parent{parent}, m_memory(process->GetMemory()), m_process(process),
m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()}, 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()} {}
@ -195,9 +195,10 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128; config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
config.only_detect_misalignment_via_page_table_on_page_boundary = true; config.only_detect_misalignment_via_page_table_on_page_boundary = true;
config.fastmem_pointer = page_table->fastmem_arena ? config.fastmem_pointer =
std::optional<uintptr_t>{reinterpret_cast<uintptr_t>(page_table->fastmem_arena)} : page_table->fastmem_arena
std::nullopt; ? std::optional<uintptr_t>{reinterpret_cast<uintptr_t>(page_table->fastmem_arena)}
: std::nullopt;
config.fastmem_exclusive_access = config.fastmem_pointer != std::nullopt; config.fastmem_exclusive_access = config.fastmem_pointer != std::nullopt;
config.recompile_on_exclusive_fastmem_failure = true; config.recompile_on_exclusive_fastmem_failure = true;

11
src/core/arm/dynarmic/arm_dynarmic_64.cpp
View file

@ -19,8 +19,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_parent{parent}, m_memory(process->GetMemory()), m_process(process),
m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()}, 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()} {}
@ -242,9 +242,10 @@ std::shared_ptr<Dynarmic::A64::Jit> ArmDynarmic64::MakeJit(Common::PageTable* pa
config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128; config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
config.only_detect_misalignment_via_page_table_on_page_boundary = true; config.only_detect_misalignment_via_page_table_on_page_boundary = true;
config.fastmem_pointer = page_table->fastmem_arena ? config.fastmem_pointer =
std::optional<uintptr_t>{reinterpret_cast<uintptr_t>(page_table->fastmem_arena)} : page_table->fastmem_arena
std::nullopt; ? std::optional<uintptr_t>{reinterpret_cast<uintptr_t>(page_table->fastmem_arena)}
: std::nullopt;
config.fastmem_address_space_bits = std::uint32_t(address_space_bits); config.fastmem_address_space_bits = std::uint32_t(address_space_bits);
config.silently_mirror_fastmem = false; config.silently_mirror_fastmem = false;

49
src/core/arm/nce/lru_cache.h
View file

@ -20,21 +20,27 @@ public:
struct Statistics { struct Statistics {
size_type hits = 0; size_type hits = 0;
size_type misses = 0; size_type misses = 0;
void reset() noexcept { hits = misses = 0; } void reset() noexcept {
hits = misses = 0;
}
}; };
explicit LRUCache(size_type capacity, bool enabled = true) explicit LRUCache(size_type capacity, bool enabled = true)
: enabled_{enabled}, capacity_{capacity} { : enabled_{enabled}, capacity_{capacity} {
cache_map_.reserve(capacity_); cache_map_.reserve(capacity_);
LOG_WARNING(Core, "LRU Cache initialised (state: {} | capacity: {})", enabled_ ? "enabled" : "disabled", capacity_); LOG_WARNING(Core, "LRU Cache initialised (state: {} | capacity: {})",
enabled_ ? "enabled" : "disabled", capacity_);
} }
// Non-movable copy semantics // Non-movable copy semantics
LRUCache(const LRUCache&) = delete; LRUCache(const LRUCache&) = delete;
LRUCache& operator=(const LRUCache&) = delete; LRUCache& operator=(const LRUCache&) = delete;
LRUCache(LRUCache&& other) noexcept { *this = std::move(other); } LRUCache(LRUCache&& other) noexcept {
*this = std::move(other);
}
LRUCache& operator=(LRUCache&& other) noexcept { LRUCache& operator=(LRUCache&& other) noexcept {
if (this == &other) return *this; if (this == &other)
return *this;
std::unique_lock this_lock(mutex_, std::defer_lock); std::unique_lock this_lock(mutex_, std::defer_lock);
std::unique_lock other_lock(other.mutex_, std::defer_lock); std::unique_lock other_lock(other.mutex_, std::defer_lock);
std::lock(this_lock, other_lock); std::lock(this_lock, other_lock);
@ -48,7 +54,8 @@ public:
~LRUCache() = default; ~LRUCache() = default;
[[nodiscard]] value_type* get(const key_type& key) { [[nodiscard]] value_type* get(const key_type& key) {
if (!enabled_) [[unlikely]] return nullptr; if (!enabled_) [[unlikely]]
return nullptr;
std::unique_lock lock(mutex_); std::unique_lock lock(mutex_);
auto it = cache_map_.find(key); auto it = cache_map_.find(key);
if (it == cache_map_.end()) { if (it == cache_map_.end()) {
@ -61,7 +68,8 @@ public:
} }
[[nodiscard]] value_type* peek(const key_type& key) const { [[nodiscard]] value_type* peek(const key_type& key) const {
if (!enabled_) [[unlikely]] return nullptr; if (!enabled_) [[unlikely]]
return nullptr;
std::shared_lock lock(mutex_); std::shared_lock lock(mutex_);
auto it = cache_map_.find(key); auto it = cache_map_.find(key);
return it == cache_map_.end() ? nullptr : &it->second.second; return it == cache_map_.end() ? nullptr : &it->second.second;
@ -69,7 +77,8 @@ public:
template <typename V> template <typename V>
void put(const key_type& key, V&& value) { void put(const key_type& key, V&& value) {
if (!enabled_) [[unlikely]] return; if (!enabled_) [[unlikely]]
return;
std::unique_lock lock(mutex_); std::unique_lock lock(mutex_);
insert_or_update(key, std::forward<V>(value)); insert_or_update(key, std::forward<V>(value));
} }
@ -88,16 +97,19 @@ public:
} }
[[nodiscard]] bool contains(const key_type& key) const { [[nodiscard]] bool contains(const key_type& key) const {
if (!enabled_) return false; if (!enabled_)
return false;
std::shared_lock lock(mutex_); std::shared_lock lock(mutex_);
return cache_map_.find(key) != cache_map_.end(); return cache_map_.find(key) != cache_map_.end();
} }
bool erase(const key_type& key) { bool erase(const key_type& key) {
if (!enabled_) return false; if (!enabled_)
return false;
std::unique_lock lock(mutex_); std::unique_lock lock(mutex_);
auto it = cache_map_.find(key); auto it = cache_map_.find(key);
if (it == cache_map_.end()) return false; if (it == cache_map_.end())
return false;
cache_list_.erase(it->second.first); cache_list_.erase(it->second.first);
cache_map_.erase(it); cache_map_.erase(it);
return true; return true;
@ -111,15 +123,19 @@ public:
} }
[[nodiscard]] size_type size() const { [[nodiscard]] size_type size() const {
if (!enabled_) return 0; if (!enabled_)
return 0;
std::shared_lock lock(mutex_); std::shared_lock lock(mutex_);
return cache_map_.size(); return cache_map_.size();
} }
[[nodiscard]] size_type get_capacity() const { return capacity_; } [[nodiscard]] size_type get_capacity() const {
return capacity_;
}
void resize(size_type new_capacity) { void resize(size_type new_capacity) {
if (!enabled_) return; if (!enabled_)
return;
std::unique_lock lock(mutex_); std::unique_lock lock(mutex_);
capacity_ = new_capacity; capacity_ = new_capacity;
shrink_if_needed(); shrink_if_needed();
@ -130,10 +146,13 @@ public:
std::unique_lock lock(mutex_); std::unique_lock lock(mutex_);
enabled_ = state; enabled_ = state;
LOG_WARNING(Core, "LRU Cache state changed to: {}", state ? "enabled" : "disabled"); LOG_WARNING(Core, "LRU Cache state changed to: {}", state ? "enabled" : "disabled");
if (!enabled_) clear(); if (!enabled_)
clear();
} }
[[nodiscard]] bool isEnabled() const { return enabled_; } [[nodiscard]] bool isEnabled() const {
return enabled_;
}
[[nodiscard]] Statistics stats() const { [[nodiscard]] Statistics stats() const {
std::shared_lock lock(mutex_); std::shared_lock lock(mutex_);

11
src/core/arm/nce/patcher.cpp
View file

@ -16,21 +16,16 @@ namespace Core::NCE {
Patcher::Patcher(Patcher&& other) noexcept Patcher::Patcher(Patcher&& other) noexcept
: patch_cache(std::move(other.patch_cache)), : patch_cache(std::move(other.patch_cache)),
m_patch_instructions(std::move(other.m_patch_instructions)), m_patch_instructions(std::move(other.m_patch_instructions)), c(m_patch_instructions),
c(m_patch_instructions), m_save_context(other.m_save_context), m_load_context(other.m_load_context), mode(other.mode),
m_save_context(other.m_save_context),
m_load_context(other.m_load_context),
mode(other.mode),
total_program_size(other.total_program_size), total_program_size(other.total_program_size),
m_relocate_module_index(other.m_relocate_module_index), m_relocate_module_index(other.m_relocate_module_index), modules(std::move(other.modules)),
modules(std::move(other.modules)),
curr_patch(nullptr) { curr_patch(nullptr) {
if (!modules.empty()) { if (!modules.empty()) {
curr_patch = &modules.back(); curr_patch = &modules.back();
} }
} }
using namespace Common::Literals; using namespace Common::Literals;
using namespace oaknut::util; using namespace oaknut::util;

11
src/core/arm/nce/patcher.h
View file

@ -9,13 +9,13 @@
#include <oaknut/code_block.hpp> #include <oaknut/code_block.hpp>
#include <oaknut/oaknut.hpp> #include <oaknut/oaknut.hpp>
#include <utility>
#include "common/common_types.h" #include "common/common_types.h"
#include "common/settings.h" #include "common/settings.h"
#include "core/hle/kernel/code_set.h" #include "core/hle/kernel/code_set.h"
#include "core/hle/kernel/k_typed_address.h" #include "core/hle/kernel/k_typed_address.h"
#include "core/hle/kernel/physical_memory.h" #include "core/hle/kernel/physical_memory.h"
#include "lru_cache.h" #include "lru_cache.h"
#include <utility>
namespace Core::NCE { namespace Core::NCE {
@ -68,7 +68,8 @@ private:
private: private:
static constexpr size_t CACHE_SIZE = 16384; // Cache size for patch entries static constexpr size_t CACHE_SIZE = 16384; // Cache size for patch entries
LRUCache<uintptr_t, PatchTextAddress> patch_cache{CACHE_SIZE, Settings::values.lru_cache_enabled.GetValue()}; LRUCache<uintptr_t, PatchTextAddress> patch_cache{
CACHE_SIZE, Settings::values.lru_cache_enabled.GetValue()};
void BranchToPatch(uintptr_t module_dest) { void BranchToPatch(uintptr_t module_dest) {
if (patch_cache.isEnabled()) { if (patch_cache.isEnabled()) {
@ -79,14 +80,16 @@ private:
curr_patch->m_branch_to_patch_relocations.push_back({c.offset(), *cached_patch}); curr_patch->m_branch_to_patch_relocations.push_back({c.offset(), *cached_patch});
return; return;
} }
LOG_DEBUG(Core_ARM, "LRU cache miss for address {:#x}, creating new patch", module_dest); LOG_DEBUG(Core_ARM, "LRU cache miss for address {:#x}, creating new patch",
module_dest);
// If not in cache, create new entry and cache it // If not in cache, create new entry and cache it
const auto patch_addr = c.offset(); const auto patch_addr = c.offset();
curr_patch->m_branch_to_patch_relocations.push_back({patch_addr, module_dest}); curr_patch->m_branch_to_patch_relocations.push_back({patch_addr, module_dest});
patch_cache.put(module_dest, patch_addr); patch_cache.put(module_dest, patch_addr);
} else { } else {
LOG_DEBUG(Core_ARM, "LRU cache disabled - creating direct patch for address {:#x}", module_dest); LOG_DEBUG(Core_ARM, "LRU cache disabled - creating direct patch for address {:#x}",
module_dest);
// LRU disabled - use pre-LRU approach // LRU disabled - use pre-LRU approach
curr_patch->m_branch_to_patch_relocations.push_back({c.offset(), module_dest}); curr_patch->m_branch_to_patch_relocations.push_back({c.offset(), module_dest});
} }

8
src/core/core_timing.cpp
View file

@ -17,8 +17,8 @@
#include "common/x64/cpu_wait.h" #include "common/x64/cpu_wait.h"
#endif #endif
#include "common/settings.h"
#include "common/microprofile.h" #include "common/microprofile.h"
#include "common/settings.h"
#include "core/core_timing.h" #include "core/core_timing.h"
#include "core/hardware_properties.h" #include "core/hardware_properties.h"
@ -198,13 +198,13 @@ u64 CoreTiming::GetClockTicks() const {
} }
if (Settings::values.use_fast_cpu_time) { if (Settings::values.use_fast_cpu_time) {
fres = (u64) ((double) fres fres = (u64)((double)fres * (1.7 + 0.3 * (u32)Settings::values.fast_cpu_time.GetValue()));
* (1.7 + 0.3 * (u32) Settings::values.fast_cpu_time.GetValue()));
} }
if (Settings::values.sync_core_speed.GetValue()) { if (Settings::values.sync_core_speed.GetValue()) {
const double ticks = static_cast<double>(fres); const double ticks = static_cast<double>(fres);
const double speed_limit = static_cast<double>(Settings::values.speed_limit.GetValue())*0.01; const double speed_limit =
static_cast<double>(Settings::values.speed_limit.GetValue()) * 0.01;
return static_cast<u64>(ticks / speed_limit); return static_cast<u64>(ticks / speed_limit);
} else { } else {
return fres; return fres;

4
src/core/file_sys/card_image.cpp
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(partition_names.size()), partitions_raw(partition_names.size()),
partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} { 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;

11
src/core/file_sys/fs_path_utility.h
View file

@ -87,12 +87,15 @@ private:
u32 m_value; u32 m_value;
public: public:
constexpr PathFlags() : m_value(0) { /* ... */ constexpr PathFlags() : m_value(0) { /* ... */ }
}
#define DECLARE_PATH_FLAG_HANDLER(__WHICH__) \ #define DECLARE_PATH_FLAG_HANDLER(__WHICH__) \
constexpr bool Is##__WHICH__##Allowed() const { return (m_value & __WHICH__##Flag) != 0; } \ constexpr bool Is##__WHICH__##Allowed() const { \
constexpr void Allow##__WHICH__() { m_value |= __WHICH__##Flag; } return (m_value & __WHICH__##Flag) != 0; \
} \
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)

22
src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp
View file

@ -4,23 +4,18 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include "core/file_sys/fssystem/fssystem_integrity_verification_storage.h"
#include "common/alignment.h" #include "common/alignment.h"
#include "core/file_sys/fssystem/fssystem_integrity_verification_storage.h"
namespace FileSys { namespace FileSys {
constexpr inline u32 ILog2(u32 val) constexpr inline u32 ILog2(u32 val) {
{
ASSERT(val > 0); ASSERT(val > 0);
return static_cast<u32>((sizeof(u32) * 8) - 1 - std::countl_zero<u32>(val)); return static_cast<u32>((sizeof(u32) * 8) - 1 - std::countl_zero<u32>(val));
} }
void IntegrityVerificationStorage::Initialize(VirtualFile hs, void IntegrityVerificationStorage::Initialize(VirtualFile hs, VirtualFile ds, s64 verif_block_size,
VirtualFile ds, s64 upper_layer_verif_block_size, bool is_real_data) {
s64 verif_block_size,
s64 upper_layer_verif_block_size,
bool is_real_data)
{
// Validate preconditions. // Validate preconditions.
ASSERT(verif_block_size >= HashSize); ASSERT(verif_block_size >= HashSize);
@ -54,14 +49,12 @@ void IntegrityVerificationStorage::Initialize(VirtualFile hs,
m_is_real_data = is_real_data; m_is_real_data = is_real_data;
} }
void IntegrityVerificationStorage::Finalize() void IntegrityVerificationStorage::Finalize() {
{
m_hash_storage = VirtualFile(); m_hash_storage = VirtualFile();
m_data_storage = VirtualFile(); m_data_storage = VirtualFile();
} }
size_t IntegrityVerificationStorage::Read(u8* buffer, size_t size, size_t offset) const size_t IntegrityVerificationStorage::Read(u8* buffer, size_t size, size_t offset) const {
{
// Succeed if zero size. // Succeed if zero size.
if (size == 0) { if (size == 0) {
return size; return size;
@ -104,8 +97,7 @@ size_t IntegrityVerificationStorage::Read(u8* buffer, size_t size, size_t offset
return m_data_storage->Read(buffer, read_size, offset); return m_data_storage->Read(buffer, read_size, offset);
} }
size_t IntegrityVerificationStorage::GetSize() const size_t IntegrityVerificationStorage::GetSize() const {
{
return m_data_storage->GetSize(); return m_data_storage->GetSize();
} }

4
src/core/file_sys/registered_cache.cpp
View file

@ -790,7 +790,9 @@ InstallResult RegisteredCache::RawInstallNCA(const NCA& nca, const VfsCopyFuncti
if (GetFileAtID(id) != nullptr) { if (GetFileAtID(id) != nullptr) {
LOG_WARNING(Loader, "Overwriting existing NCA..."); LOG_WARNING(Loader, "Overwriting existing NCA...");
VirtualDir c_dir; VirtualDir c_dir;
{ c_dir = dir->GetFileRelative(path)->GetContainingDirectory(); } {
c_dir = dir->GetFileRelative(path)->GetContainingDirectory();
}
c_dir->DeleteFile(Common::FS::GetFilename(path)); c_dir->DeleteFile(Common::FS::GetFilename(path));
} }

4
src/core/file_sys/sdmc_factory.cpp
View file

@ -15,9 +15,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
: sd_dir(std::move(sd_dir_)), sd_mod_dir(std::move(sd_mod_dir_)), : sd_dir(std::move(sd_dir_)), sd_mod_dir(std::move(sd_mod_dir_)),
contents(std::make_unique<RegisteredCache>( contents(std::make_unique<RegisteredCache>(
GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents/registered"), GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents/registered"),
[](const VirtualFile& file, const NcaID& id) { [](const VirtualFile& file, const NcaID& id) { return NAX{file, id}.GetDecrypted(); })),
return NAX{file, id}.GetDecrypted();
})),
placeholder(std::make_unique<PlaceholderCache>( placeholder(std::make_unique<PlaceholderCache>(
GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents/placehld"))) {} GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents/placehld"))) {}

6
src/core/file_sys/submission_package.cpp
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_), : file(std::move(file_)), expected_program_id(title_id_), program_index(program_index_),
program_index(program_index_), status{Loader::ResultStatus::Success}, status{Loader::ResultStatus::Success}, pfs(std::make_shared<PartitionFilesystem>(file)),
pfs(std::make_shared<PartitionFilesystem>(file)), keys{Core::Crypto::KeyManager::Instance()} { 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;

8
src/core/file_sys/xts_archive.cpp
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>()), : header(std::make_unique<NAXHeader>()), file(std::move(file_)),
file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} { 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>()), : header(std::make_unique<NAXHeader>()), file(std::move(file_)),
file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} { 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],

16
src/core/hle/kernel/k_auto_object.h
View file

@ -24,7 +24,9 @@ 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() { return ::Kernel::ClassToken<CLASS>; } \ static constexpr inline ClassTokenType ClassToken() { \
return ::Kernel::ClassToken<CLASS>; \
} \
\ \
public: \ public: \
YUZU_NON_COPYABLE(CLASS); \ YUZU_NON_COPYABLE(CLASS); \
@ -35,9 +37,15 @@ public:
constexpr ClassTokenType Token = ClassToken(); \ constexpr ClassTokenType Token = ClassToken(); \
return TypeObj(TypeName, Token); \ return TypeObj(TypeName, Token); \
} \ } \
static constexpr const char* GetStaticTypeName() { return TypeName; } \ static constexpr const char* GetStaticTypeName() { \
virtual TypeObj GetTypeObj() ATTRIBUTE { return GetStaticTypeObj(); } \ return TypeName; \
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)

4
src/core/hle/kernel/k_memory_layout.cpp
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_physical_linear_tree{ m_virtual_linear_tree{m_memory_region_allocator},
m_memory_region_allocator} {} m_physical_linear_tree{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) {

14
src/core/hle/kernel/k_priority_queue.h
View file

@ -17,8 +17,7 @@ namespace Kernel {
class KThread; class KThread;
template <typename T> template <typename T>
concept KPriorityQueueAffinityMask = ! concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T& t) {
std::is_reference_v<T>&& requires(T& t) {
{ t.GetAffinityMask() } -> Common::ConvertibleTo<u64>; { t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
{ t.SetAffinityMask(0) }; { t.SetAffinityMask(0) };
@ -28,22 +27,17 @@ std::is_reference_v<T>&& requires(T& t) {
}; };
template <typename T> template <typename T>
concept KPriorityQueueMember = ! concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T& t) {
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>;

3
src/core/hle/kernel/k_scoped_lock.h
View file

@ -10,8 +10,7 @@
namespace Kernel { namespace Kernel {
template <typename T> template <typename T>
concept KLockable = ! concept KLockable = !std::is_reference_v<T> && requires(T& t) {
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>;
}; };

8
src/core/hle/result.h
View file

@ -458,9 +458,13 @@ 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_THROW(static_cast<Result>(convert_type)); } R_CATCH(catch_type) { \
R_THROW(static_cast<Result>(convert_type)); \
}
#define R_CONVERT_ALL(convert_type) \ #define R_CONVERT_ALL(convert_type) \
R_CATCH_ALL() { R_THROW(static_cast<Result>(convert_type)); } R_CATCH_ALL() { \
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))

1
src/core/hle/service/acc/profile_manager.cpp
View file

@ -496,5 +496,4 @@ void ProfileManager::SetUserPosition(u64 position, Common::UUID uuid) {
WriteUserSaveFile(); WriteUserSaveFile();
} }
}; // namespace Service::Account }; // namespace Service::Account

5
src/core/hle/service/am/frontend/applet_cabinet.cpp
View file

@ -18,9 +18,8 @@ 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_}, service_context{ : FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_},
system_, service_context{system_, "CabinetApplet"} {
"CabinetApplet"} {
availability_change_event = availability_change_event =
service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent"); service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent");

4
src/core/hle/service/am/frontend/applet_net_connect.cpp
View file

@ -15,7 +15,9 @@
namespace Service::AM::Frontend { namespace Service::AM::Frontend {
NetConnect::NetConnect(Core::System& system_, std::shared_ptr<Applet> applet_, LibraryAppletMode applet_mode_, const Core::Frontend::NetConnectApplet& frontend_) NetConnect::NetConnect(Core::System& system_, std::shared_ptr<Applet> applet_,
LibraryAppletMode applet_mode_,
const Core::Frontend::NetConnectApplet& frontend_)
: FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_} {} : FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_} {}
NetConnect::~NetConnect() = default; NetConnect::~NetConnect() = default;

3
src/core/hle/service/am/frontend/applets.cpp
View file

@ -85,7 +85,8 @@ FrontendAppletSet::FrontendAppletSet(CabinetApplet cabinet_applet,
MiiEdit mii_edit_, MiiEdit mii_edit_,
ParentalControlsApplet parental_controls_applet, ParentalControlsApplet parental_controls_applet,
PhotoViewer photo_viewer_, ProfileSelect profile_select_, PhotoViewer photo_viewer_, ProfileSelect profile_select_,
SoftwareKeyboard software_keyboard_, WebBrowser web_browser_, NetConnect net_connect_) SoftwareKeyboard software_keyboard_, WebBrowser web_browser_,
NetConnect net_connect_)
: cabinet{std::move(cabinet_applet)}, controller{std::move(controller_applet)}, : cabinet{std::move(cabinet_applet)}, controller{std::move(controller_applet)},
error{std::move(error_applet)}, mii_edit{std::move(mii_edit_)}, error{std::move(error_applet)}, mii_edit{std::move(mii_edit_)},
parental_controls{std::move(parental_controls_applet)}, parental_controls{std::move(parental_controls_applet)},

2
src/core/hle/service/am/frontend/applets.h
View file

@ -10,8 +10,8 @@
#include <queue> #include <queue>
#include "common/swap.h" #include "common/swap.h"
#include "core/hle/service/am/applet.h"
#include "core/frontend/applets/net_connect.h" #include "core/frontend/applets/net_connect.h"
#include "core/hle/service/am/applet.h"
union Result; union Result;

4
src/core/hle/service/am/service/application_proxy.cpp
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"}, : ServiceFramework{system_, "IApplicationProxy"}, m_window_system{window_system},
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} { 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"},

4
src/core/hle/service/am/service/library_applet_creator.cpp
View file

@ -167,8 +167,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"}, : ServiceFramework{system_, "ILibraryAppletCreator"}, m_window_system{window_system},
m_window_system{window_system}, m_applet{std::move(applet)} { 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"},

4
src/core/hle/service/am/service/library_applet_proxy.cpp
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"}, : ServiceFramework{system_, "ILibraryAppletProxy"}, m_window_system{window_system},
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} { 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"},

4
src/core/hle/service/am/service/self_controller.cpp
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}, m_applet{ : ServiceFramework{system_, "ISelfController"}, m_process{process},
std::move(applet)} { m_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"},

4
src/core/hle/service/am/service/system_applet_proxy.cpp
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"}, : ServiceFramework{system_, "ISystemAppletProxy"}, m_window_system{window_system},
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} { 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"},

4
src/core/hle/service/am/service/window_controller.cpp
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"}, : ServiceFramework{system_, "IWindowController"}, m_window_system{window_system},
m_window_system{window_system}, m_applet{std::move(applet)} { 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"},

4
src/core/hle/service/aoc/purchase_event_manager.cpp
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"}, service_context{system, : ServiceFramework{system_, "IPurchaseEventManager"},
"IPurchaseEventManager"} { service_context{system, "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"},

5
src/core/hle/service/audio/audio_in.cpp
View file

@ -12,9 +12,8 @@ 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")}, impl{std::make_shared<In>(system_, event{service_context.CreateEvent("AudioInEvent")},
manager, event, impl{std::make_shared<In>(system_, manager, event, session_id)} {
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"},

4
src/core/hle/service/audio/audio_in_manager.cpp
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"}, impl{std::make_unique<AudioCore::AudioIn::Manager>( : ServiceFramework{system_, "audin:u"},
system_)} { impl{std::make_unique<AudioCore::AudioIn::Manager>(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"},

4
src/core/hle/service/audio/audio_renderer.cpp
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)}, process_handle{ impl{std::make_unique<Renderer>(system_, manager, rendered_event)},
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"},

5
src/core/hle/service/bcat/news/newly_arrived_event_holder.cpp
View file

@ -7,9 +7,8 @@
namespace Service::News { namespace Service::News {
INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_) INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
: ServiceFramework{system_, "INewlyArrivedEventHolder"}, service_context{ : ServiceFramework{system_, "INewlyArrivedEventHolder"},
system_, service_context{system_, "INewlyArrivedEventHolder"} {
"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"},

4
src/core/hle/service/bcat/news/overwrite_event_holder.cpp
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"}, service_context{system_, : ServiceFramework{system_, "IOverwriteEventHolder"},
"IOverwriteEventHolder"} { service_context{system_, "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"},

4
src/core/hle/service/filesystem/fsp/fs_i_filesystem.cpp
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"}, backend{std::make_unique<FileSys::Fsa::IFileSystem>( : ServiceFramework{system_, "IFileSystem"},
dir_)}, backend{std::make_unique<FileSys::Fsa::IFileSystem>(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"},

4
src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
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"}, save_data_controller{ : ServiceFramework{system_, "ISaveDataInfoReader"},
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"},
}; };

4
src/core/hle/service/glue/time/alarm_worker.cpp
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_steady_clock_resource{ : m_system{system}, m_ctx{system, "Glue:AlarmWorker"},
steady_clock_resource} {} m_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);

6
src/core/hle/service/glue/time/manager.cpp
View file

@ -87,10 +87,8 @@ 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_worker{ : m_steady_clock_resource{system}, m_time_zone_binary{system},
system, m_worker{system, m_steady_clock_resource, m_file_timestamp_worker} {
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);

6
src/core/hle/service/glue/time/time_zone.cpp
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_wrapped_service{std::move( m_file_timestamp_worker{file_timestamp_worker},
time_zone_service)}, m_wrapped_service{std::move(time_zone_service)}, m_operation_event{m_system},
m_operation_event{m_system}, m_time_zone_binary{time_zone_binary} { 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"},

8
src/core/hle/service/glue/time/worker.cpp
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_event{m_ctx.CreateEvent( : m_system{system}, m_ctx{m_system, "Glue:TimeWorker"},
"Glue:TimeWorker:Event")}, m_event{m_ctx.CreateEvent("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_timer_steady_clock{m_ctx.CreateEvent( m_file_timestamp_worker{file_timestamp_worker},
"Glue:TimeWorker:SteadyClockTimerEvent")}, m_timer_steady_clock{m_ctx.CreateEvent("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(

4
src/core/hle/service/hid/hid_debug_server.cpp
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}, firmware_settings{ : ServiceFramework{system_, "hid:dbg"}, resource_manager{resource},
settings} { firmware_settings{settings} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, nullptr, "DeactivateDebugPad"}, {0, nullptr, "DeactivateDebugPad"},

6
src/core/hle/service/hid/hid_server.cpp
View file

@ -587,10 +587,8 @@ Result IHidServer::ActivateGesture(u32 basic_gesture_id, ClientAppletResourceUse
Result IHidServer::SetGestureOutputRanges(u32 param1, u32 param2, u32 param3, u32 param4) { Result IHidServer::SetGestureOutputRanges(u32 param1, u32 param2, u32 param3, u32 param4) {
// https://switchbrew.org/wiki/HID_services , Undocumented. 92 [18.0.0+] SetGestureOutputRanges // https://switchbrew.org/wiki/HID_services , Undocumented. 92 [18.0.0+] SetGestureOutputRanges
LOG_WARNING( LOG_WARNING(Service_HID, "(STUBBED) called, param1={}, param2={}, param3={}, param4={}", param1,
Service_HID, param2, param3, param4);
"(STUBBED) called, param1={}, param2={}, param3={}, param4={}",
param1, param2, param3, param4);
R_SUCCEED(); R_SUCCEED();
} }

4
src/core/hle/service/ipc_helpers.h
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_handles_to_copy(num_handles_to_copy_), num_objects_to_move(num_objects_to_move_),
num_objects_to_move(num_objects_to_move_), kernel{ctx.kernel} { kernel{ctx.kernel} {
memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH); memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);

4
src/core/hle/service/jit/jit_context.cpp
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_}, : memory{memory_}, local_memory{local_memory_}, mapped_ranges{mapped_ranges_},
mapped_ranges{mapped_ranges_}, parent{parent_} {} parent{parent_} {}
u8 MemoryRead8(u64 vaddr) override { u8 MemoryRead8(u64 vaddr) override {
return ReadMemory<u8>(vaddr); return ReadMemory<u8>(vaddr);

3
src/core/hle/service/ldn/user_local_communication_service.cpp
View file

@ -24,8 +24,7 @@ namespace Service::LDN {
IUserLocalCommunicationService::IUserLocalCommunicationService(Core::System& system_) IUserLocalCommunicationService::IUserLocalCommunicationService(Core::System& system_)
: ServiceFramework{system_, "IUserLocalCommunicationService"}, : ServiceFramework{system_, "IUserLocalCommunicationService"},
service_context{system, "IUserLocalCommunicationService"}, service_context{system, "IUserLocalCommunicationService"}, lan_discovery{} {
lan_discovery{} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, C<&IUserLocalCommunicationService::GetState>, "GetState"}, {0, C<&IUserLocalCommunicationService::GetState>, "GetState"},

4
src/core/hle/service/mii/mii.cpp
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}, is_system{ : ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager},
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"},

20
src/core/hle/service/nifm/nifm.cpp
View file

@ -67,7 +67,6 @@ static u128 MakeUuidFromName(std::string_view name) {
return {h1, h2}; return {h1, h2};
} }
// This is nn::nifm::RequestState // This is nn::nifm::RequestState
enum class RequestState : u32 { enum class RequestState : u32 {
NotSubmitted = 1, NotSubmitted = 1,
@ -217,7 +216,6 @@ struct PendingProfile {
std::array<char, 0x41> passphrase{}; std::array<char, 0x41> passphrase{};
}; };
constexpr Result ResultPendingConnection{ErrorModule::NIFM, 111}; constexpr Result ResultPendingConnection{ErrorModule::NIFM, 111};
constexpr Result ResultInvalidInput{ErrorModule::NIFM, 112}; constexpr Result ResultInvalidInput{ErrorModule::NIFM, 112};
constexpr Result ResultNetworkCommunicationDisabled{ErrorModule::NIFM, 1111}; constexpr Result ResultNetworkCommunicationDisabled{ErrorModule::NIFM, 1111};
@ -278,8 +276,7 @@ private:
IPC::ResponseBuilder{ctx, 2}.Push(ResultSuccess); IPC::ResponseBuilder{ctx, 2}.Push(ResultSuccess);
} }
void IsProcessing(HLERequestContext& ctx) void IsProcessing(HLERequestContext& ctx) {
{
const bool processing = state.load() == State::Processing; const bool processing = state.load() == State::Processing;
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -321,7 +318,6 @@ private:
Finish(ok ? ResultSuccess : ResultPendingConnection); Finish(ok ? ResultSuccess : ResultPendingConnection);
} }
void Finish(Result rc) { void Finish(Result rc) {
worker_result.store(rc); worker_result.store(rc);
state.store(State::Finished); state.store(State::Finished);
@ -665,7 +661,8 @@ void IGeneralService::GetNetworkProfile(HLERequestContext& ctx) {
std::memcpy(net_name.data(), net_state.ssid, ssid_len); std::memcpy(net_name.data(), net_state.ssid, ssid_len);
SfWirelessSettingData wifi{}; SfWirelessSettingData wifi{};
wifi.ssid_length = static_cast<u8>(std::min<size_t>(std::strlen(net_state.ssid), net_name.size())); wifi.ssid_length =
static_cast<u8>(std::min<size_t>(std::strlen(net_state.ssid), net_name.size()));
wifi.is_secured = !net_state.secure; // somehow reversed wifi.is_secured = !net_state.secure; // somehow reversed
wifi.passphrase = {"password"}; wifi.passphrase = {"password"};
std::memcpy(wifi.ssid.data(), net_state.ssid, wifi.ssid_length); std::memcpy(wifi.ssid.data(), net_state.ssid, wifi.ssid_length);
@ -693,11 +690,10 @@ void IGeneralService::GetNetworkProfile(HLERequestContext& ctx) {
.uuid{MakeUuidFromName(net_state.ssid)}, .uuid{MakeUuidFromName(net_state.ssid)},
.network_name{net_name}, .network_name{net_name},
.profile_type = static_cast<u8>(NetworkProfileType::User), .profile_type = static_cast<u8>(NetworkProfileType::User),
.interface_type = .interface_type = static_cast<u8>(net_iface->kind == Network::HostAdapterKind::Wifi
static_cast<u8>(net_iface->kind == ? NetworkInterfaceType::WiFi_Ieee80211
Network::HostAdapterKind::Wifi ? NetworkInterfaceType::WiFi_Ieee80211 : NetworkInterfaceType::Ethernet), : NetworkInterfaceType::Ethernet),
.wireless_setting_data{wifi} .wireless_setting_data{wifi}};
};
}(); }();
ctx.WriteBuffer(profile); ctx.WriteBuffer(profile);
@ -732,7 +728,6 @@ void IGeneralService::SetNetworkProfile(HLERequestContext& ctx) {
IPC::ResponseBuilder{ctx, 2}.Push(ResultSuccess); IPC::ResponseBuilder{ctx, 2}.Push(ResultSuccess);
} }
void IGeneralService::RemoveNetworkProfile(HLERequestContext& ctx) { void IGeneralService::RemoveNetworkProfile(HLERequestContext& ctx) {
LOG_WARNING(Service_NIFM, "(STUBBED) called"); LOG_WARNING(Service_NIFM, "(STUBBED) called");
@ -759,7 +754,6 @@ void IGeneralService::GetScanDataV2(HLERequestContext& ctx) {
const std::size_t max_rows = guest_bytes / sizeof(AccessPointDataV3); const std::size_t max_rows = guest_bytes / sizeof(AccessPointDataV3);
const std::size_t rows_copy = std::min<std::size_t>(scans.size(), max_rows); const std::size_t rows_copy = std::min<std::size_t>(scans.size(), max_rows);
std::vector<AccessPointDataV3> rows; std::vector<AccessPointDataV3> rows;
rows.resize(rows_copy); rows.resize(rows_copy);

3
src/core/hle/service/ns/application_manager_interface.cpp
View file

@ -315,7 +315,8 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
IApplicationManagerInterface::~IApplicationManagerInterface() = default; IApplicationManagerInterface::~IApplicationManagerInterface() = default;
Result IApplicationManagerInterface::UnregisterNetworkServiceAccountWithUserSaveDataDeletion(Common::UUID user_id) { Result IApplicationManagerInterface::UnregisterNetworkServiceAccountWithUserSaveDataDeletion(
Common::UUID user_id) {
LOG_DEBUG(Service_NS, "called, user_id={}", user_id.FormattedString()); LOG_DEBUG(Service_NS, "called, user_id={}", user_id.FormattedString());
R_SUCCEED(); R_SUCCEED();
} }

4
src/core/hle/service/ns/dynamic_rights_interface.cpp
View file

@ -63,8 +63,8 @@ Result IDynamicRightsInterface::VerifyActivatedRightsOwners(u64 rights_handle) {
R_SUCCEED(); R_SUCCEED();
} }
Result IDynamicRightsInterface::HasAccountRestrictedRightsInRunningApplications( Result IDynamicRightsInterface::HasAccountRestrictedRightsInRunningApplications(Out<u32> out_status,
Out<u32> out_status, u64 rights_handle) { u64 rights_handle) {
LOG_WARNING(Service_NS, "(STUBBED) called, rights_handle={:#x}", rights_handle); LOG_WARNING(Service_NS, "(STUBBED) called, rights_handle={:#x}", rights_handle);
*out_status = 0; *out_status = 0;
R_SUCCEED(); R_SUCCEED();

3
src/core/hle/service/ns/dynamic_rights_interface.h
View file

@ -20,8 +20,7 @@ private:
Result NotifyApplicationRightsCheckStart(); Result NotifyApplicationRightsCheckStart();
Result GetRunningApplicationStatus(Out<u32> out_status, u64 rights_handle); Result GetRunningApplicationStatus(Out<u32> out_status, u64 rights_handle);
Result VerifyActivatedRightsOwners(u64 rights_handle); Result VerifyActivatedRightsOwners(u64 rights_handle);
Result HasAccountRestrictedRightsInRunningApplications(Out<u32> out_status, Result HasAccountRestrictedRightsInRunningApplications(Out<u32> out_status, u64 rights_handle);
u64 rights_handle);
}; };
} // namespace Service::NS } // namespace Service::NS

4
src/core/hle/service/psc/time/alarms.cpp
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_event{m_ctx.CreateEvent( m_power_state_request_manager{power_state_request_manager},
"Psc:Alarms:Event")} {} m_event{m_ctx.CreateEvent("Psc:Alarms:Event")} {}
Alarms::~Alarms() { Alarms::~Alarms() {
m_ctx.CloseEvent(m_event); m_ctx.CloseEvent(m_event);

4
src/core/hle/service/psc/time/clocks/standard_user_system_clock_core.cpp
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_event{m_ctx.CreateEvent( m_network_system_clock{network_clock},
"Psc:StandardUserSystemClockCore:Event")} {} m_event{m_ctx.CreateEvent("Psc:StandardUserSystemClockCore:Event")} {}
StandardUserSystemClockCore::~StandardUserSystemClockCore() { StandardUserSystemClockCore::~StandardUserSystemClockCore() {
m_ctx.CloseEvent(m_event); m_ctx.CloseEvent(m_event);

4
src/core/hle/service/psc/time/common.cpp
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_event{ : m_ctx{system, "Time:OperationEvent"},
m_ctx.CreateEvent("Time:OperationEvent:Event")} {} m_event{m_ctx.CreateEvent("Time:OperationEvent:Event")} {}
OperationEvent::~OperationEvent() { OperationEvent::~OperationEvent() {
m_ctx.CloseEvent(m_event); m_ctx.CloseEvent(m_event);

4
src/core/hle/service/psc/time/manager.h
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_alarms{m_system, m_standard_steady_clock, m_power_state_request_manager{m_system},
m_power_state_request_manager}, m_alarms{m_system, m_standard_steady_clock, 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},

4
src/core/hle/service/psc/time/power_state_service.cpp
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}, m_power_state_request_manager{ : ServiceFramework{system_, "time:p"}, m_system{system},
power_state_request_manager} { m_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"},

4
src/core/hle/service/psc/time/static.cpp
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_shared_memory{ m_ephemeral_network_clock{m_time->m_ephemeral_network_clock},
m_time->m_shared_memory} { 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"},

4
src/core/hle/service/psc/time/steady_clock.cpp
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_uninitialized_clock{ m_can_write_steady_clock{can_write_steady_clock},
can_write_uninitialized_clock} { m_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"},

4
src/core/hle/service/psc/time/system_clock.cpp
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_uninitialized_clock{ m_can_write_clock{can_write_clock},
can_write_uninitialized_clock} { m_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"},

4
src/core/hle/service/psc/time/time_zone_service.cpp
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_can_write_timezone_device_location{ m_time_zone{time_zone},
can_write_timezone_device_location} { m_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"},

3
src/core/hle/service/set/settings_server.cpp
View file

@ -240,7 +240,8 @@ Result ISettingsServer::GetDeviceNickName(
R_SUCCEED(); R_SUCCEED();
} }
Result ISettingsServer::GetKeyCodeMapByPort(OutLargeData<KeyCodeMap, BufferAttr_HipcMapAlias> out_key_code_map, u32 port) { Result ISettingsServer::GetKeyCodeMapByPort(
OutLargeData<KeyCodeMap, BufferAttr_HipcMapAlias> out_key_code_map, u32 port) {
LOG_DEBUG(Service_SET, "called, port={}", port); LOG_DEBUG(Service_SET, "called, port={}", port);
// Similar to other key code map functions, just pass through to the main implementation // Similar to other key code map functions, just pass through to the main implementation

3
src/core/hle/service/set/settings_server.h
View file

@ -47,7 +47,8 @@ private:
Result GetDeviceNickName( Result GetDeviceNickName(
OutLargeData<std::array<u8, 0x80>, BufferAttr_HipcMapAlias> out_device_name); OutLargeData<std::array<u8, 0x80>, BufferAttr_HipcMapAlias> out_device_name);
Result GetKeyCodeMapByPort(OutLargeData<KeyCodeMap, BufferAttr_HipcMapAlias> out_key_code_map, u32 port); Result GetKeyCodeMapByPort(OutLargeData<KeyCodeMap, BufferAttr_HipcMapAlias> out_key_code_map,
u32 port);
}; };
} // namespace Service::Set } // namespace Service::Set

4
src/core/hle/service/sm/sm.cpp
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}, : ServiceFramework{system_, "sm:", 4}, service_manager{service_manager_},
service_manager{service_manager_}, kernel{system_.Kernel()} { kernel{system_.Kernel()} {
RegisterHandlers({ RegisterHandlers({
{0, &SM::Initialize, "Initialize"}, {0, &SM::Initialize, "Initialize"},
{1, &SM::GetServiceCmif, "GetService"}, {1, &SM::GetServiceCmif, "GetService"},

4
src/core/hle/service/sm/sm_controller.cpp
View file

@ -101,13 +101,13 @@ void Controller::SetPointerBufferSize(HLERequestContext& ctx) {
process->SetPointerBufferSize(requested_size); process->SetPointerBufferSize(requested_size);
LOG_INFO(Service, "Pointer buffer size dynamically updated to {:#x} bytes by process", requested_size); LOG_INFO(Service, "Pointer buffer size dynamically updated to {:#x} bytes by process",
requested_size);
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
} }
// https://switchbrew.org/wiki/IPC_Marshalling // https://switchbrew.org/wiki/IPC_Marshalling
Controller::Controller(Core::System& system_) : ServiceFramework{system_, "IpcController"} { Controller::Controller(Core::System& system_) : ServiceFramework{system_, "IpcController"} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {

5
src/core/hle/service/sockets/bsd.cpp
View file

@ -11,6 +11,7 @@
#include <fmt/ranges.h> #include <fmt/ranges.h>
#include <common/settings.h>
#include "common/microprofile.h" #include "common/microprofile.h"
#include "common/socket_types.h" #include "common/socket_types.h"
#include "core/core.h" #include "core/core.h"
@ -22,7 +23,6 @@
#include "core/internal_network/socket_proxy.h" #include "core/internal_network/socket_proxy.h"
#include "core/internal_network/sockets.h" #include "core/internal_network/sockets.h"
#include "network/network.h" #include "network/network.h"
#include <common/settings.h>
using Common::Expected; using Common::Expected;
using Common::Unexpected; using Common::Unexpected;
@ -979,8 +979,7 @@ void BSD::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
} }
} }
BSD::BSD(Core::System& system_, const char* name) BSD::BSD(Core::System& system_, const char* name) : ServiceFramework{system_, name} {
: ServiceFramework{system_, name} {
// clang-format off // clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &BSD::RegisterClient, "RegisterClient"}, {0, &BSD::RegisterClient, "RegisterClient"},

9
src/core/hle/service/ssl/ssl_types.h
View file

@ -42,9 +42,12 @@ enum class CaCertificateId : s32 {
StarfieldRootCertificateAuthorityG2 = 1027, StarfieldRootCertificateAuthorityG2 = 1027,
thawtePrimaryRootCAG3 = 1028, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted thawtePrimaryRootCAG3 = 1028, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted
thawtePrimaryRootCA = 1029, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted thawtePrimaryRootCA = 1029, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted
VeriSignClass3PublicPrimaryCertificationAuthorityG3 = 1030, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted VeriSignClass3PublicPrimaryCertificationAuthorityG3 =
VeriSignClass3PublicPrimaryCertificationAuthorityG5 = 1031, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted 1030, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted
VeriSignUniversalRootCertificationAuthority = 1032, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted VeriSignClass3PublicPrimaryCertificationAuthorityG5 =
1031, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted
VeriSignUniversalRootCertificationAuthority =
1032, // [8.0.0+] TrustedCertStatus is EnabledNotTrusted
DSTRootCAX3 = 1033, // [6.0.0+] DSTRootCAX3 = 1033, // [6.0.0+]
USERTrustRsaCertificationAuthority = 1034, // [10.0.3+] USERTrustRsaCertificationAuthority = 1034, // [10.0.3+]
ISRGRootX10 = 1035, // [10.1.0+] ISRGRootX10 = 1035, // [10.1.0+]

9
src/core/hle/service/vi/application_display_service.cpp
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"}, : ServiceFramework{system_, "IApplicationDisplayService"}, m_container{std::move(container)},
m_container{std::move(container)}, m_context{system, "IApplicationDisplayService"} { 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"},
@ -91,9 +91,8 @@ Result IApplicationDisplayService::OpenDisplay(Out<u64> out_display_id, DisplayN
display_name[display_name.size() - 1] = '\0'; display_name[display_name.size() - 1] = '\0';
// According to switchbrew, only "Default", "External", "Edid", "Internal" and "Null" are valid // According to switchbrew, only "Default", "External", "Edid", "Internal" and "Null" are valid
const std::array<std::string_view, 5> valid_names = { const std::array<std::string_view, 5> valid_names = {"Default", "External", "Edid", "Internal",
"Default", "External", "Edid", "Internal", "Null" "Null"};
};
bool valid_name = false; bool valid_name = false;
for (const auto& name : valid_names) { for (const auto& name : valid_names) {

5
src/core/hle/service/vi/conductor.cpp
View file

@ -15,9 +15,8 @@ namespace Service::VI {
Conductor::Conductor(Core::System& system, Container& container, DisplayList& displays) Conductor::Conductor(Core::System& system, Container& container, DisplayList& displays)
: m_system(system), m_container(container) { : m_system(system), m_container(container) {
displays.ForEachDisplay([&](Display& display) { displays.ForEachDisplay(
m_vsync_managers.insert({display.GetId(), VsyncManager{}}); [&](Display& display) { m_vsync_managers.insert({display.GetId(), VsyncManager{}}); });
});
if (system.IsMulticore()) { if (system.IsMulticore()) {
m_event = Core::Timing::CreateEvent( m_event = Core::Timing::CreateEvent(

2
src/core/internal_network/emu_net_state.h
View file

@ -3,8 +3,8 @@
#pragma once #pragma once
#include <atomic> #include <atomic>
#include <common/socket_types.h>
#include <mutex> #include <mutex>
#include <common/socket_types.h>
namespace Network { namespace Network {

Some files were not shown because too many files have changed in this diff Show more