HLE coverage: implement the logging stubs the maintainer's games hit

CMakeLists.txt

@@ -253,6 +253,46 @@ if(PSPRECOMP_BUILD_TESTS)
     add_test(NAME portablekit_pool_tests COMMAND portablekit_pool_tests)
 endif()
 
+# Message pipes (sceKernel*MsgPipe): their bookkeeping, with no kernel.
+if(PSPRECOMP_BUILD_TESTS)
+    add_executable(portablekit_pipe_tests
+        "${PORTABLEKIT_ROOT}/tests/pipe_tests.cpp"
+        "${PORTABLEKIT_ROOT}/host/kernel/message_pipe.cpp")
+    target_include_directories(portablekit_pipe_tests PRIVATE "${PORTABLEKIT_ROOT}/host")
+    set_target_properties(portablekit_pipe_tests PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+    add_test(NAME portablekit_pipe_tests COMMAND portablekit_pipe_tests)
+endif()
+
+# The PSMF header as scePsmf reads it.
+if(PSPRECOMP_BUILD_TESTS)
+    add_executable(portablekit_psmf_tests
+        "${PORTABLEKIT_ROOT}/tests/psmf_tests.cpp"
+        "${PORTABLEKIT_ROOT}/host/movie/psmf_header.cpp")
+    target_include_directories(portablekit_psmf_tests PRIVATE "${PORTABLEKIT_ROOT}/host")
+    set_target_properties(portablekit_psmf_tests PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+    add_test(NAME portablekit_psmf_tests COMMAND portablekit_psmf_tests)
+endif()
+
+# The desktop app's response files for long compile and link command lines.
+if(PSPRECOMP_BUILD_TESTS)
+    add_executable(portablekit_response_file_tests
+        "${PORTABLEKIT_ROOT}/tests/response_file_tests.cpp"
+        "${PORTABLEKIT_ROOT}/apps/portablekit/src/response_file.cpp")
+    target_include_directories(portablekit_response_file_tests PRIVATE "${PORTABLEKIT_ROOT}/apps/portablekit/src")
+    set_target_properties(portablekit_response_file_tests PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+    add_test(NAME portablekit_response_file_tests COMMAND portablekit_response_file_tests)
+endif()
+
+# sceRtc's calendar arithmetic.
+if(PSPRECOMP_BUILD_TESTS)
+    add_executable(portablekit_rtc_tests
+        "${PORTABLEKIT_ROOT}/tests/rtc_tests.cpp"
+        "${PORTABLEKIT_ROOT}/host/kernel/rtc_time.cpp")
+    target_include_directories(portablekit_rtc_tests PRIVATE "${PORTABLEKIT_ROOT}/host")
+    set_target_properties(portablekit_rtc_tests PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+    add_test(NAME portablekit_rtc_tests COMMAND portablekit_rtc_tests)
+endif()
+
 # Each platform's settings defaults.
 if(PSPRECOMP_BUILD_TESTS)
     add_executable(portablekit_settings_tests

apps/portablekit/CMakeLists.txt

@@ -32,6 +32,7 @@ set(app_sources
     src/keys_file.cpp
     src/launcher_ui.cpp
     src/process.cpp
+    src/response_file.cpp
     src/text_format.cpp)
 
 set(profile_index 0)

apps/portablekit/src/corpus.cpp

@@ -2,6 +2,7 @@
 
 #include "app_home.hpp"
 #include "process.hpp"
+#include "response_file.hpp"
 #include "text_format.hpp"
 
 #include "corpus_abi.hpp"
@@ -25,6 +26,10 @@ namespace portablekit::app {
 namespace {
 
 namespace fs = std::filesystem;
+
+// Past this many characters a command goes through a response file. Windows
+// starts nothing longer than 32767; this leaves room for the program path.
+constexpr std::size_t kLongCommandLine = 8000u;
 using Clock = std::chrono::steady_clock;
 
 // Exit codes (app_main.cpp lists them all).
@@ -475,11 +480,18 @@ int compile_corpus(const GameRecord &game, const CompileOptions &options) {
             if (!current) {
                 // Written under another name and renamed when complete, so a
                 // compile stopped halfway never leaves an object that looks
-                // finished.
+                // finished. Compile lines are short; one that is not goes
+                // through a response file, as the link does.
                 fs::path partial_object = object;
                 partial_object += ".part";
-                const ProcessResult result = run_process(
-                    compile_arguments(command, options.opt_level, source, partial_object, paths.generated), paths.log);
+                std::vector<std::string> arguments =
+                    compile_arguments(command, options.opt_level, source, partial_object, paths.generated);
+                if (command_line_length(arguments) > kLongCommandLine) {
+                    fs::path rsp = object;
+                    rsp += ".rsp";
+                    arguments = with_response_file(arguments, command.prefix.size(), rsp);
+                }
+                const ProcessResult result = run_process(arguments, paths.log);
                 if (!result.started || result.exit_code != 0) {
                     const std::lock_guard<std::mutex> guard(status_lock);
                     if (!failed) failure = result.started ? "Compiling " + source.filename().string() + " failed; see " + path_text(paths.log) + "." : result.error;
@@ -509,7 +521,11 @@ int compile_corpus(const GameRecord &game, const CompileOptions &options) {
     const auto link_start = Clock::now();
     fs::path partial = paths.library;
     partial += ".part";
-    const ProcessResult linked = run_process(link_arguments(command, partial, objects), paths.log);
+    // Every object by full path is too long a command line for Windows once
+    // a game has a few hundred units (32767 characters): through a file.
+    const ProcessResult linked = run_process(
+        with_response_file(link_arguments(command, partial, objects), command.prefix.size(), paths.root / "link.rsp"),
+        paths.log);
     status.link_seconds = seconds_since(link_start);
     if (!linked.started || linked.exit_code != 0)
         return fail(kLinkFailed, linked.started ? "Linking failed; see " + path_text(paths.log) + "." : linked.error);

apps/portablekit/src/response_file.cpp

@@ -0,0 +1,42 @@
+#include "response_file.hpp"
+
+#include <fstream>
+
+namespace portablekit::app {
+
+std::string response_file_text(const std::vector<std::string> &arguments) {
+    std::string text;
+    for (const std::string &argument : arguments) {
+        text += '"';
+        for (const char c : argument) {
+            if (c == '\\') text += '/';
+            else if (c == '"') text += "\\\"";
+            else text += c;
+        }
+        text += "\"\n";
+    }
+    return text;
+}
+
+std::vector<std::string> with_response_file(const std::vector<std::string> &command, std::size_t keep,
+                                            const std::filesystem::path &path) {
+    if (command.size() <= keep) return command;
+    const std::vector<std::string> rest(command.begin() + static_cast<std::ptrdiff_t>(keep), command.end());
+    {
+        std::ofstream file(path, std::ios::binary | std::ios::trunc);
+        if (!file) return command;
+        file << response_file_text(rest);
+        if (!file) return command;
+    }
+    std::vector<std::string> result(command.begin(), command.begin() + static_cast<std::ptrdiff_t>(keep));
+    result.push_back("@" + path.string());
+    return result;
+}
+
+std::size_t command_line_length(const std::vector<std::string> &command) {
+    std::size_t length = 0u;
+    for (const std::string &argument : command) length += argument.size() + 3u;  // quotes and a space
+    return length;
+}
+
+} // namespace portablekit::app

apps/portablekit/src/response_file.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+// Long command lines through a response file. Windows refuses to start a
+// process whose command line is longer than 32767 characters, and a large
+// game's link lists hundreds of objects by full path: PSP2i (NPJH50332),
+// 385 units, failed there with error 206. Compilers and linkers of every
+// toolchain the app drives (clang, clang-cl, lld) read "@file" as the
+// arguments in that file.
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+namespace portablekit::app {
+
+// The file's text: one argument a line, each in double quotes, with
+// backslashes written as forward slashes (every argument with a backslash
+// is a Windows path, which accepts either) so that the GNU and the Windows
+// rules for reading response files give the same arguments.
+[[nodiscard]] std::string response_file_text(const std::vector<std::string> &arguments);
+
+// `command` with everything after the first `keep` arguments (the program,
+// usually) moved into a response file at `path`, written here. Returns the
+// command unchanged if the file cannot be written.
+[[nodiscard]] std::vector<std::string> with_response_file(const std::vector<std::string> &command, std::size_t keep,
+                                                          const std::filesystem::path &path);
+
+// The length of the command line the arguments make, spaces and quotes
+// included, as a program starting them would build it.
+[[nodiscard]] std::size_t command_line_length(const std::vector<std::string> &command);
+
+} // namespace portablekit::app

cmake/PortableKit.cmake

@@ -29,6 +29,7 @@ set(PORTABLEKIT_HOST_SOURCES
     host/audio/atrac_decoder.cpp
     host/movie/avc_decoder.cpp
     host/movie/psmf_demuxer.cpp
+    host/movie/psmf_header.cpp
     host/audio/audio_sink.cpp
     host/audio/sas_core.cpp
     host/camera_probe.cpp
@@ -45,6 +46,8 @@ set(PORTABLEKIT_HOST_SOURCES
     host/system.cpp
     host/kernel/kernel.cpp
     host/kernel/fixed_pool.cpp
+    host/kernel/message_pipe.cpp
+    host/kernel/rtc_time.cpp
     host/kernel/load_trace.cpp
     host/kernel/fast_loading.cpp
     host/kernel/load_detector.cpp
@@ -58,6 +61,8 @@ set(PORTABLEKIT_HOST_SOURCES
     host/hle/hle_atrac.cpp
     host/hle/hle_mpeg.cpp
     host/hle/hle_psmfplayer.cpp
+    host/hle/hle_psmf.cpp
+    host/hle/hle_net_offline.cpp
     host/fonts/game_font.cpp
     host/hle/hle_font.cpp
     host/hle/hle_utility.cpp