mirror of
https://github.com/patchzyy/wiicompiled
synced 2026-09-10 17:16:47 -04:00
patchzyy
927 lines
63 KiB
C#
927 lines
63 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Translator.Core.Analysis;
|
|
using Translator.Core.Analysis.Representation;
|
|
using Translator.Core.CodeGen;
|
|
using Translator.Core.Ir;
|
|
using Translator.Core.Loading;
|
|
using Translator.Core.Parsing.Dol;
|
|
using Translator.Core.Parsing.Rel;
|
|
using Translator.Core.Translation;
|
|
using Translator.Core.Representation;
|
|
using Xunit;
|
|
|
|
namespace Translator.Tests;
|
|
|
|
public class MtxIntegrationTests
|
|
{
|
|
private static string RepositoryRoot => Path.GetFullPath(Path.Combine(
|
|
AppContext.BaseDirectory, "..", "..", "..", "..", "..", ".."));
|
|
|
|
private enum ParamKind
|
|
{
|
|
Gpr,
|
|
Fpr
|
|
}
|
|
|
|
private enum ReturnKind
|
|
{
|
|
Void,
|
|
Gpr,
|
|
Float
|
|
}
|
|
|
|
private record MtxFuncSpec(uint Address, string Name, ReturnKind Return, IReadOnlyList<ParamKind> Params);
|
|
|
|
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 = true;
|
|
if (timeout.HasValue)
|
|
{
|
|
exitedInTime = process.WaitForExit((int)timeout.Value.TotalMilliseconds);
|
|
}
|
|
else
|
|
{
|
|
process.WaitForExit();
|
|
}
|
|
|
|
if (!exitedInTime)
|
|
{
|
|
try
|
|
{
|
|
process.Kill(entireProcessTree: true);
|
|
}
|
|
catch
|
|
{
|
|
// ignored: process might have already exited between WaitForExit and Kill
|
|
}
|
|
|
|
process.WaitForExit();
|
|
var staleOutput = stdoutTask.GetAwaiter().GetResult() + stderrTask.GetAwaiter().GetResult();
|
|
throw new TimeoutException($"Process '{fileName}' timed out after {timeout!.Value.TotalSeconds:F0}s. Output before kill:\n{staleOutput}");
|
|
}
|
|
|
|
process.WaitForExit();
|
|
var output = stdoutTask.GetAwaiter().GetResult() + stderrTask.GetAwaiter().GetResult();
|
|
return (process.ExitCode, output);
|
|
}
|
|
|
|
private static FunctionTranslator BuildTranslator()
|
|
{
|
|
var root = RepositoryRoot;
|
|
var dol = DolFile.Load(Path.Combine(root, "assets", "main.dol"));
|
|
var rel = RelFile.Load(Path.Combine(root, "assets", "StaticR.rel"))
|
|
.BuildImage(0x805102E0);
|
|
var image = new ProgramImageBuilder().Build(dol, rel);
|
|
return new FunctionTranslator(image);
|
|
}
|
|
|
|
[Fact]
|
|
public void Translated_MTX_Primitives_ExecuteCorrectly()
|
|
{
|
|
var specs = new[]
|
|
{
|
|
Spec(0x80199D04, "PSMTXIdentity_80199d04", ReturnKind.Void, ParamKind.Gpr),
|
|
Spec(0x80199D30, "PSMTXCopy_80199d30", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x80199D64, "PSMTXConcat_80199d64", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x80199E30, "PSMTXConcatArray_80199e30", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x80199FC8, "PSMTXInverse_80199fc8", ReturnKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019A0C0, "PSMTXInvXpose_8019a0c0", ReturnKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019A188, "PSMTXRotRad_8019a188", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr),
|
|
Spec(0x8019A204, "PSMTXRotTrig_8019a204", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A2B4, "PSMTXRotAxisRadInternal_8019a2b4", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A364, "PSMTXRotAxisRad_8019a364", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr),
|
|
Spec(0x8019A3E0, "PSMTXTrans_8019a3e0", ReturnKind.Void, ParamKind.Gpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A414, "PSMTXTransApply_8019a414", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A460, "PSMTXScale_8019a460", ReturnKind.Void, ParamKind.Gpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A488, "PSMTXScaleApply_8019a488", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A4E0, "PSMTXQuat_8019a4e0", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019A584, "C_MTXLookAt_8019a584", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019A6F8, "C_MTXLightFrustum_8019a6f8", ReturnKind.Void, ParamKind.Gpr,
|
|
ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A79C, "C_MTXLightPerspective_8019a79c", ReturnKind.Void, ParamKind.Gpr,
|
|
ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A894, "C_MTXLightOrtho_8019a894", ReturnKind.Void, ParamKind.Gpr,
|
|
ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019A91C, "PSMTXMultVec_8019a91c", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019A970, "PSMTXMultVecSR_8019a970", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019A9C4, "C_MTXFrustum_8019a9c4", ReturnKind.Void, ParamKind.Gpr,
|
|
ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019AA60, "C_MTXPerspective_8019aa60", ReturnKind.Void, ParamKind.Gpr,
|
|
ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019AB4C, "C_MTXOrtho_8019ab4c", ReturnKind.Void, ParamKind.Gpr,
|
|
ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr, ParamKind.Fpr),
|
|
Spec(0x8019ABE4, "MTX__PSVECAdd_8019abe4", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019AC08, "MTX__PSVECScale_8019ac08", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr),
|
|
Spec(0x8019AC24, "MTX__PSVECNormalize_8019ac24", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019AC68, "MTX__PSVECMag_8019ac68", ReturnKind.Float, ParamKind.Gpr),
|
|
Spec(0x8019ACAC, "MTX__PSVECDotProduct_8019acac", ReturnKind.Float, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019ACCC, "MTX__PSVECCrossProduct_8019accc", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019AD08, "MTX__C_VECHalfAngle_8019ad08", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019ADE0, "MTX__PSVECSquareDistance_8019ade0", ReturnKind.Float, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019AE08, "MTX__PSQUATMultiply_8019ae08", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019AE64, "MTX__PSQUATScale_8019ae64", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr),
|
|
Spec(0x8019AE80, "MTX__PSQUATDotProduct_8019ae80", ReturnKind.Float, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019AEA0, "MTX__PSQUATNormalize_8019aea0", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019AEF4, "MTX__PSQUATInverse_8019aef4", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019AF48, "MTX__C_QUATMtx_8019af48", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr),
|
|
Spec(0x8019B114, "MTX__C_QUATLerp_8019b114", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr),
|
|
Spec(0x8019B178, "MTX__C_QUATSlerp_8019b178", ReturnKind.Void, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Gpr, ParamKind.Fpr),
|
|
};
|
|
|
|
var translator = BuildTranslator();
|
|
var repoRoot = RepositoryRoot;
|
|
var tempRoot = Path.Combine(repoRoot, "test_output", "mtx");
|
|
Directory.CreateDirectory(tempRoot);
|
|
|
|
var generatedFiles = new List<string>();
|
|
var translations = TranslateWithDependencies(
|
|
translator,
|
|
specs.Select(s => (s.Address, s.Name)),
|
|
tempRoot,
|
|
generatedFiles);
|
|
|
|
var translationMap = translations.ToDictionary(t => t.Name, StringComparer.Ordinal);
|
|
foreach (var spec in specs)
|
|
{
|
|
Assert.True(translationMap.TryGetValue(spec.Name, out var translation), $"Missing translation for {spec.Name}.");
|
|
AssertReturnAbiMatches(spec, translation.AbiClassification);
|
|
}
|
|
|
|
var harness = new StringBuilder();
|
|
harness.AppendLine("#include <cassert>");
|
|
harness.AppendLine("#include <cmath>");
|
|
harness.AppendLine("#include <cstdlib>");
|
|
harness.AppendLine("#include <cstdint>");
|
|
harness.AppendLine("#include <cstdio>");
|
|
harness.AppendLine("#include <array>");
|
|
harness.AppendLine("#include <type_traits>");
|
|
harness.AppendLine("#include \"memory.h\"");
|
|
harness.AppendLine("#include \"ppc_runtime.h\"");
|
|
harness.AppendLine("#include \"RuntimeConfig.h\"");
|
|
|
|
// Stubs for runtime dependencies
|
|
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 InsertAlarm_801a0620(CpuContext*) {}");
|
|
harness.AppendLine("extern \"C\" void OS____TimeToSystemTime_801aade0(CpuContext*) {}");
|
|
harness.AppendLine("void VI_HLE_SimulateRetrace(CpuContext*) {}");
|
|
harness.AppendLine("void DumpRecentPcTrace(size_t) {}");
|
|
harness.AppendLine("void MarkFatalErrorReported() {}");
|
|
harness.AppendLine("extern \"C\" void InitializeDataSections();");
|
|
|
|
foreach (var translation in translations)
|
|
{
|
|
harness.AppendLine(PrototypeFor(translation.AbiClassification));
|
|
}
|
|
|
|
harness.AppendLine("template <typename T>");
|
|
harness.AppendLine("uint32_t ToGpr(T v) {");
|
|
harness.AppendLine(" if constexpr (std::is_pointer_v<T>) {");
|
|
harness.AppendLine(" return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(v));");
|
|
harness.AppendLine(" } else {");
|
|
harness.AppendLine(" return static_cast<uint32_t>(v);");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine("}");
|
|
|
|
harness.AppendLine("static void WriteF32(uint32_t addr, float value) {");
|
|
harness.AppendLine(" Memory::WriteFloat32(addr, value);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static float ReadF32(uint32_t addr) {");
|
|
harness.AppendLine(" return Memory::ReadFloat32(addr);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void WriteMat34(uint32_t addr, const float* m) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) WriteF32(addr + static_cast<uint32_t>(i * 4), m[i]);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void ReadMat34(uint32_t addr, float* m) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) m[i] = ReadF32(addr + static_cast<uint32_t>(i * 4));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void WriteMat44(uint32_t addr, const float* m) {");
|
|
harness.AppendLine(" for (int i = 0; i < 16; ++i) WriteF32(addr + static_cast<uint32_t>(i * 4), m[i]);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void ReadMat44(uint32_t addr, float* m) {");
|
|
harness.AppendLine(" for (int i = 0; i < 16; ++i) m[i] = ReadF32(addr + static_cast<uint32_t>(i * 4));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void WriteVec3(uint32_t addr, const float* v) {");
|
|
harness.AppendLine(" for (int i = 0; i < 3; ++i) WriteF32(addr + static_cast<uint32_t>(i * 4), v[i]);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void ReadVec3(uint32_t addr, float* v) {");
|
|
harness.AppendLine(" for (int i = 0; i < 3; ++i) v[i] = ReadF32(addr + static_cast<uint32_t>(i * 4));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void WriteQuat(uint32_t addr, const float* q) {");
|
|
harness.AppendLine(" for (int i = 0; i < 4; ++i) WriteF32(addr + static_cast<uint32_t>(i * 4), q[i]);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void ReadQuat(uint32_t addr, float* q) {");
|
|
harness.AppendLine(" for (int i = 0; i < 4; ++i) q[i] = ReadF32(addr + static_cast<uint32_t>(i * 4));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static float ReadFprPs0(const CpuContext& cpu, int index) {");
|
|
harness.AppendLine(" return static_cast<float>(PPC_PsToScalar(cpu.fpr[index].d));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static float ReadFprFloat(const CpuContext& cpu, int index) {");
|
|
harness.AppendLine(" return static_cast<float>(cpu.fpr[index].d);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static bool Near(float a, float b, float eps = 1e-4f) {");
|
|
harness.AppendLine(" const float diff = std::fabs(a - b);");
|
|
harness.AppendLine(" const float scale = std::fmax(1.0f, std::fmax(std::fabs(a), std::fabs(b)));\n return diff <= eps * scale;\n}");
|
|
harness.AppendLine("static float VecDot(const float* a, const float* b) {");
|
|
harness.AppendLine(" return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static float VecMag(const float* v) {");
|
|
harness.AppendLine(" return std::sqrt(VecDot(v, v));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void VecNormalize(const float* v, float* out) {");
|
|
harness.AppendLine(" const float m = VecMag(v);\n if (m == 0.0f) { out[0] = out[1] = out[2] = 0.0f; return; }\n out[0] = v[0] / m; out[1] = v[1] / m; out[2] = v[2] / m;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void VecCross(const float* a, const float* b, float* out) {");
|
|
harness.AppendLine(" out[0] = a[1] * b[2] - a[2] * b[1];\n out[1] = a[2] * b[0] - a[0] * b[2];\n out[2] = a[0] * b[1] - a[1] * b[0];");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static float VecSquareDistance(const float* a, const float* b) {");
|
|
harness.AppendLine(" const float dx = a[0] - b[0]; const float dy = a[1] - b[1]; const float dz = a[2] - b[2];");
|
|
harness.AppendLine(" return dx * dx + dy * dy + dz * dz;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void VecHalfAngle(const float* a, const float* b, float* out) {");
|
|
harness.AppendLine(" float an[3] = { -a[0], -a[1], -a[2] };");
|
|
harness.AppendLine(" float bn[3] = { -b[0], -b[1], -b[2] };");
|
|
harness.AppendLine(" VecNormalize(an, an);");
|
|
harness.AppendLine(" VecNormalize(bn, bn);");
|
|
harness.AppendLine(" float sum[3] = { an[0] + bn[0], an[1] + bn[1], an[2] + bn[2] };");
|
|
harness.AppendLine(" const float len2 = VecDot(sum, sum);");
|
|
harness.AppendLine(" if (len2 <= 1e-7f) { out[0] = sum[0]; out[1] = sum[1]; out[2] = sum[2]; return; }");
|
|
harness.AppendLine(" VecNormalize(sum, out);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void QuatMul(const float* a, const float* b, float* out) {");
|
|
harness.AppendLine(" const float ax = a[0], ay = a[1], az = a[2], aw = a[3];");
|
|
harness.AppendLine(" const float bx = b[0], by = b[1], bz = b[2], bw = b[3];");
|
|
harness.AppendLine(" out[0] = aw * bx + bw * ax + ay * bz - az * by;");
|
|
harness.AppendLine(" out[1] = aw * by + bw * ay + az * bx - ax * bz;");
|
|
harness.AppendLine(" out[2] = aw * bz + bw * az + ax * by - ay * bx;");
|
|
harness.AppendLine(" out[3] = aw * bw - (ax * bx + ay * by + az * bz);");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static float QuatDot(const float* a, const float* b) {");
|
|
harness.AppendLine(" return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void QuatNormalize(const float* q, float* out) {");
|
|
harness.AppendLine(" const float d = QuatDot(q, q);\n if (d == 0.0f) { out[0] = out[1] = out[2] = 0.0f; out[3] = 1.0f; return; }\n const float inv = 1.0f / std::sqrt(d);\n out[0] = q[0] * inv; out[1] = q[1] * inv; out[2] = q[2] * inv; out[3] = q[3] * inv;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void QuatInverse(const float* q, float* out) {");
|
|
harness.AppendLine(" const float d = QuatDot(q, q);\n if (d == 0.0f) { out[0] = out[1] = out[2] = 0.0f; out[3] = 1.0f; return; }\n const float inv = 1.0f / d;\n out[0] = -q[0] * inv; out[1] = -q[1] * inv; out[2] = -q[2] * inv; out[3] = q[3] * inv;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void QuatLerp(const float* a, const float* b, float t, float* out) {");
|
|
harness.AppendLine(" out[0] = a[0] + (b[0] - a[0]) * t;\n out[1] = a[1] + (b[1] - a[1]) * t;\n out[2] = a[2] + (b[2] - a[2]) * t;\n out[3] = a[3] + (b[3] - a[3]) * t;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void QuatSlerp(const float* a, const float* bIn, float t, float* out) {");
|
|
harness.AppendLine(" float b[4] = { bIn[0], bIn[1], bIn[2], bIn[3] };");
|
|
harness.AppendLine(" float dot = QuatDot(a, b);");
|
|
harness.AppendLine(" if (dot < 0.0f) { dot = -dot; b[0] = -b[0]; b[1] = -b[1]; b[2] = -b[2]; b[3] = -b[3]; }");
|
|
harness.AppendLine(" if (dot > 0.9995f) { QuatLerp(a, b, t, out); QuatNormalize(out, out); return; }");
|
|
harness.AppendLine(" const float theta = std::acos(dot);\n const float sinT = std::sin(theta);\n const float w1 = std::sin((1.0f - t) * theta) / sinT;\n const float w2 = std::sin(t * theta) / sinT;");
|
|
harness.AppendLine(" out[0] = a[0] * w1 + b[0] * w2;\n out[1] = a[1] * w1 + b[1] * w2;\n out[2] = a[2] * w1 + b[2] * w2;\n out[3] = a[3] * w1 + b[3] * w2;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void ExpectMat34(const float* got, const float* exp, const char* label) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) {");
|
|
harness.AppendLine(" if (!Near(got[i], exp[i])) {");
|
|
harness.AppendLine(" std::printf(\"[mtx] %s mismatch at %d: got %.6f exp %.6f\\n\", label, i, got[i], exp[i]);");
|
|
harness.AppendLine(" assert(false);");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void ExpectMat44(const float* got, const float* exp, const char* label) {");
|
|
harness.AppendLine(" for (int i = 0; i < 16; ++i) {");
|
|
harness.AppendLine(" if (!Near(got[i], exp[i])) {");
|
|
harness.AppendLine(" std::printf(\"[mtx] %s mismatch at %d: got %.6f exp %.6f\\n\", label, i, got[i], exp[i]);");
|
|
harness.AppendLine(" assert(false);");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine("}");
|
|
|
|
harness.AppendLine("static void RefIdentity(float* m) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) m[i] = 0.0f;");
|
|
harness.AppendLine(" m[0] = 1.0f; m[5] = 1.0f; m[10] = 1.0f;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void RefScale(float* m, float x, float y, float z) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) m[i] = 0.0f;");
|
|
harness.AppendLine(" m[0] = x; m[5] = y; m[10] = z;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void RefTrans(float* m, float x, float y, float z) {");
|
|
harness.AppendLine(" RefIdentity(m);");
|
|
harness.AppendLine(" m[3] = x; m[7] = y; m[11] = z;");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void RefRotTrig(float* m, char axis, float sinA, float cosA) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) m[i] = 0.0f;");
|
|
harness.AppendLine(" switch (axis) {");
|
|
harness.AppendLine(" case 'x': case 'X':");
|
|
harness.AppendLine(" m[0] = 1.0f; m[5] = cosA; m[6] = -sinA; m[9] = sinA; m[10] = cosA; break;");
|
|
harness.AppendLine(" case 'y': case 'Y':");
|
|
harness.AppendLine(" m[0] = cosA; m[2] = sinA; m[5] = 1.0f; m[8] = -sinA; m[10] = cosA; break;");
|
|
harness.AppendLine(" case 'z': case 'Z':");
|
|
harness.AppendLine(" m[0] = cosA; m[1] = -sinA; m[4] = sinA; m[5] = cosA; m[10] = 1.0f; break;");
|
|
harness.AppendLine(" default: break;");
|
|
harness.AppendLine(" }");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void RefRotRad(float* m, char axis, float rad) {");
|
|
harness.AppendLine(" RefRotTrig(m, axis, sinf(rad), cosf(rad));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void RefRotAxisRadInternal(float* m, const float* axis, float sinA, float cosA) {");
|
|
harness.AppendLine(" float x = axis[0], y = axis[1], z = axis[2];");
|
|
harness.AppendLine(" float len = std::sqrt(x * x + y * y + z * z);");
|
|
harness.AppendLine(" if (len == 0.0f) { RefIdentity(m); return; }");
|
|
harness.AppendLine(" x /= len; y /= len; z /= len;\n const float t = 1.0f - cosA;\n m[0] = t * x * x + cosA;\n m[1] = t * x * y - sinA * z;\n m[2] = t * x * z + sinA * y;\n m[3] = 0.0f;\n m[4] = t * x * y + sinA * z;\n m[5] = t * y * y + cosA;\n m[6] = t * y * z - sinA * x;\n m[7] = 0.0f;\n m[8] = t * x * z - sinA * y;\n m[9] = t * y * z + sinA * x;\n m[10] = t * z * z + cosA;\n m[11] = 0.0f;\n}");
|
|
harness.AppendLine("static void RefRotAxisRad(float* m, const float* axis, float rad) {");
|
|
harness.AppendLine(" RefRotAxisRadInternal(m, axis, sinf(rad), cosf(rad));");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static void RefQuat(float* m, const float* q) {");
|
|
harness.AppendLine(" const float x = q[0], y = q[1], z = q[2], w = q[3];");
|
|
harness.AppendLine(" const float norm = x*x + y*y + z*z + w*w;\n const float s = norm == 0.0f ? 0.0f : (2.0f / norm);\n m[0] = 1.0f - (y*y + z*z) * s;\n m[1] = (x*y - z*w) * s;\n m[2] = (x*z + y*w) * s;\n m[3] = 0.0f;\n m[4] = (x*y + z*w) * s;\n m[5] = 1.0f - (x*x + z*z) * s;\n m[6] = (y*z - x*w) * s;\n m[7] = 0.0f;\n m[8] = (x*z - y*w) * s;\n m[9] = (y*z + x*w) * s;\n m[10] = 1.0f - (x*x + y*y) * s;\n m[11] = 0.0f;\n}");
|
|
harness.AppendLine("static void RefConcat(const float* a, const float* b, float* out) {");
|
|
harness.AppendLine(" for (int r = 0; r < 3; ++r) {\n const int r0 = r * 4;\n out[r0 + 0] = a[r0 + 0] * b[0] + a[r0 + 1] * b[4] + a[r0 + 2] * b[8];\n out[r0 + 1] = a[r0 + 0] * b[1] + a[r0 + 1] * b[5] + a[r0 + 2] * b[9];\n out[r0 + 2] = a[r0 + 0] * b[2] + a[r0 + 1] * b[6] + a[r0 + 2] * b[10];\n out[r0 + 3] = a[r0 + 0] * b[3] + a[r0 + 1] * b[7] + a[r0 + 2] * b[11] + a[r0 + 3];\n }\n}");
|
|
harness.AppendLine("static void RefConcatArray(const float* a, const float* b, float* out, int count) {");
|
|
harness.AppendLine(" for (int i = 0; i < count; ++i) { RefConcat(a, b + i * 12, out + i * 12); }");
|
|
harness.AppendLine("}");
|
|
harness.AppendLine("static bool RefInverse(const float* src, float* inv) {");
|
|
harness.AppendLine(" const float a00 = src[0], a01 = src[1], a02 = src[2];\n const float a10 = src[4], a11 = src[5], a12 = src[6];\n const float a20 = src[8], a21 = src[9], a22 = src[10];\n const float b00 = a11 * a22 - a12 * a21;\n const float b01 = a12 * a20 - a10 * a22;\n const float b02 = a10 * a21 - a11 * a20;\n const float det = a00 * b00 + a01 * b01 + a02 * b02;\n if (det == 0.0f) { return false; }\n const float invDet = 1.0f / det;\n const float r00 = b00 * invDet;\n const float r01 = (a02 * a21 - a01 * a22) * invDet;\n const float r02 = (a01 * a12 - a02 * a11) * invDet;\n const float r10 = b01 * invDet;\n const float r11 = (a00 * a22 - a02 * a20) * invDet;\n const float r12 = (a02 * a10 - a00 * a12) * invDet;\n const float r20 = b02 * invDet;\n const float r21 = (a01 * a20 - a00 * a21) * invDet;\n const float r22 = (a00 * a11 - a01 * a10) * invDet;\n inv[0] = r00; inv[1] = r01; inv[2] = r02;\n inv[4] = r10; inv[5] = r11; inv[6] = r12;\n inv[8] = r20; inv[9] = r21; inv[10] = r22;\n inv[3] = -(r00 * src[3] + r01 * src[7] + r02 * src[11]);\n inv[7] = -(r10 * src[3] + r11 * src[7] + r12 * src[11]);\n inv[11] = -(r20 * src[3] + r21 * src[7] + r22 * src[11]);\n return true;\n}");
|
|
harness.AppendLine("static bool RefInvXpose(const float* src, float* out) {");
|
|
harness.AppendLine(" const float a00 = src[0], a01 = src[1], a02 = src[2];\n const float a10 = src[4], a11 = src[5], a12 = src[6];\n const float a20 = src[8], a21 = src[9], a22 = src[10];\n const float c00 = a11 * a22 - a12 * a21;\n const float c01 = a12 * a20 - a10 * a22;\n const float c02 = a10 * a21 - a11 * a20;\n const float c10 = a02 * a21 - a01 * a22;\n const float c11 = a00 * a22 - a02 * a20;\n const float c12 = a01 * a20 - a00 * a21;\n const float c20 = a01 * a12 - a02 * a11;\n const float c21 = a02 * a10 - a00 * a12;\n const float c22 = a00 * a11 - a01 * a10;\n const float det = a00 * c00 + a01 * c01 + a02 * c02;\n if (det == 0.0f) { return false; }\n const float invDet = 1.0f / det;\n out[0] = c00 * invDet; out[1] = c01 * invDet; out[2] = c02 * invDet; out[3] = 0.0f;\n out[4] = c10 * invDet; out[5] = c11 * invDet; out[6] = c12 * invDet; out[7] = 0.0f;\n out[8] = c20 * invDet; out[9] = c21 * invDet; out[10] = c22 * invDet; out[11] = 0.0f;\n return true;\n}");
|
|
harness.AppendLine("static void RefTransApply(const float* src, float* dst, float x, float y, float z) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) dst[i] = src[i];\n dst[3] += x; dst[7] += y; dst[11] += z;\n}");
|
|
harness.AppendLine("static void RefScaleApply(const float* src, float* dst, float x, float y, float z) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) dst[i] = src[i];\n for (int c = 0; c < 4; ++c) { dst[c] *= x; dst[4 + c] *= y; dst[8 + c] *= z; }\n}");
|
|
harness.AppendLine("static void RefMultVec(const float* m, const float* v, float* out) {");
|
|
harness.AppendLine(" out[0] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];\n out[1] = m[4] * v[0] + m[5] * v[1] + m[6] * v[2] + m[7];\n out[2] = m[8] * v[0] + m[9] * v[1] + m[10] * v[2] + m[11];\n}");
|
|
harness.AppendLine("static void RefMultVecSR(const float* m, const float* v, float* out) {");
|
|
harness.AppendLine(" out[0] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2];\n out[1] = m[4] * v[0] + m[5] * v[1] + m[6] * v[2];\n out[2] = m[8] * v[0] + m[9] * v[1] + m[10] * v[2];\n}");
|
|
harness.AppendLine("static void RefLookAt(float* m, const float* camPos, const float* camUp, const float* target) {");
|
|
harness.AppendLine(" float f[3] = { camPos[0] - target[0], camPos[1] - target[1], camPos[2] - target[2] };\n auto norm = [](float* v) { float len = std::sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); if (len != 0.0f) { v[0] /= len; v[1] /= len; v[2] /= len; } };\n norm(f);\n float s[3] = { camUp[1] * f[2] - camUp[2] * f[1], camUp[2] * f[0] - camUp[0] * f[2], camUp[0] * f[1] - camUp[1] * f[0] };\n norm(s);\n float u[3] = { f[1] * s[2] - f[2] * s[1], f[2] * s[0] - f[0] * s[2], f[0] * s[1] - f[1] * s[0] };\n m[0] = s[0]; m[1] = s[1]; m[2] = s[2]; m[3] = -(camPos[0]*s[0] + camPos[1]*s[1] + camPos[2]*s[2]);\n m[4] = u[0]; m[5] = u[1]; m[6] = u[2]; m[7] = -(camPos[0]*u[0] + camPos[1]*u[1] + camPos[2]*u[2]);\n m[8] = f[0]; m[9] = f[1]; m[10] = f[2]; m[11] = -(camPos[0]*f[0] + camPos[1]*f[1] + camPos[2]*f[2]);\n}");
|
|
harness.AppendLine("static void RefFrustum(float* m, float t, float b, float l, float r, float n, float f) {");
|
|
harness.AppendLine(" for (int i = 0; i < 16; ++i) m[i] = 0.0f;\n const float invRL = 1.0f / (r - l);\n const float invTB = 1.0f / (t - b);\n const float invFN = 1.0f / (f - n);\n m[0] = 2.0f * n * invRL;\n m[5] = 2.0f * n * invTB;\n m[2] = (r + l) * invRL;\n m[6] = (t + b) * invTB;\n m[10] = -n * invFN;\n m[11] = -(f * n) * invFN;\n m[14] = -1.0f;\n}");
|
|
harness.AppendLine("static void RefPerspective(float* m, float fovY, float aspect, float n, float f) {");
|
|
harness.AppendLine(" for (int i = 0; i < 16; ++i) m[i] = 0.0f;\n const float fov = 0.5f * (3.14159265358979323846f / 180.0f) * fovY;\n const float cot = 1.0f / tanf(fov);\n const float invFN = 1.0f / (f - n);\n m[0] = cot / aspect;\n m[5] = cot;\n m[10] = -n * invFN;\n m[11] = -(f * n) * invFN;\n m[14] = -1.0f;\n}");
|
|
harness.AppendLine("static void RefOrtho(float* m, float t, float b, float l, float r, float n, float f) {");
|
|
harness.AppendLine(" for (int i = 0; i < 16; ++i) m[i] = 0.0f;\n const float invRL = 1.0f / (r - l);\n const float invTB = 1.0f / (t - b);\n const float invFN = 1.0f / (f - n);\n m[0] = 2.0f * invRL;\n m[3] = -(r + l) * invRL;\n m[5] = 2.0f * invTB;\n m[7] = -(t + b) * invTB;\n m[10] = -1.0f * invFN;\n m[11] = -f * invFN;\n m[15] = 1.0f;\n}");
|
|
harness.AppendLine("static void RefLightPerspective(float* m, float fovY, float aspect, float scaleS, float scaleT, float transS, float transT) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) m[i] = 0.0f;\n const float fov = 0.5f * (3.14159265358979323846f / 180.0f) * fovY;\n const float cot = 1.0f / tanf(fov);\n m[0] = scaleS * (cot / aspect);\n m[5] = scaleT * cot;\n m[2] = -transS;\n m[6] = -transT;\n m[10] = -1.0f;\n}");
|
|
harness.AppendLine("static void RefLightFrustum(float* m, float t, float b, float l, float r, float n, float scaleS, float scaleT, float transS, float transT) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) m[i] = 0.0f;\n const float invRL = 1.0f / (r - l);\n const float invTB = 1.0f / (t - b);\n m[0] = scaleS * (2.0f * n * invRL);\n m[2] = scaleS * (invRL * (r + l)) - transS;\n m[5] = scaleT * (2.0f * n * invTB);\n m[6] = scaleT * (invTB * (t + b)) - transT;\n m[10] = -1.0f;\n}");
|
|
harness.AppendLine("static void RefLightOrtho(float* m, float t, float b, float l, float r, float scaleS, float scaleT, float transS, float transT) {");
|
|
harness.AppendLine(" for (int i = 0; i < 12; ++i) m[i] = 0.0f;\n const float invRL = 1.0f / (r - l);\n const float invTB = 1.0f / (t - b);\n m[0] = scaleS * (2.0f * invRL);\n m[3] = transS + scaleS * (invRL * -(r + l));\n m[5] = scaleT * (2.0f * invTB);\n m[7] = transT + scaleT * (invTB * -(t + b));\n m[11] = 1.0f;\n}");
|
|
|
|
harness.AppendLine("int main() {");
|
|
harness.AppendLine(" std::puts(\"mtx harness start\");");
|
|
harness.AppendLine(" Memory::Init(0x02000000);");
|
|
harness.AppendLine(" InitializeDataSections();");
|
|
harness.AppendLine(" CpuContext g_cpu{};");
|
|
harness.AppendLine(" g_cpu.gpr[1] = 0x81700000;");
|
|
harness.AppendLine(" g_cpu.gpr[2] = RuntimeConfig::SDA2_BASE;");
|
|
harness.AppendLine(" g_cpu.gpr[13] = RuntimeConfig::SDA1_BASE;");
|
|
harness.AppendLine(" CpuContextScope cpuScope(&g_cpu);");
|
|
harness.AppendLine(" const uint32_t base = 0x80000000;");
|
|
harness.AppendLine(" const uint32_t matA = base + 0x100;");
|
|
harness.AppendLine(" const uint32_t matB = base + 0x200;");
|
|
harness.AppendLine(" const uint32_t matC = base + 0x300;");
|
|
harness.AppendLine(" const uint32_t matD = base + 0x400;");
|
|
harness.AppendLine(" const uint32_t matArr = base + 0x500;");
|
|
harness.AppendLine(" const uint32_t vecA = base + 0x800;");
|
|
harness.AppendLine(" const uint32_t vecB = base + 0x820;");
|
|
harness.AppendLine(" const uint32_t vecC = base + 0x840;");
|
|
harness.AppendLine(" const uint32_t quatA = base + 0x900;");
|
|
harness.AppendLine(" const uint32_t quatB = base + 0x920;");
|
|
harness.AppendLine(" const uint32_t quatC = base + 0x940;");
|
|
harness.AppendLine(" const uint32_t mat44A = base + 0xA00;");
|
|
harness.AppendLine(" const uint32_t mat44B = base + 0xB00;");
|
|
harness.AppendLine(" float a[12] = { 1.2f, 0.3f, -0.7f, 2.0f, -0.4f, 1.5f, 0.25f, -1.0f, 0.8f, -0.2f, 1.1f, 0.5f };");
|
|
harness.AppendLine(" float b[12] = { 0.9f, -0.1f, 0.4f, -0.3f, 0.2f, 1.3f, -0.6f, 0.7f, -0.5f, 0.8f, 1.2f, -0.9f };");
|
|
harness.AppendLine(" float c[12] = { -0.2f, 1.1f, 0.0f, 0.3f, 0.4f, -0.7f, 0.9f, -0.1f, 0.6f, 0.2f, 1.3f, -0.8f };");
|
|
harness.AppendLine(" float vec[3] = { 1.0f, 2.0f, -3.0f };");
|
|
harness.AppendLine(" float vecOut[3] = { 0.0f, 0.0f, 0.0f };");
|
|
harness.AppendLine(" float quat[4] = { 0.2f, -0.5f, 0.3f, 0.7f };");
|
|
harness.AppendLine(" float zero34[12] = {};");
|
|
harness.AppendLine(" float zero44[16] = {};");
|
|
|
|
// PSMTXIdentity
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefIdentity(exp); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXIdentity_80199d04", new[] { "matA" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXIdentity\"); }");
|
|
|
|
// PSMTXCopy
|
|
harness.AppendLine(" { float got[12]; WriteMat34(matA, a); WriteMat34(matB, b);");
|
|
EmitCall(harness, specs, "PSMTXCopy_80199d30", new[] { "matA", "matB" });
|
|
harness.AppendLine(" ReadMat34(matB, got); ExpectMat34(got, a, \"PSMTXCopy\"); }");
|
|
|
|
// PSMTXConcat
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefConcat(a, b, exp); WriteMat34(matA, a); WriteMat34(matB, b);");
|
|
EmitCall(harness, specs, "PSMTXConcat_80199d64", new[] { "matA", "matB", "matC" });
|
|
harness.AppendLine(" ReadMat34(matC, got); ExpectMat34(got, exp, \"PSMTXConcat\"); }");
|
|
|
|
// PSMTXConcatArray
|
|
harness.AppendLine(" { float got[24]; float exp[24]; WriteMat34(matA, a); WriteMat34(matArr, b); WriteMat34(matArr + 0x30, c);\n RefConcat(a, b, exp);\n RefConcat(a, c, exp + 12);\n for (int i = 0; i < 24; ++i) got[i] = 0.0f;\n WriteMat34(matC, zero34);\n WriteMat34(matC + 0x30, zero34);\n ");
|
|
EmitCall(harness, specs, "PSMTXConcatArray_80199e30", new[] { "matA", "matArr", "matC", "2" });
|
|
harness.AppendLine(" ReadMat34(matC, got); ReadMat34(matC + 0x30, got + 12); ExpectMat34(got, exp, \"PSMTXConcatArray[0]\"); ExpectMat34(got + 12, exp + 12, \"PSMTXConcatArray[1]\"); }");
|
|
|
|
// PSMTXInverse
|
|
harness.AppendLine(" { float got[12]; float exp[12]; WriteMat34(matA, a);\n bool ok = RefInverse(a, exp);\n assert(ok);\n");
|
|
EmitCall(harness, specs, "PSMTXInverse_80199fc8", new[] { "matA", "matB" }, resultVar: "ret");
|
|
harness.AppendLine(" ReadMat34(matB, got); ExpectMat34(got, exp, \"PSMTXInverse\"); assert(ret == 1); }");
|
|
|
|
// PSMTXInvXpose
|
|
harness.AppendLine(" { float got[12]; float exp[12]; WriteMat34(matA, a);\n bool ok = RefInvXpose(a, exp);\n assert(ok);\n");
|
|
EmitCall(harness, specs, "PSMTXInvXpose_8019a0c0", new[] { "matA", "matB" }, resultVar: "ret");
|
|
harness.AppendLine(" ReadMat34(matB, got); ExpectMat34(got, exp, \"PSMTXInvXpose\"); assert(ret == 1); }");
|
|
|
|
// PSMTXRotRad
|
|
harness.AppendLine(" { float got[12]; float exp[12]; const float rad = 0.7f; RefRotRad(exp, 'y', rad);\n WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXRotRad_8019a188", new[] { "matA", "'y'", "rad" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXRotRad\"); }");
|
|
|
|
// PSMTXRotTrig (test x,y,z)
|
|
harness.AppendLine(" { float got[12]; float exp[12]; const float rad = 0.4f; const float s = sinf(rad); const float c = cosf(rad);\n");
|
|
harness.AppendLine(" RefRotTrig(exp, 'x', s, c); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXRotTrig_8019a204", new[] { "matA", "'x'", "s", "c" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXRotTrigX\");\n RefRotTrig(exp, 'z', s, c); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXRotTrig_8019a204", new[] { "matA", "'z'", "s", "c" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXRotTrigZ\"); }");
|
|
|
|
// PSMTXRotAxisRadInternal
|
|
harness.AppendLine(" { float got[12]; float exp[12]; float axis[3] = { 1.0f, 2.0f, 3.0f }; const float rad = 0.9f;\n const float s = sinf(rad); const float c0 = cosf(rad); RefRotAxisRadInternal(exp, axis, s, c0);\n WriteVec3(vecA, axis); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXRotAxisRadInternal_8019a2b4", new[] { "matA", "vecA", "s", "c0" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXRotAxisRadInternal\"); }");
|
|
|
|
// PSMTXRotAxisRad
|
|
harness.AppendLine(" { float got[12]; float exp[12]; float axis[3] = { -0.5f, 1.3f, 0.8f }; const float rad = -0.6f; RefRotAxisRad(exp, axis, rad);\n WriteVec3(vecA, axis); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXRotAxisRad_8019a364", new[] { "matA", "vecA", "rad" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXRotAxisRad\"); }");
|
|
|
|
// PSMTXTrans
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefTrans(exp, 1.5f, -2.0f, 0.75f);\n WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXTrans_8019a3e0", new[] { "matA", "1.5f", "-2.0f", "0.75f" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXTrans\"); }");
|
|
|
|
// PSMTXTransApply
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefTransApply(a, exp, 0.25f, -0.5f, 1.2f); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXTransApply_8019a414", new[] { "matA", "matB", "0.25f", "-0.5f", "1.2f" });
|
|
harness.AppendLine(" ReadMat34(matB, got); ExpectMat34(got, exp, \"PSMTXTransApply\"); }");
|
|
|
|
// PSMTXScale
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefScale(exp, 2.0f, 0.5f, -1.5f); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXScale_8019a460", new[] { "matA", "2.0f", "0.5f", "-1.5f" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXScale\"); }");
|
|
|
|
// PSMTXScaleApply
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefScaleApply(a, exp, 1.1f, -0.7f, 0.6f); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXScaleApply_8019a488", new[] { "matA", "matB", "1.1f", "-0.7f", "0.6f" });
|
|
harness.AppendLine(" ReadMat34(matB, got); ExpectMat34(got, exp, \"PSMTXScaleApply\"); }");
|
|
|
|
// PSMTXQuat
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefQuat(exp, quat);\n WriteF32(quatA + 0, quat[0]); WriteF32(quatA + 4, quat[1]); WriteF32(quatA + 8, quat[2]); WriteF32(quatA + 12, quat[3]);\n WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "PSMTXQuat_8019a4e0", new[] { "matA", "quatA" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"PSMTXQuat\"); }");
|
|
|
|
// C_MTXLookAt
|
|
harness.AppendLine(" { float got[12]; float exp[12]; float camPos[3] = { 1.0f, 2.0f, 3.0f }; float camUp[3] = { 0.0f, 1.0f, 0.0f }; float target[3] = { 0.0f, 0.0f, 0.0f };\n RefLookAt(exp, camPos, camUp, target); WriteVec3(vecA, camPos); WriteVec3(vecB, camUp); WriteVec3(vecC, target);\n WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "C_MTXLookAt_8019a584", new[] { "matA", "vecA", "vecB", "vecC" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"C_MTXLookAt\"); }");
|
|
|
|
// C_MTXLightPerspective
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefLightPerspective(exp, 30.0f, 1.2f, 0.5f, 0.75f, 0.5f, 0.25f); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "C_MTXLightPerspective_8019a79c", new[] { "matA", "30.0f", "1.2f", "0.5f", "0.75f", "0.5f", "0.25f" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"C_MTXLightPerspective\"); }");
|
|
|
|
// C_MTXLightFrustum (with stack arg for transT)
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefLightFrustum(exp, 1.2f, -0.8f, -1.0f, 1.4f, 0.6f, 0.5f, 0.5f, 0.4f, 0.6f); WriteMat34(matA, a);\n WriteF32(g_cpu.gpr[1] + 8, 0.6f);");
|
|
EmitCall(harness, specs, "C_MTXLightFrustum_8019a6f8", new[] { "matA", "1.2f", "-0.8f", "-1.0f", "1.4f", "0.6f", "0.5f", "0.5f", "0.4f" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"C_MTXLightFrustum\"); }");
|
|
|
|
// C_MTXLightOrtho
|
|
harness.AppendLine(" { float got[12]; float exp[12]; RefLightOrtho(exp, 1.0f, -1.0f, -2.0f, 2.0f, 0.5f, 0.7f, 0.2f, 0.3f); WriteMat34(matA, a);");
|
|
EmitCall(harness, specs, "C_MTXLightOrtho_8019a894", new[] { "matA", "1.0f", "-1.0f", "-2.0f", "2.0f", "0.5f", "0.7f", "0.2f", "0.3f" });
|
|
harness.AppendLine(" ReadMat34(matA, got); ExpectMat34(got, exp, \"C_MTXLightOrtho\"); }");
|
|
|
|
// PSMTXMultVec
|
|
harness.AppendLine(" { float got[3]; float exp[3]; RefMultVec(a, vec, exp); WriteMat34(matA, a); WriteVec3(vecA, vec);\n");
|
|
EmitCall(harness, specs, "PSMTXMultVec_8019a91c", new[] { "matA", "vecA", "vecB" });
|
|
harness.AppendLine(" ReadVec3(vecB, got); for (int i = 0; i < 3; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSMTXMultVec mismatch %d\\n\", i); assert(false);} } }");
|
|
|
|
// PSMTXMultVecSR
|
|
harness.AppendLine(" { float got[3]; float exp[3]; RefMultVecSR(a, vec, exp); WriteMat34(matA, a); WriteVec3(vecA, vec);\n");
|
|
EmitCall(harness, specs, "PSMTXMultVecSR_8019a970", new[] { "matA", "vecA", "vecB" });
|
|
harness.AppendLine(" ReadVec3(vecB, got); for (int i = 0; i < 3; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSMTXMultVecSR mismatch %d\\n\", i); assert(false);} } }");
|
|
|
|
// C_MTXFrustum
|
|
harness.AppendLine(" { float got[16]; float exp[16]; RefFrustum(exp, 1.0f, -1.0f, -1.5f, 1.5f, 1.0f, 10.0f);\n WriteMat44(mat44A, zero44);");
|
|
EmitCall(harness, specs, "C_MTXFrustum_8019a9c4", new[] { "mat44A", "1.0f", "-1.0f", "-1.5f", "1.5f", "1.0f", "10.0f" });
|
|
harness.AppendLine(" ReadMat44(mat44A, got); ExpectMat44(got, exp, \"C_MTXFrustum\"); }");
|
|
|
|
// C_MTXPerspective
|
|
harness.AppendLine(" { float got[16]; float exp[16]; RefPerspective(exp, 60.0f, 1.3333f, 1.0f, 100.0f);\n WriteMat44(mat44A, zero44);");
|
|
EmitCall(harness, specs, "C_MTXPerspective_8019aa60", new[] { "mat44A", "60.0f", "1.3333f", "1.0f", "100.0f" });
|
|
harness.AppendLine(" ReadMat44(mat44A, got); ExpectMat44(got, exp, \"C_MTXPerspective\"); }");
|
|
|
|
// C_MTXOrtho
|
|
harness.AppendLine(" { float got[16]; float exp[16]; RefOrtho(exp, 1.0f, -1.0f, -2.0f, 2.0f, 0.5f, 20.0f);\n WriteMat44(mat44A, zero44);");
|
|
EmitCall(harness, specs, "C_MTXOrtho_8019ab4c", new[] { "mat44A", "1.0f", "-1.0f", "-2.0f", "2.0f", "0.5f", "20.0f" });
|
|
harness.AppendLine(" ReadMat44(mat44A, got); ExpectMat44(got, exp, \"C_MTXOrtho\"); }");
|
|
|
|
// MTX__PSVECAdd
|
|
harness.AppendLine(" { float aV[3] = { 1.0f, 2.0f, 3.0f }; float bV[3] = { 4.0f, -5.0f, 6.0f }; float got[3]; float exp[3] = { 5.0f, -3.0f, 9.0f };");
|
|
harness.AppendLine(" WriteVec3(vecA, aV); WriteVec3(vecB, bV);");
|
|
EmitCall(harness, specs, "MTX__PSVECAdd_8019abe4", new[] { "vecA", "vecB", "vecC" });
|
|
harness.AppendLine(" ReadVec3(vecC, got); for (int i = 0; i < 3; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSVECAdd mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__PSVECScale
|
|
harness.AppendLine(" { float src[3] = { 1.5f, -2.0f, 3.0f }; float got[3]; float exp[3] = { 3.0f, -4.0f, 6.0f };");
|
|
harness.AppendLine(" WriteVec3(vecA, src);");
|
|
EmitCall(harness, specs, "MTX__PSVECScale_8019ac08", new[] { "vecA", "vecB", "2.0f" });
|
|
harness.AppendLine(" ReadVec3(vecB, got); for (int i = 0; i < 3; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSVECScale mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__PSVECNormalize
|
|
harness.AppendLine(" { float src[3] = { 3.0f, 4.0f, 0.0f }; float got[3]; float exp[3]; VecNormalize(src, exp);");
|
|
harness.AppendLine(" WriteVec3(vecA, src);");
|
|
EmitCall(harness, specs, "MTX__PSVECNormalize_8019ac24", new[] { "vecA", "vecB" });
|
|
harness.AppendLine(" ReadVec3(vecB, got); for (int i = 0; i < 3; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSVECNormalize mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__PSVECMag
|
|
harness.AppendLine(" { float src[3] = { 3.0f, 4.0f, 0.0f }; WriteVec3(vecA, src);");
|
|
EmitCall(harness, specs, "MTX__PSVECMag_8019ac68", new[] { "vecA" });
|
|
harness.AppendLine(" const float got = ReadFprFloat(g_cpu, 1); const float exp = VecMag(src); if (!Near(got, exp)) { std::printf(\"[mtx] PSVECMag mismatch got %.6f exp %.6f\\n\", got, exp); assert(false); } }");
|
|
|
|
// MTX__PSVECDotProduct
|
|
harness.AppendLine(" { float aV[3] = { 1.0f, 2.0f, 3.0f }; float bV[3] = { 4.0f, -5.0f, 6.0f }; WriteVec3(vecA, aV); WriteVec3(vecB, bV);");
|
|
EmitCall(harness, specs, "MTX__PSVECDotProduct_8019acac", new[] { "vecA", "vecB" });
|
|
harness.AppendLine(" const float got = ReadFprPs0(g_cpu, 1); const float exp = VecDot(aV, bV); if (!Near(got, exp)) { std::printf(\"[mtx] PSVECDotProduct mismatch got %.6f exp %.6f\\n\", got, exp); assert(false); } }");
|
|
|
|
// MTX__PSVECCrossProduct
|
|
harness.AppendLine(" { float aV[3] = { 1.0f, 0.0f, 0.0f }; float bV[3] = { 0.0f, 1.0f, 0.0f }; float got[3]; float exp[3]; VecCross(aV, bV, exp);");
|
|
harness.AppendLine(" WriteVec3(vecA, aV); WriteVec3(vecB, bV);");
|
|
EmitCall(harness, specs, "MTX__PSVECCrossProduct_8019accc", new[] { "vecA", "vecB", "vecC" });
|
|
harness.AppendLine(" ReadVec3(vecC, got); for (int i = 0; i < 3; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSVECCrossProduct mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__C_VECHalfAngle
|
|
harness.AppendLine(" { float aV[3] = { 1.0f, 0.0f, 0.0f }; float bV[3] = { 0.0f, 1.0f, 0.0f }; float got[3]; float exp[3]; VecHalfAngle(aV, bV, exp);");
|
|
harness.AppendLine(" WriteVec3(vecA, aV); WriteVec3(vecB, bV);");
|
|
EmitCall(harness, specs, "MTX__C_VECHalfAngle_8019ad08", new[] { "vecA", "vecB", "vecC" });
|
|
harness.AppendLine(" ReadVec3(vecC, got); for (int i = 0; i < 3; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] C_VECHalfAngle mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__PSVECSquareDistance
|
|
harness.AppendLine(" { float aV[3] = { 1.0f, 2.0f, 3.0f }; float bV[3] = { 4.0f, -2.0f, 6.0f }; WriteVec3(vecA, aV); WriteVec3(vecB, bV);");
|
|
EmitCall(harness, specs, "MTX__PSVECSquareDistance_8019ade0", new[] { "vecA", "vecB" });
|
|
harness.AppendLine(" const float got = ReadFprPs0(g_cpu, 1); const float exp = VecSquareDistance(aV, bV); if (!Near(got, exp)) { std::printf(\"[mtx] PSVECSquareDistance mismatch got %.6f exp %.6f\\n\", got, exp); assert(false); } }");
|
|
|
|
// MTX__PSQUATMultiply
|
|
harness.AppendLine(" { float aQ[4] = { 0.1f, 0.2f, 0.3f, 0.9f }; float bQ[4] = { -0.3f, 0.5f, 0.1f, 0.8f }; float got[4]; float exp[4]; QuatMul(aQ, bQ, exp);");
|
|
harness.AppendLine(" WriteQuat(quatA, aQ); WriteQuat(quatB, bQ);");
|
|
EmitCall(harness, specs, "MTX__PSQUATMultiply_8019ae08", new[] { "quatA", "quatB", "quatC" });
|
|
harness.AppendLine(" ReadQuat(quatC, got); for (int i = 0; i < 4; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSQUATMultiply mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__PSQUATScale
|
|
harness.AppendLine(" { float src[4] = { 1.0f, -2.0f, 3.0f, -4.0f }; float got[4]; float exp[4] = { 0.5f, -1.0f, 1.5f, -2.0f };");
|
|
harness.AppendLine(" WriteQuat(quatA, src);");
|
|
EmitCall(harness, specs, "MTX__PSQUATScale_8019ae64", new[] { "quatA", "quatB", "0.5f" });
|
|
harness.AppendLine(" ReadQuat(quatB, got); for (int i = 0; i < 4; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSQUATScale mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__PSQUATDotProduct
|
|
harness.AppendLine(" { float aQ[4] = { 1.0f, 2.0f, 3.0f, 4.0f }; float bQ[4] = { -2.0f, 0.5f, 1.0f, -1.5f }; WriteQuat(quatA, aQ); WriteQuat(quatB, bQ);");
|
|
EmitCall(harness, specs, "MTX__PSQUATDotProduct_8019ae80", new[] { "quatA", "quatB" });
|
|
harness.AppendLine(" const float got = ReadFprPs0(g_cpu, 1); const float exp = QuatDot(aQ, bQ); if (!Near(got, exp)) { std::printf(\"[mtx] PSQUATDotProduct mismatch got %.6f exp %.6f\\n\", got, exp); assert(false); } }");
|
|
|
|
// MTX__PSQUATNormalize
|
|
harness.AppendLine(" { float src[4] = { 0.0f, 0.0f, 0.0f, 2.0f }; float got[4]; float exp[4]; QuatNormalize(src, exp);");
|
|
harness.AppendLine(" WriteQuat(quatA, src);");
|
|
EmitCall(harness, specs, "MTX__PSQUATNormalize_8019aea0", new[] { "quatA", "quatB" });
|
|
harness.AppendLine(" ReadQuat(quatB, got); for (int i = 0; i < 4; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSQUATNormalize mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__PSQUATInverse
|
|
harness.AppendLine(" { float src[4] = { 0.2f, -0.3f, 0.4f, 0.5f }; float got[4]; float exp[4]; QuatInverse(src, exp);");
|
|
harness.AppendLine(" WriteQuat(quatA, src);");
|
|
EmitCall(harness, specs, "MTX__PSQUATInverse_8019aef4", new[] { "quatA", "quatB" });
|
|
harness.AppendLine(" ReadQuat(quatB, got); for (int i = 0; i < 4; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] PSQUATInverse mismatch %d got %.6f exp %.6f\\n\", i, got[i], exp[i]); assert(false); } } }");
|
|
|
|
// MTX__C_QUATMtx
|
|
harness.AppendLine(" { float ident[12] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f }; float got[4]; float exp[4] = { 0.0f, 0.0f, 0.0f, 1.0f };");
|
|
harness.AppendLine(" WriteMat34(matA, ident);");
|
|
EmitCall(harness, specs, "MTX__C_QUATMtx_8019af48", new[] { "quatA", "matA" });
|
|
harness.AppendLine(" ReadQuat(quatA, got); for (int i = 0; i < 4; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] C_QUATMtx mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__C_QUATLerp
|
|
harness.AppendLine(" { float aQ[4] = { 0.0f, 0.5f, 0.0f, 0.5f }; float bQ[4] = { 1.0f, -0.5f, 0.5f, 0.0f }; float got[4]; float exp[4]; QuatLerp(aQ, bQ, 0.25f, exp);");
|
|
harness.AppendLine(" WriteQuat(quatA, aQ); WriteQuat(quatB, bQ);");
|
|
EmitCall(harness, specs, "MTX__C_QUATLerp_8019b114", new[] { "quatA", "quatB", "quatC", "0.25f" });
|
|
harness.AppendLine(" ReadQuat(quatC, got); for (int i = 0; i < 4; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] C_QUATLerp mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
// MTX__C_QUATSlerp
|
|
harness.AppendLine(" { float aQ[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; float bQ[4] = { 0.1f, 0.2f, 0.3f, 0.9f }; float got[4]; float exp[4]; QuatSlerp(aQ, bQ, 0.5f, exp);");
|
|
harness.AppendLine(" WriteQuat(quatA, aQ); WriteQuat(quatB, bQ);");
|
|
EmitCall(harness, specs, "MTX__C_QUATSlerp_8019b178", new[] { "quatA", "quatB", "quatC", "0.5f" });
|
|
harness.AppendLine(" ReadQuat(quatC, got); for (int i = 0; i < 4; ++i) { if (!Near(got[i], exp[i])) { std::printf(\"[mtx] C_QUATSlerp mismatch %d\\n\", i); assert(false); } } }");
|
|
|
|
harness.AppendLine(" return 0;");
|
|
harness.AppendLine("}");
|
|
|
|
var harnessPath = Path.Combine(tempRoot, "harness_mtx.cpp");
|
|
File.WriteAllText(harnessPath, harness.ToString());
|
|
|
|
var root = RepositoryRoot;
|
|
var runnerBasePath = Path.Combine(tempRoot, "runner_mtx");
|
|
var compileArgs = TranslatorCppTestHarness.BuildCompileArguments(root, tempRoot, generatedFiles, harnessPath, runnerBasePath);
|
|
compileArgs += " -ldbghelp";
|
|
|
|
Console.WriteLine("[compile] clang++ (mtx)");
|
|
var (exitCode, compileOutput) = RunProcess("clang++", compileArgs.ToString());
|
|
Assert.True(exitCode == 0, $"clang++ failed: {compileOutput}");
|
|
|
|
var runnerPath = runnerBasePath;
|
|
if (OperatingSystem.IsWindows() && !File.Exists(runnerPath))
|
|
{
|
|
runnerPath += ".exe";
|
|
}
|
|
|
|
Console.WriteLine($"[run] {runnerPath}");
|
|
var (runExitCode, runOutput) = RunProcess(runnerPath, string.Empty, TimeSpan.FromSeconds(60));
|
|
Console.Write(runOutput);
|
|
Assert.True(runExitCode == 0, $"Runner failed (exit code {runExitCode}). Output:\n{runOutput}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Leaf-inlining admission checked against real MTX bodies. Stackless primitives stay eligible,
|
|
/// while <c>PSMTXConcat</c> must not: its 64-byte r1 frame is unsafe to splice into a caller's stack analysis.
|
|
/// </summary>
|
|
[Fact]
|
|
public void LeafInliningRejectsStackFramedMatrixPrimitives()
|
|
{
|
|
var translator = BuildTranslator();
|
|
var options = TranslationOptions.Default with
|
|
{
|
|
AllowUnsupportedInstructions = true
|
|
};
|
|
|
|
LeafInlineCandidate? Classify(uint address, LeafInliningPolicy policy, out LeafInlineRejection rejection)
|
|
{
|
|
var translation = translator.Translate(address, options);
|
|
return LeafFunctionInliner.TryCreateCandidate(
|
|
address, translation.LinearIr, translation.Instructions, policy, out rejection);
|
|
}
|
|
|
|
var shipped = new LeafInliningPolicy(
|
|
MaxCalleeGuestInstructions: TranslationOptions.Default.LeafInliningMaxCalleeInstructions);
|
|
var oldCap = new LeafInliningPolicy(MaxCalleeGuestInstructions: 32);
|
|
|
|
// PSMTXCopy was admitted before the cap moved and must be admitted in
|
|
// exactly the same form afterwards - a flat statement list, not a
|
|
// spliced region - or every caller that already inlines it changes.
|
|
var copy = Classify(0x80199D30u, shipped, out var copyRejection);
|
|
Assert.Equal(LeafInlineRejection.None, copyRejection);
|
|
Assert.NotNull(copy);
|
|
Assert.Null(copy!.Blocks);
|
|
Assert.Equal(13, copy.GuestInstructionCount);
|
|
Classify(0x80199D30u, oldCap, out var copyAtOldCap);
|
|
Assert.Equal(LeafInlineRejection.None, copyAtOldCap);
|
|
|
|
var concat = Classify(0x80199D64u, shipped, out var concatRejection);
|
|
Assert.Equal(LeafInlineRejection.TouchesStackPointer, concatRejection);
|
|
Assert.Null(concat);
|
|
Classify(0x80199D64u, oldCap, out var concatAtOldCap);
|
|
Assert.Equal(LeafInlineRejection.TooLarge, concatAtOldCap);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <c>nw4r::ut::List_GetNext</c> is the acyclic multi-block case: eight guest instructions across
|
|
/// four blocks, a compare/branch and two return arms that must converge on one caller continuation.
|
|
/// </summary>
|
|
[Fact]
|
|
public void LeafInliningAdmitsAnAcyclicMultiBlockListWalker()
|
|
{
|
|
var translator = BuildTranslator();
|
|
var options = TranslationOptions.Default with
|
|
{
|
|
AllowUnsupportedInstructions = true
|
|
};
|
|
var translation = translator.Translate(0x800AF180u, options);
|
|
|
|
var candidate = LeafFunctionInliner.TryCreateCandidate(
|
|
0x800AF180u,
|
|
translation.LinearIr,
|
|
translation.Instructions,
|
|
new LeafInliningPolicy(),
|
|
out var rejection);
|
|
|
|
Assert.Equal(LeafInlineRejection.None, rejection);
|
|
Assert.NotNull(candidate);
|
|
Assert.Equal(8, candidate!.GuestInstructionCount);
|
|
Assert.NotNull(candidate.Blocks);
|
|
Assert.Equal(4, candidate.Blocks!.Count);
|
|
Assert.Equal(2, candidate.Blocks.Count(block => block.Instructions[^1] is IrReturn));
|
|
// Every block leaves through an explicit terminator, so the spliced copy
|
|
// does not depend on where the caller places these blocks.
|
|
Assert.All(
|
|
candidate.Blocks,
|
|
block => Assert.True(block.Instructions[^1] is IrReturn or IrJump or IrBranch));
|
|
|
|
// Turning the shape off puts the callee straight back outside the
|
|
// admissible set.
|
|
LeafFunctionInliner.TryCreateCandidate(
|
|
0x800AF180u,
|
|
translation.LinearIr,
|
|
translation.Instructions,
|
|
new LeafInliningPolicy(AllowAcyclicMultiBlockCallees: false),
|
|
out var withoutMultiBlock);
|
|
Assert.Equal(LeafInlineRejection.ControlFlow, withoutMultiBlock);
|
|
}
|
|
|
|
/// <summary>
|
|
/// <c>EGG::Math::Sqrt</c> looked like a multi-block leaf from a profile, but
|
|
/// it saves the link register and calls out, so no relaxation of the block
|
|
/// shape can admit it. Pinned so a future rule change has to notice.
|
|
/// </summary>
|
|
[Fact]
|
|
public void EggMathSqrtIsNotALeafAndStaysRefused()
|
|
{
|
|
var translator = BuildTranslator();
|
|
var options = TranslationOptions.Default with
|
|
{
|
|
AllowUnsupportedInstructions = true
|
|
};
|
|
var translation = translator.Translate(0x8022F80Cu, options);
|
|
|
|
LeafFunctionInliner.TryCreateCandidate(
|
|
0x8022F80Cu,
|
|
translation.LinearIr,
|
|
translation.Instructions,
|
|
new LeafInliningPolicy(),
|
|
out var rejection);
|
|
|
|
Assert.Equal(LeafInlineRejection.TouchesLinkRegister, rejection);
|
|
}
|
|
|
|
private static MtxFuncSpec Spec(uint address, string name, ReturnKind ret, params ParamKind[] paramKinds)
|
|
=> new(address, name, ret, paramKinds);
|
|
|
|
private static void AssertReturnAbiMatches(MtxFuncSpec spec, FunctionAbiClassification classification)
|
|
{
|
|
if (spec.Return == ReturnKind.Void)
|
|
{
|
|
var isFloatReturn = classification.ReturnRepresentation is ValueRepresentation prim && prim.IsFloat;
|
|
Assert.False(isFloatReturn, $"{spec.Name} expected non-float return, got {classification.ReturnRepresentation}.");
|
|
}
|
|
else if (spec.Return == ReturnKind.Float)
|
|
{
|
|
Assert.True(classification.ReturnRepresentation is ValueRepresentation prim && prim.IsFloat,
|
|
$"{spec.Name} expected float return, got {classification.ReturnRepresentation}.");
|
|
}
|
|
else
|
|
{
|
|
Assert.True(classification.ReturnRepresentation is ValueRepresentation prim && !prim.IsFloat,
|
|
$"{spec.Name} expected integer return, got {classification.ReturnRepresentation}.");
|
|
}
|
|
}
|
|
|
|
private static IReadOnlyList<FunctionTranslationResult> TranslateWithDependencies(
|
|
FunctionTranslator translator,
|
|
IEnumerable<(uint Address, string Name)> seeds,
|
|
string outputDirectory,
|
|
List<string> generatedFiles)
|
|
{
|
|
const int MaxTranslations = 256;
|
|
var translations = new List<FunctionTranslationResult>();
|
|
var scheduled = new HashSet<uint>();
|
|
var translated = new HashSet<uint>();
|
|
var queue = new Queue<(uint Address, string Name)>();
|
|
|
|
foreach (var spec in seeds)
|
|
{
|
|
if (scheduled.Add(spec.Address))
|
|
{
|
|
queue.Enqueue(spec);
|
|
}
|
|
}
|
|
|
|
while (queue.Count > 0)
|
|
{
|
|
if (scheduled.Count > MaxTranslations)
|
|
{
|
|
throw new InvalidOperationException($"Auto-translation queue exceeded {MaxTranslations} functions. Check for runaway dependency discovery.");
|
|
}
|
|
|
|
var spec = queue.Dequeue();
|
|
if (translated.Contains(spec.Address))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var preferredName = string.IsNullOrWhiteSpace(spec.Name) ? $"func_{spec.Address:X8}" : spec.Name;
|
|
Console.WriteLine($"[translate] {preferredName} 0x{spec.Address:X8}");
|
|
var result = translator.Translate(spec.Address, new TranslationOptions(preferredName));
|
|
|
|
var classification = result.AbiClassification;
|
|
Console.WriteLine($" [abi] {classification.Name} -> {classification.ReturnRepresentation}");
|
|
|
|
var path = Path.Combine(outputDirectory, $"{result.Name}.cpp");
|
|
File.WriteAllText(path, result.CxxCode);
|
|
generatedFiles.Add(path);
|
|
translations.Add(result);
|
|
translated.Add(result.EntryPoint);
|
|
|
|
foreach (var dependency in DiscoverCallTargets(result))
|
|
{
|
|
if (translated.Contains(dependency))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (scheduled.Add(dependency))
|
|
{
|
|
queue.Enqueue((dependency, $"func_{dependency:X8}"));
|
|
}
|
|
}
|
|
}
|
|
|
|
return translations;
|
|
}
|
|
|
|
private static IEnumerable<uint> DiscoverCallTargets(FunctionTranslationResult translation)
|
|
{
|
|
var discovered = new HashSet<uint>();
|
|
foreach (var block in translation.LinearIr.Blocks)
|
|
{
|
|
foreach (var instruction in block.Instructions)
|
|
{
|
|
if (instruction is not IrCall call)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(call.Target) || !call.Target.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!uint.TryParse(call.Target.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var address))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (address == translation.EntryPoint)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (discovered.Add(address))
|
|
{
|
|
yield return address;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string PrototypeFor(FunctionAbiClassification signature)
|
|
{
|
|
return $"extern \"C\" void {signature.Name}(CpuContext* ctx);";
|
|
}
|
|
|
|
private static void EmitCall(StringBuilder sb, IReadOnlyList<MtxFuncSpec> specs, string name, string[] args, string? resultVar = null)
|
|
{
|
|
var spec = specs.Single(s => s.Name == name);
|
|
var gprIndex = 3;
|
|
var fprIndex = 1;
|
|
|
|
for (int i = 0; i < spec.Params.Count; i++)
|
|
{
|
|
var arg = args.Length > i ? args[i] : "0";
|
|
if (spec.Params[i] == ParamKind.Fpr)
|
|
{
|
|
sb.AppendLine($" g_cpu.fpr[{fprIndex}].d = {arg};");
|
|
fprIndex++;
|
|
}
|
|
else
|
|
{
|
|
sb.AppendLine($" g_cpu.gpr[{gprIndex}] = ToGpr({arg});");
|
|
gprIndex++;
|
|
}
|
|
}
|
|
|
|
sb.AppendLine($" {name}(&g_cpu);");
|
|
if (!string.IsNullOrWhiteSpace(resultVar))
|
|
{
|
|
sb.AppendLine($" auto {resultVar} = g_cpu.gpr[3];");
|
|
}
|
|
}
|
|
}
|