vi: Copy data directly into the std::vector within Parcel's ReadBlock function

Previously this would unnecessarily zero-initialize the vector before
copying the actual data into the vector instance.

src/common/logging/backend.cpp

@@ -43,6 +43,7 @@ namespace Log {
     SUB(HW, LCD)                                                                                   \
     SUB(HW, GPU)                                                                                   \
     SUB(HW, AES)                                                                                   \
+    CLS(IPC)                                                                                       \
     CLS(Frontend)                                                                                  \
     CLS(Render)                                                                                    \
     SUB(Render, Software)                                                                          \
@@ -91,8 +92,8 @@ const char* GetLevelName(Level log_level) {
 
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                   const char* function, const char* format, va_list args) {
-    using std::chrono::steady_clock;
     using std::chrono::duration_cast;
+    using std::chrono::steady_clock;
 
     static steady_clock::time_point time_origin = steady_clock::now();
 

src/common/logging/log.h

@@ -60,6 +60,7 @@ enum class Class : ClassType {
     HW_LCD,            ///< LCD register emulation
     HW_GPU,            ///< GPU control emulation
     HW_AES,            ///< AES engine emulation
+    IPC,               ///< IPC interface
     Frontend,          ///< Emulator UI
     Render,            ///< Emulator video output and hardware acceleration
     Render_Software,   ///< Software renderer backend

src/core/CMakeLists.txt

@@ -58,7 +58,6 @@ set(SRCS
             hle/service/sm/controller.cpp
             hle/service/sm/sm.cpp
             hle/service/time/time.cpp
-            hle/service/time/time_s.cpp
             hle/service/vi/vi.cpp
             hle/service/vi/vi_m.cpp
             hle/shared_page.cpp
@@ -90,6 +89,7 @@ set(HEADERS
             file_sys/ivfc_archive.h
             file_sys/path_parser.h
             file_sys/savedata_archive.h
+            file_sys/title_metadata.h
             frontend/emu_window.h
             frontend/framebuffer_layout.h
             frontend/input.h
@@ -148,7 +148,6 @@ set(HEADERS
             hle/service/sm/controller.h
             hle/service/sm/sm.h
             hle/service/time/time.h
-            hle/service/time/time_s.h
             hle/service/vi/vi.h
             hle/service/vi/vi_m.h
             hle/shared_page.h

src/core/file_sys/title_metadata.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <array>
 #include <string>
 #include <vector>
 #include "common/common_types.h"

src/core/gdbstub/gdbstub.cpp

@@ -905,7 +905,7 @@ void ToggleServer(bool status) {
         server_enabled = status;
 
         // Start server
-        if (!IsConnected() && Core::System().GetInstance().IsPoweredOn()) {
+        if (!IsConnected() && Core::System::GetInstance().IsPoweredOn()) {
             Init();
         }
     } else {

src/core/hle/ipc.h

@@ -143,6 +143,11 @@ struct DataPayloadHeader {
 static_assert(sizeof(DataPayloadHeader) == 8, "DataPayloadRequest size is incorrect");
 
 struct DomainMessageHeader {
+    enum class CommandType : u32_le {
+        SendMessage = 1,
+        CloseVirtualHandle = 2,
+    };
+
     union {
         // Used when responding to an IPC request, Server -> Client.
         struct {
@@ -153,7 +158,7 @@ struct DomainMessageHeader {
         // Used when performing an IPC request, Client -> Server.
         struct {
             union {
-                BitField<0, 8, u32_le> command;
+                BitField<0, 8, CommandType> command;
                 BitField<16, 16, u32_le> size;
             };
             u32_le object_id;

src/core/hle/kernel/domain.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/domain.h"
 #include "core/hle/kernel/handle_table.h"
@@ -36,7 +38,24 @@ ResultCode Domain::SendSyncRequest(SharedPtr<Thread> thread) {
     if (domain_message_header) {
         // If there is a DomainMessageHeader, then this is CommandType "Request"
         const u32 object_id{context.GetDomainMessageHeader()->object_id};
-        return request_handlers[object_id - 1]->HandleSyncRequest(context);
+        switch (domain_message_header->command) {
+        case IPC::DomainMessageHeader::CommandType::SendMessage:
+            return request_handlers[object_id - 1]->HandleSyncRequest(context);
+
+        case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
+            LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x%08X", object_id);
+
+            request_handlers[object_id - 1] = nullptr;
+
+            IPC::RequestBuilder rb{context, 2};
+            rb.Push(RESULT_SUCCESS);
+
+            return RESULT_SUCCESS;
+        }
+        }
+
+        LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
+        UNIMPLEMENTED();
     }
     return request_handlers.front()->HandleSyncRequest(context);
 }

src/core/hle/kernel/hle_ipc.cpp

@@ -102,13 +102,21 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     data_payload_header =
         std::make_unique<IPC::DataPayloadHeader>(rp.PopRaw<IPC::DataPayloadHeader>());
 
+    data_payload_offset = rp.GetCurrentOffset();
+
+    if (domain_message_header &&
+        domain_message_header->command ==
+            IPC::DomainMessageHeader::CommandType::CloseVirtualHandle) {
+        // CloseVirtualHandle command does not have SFC* or any data
+        return;
+    }
+
     if (incoming) {
         ASSERT(data_payload_header->magic == Common::MakeMagic('S', 'F', 'C', 'I'));
     } else {
         ASSERT(data_payload_header->magic == Common::MakeMagic('S', 'F', 'C', 'O'));
     }
 
-    data_payload_offset = rp.GetCurrentOffset();
     command = rp.Pop<u32_le>();
     rp.Skip(1, false); // The command is actually an u64, but we don't use the high part.
 }

src/core/hle/kernel/svc.cpp

@@ -255,9 +255,8 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
 /// Attempts to locks a mutex, creating it if it does not already exist
 static ResultCode LockMutex(Handle holding_thread_handle, VAddr mutex_addr,
                             Handle requesting_thread_handle) {
-    LOG_TRACE(Kernel_SVC,
-              "called holding_thread_handle=0x%08X, mutex_addr=0x%llx, "
-              "requesting_current_thread_handle=0x%08X",
+    LOG_TRACE(Kernel_SVC, "called holding_thread_handle=0x%08X, mutex_addr=0x%llx, "
+                          "requesting_current_thread_handle=0x%08X",
               holding_thread_handle, mutex_addr, requesting_thread_handle);
 
     SharedPtr<Thread> holding_thread = g_handle_table.Get<Thread>(holding_thread_handle);
@@ -547,9 +546,8 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
 
     Core::System::GetInstance().PrepareReschedule();
 
-    LOG_TRACE(Kernel_SVC,
-              "called entrypoint=0x%08X (%s), arg=0x%08X, stacktop=0x%08X, "
-              "threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X",
+    LOG_TRACE(Kernel_SVC, "called entrypoint=0x%08X (%s), arg=0x%08X, stacktop=0x%08X, "
+                          "threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X",
               entry_point, name.c_str(), arg, stack_top, priority, processor_id, *out_handle);
 
     return RESULT_SUCCESS;

src/core/hle/service/hid/hid.cpp

@@ -18,9 +18,9 @@ namespace HID {
 
 // Updating period for each HID device.
 // TODO(shinyquagsire23): These need better values.
-constexpr u64 pad_update_ticks = BASE_CLOCK_RATE / 234;
-constexpr u64 accelerometer_update_ticks = BASE_CLOCK_RATE / 104;
-constexpr u64 gyroscope_update_ticks = BASE_CLOCK_RATE / 101;
+constexpr u64 pad_update_ticks = BASE_CLOCK_RATE / 10000;
+constexpr u64 accelerometer_update_ticks = BASE_CLOCK_RATE / 10000;
+constexpr u64 gyroscope_update_ticks = BASE_CLOCK_RATE / 10000;
 
 class IAppletResource final : public ServiceFramework<IAppletResource> {
 public:

src/core/hle/service/nvdrv/interface.cpp

@@ -48,6 +48,18 @@ void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
     rb.Push(nv_result);
 }
 
+void NVDRV::Close(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service, "(STUBBED) called");
+
+    IPC::RequestParser rp{ctx};
+    u32 fd = rp.Pop<u32>();
+
+    auto result = nvdrv->Close(fd);
+
+    IPC::RequestBuilder rb{ctx, 2};
+    rb.Push(result);
+}
+
 void NVDRV::Initialize(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
     IPC::RequestBuilder rb{ctx, 3};
@@ -60,6 +72,7 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
     static const FunctionInfo functions[] = {
         {0, &NVDRV::Open, "Open"},
         {1, &NVDRV::Ioctl, "Ioctl"},
+        {2, &NVDRV::Close, "Close"},
         {3, &NVDRV::Initialize, "Initialize"},
     };
     RegisterHandlers(functions);

src/core/hle/service/nvdrv/interface.h

@@ -20,6 +20,7 @@ public:
 private:
     void Open(Kernel::HLERequestContext& ctx);
     void Ioctl(Kernel::HLERequestContext& ctx);
+    void Close(Kernel::HLERequestContext& ctx);
     void Initialize(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<Module> nvdrv;

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -49,5 +49,15 @@ u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector
     return device->ioctl(command, input, output);
 }
 
+ResultCode Module::Close(u32 fd) {
+    auto itr = open_files.find(fd);
+    ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");
+
+    open_files.erase(itr);
+
+    // TODO(flerovium): return correct result code if operation failed.
+    return RESULT_SUCCESS;
+}
+
 } // namespace Nvidia
 } // namespace Service

src/core/hle/service/nvdrv/nvdrv.h

@@ -35,6 +35,8 @@ public:
     u32 Open(std::string device_name);
     /// Sends an ioctl command to the specified file descriptor.
     u32 Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output);
+    /// Closes a device file descriptor and returns operation success.
+    ResultCode Close(u32 fd);
 
 private:
     /// Id to use for the next open file descriptor.

src/core/hle/service/time/time.cpp

@@ -2,14 +2,140 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <chrono>
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/client_port.h"
+#include "core/hle/kernel/client_session.h"
 #include "core/hle/service/time/time.h"
-#include "core/hle/service/time/time_s.h"
 
 namespace Service {
 namespace Time {
 
+class ISystemClock final : public ServiceFramework<ISystemClock> {
+public:
+    ISystemClock() : ServiceFramework("ISystemClock") {
+        static const FunctionInfo functions[] = {
+            {0, &ISystemClock::GetCurrentTime, "GetCurrentTime"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetCurrentTime(Kernel::HLERequestContext& ctx) {
+        const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::milliseconds>(
+                                       std::chrono::system_clock::now().time_since_epoch())
+                                       .count()};
+        IPC::RequestBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u64>(time_since_epoch);
+        LOG_DEBUG(Service, "called");
+    }
+};
+
+class ISteadyClock final : public ServiceFramework<ISteadyClock> {
+public:
+    ISteadyClock() : ServiceFramework("ISteadyClock") {}
+};
+
+class ITimeZoneService final : public ServiceFramework<ITimeZoneService> {
+public:
+    ITimeZoneService() : ServiceFramework("ITimeZoneService") {
+        static const FunctionInfo functions[] = {
+            {0, &ITimeZoneService::GetDeviceLocationName, "GetDeviceLocationName"},
+            {101, &ITimeZoneService::ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetDeviceLocationName(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service, "(STUBBED) called");
+        LocationName name{};
+        IPC::RequestBuilder rb{ctx, 11};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw(name);
+    }
+
+    void ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        u64 posixTime = rp.Pop<u64>();
+
+        LOG_WARNING(Service, "(STUBBED) called, posixTime=0x%016llX", posixTime);
+
+        CalendarTime calendarTime{2018, 1, 1, 0, 0, 0};
+        CalendarAdditionalInfo additionalInfo{};
+        IPC::RequestBuilder rb{ctx, 10};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw(calendarTime);
+        rb.PushRaw(additionalInfo);
+    }
+};
+
+void TIME::GetStandardUserSystemClock(Kernel::HLERequestContext& ctx) {
+    auto client_port = std::make_shared<ISystemClock>()->CreatePort();
+    auto session = client_port->Connect();
+    if (session.Succeeded()) {
+        LOG_DEBUG(Service, "called, initialized ISystemClock -> session=%u",
+                  (*session)->GetObjectId());
+        IPC::RequestBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushMoveObjects(std::move(session).Unwrap());
+    } else {
+        UNIMPLEMENTED();
+    }
+}
+
+void TIME::GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx) {
+    auto client_port = std::make_shared<ISystemClock>()->CreatePort();
+    auto session = client_port->Connect();
+    if (session.Succeeded()) {
+        LOG_DEBUG(Service, "called, initialized ISystemClock -> session=%u",
+                  (*session)->GetObjectId());
+        IPC::RequestBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushMoveObjects(std::move(session).Unwrap());
+    } else {
+        UNIMPLEMENTED();
+    }
+}
+
+void TIME::GetStandardSteadyClock(Kernel::HLERequestContext& ctx) {
+    auto client_port = std::make_shared<ISteadyClock>()->CreatePort();
+    auto session = client_port->Connect();
+    if (session.Succeeded()) {
+        LOG_DEBUG(Service, "called, initialized ISteadyClock -> session=%u",
+                  (*session)->GetObjectId());
+        IPC::RequestBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushMoveObjects(std::move(session).Unwrap());
+    } else {
+        UNIMPLEMENTED();
+    }
+}
+
+void TIME::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<ITimeZoneService>();
+    LOG_DEBUG(Service, "called");
+}
+
+TIME::TIME(const char* name) : ServiceFramework(name) {
+    static const FunctionInfo functions[] = {
+        {0x00000000, &TIME::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
+        {0x00000001, &TIME::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
+        {0x00000002, &TIME::GetStandardSteadyClock, "GetStandardSteadyClock"},
+        {0x00000003, &TIME::GetTimeZoneService, "GetTimeZoneService"},
+    };
+    RegisterHandlers(functions);
+}
+
 void InstallInterfaces(SM::ServiceManager& service_manager) {
-    std::make_shared<TimeS>()->InstallAsService(service_manager);
+    std::make_shared<TIME>("time:a")->InstallAsService(service_manager);
+    std::make_shared<TIME>("time:r")->InstallAsService(service_manager);
+    std::make_shared<TIME>("time:s")->InstallAsService(service_manager);
+    std::make_shared<TIME>("time:u")->InstallAsService(service_manager);
 }
 
 } // namespace Time

src/core/hle/service/time/time.h

@@ -9,6 +9,42 @@
 namespace Service {
 namespace Time {
 
+// TODO(Rozelette) RE this structure
+struct LocationName {
+    INSERT_PADDING_BYTES(0x24);
+};
+static_assert(sizeof(LocationName) == 0x24, "LocationName structure has incorrect size");
+
+struct CalendarTime {
+    u16_le year;
+    u8 month; // Starts at 1
+    u8 day;   // Starts at 1
+    u8 hour;
+    u8 minute;
+    u8 second;
+    INSERT_PADDING_BYTES(1);
+};
+static_assert(sizeof(CalendarTime) == 0x8, "CalendarTime structure has incorrect size");
+
+// TODO(Rozelette) RE this structure
+struct CalendarAdditionalInfo {
+    INSERT_PADDING_BYTES(0x18);
+};
+static_assert(sizeof(CalendarAdditionalInfo) == 0x18,
+              "CalendarAdditionalInfo structure has incorrect size");
+
+class TIME final : public ServiceFramework<TIME> {
+public:
+    explicit TIME(const char* name);
+    ~TIME() = default;
+
+private:
+    void GetStandardUserSystemClock(Kernel::HLERequestContext& ctx);
+    void GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx);
+    void GetStandardSteadyClock(Kernel::HLERequestContext& ctx);
+    void GetTimeZoneService(Kernel::HLERequestContext& ctx);
+};
+
 /// Registers all Time services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 

src/core/hle/service/time/time_s.cpp

@@ -1,58 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <chrono>
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/client_port.h"
-#include "core/hle/kernel/client_session.h"
-#include "core/hle/service/time/time_s.h"
-
-namespace Service {
-namespace Time {
-
-class ISystemClock final : public ServiceFramework<ISystemClock> {
-public:
-    ISystemClock() : ServiceFramework("ISystemClock") {
-        static const FunctionInfo functions[] = {
-            {0, &ISystemClock::GetCurrentTime, "GetCurrentTime"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetCurrentTime(Kernel::HLERequestContext& ctx) {
-        const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::milliseconds>(
-                                       std::chrono::system_clock::now().time_since_epoch())
-                                       .count()};
-        IPC::RequestBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(time_since_epoch);
-        LOG_DEBUG(Service, "called");
-    }
-};
-
-void TimeS::GetStandardUserSystemClock(Kernel::HLERequestContext& ctx) {
-    auto client_port = std::make_shared<ISystemClock>()->CreatePort();
-    auto session = client_port->Connect();
-    if (session.Succeeded()) {
-        LOG_DEBUG(Service, "called, initialized ISystemClock -> session=%u",
-                  (*session)->GetObjectId());
-        IPC::RequestBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushMoveObjects(std::move(session).Unwrap());
-    } else {
-        UNIMPLEMENTED();
-    }
-}
-
-TimeS::TimeS() : ServiceFramework("time:s") {
-    static const FunctionInfo functions[] = {
-        {0x00000000, &TimeS::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Time
-} // namespace Service

src/core/hle/service/time/time_s.h

@@ -1,23 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace Time {
-
-class TimeS final : public ServiceFramework<TimeS> {
-public:
-    TimeS();
-    ~TimeS() = default;
-
-private:
-    void GetStandardUserSystemClock(Kernel::HLERequestContext& ctx);
-};
-
-} // namespace Time
-} // namespace Service

src/core/hle/service/vi/vi.cpp

@@ -47,8 +47,9 @@ public:
     }
 
     std::vector<u8> ReadBlock(size_t length) {
-        std::vector<u8> data(length);
-        std::memcpy(data.data(), buffer.data() + read_index, length);
+        const u8* const begin = buffer.data() + read_index;
+        const u8* const end = begin + length;
+        std::vector<u8> data(begin, end);
         read_index += length;
         read_index = Common::AlignUp(read_index, 4);
         return data;

src/core/loader/nro.cpp

@@ -118,13 +118,6 @@ bool AppLoader_NRO::LoadNro(const std::string& path, VAddr load_base) {
     }
     program_image.resize(PageAlignSize(static_cast<u32>(program_image.size()) + bss_size));
 
-    // Relocate symbols if there was a proper MOD header - This must happen after the image has been
-    // loaded into memory
-    if (has_mod_header) {
-        Relocate(program_image, nro_header.module_header_offset + mod_header.dynamic_offset,
-                 load_base);
-    }
-
     // Load codeset for current process
     codeset->name = path;
     codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image));
@@ -154,8 +147,6 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(base_addr, 48, Kernel::DEFAULT_STACK_SIZE);
 
-    ResolveImports();
-
     is_loaded = true;
     return ResultStatus::Success;
 }

src/core/loader/nso.cpp

@@ -88,7 +88,7 @@ static constexpr u32 PageAlignSize(u32 size) {
     return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
 }
 
-VAddr AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base, bool relocate) {
+VAddr AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base) {
     FileUtil::IOFile file(path, "rb");
     if (!file.IsOpen()) {
         return {};
@@ -135,12 +135,6 @@ VAddr AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base, bool relo
     const u32 image_size{PageAlignSize(static_cast<u32>(program_image.size()) + bss_size)};
     program_image.resize(image_size);
 
-    // Relocate symbols if there was a proper MOD header - This must happen after the image has been
-    // loaded into memory
-    if (has_mod_header && relocate) {
-        Relocate(program_image, module_offset + mod_header.dynamic_offset, load_base);
-    }
-
     // Load codeset for current process
     codeset->name = path;
     codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image));
@@ -181,8 +175,6 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(Memory::PROCESS_IMAGE_VADDR, 48, Kernel::DEFAULT_STACK_SIZE);
 
-    ResolveImports();
-
     is_loaded = true;
     return ResultStatus::Success;
 }

src/core/loader/nso.h

@@ -34,7 +34,7 @@ public:
     ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
 
 private:
-    VAddr LoadNso(const std::string& path, VAddr load_base, bool relocate = false);
+    VAddr LoadNso(const std::string& path, VAddr load_base);
 
     std::string filepath;
 };

src/yuzu/CMakeLists.txt

@@ -66,11 +66,7 @@ file(GLOB_RECURSE THEMES ${CMAKE_SOURCE_DIR}/dist/qt_themes/*)
 
 create_directory_groups(${SRCS} ${HEADERS} ${UIS})
 
-if (Qt5_FOUND)
-    qt5_wrap_ui(UI_HDRS ${UIS})
-else()
-    qt4_wrap_ui(UI_HDRS ${UIS})
-endif()
+qt5_wrap_ui(UI_HDRS ${UIS})
 
 if (APPLE)
     set(MACOSX_ICON "../../dist/yuzu.icns")

src/yuzu/bootmanager.cpp

@@ -1,12 +1,8 @@
 #include <QApplication>
 #include <QHBoxLayout>
 #include <QKeyEvent>
-
-#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
-// Required for screen DPI information
 #include <QScreen>
 #include <QWindow>
-#endif
 
 #include "common/microprofile.h"
 #include "common/scm_rev.h"
@@ -120,15 +116,13 @@ GRenderWindow::~GRenderWindow() {
 
 void GRenderWindow::moveContext() {
     DoneCurrent();
-// We need to move GL context to the swapping thread in Qt5
-#if QT_VERSION > QT_VERSION_CHECK(5, 0, 0)
+
     // If the thread started running, move the GL Context to the new thread. Otherwise, move it
     // back.
     auto thread = (QThread::currentThread() == qApp->thread() && emu_thread != nullptr)
                       ? emu_thread
                       : qApp->thread();
     child->context()->moveToThread(thread);
-#endif
 }
 
 void GRenderWindow::SwapBuffers() {
@@ -191,12 +185,8 @@ QByteArray GRenderWindow::saveGeometry() {
 }
 
 qreal GRenderWindow::windowPixelRatio() {
-#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
     // windowHandle() might not be accessible until the window is displayed to screen.
     return windowHandle() ? windowHandle()->screen()->devicePixelRatio() : 1.0f;
-#else
-    return 1.0f;
-#endif
 }
 
 void GRenderWindow::closeEvent(QCloseEvent* event) {
@@ -299,9 +289,7 @@ void GRenderWindow::OnEmulationStopping() {
 void GRenderWindow::showEvent(QShowEvent* event) {
     QWidget::showEvent(event);
 
-#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
     // windowHandle() is not initialized until the Window is shown, so we connect it here.
     connect(this->windowHandle(), SIGNAL(screenChanged(QScreen*)), this,
             SLOT(OnFramebufferSizeChanged()), Qt::UniqueConnection);
-#endif
 }

src/yuzu/configuration/configure.ui

@@ -7,8 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>740</width>
-    <width>461</width>
-	<height>500</height>
+    <height>500</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -18,8 +17,7 @@
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
-      <number>4</number>
-	  <number>0</number>
+      <number>0</number>
      </property>
      <widget class="ConfigureGeneral" name="generalTab">
       <attribute name="title">

src/yuzu/configuration/configure_system.cpp

@@ -72,5 +72,6 @@ void ConfigureSystem::refreshConsoleID() {
     if (reply == QMessageBox::No)
         return;
     u64 console_id{};
-    ui->label_console_id->setText("Console ID: 0x" + QString::number(console_id, 16).toUpper());
+    ui->label_console_id->setText(
+        tr("Console ID: 0x%1").arg(QString::number(console_id, 16).toUpper()));
 }

src/yuzu_cmd/default_ini.h

@@ -124,8 +124,8 @@ custom_bottom_top =
 custom_bottom_right =
 custom_bottom_bottom =
 
-#Whether to toggle frame limiter on or off.
-# 0: Off , 1  (default): On
+# Whether to toggle frame limiter on or off.
+# 0: Off, 1 (default): On
 toggle_framelimit =
 
 # Swaps the prominent screen with the other screen.