mirror of
https://github.com/patchzyy/wiicompiled
synced 2026-09-10 17:16:47 -04:00
patchzyy
687 lines
44 KiB
C#
687 lines
44 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Text;
|
|
using Translator.Core.Loading;
|
|
using Xunit;
|
|
|
|
namespace Translator.Tests;
|
|
|
|
public class PpcRuntimeHelperTests
|
|
{
|
|
private static (int ExitCode, string Output) RunProcess(string fileName, string arguments, TimeSpan? timeout = null)
|
|
{
|
|
using var process = new Process
|
|
{
|
|
StartInfo = new ProcessStartInfo
|
|
{
|
|
FileName = fileName,
|
|
Arguments = arguments,
|
|
RedirectStandardError = true,
|
|
RedirectStandardOutput = true,
|
|
UseShellExecute = false
|
|
}
|
|
};
|
|
|
|
process.Start();
|
|
var stdoutTask = process.StandardOutput.ReadToEndAsync();
|
|
var stderrTask = process.StandardError.ReadToEndAsync();
|
|
var exitedInTime = timeout.HasValue
|
|
? process.WaitForExit((int)timeout.Value.TotalMilliseconds)
|
|
: process.WaitForExit(60000);
|
|
|
|
if (!exitedInTime)
|
|
{
|
|
try
|
|
{
|
|
process.Kill(entireProcessTree: true);
|
|
}
|
|
catch
|
|
{
|
|
// ignored
|
|
}
|
|
|
|
process.WaitForExit();
|
|
var staleOutput = stdoutTask.GetAwaiter().GetResult() + stderrTask.GetAwaiter().GetResult();
|
|
throw new TimeoutException($"Process '{fileName}' timed out. Output before kill:\n{staleOutput}");
|
|
}
|
|
|
|
var output = stdoutTask.GetAwaiter().GetResult() + stderrTask.GetAwaiter().GetResult();
|
|
return (process.ExitCode, output);
|
|
}
|
|
|
|
private static string CppCompiler()
|
|
{
|
|
var envCompiler = Environment.GetEnvironmentVariable("CXX");
|
|
if (!string.IsNullOrWhiteSpace(envCompiler) && ExecutableExists(envCompiler))
|
|
{
|
|
return envCompiler;
|
|
}
|
|
|
|
foreach (var candidate in new[] { "g++", "clang++" })
|
|
{
|
|
if (ExecutableExists(candidate))
|
|
{
|
|
return candidate;
|
|
}
|
|
}
|
|
|
|
throw new FileNotFoundException("No C++ compiler found. Set CXX or install g++/clang++ on PATH.");
|
|
}
|
|
|
|
private static bool ExecutableExists(string fileName)
|
|
{
|
|
if (Path.IsPathFullyQualified(fileName))
|
|
{
|
|
return File.Exists(fileName);
|
|
}
|
|
|
|
var path = Environment.GetEnvironmentVariable("PATH") ?? string.Empty;
|
|
var extensions = OperatingSystem.IsWindows()
|
|
? (Environment.GetEnvironmentVariable("PATHEXT") ?? ".EXE;.BAT;.CMD").Split(';', StringSplitOptions.RemoveEmptyEntries)
|
|
: new[] { string.Empty };
|
|
|
|
foreach (var directory in path.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
foreach (var extension in extensions)
|
|
{
|
|
var candidate = Path.Combine(directory, fileName);
|
|
if (!candidate.EndsWith(extension, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
candidate += extension;
|
|
}
|
|
|
|
if (File.Exists(candidate))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static string RunnerPath(string runnerBasePath)
|
|
{
|
|
if (OperatingSystem.IsWindows())
|
|
{
|
|
var exePath = runnerBasePath + ".exe";
|
|
if (File.Exists(exePath))
|
|
{
|
|
return exePath;
|
|
}
|
|
}
|
|
|
|
return runnerBasePath;
|
|
}
|
|
|
|
[Fact]
|
|
public void FselAndPsSelMatchDolphinForNaNAndSignedZeroControls()
|
|
{
|
|
var root = ProjectPaths.FindRepositoryRoot();
|
|
var tempRoot = Path.Combine(root, "test_output", "ppc_runtime_helpers");
|
|
Directory.CreateDirectory(tempRoot);
|
|
|
|
var harness = new StringBuilder();
|
|
harness.AppendLine("#include <cmath>");
|
|
harness.AppendLine("#include <cstdint>");
|
|
harness.AppendLine("#include <cstring>");
|
|
harness.AppendLine("#include <iostream>");
|
|
harness.AppendLine("#include <limits>");
|
|
harness.AppendLine("#include \"ppc_runtime.h\"");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write8(uint8_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write16(uint16_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write32(uint32_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_WriteFloat(float) {}");
|
|
harness.AppendLine("extern \"C\" void DumpRecentPcTrace(size_t) {}");
|
|
harness.AppendLine("int main() {");
|
|
harness.AppendLine(" const double nan = std::numeric_limits<double>::quiet_NaN();");
|
|
harness.AppendLine(" if (PPC_Fsel(nan, 11.0, 22.0) != 11.0) return 1;");
|
|
harness.AppendLine(" if (PPC_Fsel(-1.0, 11.0, 22.0) != 11.0) return 2;");
|
|
harness.AppendLine(" if (PPC_Fsel(-0.0, 11.0, 22.0) != 22.0) return 3;");
|
|
harness.AppendLine(" if (PPC_Fsel(0.0, 11.0, 22.0) != 22.0) return 4;");
|
|
harness.AppendLine(" PPC_FPR lhs{}; lhs.paired.ps0 = 10.0f; lhs.paired.ps1 = 20.0f;");
|
|
harness.AppendLine(" PPC_FPR rhs{}; rhs.paired.ps0 = -10.0f; rhs.paired.ps1 = -20.0f;");
|
|
harness.AppendLine(" PPC_FPR control{}; control.paired.ps0 = std::numeric_limits<float>::quiet_NaN(); control.paired.ps1 = -0.0f;");
|
|
harness.AppendLine(" PPC_FPR out{}; out.d = PPC_PsSel(lhs.d, control.d, rhs.d);");
|
|
harness.AppendLine(" if (out.paired.ps0 != rhs.paired.ps0) return 5;");
|
|
harness.AppendLine(" if (out.paired.ps1 != lhs.paired.ps1) return 6;");
|
|
harness.AppendLine(" control.paired.ps0 = 1.0f; control.paired.ps1 = -1.0f;");
|
|
harness.AppendLine(" out.d = PPC_PsSel(lhs.d, control.d, rhs.d);");
|
|
harness.AppendLine(" if (out.paired.ps0 != lhs.paired.ps0) return 7;");
|
|
harness.AppendLine(" if (out.paired.ps1 != rhs.paired.ps1) return 8;");
|
|
harness.AppendLine(" std::cout << \"ok\";");
|
|
harness.AppendLine(" return 0;");
|
|
harness.AppendLine("}");
|
|
|
|
var harnessPath = Path.Combine(tempRoot, "harness_ppc_runtime_helpers.cpp");
|
|
File.WriteAllText(harnessPath, harness.ToString());
|
|
|
|
var runnerBasePath = Path.Combine(tempRoot, "runner_ppc_runtime_helpers");
|
|
var args = TranslatorCppTestHarness.BuildCompileArguments(
|
|
root,
|
|
tempRoot,
|
|
Array.Empty<string>(),
|
|
harnessPath,
|
|
runnerBasePath,
|
|
includeDataSections: false);
|
|
|
|
var compiler = CppCompiler();
|
|
var (compileExitCode, compileOutput) = RunProcess(compiler, args, TimeSpan.FromSeconds(60));
|
|
Assert.True(compileExitCode == 0, $"{compiler} failed: {compileOutput}");
|
|
|
|
var runnerPath = RunnerPath(runnerBasePath);
|
|
var (runExitCode, runOutput) = RunProcess(runnerPath, "", TimeSpan.FromSeconds(10));
|
|
Assert.True(runExitCode == 0, $"Runner failed ({runExitCode}). Output:\n{runOutput}");
|
|
Assert.Equal("ok", runOutput.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void InlinePsqFloatFastPathPreservesGuestLaneOrder()
|
|
{
|
|
var root = ProjectPaths.FindRepositoryRoot();
|
|
var tempRoot = Path.Combine(root, "test_output", "ppc_runtime_psq_lane_order");
|
|
Directory.CreateDirectory(tempRoot);
|
|
|
|
var harness = new StringBuilder();
|
|
harness.AppendLine("#include <cstdint>");
|
|
harness.AppendLine("#include <cstring>");
|
|
harness.AppendLine("#include <iostream>");
|
|
harness.AppendLine("#include \"memory.h\"");
|
|
harness.AppendLine("#include \"ppc_runtime.h\"");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write8(uint8_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write16(uint16_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write32(uint32_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_WriteFloat(float) {}");
|
|
harness.AppendLine("extern \"C\" void DumpRecentPcTrace(size_t) {}");
|
|
harness.AppendLine("static uint32_t Bits(float value) { uint32_t raw = 0; std::memcpy(&raw, &value, sizeof(raw)); return raw; }");
|
|
harness.AppendLine("static uint64_t DBits(double value) { uint64_t raw = 0; std::memcpy(&raw, &value, sizeof(raw)); return raw; }");
|
|
harness.AppendLine("template <uint32_t GQR> static int CheckKnown(CpuContext& ctx, uint8_t* range, uint32_t base, double source, uint32_t slot) {");
|
|
harness.AppendLine(" ctx.gqr[0] = GQR; const uint32_t addr = base + 256 + slot * 96;");
|
|
harness.AppendLine(" Memory::Write64(addr, 0x81FE1234A5C35A7Eull + slot);");
|
|
harness.AppendLine(" const double pair = PPC_PsqLInline<0u, 0u>(&ctx, addr);");
|
|
harness.AppendLine(" if (DBits(pair) != DBits(PPC_PsqLKnownInline<0u, 0u, GQR>(&ctx, addr))) return 1;");
|
|
harness.AppendLine(" if (DBits(pair) != DBits(PPC_PsqLKnownStackInline<0u, 0u, GQR>(&ctx, addr))) return 2;");
|
|
harness.AppendLine(" if (DBits(pair) != DBits(PPC_PsqLKnownResolvedInline<0u, 0u, GQR>(&ctx, range, addr - base, addr))) return 3;");
|
|
harness.AppendLine(" if (DBits(pair) != DBits(PPC_PsqLKnownResolvedInline<0u, 0u, GQR>(&ctx, nullptr, 0, addr))) return 9;");
|
|
harness.AppendLine(" const double single = PPC_PsqLInline<1u, 0u>(&ctx, addr);");
|
|
harness.AppendLine(" if (DBits(single) != DBits(PPC_PsqLKnownInline<1u, 0u, GQR>(&ctx, addr))) return 4;");
|
|
harness.AppendLine(" if (DBits(single) != DBits(PPC_PsqLKnownStackInline<1u, 0u, GQR>(&ctx, addr))) return 5;");
|
|
harness.AppendLine(" if (DBits(single) != DBits(PPC_PsqLKnownResolvedInline<1u, 0u, GQR>(&ctx, range, addr - base, addr))) return 6;");
|
|
harness.AppendLine(" if (DBits(single) != DBits(PPC_PsqLKnownResolvedInline<1u, 0u, GQR>(&ctx, nullptr, 0, addr))) return 10;");
|
|
harness.AppendLine(" const uint32_t a = addr + 16, b = addr + 32, c = addr + 48, d = addr + 64, e = addr + 80;");
|
|
harness.AppendLine(" Memory::Write64(a, ~0ull); Memory::Write64(b, ~0ull); Memory::Write64(c, ~0ull); Memory::Write64(d, ~0ull); Memory::Write64(e, ~0ull);");
|
|
harness.AppendLine(" PPC_PsqStInline<0u, 0u>(&ctx, a, source);");
|
|
harness.AppendLine(" PPC_PsqStKnownInline<0u, 0u, GQR>(&ctx, b, source);");
|
|
harness.AppendLine(" PPC_PsqStKnownStackInline<0u, 0u, GQR>(&ctx, c, source);");
|
|
harness.AppendLine(" PPC_PsqStKnownResolvedInline<0u, 0u, GQR>(&ctx, range, d - base, d, source);");
|
|
harness.AppendLine(" PPC_PsqStKnownResolvedInline<0u, 0u, GQR>(&ctx, nullptr, 0, e, source);");
|
|
harness.AppendLine(" if (Memory::Read64(a) != Memory::Read64(b) || Memory::Read64(a) != Memory::Read64(c) || Memory::Read64(a) != Memory::Read64(d) || Memory::Read64(a) != Memory::Read64(e)) return 7;");
|
|
harness.AppendLine(" Memory::Write64(a, ~0ull); Memory::Write64(b, ~0ull); Memory::Write64(c, ~0ull); Memory::Write64(d, ~0ull); Memory::Write64(e, ~0ull);");
|
|
harness.AppendLine(" PPC_PsqStInline<1u, 0u>(&ctx, a, source);");
|
|
harness.AppendLine(" PPC_PsqStKnownInline<1u, 0u, GQR>(&ctx, b, source);");
|
|
harness.AppendLine(" PPC_PsqStKnownStackInline<1u, 0u, GQR>(&ctx, c, source);");
|
|
harness.AppendLine(" PPC_PsqStKnownResolvedInline<1u, 0u, GQR>(&ctx, range, d - base, d, source);");
|
|
harness.AppendLine(" PPC_PsqStKnownResolvedInline<1u, 0u, GQR>(&ctx, nullptr, 0, e, source);");
|
|
harness.AppendLine(" if (Memory::Read64(a) != Memory::Read64(b) || Memory::Read64(a) != Memory::Read64(c) || Memory::Read64(a) != Memory::Read64(d) || Memory::Read64(a) != Memory::Read64(e)) return 8;");
|
|
harness.AppendLine(" return 0;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("int main() {");
|
|
harness.AppendLine(" Memory::Init(Memory::Config::WiiDefaults());");
|
|
harness.AppendLine(" CpuContext ctx{};");
|
|
harness.AppendLine(" ctx.gpr[1] = 0x817FF000u;");
|
|
harness.AppendLine(" ctx.gqr[0] = 0;");
|
|
harness.AppendLine(" CpuContextScope scope(&ctx);");
|
|
harness.AppendLine(" const auto RefLoadPair = [](uint64_t v) { return (static_cast<uint64_t>(PpcLoadPsqFloatBitsInline(static_cast<uint32_t>(v >> 32))) << 32) | PpcLoadPsqFloatBitsInline(static_cast<uint32_t>(v)); };");
|
|
harness.AppendLine(" const auto RefStorePair = [](uint64_t v) { return (static_cast<uint64_t>(PpcStorePsqFloatBitsInline(static_cast<uint32_t>(v >> 32))) << 32) | PpcStorePsqFloatBitsInline(static_cast<uint32_t>(v)); };");
|
|
harness.AppendLine(" const uint32_t floatEdges[] = { 0u, 0x80000000u, 1u, 0x007FFFFFu, 0x00800000u, 0x7F7FFFFFu, 0x7F800000u, 0x7F800001u, 0x7FC00000u, 0xFF800001u }; ");
|
|
harness.AppendLine(" for (uint32_t hi : floatEdges) for (uint32_t lo : floatEdges) { const uint64_t v = (static_cast<uint64_t>(hi) << 32) | lo; if (PpcLoadPairPsqFloatBitsPackedInline(v) != RefLoadPair(v)) return 90; if (PpcStorePairPsqFloatBitsPackedInline(v) != RefStorePair(v)) return 91; }");
|
|
harness.AppendLine(" uint32_t pairState = 0x7E57A11Du; for (uint32_t i = 0; i < 1000000u; ++i) { pairState = pairState * 1664525u + 1013904223u; const uint64_t hi = pairState; pairState = pairState * 1664525u + 1013904223u; const uint64_t v = (hi << 32) | pairState; if (PpcLoadPairPsqFloatBitsPackedInline(v) != RefLoadPair(v)) return 92; if (PpcStorePairPsqFloatBitsPackedInline(v) != RefStorePair(v)) return 93; }");
|
|
harness.AppendLine(" constexpr uint32_t base = 0x80010000u;");
|
|
harness.AppendLine(" Memory::Write32(base, Bits(12.5f));");
|
|
harness.AppendLine(" Memory::Write32(base + 4, Bits(-7.25f));");
|
|
harness.AppendLine(" auto* range = MemoryInline::ResolveRangeHost(base, 0, 2048, true, true);");
|
|
harness.AppendLine(" if (!range) return 20;");
|
|
harness.AppendLine(" PPC_FPR loaded{};");
|
|
harness.AppendLine(" loaded.d = PPC_PsqLInline<0u, 0u>(base);");
|
|
harness.AppendLine(" if (DBits(loaded.d) != DBits(PPC_PsqLResolvedInline<0u, 0u>(&ctx, range, 0, base))) return 21;");
|
|
harness.AppendLine(" if (loaded.paired.ps0 != 12.5f) return 1;");
|
|
harness.AppendLine(" if (loaded.paired.ps1 != -7.25f) return 2;");
|
|
harness.AppendLine(" PPC_FPR source{};");
|
|
harness.AppendLine(" source.paired.ps0 = 3.5f;");
|
|
harness.AppendLine(" source.paired.ps1 = -9.75f;");
|
|
harness.AppendLine(" PPC_PsqStInline<0u, 0u>(base + 8, source.d);");
|
|
harness.AppendLine(" if (Memory::Read32(base + 8) != Bits(3.5f)) return 3;");
|
|
harness.AppendLine(" if (Memory::Read32(base + 12) != Bits(-9.75f)) return 4;");
|
|
harness.AppendLine(" PPC_PsqStResolvedInline<0u, 0u>(&ctx, range, 24, base + 24, source.d);");
|
|
harness.AppendLine(" if (Memory::Read32(base + 24) != Bits(3.5f) || Memory::Read32(base + 28) != Bits(-9.75f)) return 22;");
|
|
harness.AppendLine(" Memory::Write32(base + 16, 0xDEADBEEFu);");
|
|
harness.AppendLine(" PPC_PsqStInline<1u, 0u>(base + 16, source.d);");
|
|
harness.AppendLine(" if (Memory::Read32(base + 16) != Bits(3.5f)) return 5;");
|
|
harness.AppendLine(" Memory::Write32(base + 20, Bits(22.0f));");
|
|
harness.AppendLine(" loaded.d = PPC_PsqLInline<1u, 0u>(base + 20);");
|
|
harness.AppendLine(" if (loaded.paired.ps0 != 22.0f) return 6;");
|
|
harness.AppendLine(" if (loaded.paired.ps1 != 1.0f) return 7;");
|
|
harness.AppendLine(" const uint32_t gqrs[] = { 0x00040004u, 0x00050005u, 0x00060006u, 0x00070007u, 0x3D043D04u };");
|
|
harness.AppendLine(" for (uint32_t n = 0; n < 5; ++n) {");
|
|
harness.AppendLine(" ctx.gqr[0] = gqrs[n];");
|
|
harness.AppendLine(" const uint32_t input = base + 40 + n * 8;");
|
|
harness.AppendLine(" Memory::Write64(input, 0x81FE1234A5C35A7Eu + n);");
|
|
harness.AppendLine(" const double ordinary = PPC_PsqLInline<0u, 0u>(&ctx, input);");
|
|
harness.AppendLine(" const double resolved = PPC_PsqLResolvedInline<0u, 0u>(&ctx, range, 40 + n * 8, input);");
|
|
harness.AppendLine(" if (DBits(ordinary) != DBits(resolved)) return 30 + n;");
|
|
harness.AppendLine(" const uint32_t a = base + 88 + n * 8; const uint32_t b = base + 128 + n * 8;");
|
|
harness.AppendLine(" Memory::Write64(a, 0xCCCCCCCCCCCCCCCCull); Memory::Write64(b, 0xCCCCCCCCCCCCCCCCull);");
|
|
harness.AppendLine(" PPC_PsqStInline<0u, 0u>(&ctx, a, source.d);");
|
|
harness.AppendLine(" PPC_PsqStResolvedInline<0u, 0u>(&ctx, range, 128 + n * 8, b, source.d);");
|
|
harness.AppendLine(" if (Memory::Read64(a) != Memory::Read64(b)) return 40 + n;");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x00000000u>(ctx, range, base, source.d, 0)) return 100 + e;");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x00040004u>(ctx, range, base, source.d, 1)) return 110 + e;");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x00050005u>(ctx, range, base, source.d, 2)) return 120 + e;");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x00060006u>(ctx, range, base, source.d, 3)) return 130 + e;");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x00070007u>(ctx, range, base, source.d, 4)) return 140 + e;");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x3D043D04u>(ctx, range, base, source.d, 5)) return 150 + e;");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x05050505u>(ctx, range, base, source.d, 6)) return 160 + e;");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x21062106u>(ctx, range, base, source.d, 7)) return 170 + e;");
|
|
harness.AppendLine(" if (const int e = CheckKnown<0x0C070C07u>(ctx, range, base, source.d, 8)) return 180 + e;");
|
|
harness.AppendLine(" std::cout << \"ok\";");
|
|
harness.AppendLine(" return 0;");
|
|
harness.AppendLine("}");
|
|
|
|
var harnessPath = Path.Combine(tempRoot, "harness_psq_lane_order.cpp");
|
|
File.WriteAllText(harnessPath, harness.ToString());
|
|
|
|
var runnerBasePath = Path.Combine(tempRoot, "runner_psq_lane_order");
|
|
var args = TranslatorCppTestHarness.BuildCompileArguments(
|
|
root,
|
|
tempRoot,
|
|
Array.Empty<string>(),
|
|
harnessPath,
|
|
runnerBasePath,
|
|
includeDataSections: false);
|
|
|
|
var compiler = CppCompiler();
|
|
var (compileExitCode, compileOutput) = RunProcess(compiler, args, TimeSpan.FromSeconds(60));
|
|
Assert.True(compileExitCode == 0, $"{compiler} failed: {compileOutput}");
|
|
|
|
var runnerPath = RunnerPath(runnerBasePath);
|
|
var (runExitCode, runOutput) = RunProcess(runnerPath, "", TimeSpan.FromSeconds(10));
|
|
Assert.True(runExitCode == 0, $"Runner failed ({runExitCode}). Output:\n{runOutput}");
|
|
Assert.Equal("ok", runOutput.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void KnownU8Scale61PairedStoreMatchesExactQuantizationOnFastAndColdPaths()
|
|
{
|
|
var root = ProjectPaths.FindRepositoryRoot();
|
|
var tempRoot = Path.Combine(root, "test_output", "ppc_runtime_psq_u8_scale61");
|
|
Directory.CreateDirectory(tempRoot);
|
|
|
|
var harness = new StringBuilder();
|
|
harness.AppendLine("#include <cmath>");
|
|
harness.AppendLine("#include <cstdint>");
|
|
harness.AppendLine("#include <cstring>");
|
|
harness.AppendLine("#include <iostream>");
|
|
harness.AppendLine("#include <limits>");
|
|
harness.AppendLine("#include \"memory.h\"");
|
|
harness.AppendLine("#include \"ppc_runtime.h\"");
|
|
harness.AppendLine("static uint16_t g_fifo16 = 0; static uint32_t g_fifo16Count = 0;");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write8(uint8_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write16(uint16_t value) { g_fifo16 = value; ++g_fifo16Count; }");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write32(uint32_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_WriteFloat(float) {}");
|
|
harness.AppendLine("extern \"C\" void DumpRecentPcTrace(size_t) {}");
|
|
harness.AppendLine("static uint16_t Reference(double value) {");
|
|
harness.AppendLine(" PPC_FPR fpr{}; fpr.d = value;");
|
|
harness.AppendLine(" return static_cast<uint16_t>((static_cast<uint16_t>(PpcQuantizePsqU8Scale61Inline(fpr.paired.ps0)) << 8) | PpcQuantizePsqU8Scale61Inline(fpr.paired.ps1));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static float FromBits(uint32_t bits) { float value; std::memcpy(&value, &bits, sizeof(value)); return value; }");
|
|
harness.AppendLine("int main() {");
|
|
harness.AppendLine(" const float edges[] = { -std::numeric_limits<float>::infinity(), -2040.0f, -1.0f, -0.0f, 0.0f,");
|
|
harness.AppendLine(" std::nextafter(0.0f, 1.0f), 7.999f, 8.0f, 2039.0f, std::nextafter(2040.0f, 0.0f), 2040.0f,");
|
|
harness.AppendLine(" std::numeric_limits<float>::infinity(), std::numeric_limits<float>::quiet_NaN(), FromBits(0x7F800001u) };");
|
|
harness.AppendLine(" for (float ps0 : edges) for (float ps1 : edges) {");
|
|
harness.AppendLine(" PPC_FPR pair{}; pair.paired.ps0 = ps0; pair.paired.ps1 = ps1;");
|
|
harness.AppendLine(" if (PpcQuantizePairPsqU8Scale61PackedInline(pair.d) != Reference(pair.d)) return 1;");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine(" uint32_t state = 0xC001D00Du;");
|
|
harness.AppendLine(" for (uint32_t i = 0; i < 1000000u; ++i) {");
|
|
harness.AppendLine(" state = state * 1664525u + 1013904223u; const uint32_t a = state;");
|
|
harness.AppendLine(" state = state * 1664525u + 1013904223u; const uint32_t b = state;");
|
|
harness.AppendLine(" PPC_FPR pair{}; pair.paired.ps0 = FromBits(a); pair.paired.ps1 = FromBits(b);");
|
|
harness.AppendLine(" if (PpcQuantizePairPsqU8Scale61PackedInline(pair.d) != Reference(pair.d)) return 2;");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine(" Memory::Init(Memory::Config::WiiDefaults()); CpuContext ctx{}; CpuContextScope scope(&ctx);");
|
|
harness.AppendLine(" constexpr uint32_t base = 0x80010000u; PPC_FPR pair{}; pair.paired.ps0 = 2039.0f; pair.paired.ps1 = 15.9f;");
|
|
harness.AppendLine(" const uint16_t expected = Reference(pair.d);");
|
|
harness.AppendLine(" PPC_PsqStKnownInline<0u, 6u, 0x3D043D04u>(&ctx, base, pair.d);");
|
|
harness.AppendLine(" if (Memory::Read16(base) != expected) return 3;");
|
|
harness.AppendLine(" const uint32_t page = base >> MemoryInline::kPageShift;");
|
|
harness.AppendLine(" const uintptr_t savedBias = MemoryInline::g_fullWritablePageBias[page];");
|
|
harness.AppendLine(" if (savedBias == 0) return 4;");
|
|
harness.AppendLine(" MemoryInline::g_fullWritablePageBias[page] = 0;");
|
|
harness.AppendLine(" PPC_PsqStKnownInline<0u, 6u, 0x3D043D04u>(&ctx, base + 2, pair.d);");
|
|
harness.AppendLine(" MemoryInline::g_fullWritablePageBias[page] = savedBias;");
|
|
harness.AppendLine(" if (Memory::Read16(base + 2) != expected) return 5;");
|
|
harness.AppendLine(" uint8_t* range = MemoryInline::ResolveRangeHost(base, 0, 64, false, true);");
|
|
harness.AppendLine(" if (!range) return 6;");
|
|
harness.AppendLine(" PPC_PsqStKnownResolvedInline<0u, 6u, 0x3D043D04u>(&ctx, range, 4, base + 4, pair.d);");
|
|
harness.AppendLine(" if (Memory::Read16(base + 4) != expected) return 7;");
|
|
harness.AppendLine(" PPC_PsqStKnownStackInline<0u, 6u, 0x3D043D04u>(&ctx, base + 6, pair.d);");
|
|
harness.AppendLine(" if (Memory::Read16(base + 6) != expected) return 8;");
|
|
harness.AppendLine(" PPC_FPR exceptional{}; exceptional.paired.ps0 = std::numeric_limits<float>::quiet_NaN(); exceptional.paired.ps1 = std::numeric_limits<float>::infinity();");
|
|
harness.AppendLine(" PPC_PsqStKnownInline<0u, 6u, 0x3D043D04u>(&ctx, 0xCC008000u, exceptional.d);");
|
|
harness.AppendLine(" if (g_fifo16Count != 1 || g_fifo16 != Reference(exceptional.d)) return 9;");
|
|
harness.AppendLine(" std::cout << \"ok\"; return 0;");
|
|
harness.AppendLine("}");
|
|
|
|
var harnessPath = Path.Combine(tempRoot, "harness_psq_u8_scale61.cpp");
|
|
File.WriteAllText(harnessPath, harness.ToString());
|
|
|
|
var runnerBasePath = Path.Combine(tempRoot, "runner_psq_u8_scale61");
|
|
var args = TranslatorCppTestHarness.BuildCompileArguments(
|
|
root,
|
|
tempRoot,
|
|
Array.Empty<string>(),
|
|
harnessPath,
|
|
runnerBasePath,
|
|
includeDataSections: false);
|
|
|
|
var compiler = CppCompiler();
|
|
var (compileExitCode, compileOutput) = RunProcess(compiler, args, TimeSpan.FromSeconds(60));
|
|
Assert.True(compileExitCode == 0, $"{compiler} failed: {compileOutput}");
|
|
|
|
var runnerPath = RunnerPath(runnerBasePath);
|
|
var (runExitCode, runOutput) = RunProcess(runnerPath, "", TimeSpan.FromSeconds(10));
|
|
Assert.True(runExitCode == 0, $"Runner failed ({runExitCode}). Output:\n{runOutput}");
|
|
Assert.Equal("ok", runOutput.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void InlinePairedSingleArithmeticPreservesLaneOrder()
|
|
{
|
|
var root = ProjectPaths.FindRepositoryRoot();
|
|
var tempRoot = Path.Combine(root, "test_output", "ppc_runtime_ps_arithmetic");
|
|
Directory.CreateDirectory(tempRoot);
|
|
|
|
var harness = new StringBuilder();
|
|
harness.AppendLine("#include <cmath>");
|
|
harness.AppendLine("#include <cstdint>");
|
|
harness.AppendLine("#include <iostream>");
|
|
harness.AppendLine("#include <limits>");
|
|
harness.AppendLine("#include \"ppc_runtime.h\"");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write8(uint8_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write16(uint16_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write32(uint32_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_WriteFloat(float) {}");
|
|
harness.AppendLine("extern \"C\" void DumpRecentPcTrace(size_t) {}");
|
|
harness.AppendLine("static bool Near(float a, float b) { return std::fabs(a - b) < 0.0001f; }");
|
|
harness.AppendLine("static int Check(PPC_FPR f, float ps0, float ps1, int code) {");
|
|
harness.AppendLine(" if (!Near(f.paired.ps0, ps0)) return code;");
|
|
harness.AppendLine(" if (!Near(f.paired.ps1, ps1)) return code + 1;");
|
|
harness.AppendLine(" return 0;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static uint64_t Bits(double value) {");
|
|
harness.AppendLine(" uint64_t bits = 0;");
|
|
harness.AppendLine(" std::memcpy(&bits, &value, sizeof(bits));");
|
|
harness.AppendLine(" return bits;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static double FromBits(uint64_t bits) {");
|
|
harness.AppendLine(" double value = 0.0;");
|
|
harness.AppendLine(" std::memcpy(&value, &bits, sizeof(value));");
|
|
harness.AppendLine(" return value;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static float FloatFromBits(uint32_t bits) {");
|
|
harness.AppendLine(" float value = 0.0f;");
|
|
harness.AppendLine(" std::memcpy(&value, &bits, sizeof(value));");
|
|
harness.AppendLine(" return value;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("int main() {");
|
|
harness.AppendLine(" PPC_FPR a{}; a.paired.ps0 = 2.0f; a.paired.ps1 = -4.0f;");
|
|
harness.AppendLine(" PPC_FPR b{}; b.paired.ps0 = 8.0f; b.paired.ps1 = 0.5f;");
|
|
harness.AppendLine(" PPC_FPR c{}; c.paired.ps0 = 3.0f; c.paired.ps1 = 10.0f;");
|
|
harness.AppendLine(" PPC_FPR out{};");
|
|
harness.AppendLine(" out.d = PPC_PsAddInline(a.d, b.d); if (int rc = Check(out, 10.0f, -3.5f, 1)) return rc;");
|
|
harness.AppendLine(" out.d = PPC_PsSubInline(a.d, b.d); if (int rc = Check(out, -6.0f, -4.5f, 3)) return rc;");
|
|
harness.AppendLine(" out.d = PPC_PsDivInline(a.d, b.d); if (int rc = Check(out, 0.25f, -8.0f, 21)) return rc;");
|
|
harness.AppendLine(" out.d = PPC_PsMulInline(a.d, b.d); if (int rc = Check(out, 16.0f, -2.0f, 5)) return rc;");
|
|
harness.AppendLine(" out.d = PPC_PsMaddInline(a.d, b.d, c.d); if (int rc = Check(out, 19.0f, 8.0f, 7)) return rc;");
|
|
harness.AppendLine(" out.d = PPC_PsMsubInline(a.d, b.d, c.d); if (int rc = Check(out, 13.0f, -12.0f, 9)) return rc;");
|
|
harness.AppendLine(" out.d = PPC_PsNmsubInline(a.d, b.d, c.d); if (int rc = Check(out, -13.0f, 12.0f, 11)) return rc;");
|
|
harness.AppendLine(" out.d = PPC_PsMuls0Inline(a.d, b.d); if (int rc = Check(out, 16.0f, -32.0f, 13)) return rc;");
|
|
harness.AppendLine(" out.d = PPC_PsMuls1Inline(a.d, b.d); if (int rc = Check(out, 1.0f, -2.0f, 15)) return rc;");
|
|
harness.AppendLine(" if (PPC_Divwu(0x12345678u, 0u) != 0u) return 17;");
|
|
harness.AppendLine(" if (PPC_Divw(123, 0) != 0) return 18;");
|
|
harness.AppendLine(" if (PPC_Divw(-123, 0) != -1) return 19;");
|
|
harness.AppendLine(" if (PPC_Divw(INT32_MIN, -1) != -1) return 20;");
|
|
harness.AppendLine(" // Exact Gekko estimate bits, including interpolation and exponent parity.");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(1.0)) != 0x3FEFFE8000000000ULL) return 23;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(2.0)) != 0x3FE69FA000000000ULL) return 24;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(4.0)) != 0x3FDFFE8000000000ULL) return 25;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(3.14159265358979323846)) != 0x3FE20DD740000000ULL) return 26;");
|
|
harness.AppendLine(" // Subnormal normalization must extend the encoded exponent below zero.");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(FromBits(0x0000000000000001ULL))) != 0x617FFE8000000000ULL) return 27;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(FromBits(0x000FFFFFFFFFFFFFULL))) != 0x5FE000082C000000ULL) return 28;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(FromBits(0x0010000000000000ULL))) != 0x5FDFFE8000000000ULL) return 29;");
|
|
harness.AppendLine(" // These values drive the architectural zero/invalid/NaN paths; the helper's");
|
|
harness.AppendLine(" // contract is result bits, while instruction emission owns FPSCR effects.");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(0.0)) != 0x7FF0000000000000ULL) return 30;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(-0.0)) != 0xFFF0000000000000ULL) return 31;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(std::numeric_limits<double>::infinity())) != 0x0000000000000000ULL) return 32;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(-std::numeric_limits<double>::infinity())) != 0x7FF8000000000000ULL) return 33;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(-4.0)) != 0x7FF8000000000000ULL) return 34;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(FromBits(0x7FF0000000000001ULL))) != 0x7FF8000000000001ULL) return 35;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(FromBits(0xFFF0000000000123ULL))) != 0xFFF8000000000123ULL) return 36;");
|
|
harness.AppendLine(" if (Bits(PPC_Frsqrte(FromBits(0x7FF8000000001234ULL))) != 0x7FF8000000001234ULL) return 37;");
|
|
harness.AppendLine(" // Paired multiply-add has one float32 rounding point, not a rounded");
|
|
harness.AppendLine(" // float multiply followed by a second rounded add.");
|
|
harness.AppendLine(" PPC_FPR edgeA{}; edgeA.paired.ps0 = FloatFromBits(0x42480000u); edgeA.paired.ps1 = edgeA.paired.ps0;");
|
|
harness.AppendLine(" PPC_FPR edgeC{}; edgeC.paired.ps0 = FloatFromBits(0xBC88CC38u); edgeC.paired.ps1 = edgeC.paired.ps0;");
|
|
harness.AppendLine(" PPC_FPR edgeB{}; edgeB.paired.ps0 = FloatFromBits(0x1B1C72A0u); edgeB.paired.ps1 = edgeB.paired.ps0;");
|
|
harness.AppendLine(" out.d = PPC_PsMaddInline(edgeA.d, edgeC.d, edgeB.d);");
|
|
harness.AppendLine(" if (PpcBitCastToU32Inline(out.paired.ps0) != 0xBF55BF17u || PpcBitCastToU32Inline(out.paired.ps1) != 0xBF55BF17u) return 38;");
|
|
harness.AppendLine(" if (PpcBitCastToU32Inline(static_cast<float>(PpcFmaddsInline(edgeA.paired.ps0, edgeC.paired.ps0, edgeB.paired.ps0))) != 0xBF55BF17u) return 39;");
|
|
harness.AppendLine(" // Double fused arithmetic must retain the product error cancelled by B.");
|
|
harness.AppendLine(" const double fmaA = 1.0 + 0x1p-27;");
|
|
harness.AppendLine(" const double fmaC = 1.0 - 0x1p-27;");
|
|
harness.AppendLine(" if (Bits(PpcFmaddInline(fmaA, fmaC, -1.0)) != 0xBC90000000000000ULL) return 40;");
|
|
harness.AppendLine(" // Exact Broadway reciprocal estimates, including lane replication.");
|
|
harness.AppendLine(" PPC_FPR estimateIn{}; estimateIn.paired.ps0 = 1.0f; estimateIn.paired.ps1 = 2.0f;");
|
|
harness.AppendLine(" if (Bits(PPC_Fres(estimateIn.d)) != 0x3F7FF8003F7FF800ULL) return 41;");
|
|
harness.AppendLine(" if (Bits(PPC_PsRes(estimateIn.d)) != 0x3F7FF8003EFFF800ULL) return 42;");
|
|
harness.AppendLine(" estimateIn.paired.ps0 = 1.0f; estimateIn.paired.ps1 = 4.0f;");
|
|
harness.AppendLine(" if (Bits(PPC_PsRsqrte(estimateIn.d)) != 0x3F7FF4003EFFF400ULL) return 43;");
|
|
harness.AppendLine(" estimateIn.paired.ps0 = -0.0f; estimateIn.paired.ps1 = -4.0f;");
|
|
harness.AppendLine(" if (Bits(PPC_PsRsqrte(estimateIn.d)) != 0xFF8000007FC00000ULL) return 44;");
|
|
harness.AppendLine(" // stfs narrows the FPR payload with Gekko's bit conversion, not a host cast.");
|
|
harness.AppendLine(" if (MemoryInline::ConvertPpcDoubleToSingleBits(1.0 + 0x1.8p-23) != 0x3F800001u) return 45;");
|
|
harness.AppendLine(" if (MemoryInline::ConvertPpcDoubleToSingleBits(1.0 + 0x1.8p-24) != 0x3F800000u) return 46;");
|
|
harness.AppendLine(" // FPSCR[NI] flushes single subnormal results while preserving their sign.");
|
|
harness.AppendLine(" CpuContext niCpu{}; niCpu.fpscr = 4u;");
|
|
harness.AppendLine(" { CpuContextScope niScope(&niCpu);");
|
|
harness.AppendLine(" if (PpcBitCastToU32Inline(PpcForceSingleValueInline(0x1p-149)) != 0u) return 47;");
|
|
harness.AppendLine(" if (PpcBitCastToU32Inline(PpcForceSingleValueInline(-0x1p-149)) != 0x80000000u) return 48;");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine(" std::cout << \"ok\";");
|
|
harness.AppendLine(" return 0;");
|
|
harness.AppendLine("}");
|
|
|
|
var harnessPath = Path.Combine(tempRoot, "harness_ps_arithmetic.cpp");
|
|
File.WriteAllText(harnessPath, harness.ToString());
|
|
|
|
var runnerBasePath = Path.Combine(tempRoot, "runner_ps_arithmetic");
|
|
var args = TranslatorCppTestHarness.BuildCompileArguments(
|
|
root,
|
|
tempRoot,
|
|
Array.Empty<string>(),
|
|
harnessPath,
|
|
runnerBasePath,
|
|
includeDataSections: false);
|
|
|
|
var compiler = CppCompiler();
|
|
var (compileExitCode, compileOutput) = RunProcess(compiler, args, TimeSpan.FromSeconds(60));
|
|
Assert.True(compileExitCode == 0, $"{compiler} failed: {compileOutput}");
|
|
|
|
var runnerPath = RunnerPath(runnerBasePath);
|
|
var (runExitCode, runOutput) = RunProcess(runnerPath, "", TimeSpan.FromSeconds(10));
|
|
Assert.True(runExitCode == 0, $"Runner failed ({runExitCode}). Output:\n{runOutput}");
|
|
Assert.Equal("ok", runOutput.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void NonvolatileFprGuardPreservesPackedPairedAndScalarFprs()
|
|
{
|
|
var root = ProjectPaths.FindRepositoryRoot();
|
|
var tempRoot = Path.Combine(root, "test_output", "ppc_nonvolatile_fpr_guard");
|
|
Directory.CreateDirectory(tempRoot);
|
|
|
|
var harness = new StringBuilder();
|
|
harness.AppendLine("#include <cstdint>");
|
|
harness.AppendLine("#include <iostream>");
|
|
harness.AppendLine("#include \"abi_bridge.h\"");
|
|
harness.AppendLine("extern \"C\" void ClobberNonvolatileFprs(CpuContext* ctx) {");
|
|
harness.AppendLine(" ctx->fpr[14].raw = 0x0102030405060708ull;");
|
|
harness.AppendLine(" ctx->fpr[31].raw = 0x8877665544332211ull;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("int main() {");
|
|
harness.AppendLine(" CpuContext ctx{};");
|
|
harness.AppendLine(" PPC_FPR saved14{}; saved14.paired.ps0 = 12.5f; saved14.paired.ps1 = -7.25f;");
|
|
harness.AppendLine(" PPC_FPR saved31{}; saved31.d = 3.141592653589793;");
|
|
harness.AppendLine(" PPC_FPR volatile13{}; volatile13.paired.ps0 = 1.0f; volatile13.paired.ps1 = 2.0f;");
|
|
harness.AppendLine(" ctx.fpr[14] = saved14;");
|
|
harness.AppendLine(" ctx.fpr[31] = saved31;");
|
|
harness.AppendLine(" ctx.fpr[13] = volatile13;");
|
|
harness.AppendLine(" {");
|
|
harness.AppendLine(" PpcNonvolatileFprGuard guard(&ctx);");
|
|
harness.AppendLine(" ctx.fpr[14].paired.ps0 = 1000.0f;");
|
|
harness.AppendLine(" ctx.fpr[14].paired.ps1 = 2000.0f;");
|
|
harness.AppendLine(" ctx.fpr[31].raw = 0x123456789ABCDEF0ull;");
|
|
harness.AppendLine(" ctx.fpr[13].paired.ps0 = 9.0f;");
|
|
harness.AppendLine(" ctx.fpr[13].paired.ps1 = 10.0f;");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine(" if (ctx.fpr[14].raw != saved14.raw) return 1;");
|
|
harness.AppendLine(" if (ctx.fpr[31].raw != saved31.raw) return 2;");
|
|
harness.AppendLine(" if (ctx.fpr[13].raw == volatile13.raw) return 3;");
|
|
harness.AppendLine(" {");
|
|
harness.AppendLine(" PpcNonvolatileFprGuard guard(&ctx, 1u << 31);");
|
|
harness.AppendLine(" ctx.fpr[14].raw = 0x1111111111111111ull;");
|
|
harness.AppendLine(" ctx.fpr[31].raw = 0x2222222222222222ull;");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine(" if (ctx.fpr[14].raw == saved14.raw) return 4;");
|
|
harness.AppendLine(" if (ctx.fpr[31].raw != saved31.raw) return 5;");
|
|
harness.AppendLine(" ctx.fpr[14] = saved14;");
|
|
harness.AppendLine(" TranslatedFunctionInfo info{};");
|
|
harness.AppendLine(" info.entryPoint = reinterpret_cast<void*>(&ClobberNonvolatileFprs);");
|
|
harness.AppendLine(" info.nonvolatileFprWriteMask = 1u << 31;");
|
|
harness.AppendLine(" if (!TryDispatchResolvedCpuTarget(&info, &ctx)) return 6;");
|
|
harness.AppendLine(" if (ctx.fpr[14].raw == saved14.raw) return 7;");
|
|
harness.AppendLine(" if (ctx.fpr[31].raw != saved31.raw) return 8;");
|
|
harness.AppendLine(" ctx.fpr[14] = saved14;");
|
|
harness.AppendLine(" ctx.fpr[31] = saved31;");
|
|
harness.AppendLine(" info.nonvolatileFprWriteMask = kPpcAllNonvolatileFprMask;");
|
|
harness.AppendLine(" if (!TryDispatchResolvedCpuTarget(&info, &ctx)) return 9;");
|
|
harness.AppendLine(" if (ctx.fpr[14].raw != saved14.raw) return 10;");
|
|
harness.AppendLine(" if (ctx.fpr[31].raw != saved31.raw) return 11;");
|
|
harness.AppendLine(" info.nonvolatileFprWriteMask = 0;");
|
|
harness.AppendLine(" if (!TryDispatchResolvedCpuTarget(&info, &ctx)) return 12;");
|
|
harness.AppendLine(" if (ctx.fpr[14].raw == saved14.raw) return 13;");
|
|
harness.AppendLine(" if (ctx.fpr[31].raw == saved31.raw) return 14;");
|
|
harness.AppendLine(" std::cout << \"ok\";");
|
|
harness.AppendLine(" return 0;");
|
|
harness.AppendLine("}");
|
|
|
|
var harnessPath = Path.Combine(tempRoot, "harness_nonvolatile_fpr_guard.cpp");
|
|
File.WriteAllText(harnessPath, harness.ToString());
|
|
|
|
var runnerBasePath = Path.Combine(tempRoot, "runner_nonvolatile_fpr_guard");
|
|
var args =
|
|
"-std=c++17 " +
|
|
$"\"{harnessPath}\" " +
|
|
$"-I\"{Path.Combine(root, "runtime", "include")}\" " +
|
|
$"-o \"{runnerBasePath}\"";
|
|
|
|
var compiler = CppCompiler();
|
|
var (compileExitCode, compileOutput) = RunProcess(compiler, args, TimeSpan.FromSeconds(60));
|
|
Assert.True(compileExitCode == 0, $"{compiler} failed: {compileOutput}");
|
|
|
|
var runnerPath = RunnerPath(runnerBasePath);
|
|
var (runExitCode, runOutput) = RunProcess(runnerPath, "", TimeSpan.FromSeconds(10));
|
|
Assert.True(runExitCode == 0, $"Runner failed ({runExitCode}). Output:\n{runOutput}");
|
|
Assert.Equal("ok", runOutput.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void DirectCpuDispatchSeesModOverrideRegisteredAfterFirstBaseCall()
|
|
{
|
|
var root = ProjectPaths.FindRepositoryRoot();
|
|
var tempRoot = Path.Combine(root, "test_output", "ppc_direct_mod_override_refresh");
|
|
Directory.CreateDirectory(tempRoot);
|
|
|
|
var harness = new StringBuilder();
|
|
harness.AppendLine("#include <cstdint>");
|
|
harness.AppendLine("#include <iostream>");
|
|
harness.AppendLine("#include <utility>");
|
|
harness.AppendLine("#include \"abi_bridge.h\"");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write8(uint8_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write16(uint16_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_Write32(uint32_t) {}");
|
|
harness.AppendLine("extern \"C\" void GX_HLE_FIFO_WriteFloat(float) {}");
|
|
harness.AppendLine("extern \"C\" void BaseTranslated(CpuContext* ctx) { ctx->gpr[3] = 0xBACE0001u; }");
|
|
harness.AppendLine("extern \"C\" void ModTranslated(CpuContext* ctx) { ctx->gpr[3] = 0xC0DE0002u; }");
|
|
harness.AppendLine("template <> struct KnownTranslatedCpuCall<0x81234568u> {");
|
|
harness.AppendLine(" static constexpr bool kAvailable = true;");
|
|
harness.AppendLine(" static constexpr uint32_t kNonvolatileFprWriteMask = 0;");
|
|
harness.AppendLine(" static constexpr bool kMayBeOverridden = true;");
|
|
harness.AppendLine(" static constexpr void (*Entry)(CpuContext*) = &BaseTranslated;");
|
|
harness.AppendLine("};");
|
|
harness.AppendLine("static void Register(uint32_t priority, FunctionKind kind, const char* name, void (*entry)(CpuContext*)) {");
|
|
harness.AppendLine(" TranslatedFunctionInfo info{};");
|
|
harness.AppendLine(" info.address = 0x81234568u;");
|
|
harness.AppendLine(" info.name = name;");
|
|
harness.AppendLine(" info.kind = kind;");
|
|
harness.AppendLine(" info.priority = priority;");
|
|
harness.AppendLine(" info.entryPoint = reinterpret_cast<void*>(entry);");
|
|
harness.AppendLine(" info.nonvolatileFprWriteMask = 0;");
|
|
harness.AppendLine(" TranslatedFunctionRegistry::Register(std::move(info));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("int main() {");
|
|
harness.AppendLine(" CpuContext ctx{};");
|
|
harness.AppendLine(" Register(0, FunctionKind::BaseTranslated, \"base\", &BaseTranslated);");
|
|
harness.AppendLine(" InvokeDirectCpu<0x81234568u>(&ctx);");
|
|
harness.AppendLine(" if (ctx.gpr[3] != 0xBACE0001u) return 1;");
|
|
harness.AppendLine(" Register(100, FunctionKind::ModTranslated, \"mod\", &ModTranslated);");
|
|
harness.AppendLine(" ctx.gpr[3] = 0;");
|
|
harness.AppendLine(" InvokeDirectCpu<0x81234568u>(&ctx);");
|
|
harness.AppendLine(" if (ctx.gpr[3] != 0xC0DE0002u) return 2;");
|
|
harness.AppendLine(" TranslatedFunctionRegistry::Finalize();");
|
|
harness.AppendLine(" ctx.gpr[3] = 0;");
|
|
harness.AppendLine(" InvokeDirectCpu<0x81234568u>(&ctx);");
|
|
harness.AppendLine(" if (ctx.gpr[3] != 0xC0DE0002u) return 3;");
|
|
harness.AppendLine(" std::cout << \"ok\";");
|
|
harness.AppendLine(" return 0;");
|
|
harness.AppendLine("}");
|
|
|
|
var harnessPath = Path.Combine(tempRoot, "harness_direct_mod_override_refresh.cpp");
|
|
File.WriteAllText(harnessPath, harness.ToString());
|
|
|
|
var runnerBasePath = Path.Combine(tempRoot, "runner_direct_mod_override_refresh");
|
|
var args = TranslatorCppTestHarness.BuildCompileArguments(
|
|
root,
|
|
tempRoot,
|
|
Array.Empty<string>(),
|
|
harnessPath,
|
|
runnerBasePath,
|
|
includeDataSections: false);
|
|
|
|
var compiler = CppCompiler();
|
|
var (compileExitCode, compileOutput) = RunProcess(compiler, args, TimeSpan.FromSeconds(60));
|
|
Assert.True(compileExitCode == 0, $"{compiler} failed: {compileOutput}");
|
|
|
|
var runnerPath = RunnerPath(runnerBasePath);
|
|
var (runExitCode, runOutput) = RunProcess(runnerPath, "", TimeSpan.FromSeconds(10));
|
|
Assert.True(runExitCode == 0, $"Runner failed ({runExitCode}). Output:\n{runOutput}");
|
|
Assert.Contains("ok", runOutput);
|
|
}
|
|
}
|