Merge c3dc5bed72 into 0568346cc3

src/core/CMakeLists.txt

@@ -58,6 +58,7 @@ 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
@@ -147,6 +148,7 @@ 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/hle/service/time/time.cpp

@@ -2,140 +2,14 @@
 // 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<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);
+    std::make_shared<TimeS>()->InstallAsService(service_manager);
 }
 
 } // namespace Time

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

@@ -9,42 +9,6 @@
 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

@@ -0,0 +1,58 @@
+// 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

@@ -0,0 +1,23 @@
+// 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/loader/nro.cpp

@@ -62,6 +62,20 @@ static constexpr u32 PageAlignSize(u32 size) {
     return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
 }
 
+static std::vector<u8> ReadSegment(FileUtil::IOFile& file, const NroSegmentHeader& header) {
+    std::vector<u8> data;
+    data.resize(header.size);
+
+    file.Seek(header.offset + sizeof(NroHeader), SEEK_SET);
+    size_t bytes_read{file.ReadBytes(data.data(), header.size)};
+    if (header.size != PageAlignSize(static_cast<u32>(bytes_read))) {
+        LOG_CRITICAL(Loader, "Failed to read NRO segment bytes", header.size);
+        return {};
+    }
+
+    return data;
+}
+
 bool AppLoader_NRO::LoadNro(const std::string& path, VAddr load_base) {
     FileUtil::IOFile file(path, "rb");
     if (!file.IsOpen()) {
@@ -81,7 +95,7 @@ bool AppLoader_NRO::LoadNro(const std::string& path, VAddr load_base) {
     // Build program image
     Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("", 0);
     std::vector<u8> program_image;
-    program_image.resize(PageAlignSize(nro_header.file_size));
+    program_image.resize(PageAlignSize(nro_header.file_size + nro_header.bss_size));
     file.Seek(0, SEEK_SET);
     file.ReadBytes(program_image.data(), nro_header.file_size);
 
@@ -93,18 +107,24 @@ bool AppLoader_NRO::LoadNro(const std::string& path, VAddr load_base) {
 
     // Read MOD header
     ModHeader mod_header{};
-    // Default .bss to NRO header bss size if MOD0 section doesn't exist
-    u32 bss_size{PageAlignSize(nro_header.bss_size)};
+    u32 bss_size{Memory::PAGE_SIZE}; // Default .bss to page size if MOD0 section doesn't exist
     std::memcpy(&mod_header, program_image.data() + nro_header.module_header_offset,
                 sizeof(ModHeader));
     const bool has_mod_header{mod_header.magic == Common::MakeMagic('M', 'O', 'D', '0')};
     if (has_mod_header) {
         // Resize program image to include .bss section and page align each section
         bss_size = PageAlignSize(mod_header.bss_end_offset - mod_header.bss_start_offset);
+        codeset->data.size += bss_size;
     }
-    codeset->data.size += bss_size;
     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));
@@ -121,11 +141,9 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
         return ResultStatus::Error;
     }
 
-    process = Kernel::Process::Create("main");
-
-    // Load NRO
+    // Load and relocate "main" and "sdk" NSO
     static constexpr VAddr base_addr{Memory::PROCESS_IMAGE_VADDR};
-
+    process = Kernel::Process::Create("main");
     if (!LoadNro(filepath, base_addr)) {
         return ResultStatus::ErrorInvalidFormat;
     }
@@ -134,7 +152,9 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process->address_mappings = default_address_mappings;
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
-    process->Run(base_addr + sizeof(NroHeader), 48, Kernel::DEFAULT_STACK_SIZE);
+    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) {
+VAddr AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base, bool relocate) {
     FileUtil::IOFile file(path, "rb");
     if (!file.IsOpen()) {
         return {};
@@ -135,6 +135,12 @@ VAddr AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base) {
     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));
@@ -175,6 +181,8 @@ 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);
+    VAddr LoadNso(const std::string& path, VAddr load_base, bool relocate = false);
 
     std::string filepath;
 };

src/yuzu/CMakeLists.txt

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

src/yuzu/bootmanager.cpp

@@ -1,8 +1,12 @@
 #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"
@@ -116,13 +120,15 @@ 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() {
@@ -185,8 +191,12 @@ 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) {
@@ -289,7 +299,9 @@ 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,7 +7,8 @@
     <x>0</x>
     <y>0</y>
     <width>740</width>
-    <height>500</height>
+    <width>461</width>
+	<height>500</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -17,7 +18,8 @@
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
-      <number>0</number>
+      <number>4</number>
+	  <number>0</number>
      </property>
      <widget class="ConfigureGeneral" name="generalTab">
       <attribute name="title">

src/yuzu/configuration/configure_system.cpp

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