@fraczak/k 7.0.1 → 7.1.0

package/scripts/perf-ieee.mjs

@@ -11,21 +11,19 @@ import {
   evaluateInput,
   executeKVM,
   exportPatternGraph,
-  parseFloat64,
   patternToPropertyList,
   propertyListToPattern,
   run,
   run_converged,
-  valueForCode,
   Value
 } from "@fraczak/k/backend-api.mjs";
+import { parse as parseFloatValue } from "@fraczak/k/codecs/ieee.mjs";
+import { inputPatternForObjectRelation } from "../backends/llvm/src/executable.mjs";
 
 import {
   csvEnv,
   formatTiming,
   createLLVMRunner,
-  createARM64Runner,
-  arm64LaneName,
   llvmLaneName,
   makeCacheDir,
   parseNonNegativeIntEnv,
@@ -50,14 +48,13 @@ import {
 } from "../backends/wasm/tests/perf-support.mjs";
 
 import { compileWasmArtifactFromObject } from "../backends/wasm/src/wasm.mjs";
-import { compileARM64ArtifactFromObject } from "../backends/arm64/src/arm64.mjs";
 
 function printHelp() {
   console.log(`Usage: node scripts/perf-ieee.mjs [options]
 
 IEEE 754 Floating-Point Arithmetic Benchmark Harness.
 Benchmarks add, sub, mul, and div on Examples/ieee.k across
-Native JS, kVM interpreter, LLVM, Wasm, and ARM64 backends.
+Native JS, kVM interpreter, LLVM, Wasm, and PKIR backends.
 
 Options:
   --opt=<levels>, --opts=<levels>
@@ -68,18 +65,20 @@ Options:
       Run full LLVM optimization sweep (-O0, -O1, -O2).
   --wasm-in-process
       Run WebAssembly in-process instead of persistent subprocess runner.
+  --pkir-only
+      Run only PKIR backend.
   -h, --help
       Show this help message and exit.
 
 Environment Variables:
   BACKENDS
-      Target backend to run: 'llvm', 'wasm', or 'arm64'.
+      Target backend to run: 'llvm', 'wasm', or 'pkir'.
   LLVM_ONLY
       Run only LLVM backend ('1' to enable).
   WASM_ONLY
       Run only WebAssembly backend ('1' to enable).
-  ARM64_ONLY
-      Run only ARM64 backend ('1' to enable).
+  PKIR_ONLY
+      Run only PKIR backend ('1' to enable).
   BACKENDS_ONLY
       Skip JS and kVM interpreter baselines ('1' to enable).
   VALUES
@@ -87,14 +86,6 @@ Environment Variables:
       (default: 0.5,-4,0,Infinity,-Infinity,NaN).
   ITERATIONS
       Measured iterations per benchmark (default: 3).
-  ARM64_WARMUP_ITERATIONS
-      Warmup iterations for ARM64 backend (default: 1).
-  ARM64_OPT
-      ARM64 backend optimization flags (default: -O2).
-  ARM64_SPAWN_PER_CALL
-      Spawn process per ARM64 call instead of persistent ('1' or '0').
-  ARM64_PIPELINE
-      Use persistent pipelined runner for ARM64 ('1' or '0').
   LLVM_WARMUP_ITERATIONS
       Warmup iterations for LLVM backend (default: 1).
   LLVM_SPAWN_PER_CALL
@@ -129,24 +120,57 @@ if (process.argv.includes("-h") || process.argv.includes("--help")) {
 
 // Backend selection
 const backendsEnv = process.env.BACKENDS?.toLowerCase();
-const llvmOnly = process.env.LLVM_ONLY === "1" || backendsEnv === "llvm";
-const wasmOnly = process.env.WASM_ONLY === "1" || backendsEnv === "wasm";
-const arm64Only = process.env.ARM64_ONLY === "1" || backendsEnv === "arm64";
-
-const isArm64Host = process.arch === "arm64" && process.platform === "linux";
-const runARM64 = !wasmOnly && !llvmOnly && (isArm64Host || arm64Only);
-const runLLVM = !wasmOnly && !arm64Only;
-const runWasm = !llvmOnly && !arm64Only;
-const runBaselines = !process.env.BACKENDS_ONLY && (process.env.LLVM_ONLY !== "1") && (process.env.WASM_ONLY !== "1") && (process.env.ARM64_ONLY !== "1");
+const backendsList = backendsEnv
+  ? backendsEnv.split(",").map(s => s.trim())
+  : null;
+const llvmPkirOnly = process.env.LLVM_PKIR_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "llvm-pkir")
+  || process.argv.includes("--llvm-pkir-only");
+const pkirOnly = !llvmPkirOnly && (
+  process.env.PKIR_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "pkir")
+  || process.argv.includes("--pkir-only")
+);
+const llvmOnly = !pkirOnly && !llvmPkirOnly && (
+  process.env.LLVM_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "llvm")
+);
+const wasmOnly = !pkirOnly && !llvmPkirOnly && !llvmOnly && (
+  process.env.WASM_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "wasm")
+);
+const runLLVM = backendsList
+  ? backendsList.includes("llvm")
+  : !wasmOnly && !pkirOnly && !llvmPkirOnly;
+const runLLVMPKIR = backendsList
+  ? backendsList.includes("llvm-pkir")
+  : !wasmOnly && !pkirOnly && !llvmOnly;
+const runWasm = backendsList
+  ? backendsList.includes("wasm")
+  : !llvmOnly && !pkirOnly && !llvmPkirOnly;
+const runPKIR = backendsList
+  ? backendsList.includes("pkir")
+  : !llvmOnly && !wasmOnly && !llvmPkirOnly;
+const runBaselines = !process.env.BACKENDS_ONLY
+  && (backendsList == null || backendsList.includes("kvm") ||
+      backendsList.includes("js"))
+  && !llvmOnly && !wasmOnly && !pkirOnly && !llvmPkirOnly;
+
+function llvmLaneNameStr() {
+  return llvmLaneName();
+}
+function llvmPkirLaneNameStr() {
+  return llvmLaneName().replace("LLVM", "LLVM-PKIR");
+}
 
 const ops = ["add", "sub", "mul", "div"];
 const values = csvEnv("VALUES", "0.5,-4,0,Infinity,-Infinity,NaN");
 const iterations = parsePositiveIntEnv("ITERATIONS", 3);
 
-// ARM64 options
-const arm64WarmupIterations = parseNonNegativeIntEnv("ARM64_WARMUP_ITERATIONS", 1);
-const arm64OptLevel = process.env.ARM64_OPT || "-O2";
-
 // LLVM options
 const llvmWarmupIterations = parseNonNegativeIntEnv("LLVM_WARMUP_ITERATIONS", 1);
 const llvmRuntimeMode = process.env.K_LLVM_IEEE_RUNTIME_MODE || "fast";
@@ -193,6 +217,9 @@ function wasmLaneName() {
   const mode = wasmPipe ? "persistent" : "in-process";
   return `WebAssembly (${mode})`;
 }
+function pkirLaneName() {
+  return "PKIR (Wasm persistent)";
+}
 
 console.log("==> Initializing state and loading @fraczak/k/Examples/ieee.k");
 const state = createState();
@@ -200,10 +227,7 @@ const ieeePath = fileURLToPath(import.meta.resolve("@fraczak/k/Examples/ieee.k")
 await evaluateInput(`:load ${ieeePath}`, state);
 
 function generatePerfK(values) {
-  const paramFields = values.map((_, i) => `  float64 p${i}`).join(",\n");
-  const lines = [
-    `$params = {\n${paramFields}\n};`
-  ];
+  const lines = [];
   for (const op of ops) {
     lines.push(`perf_${op} =`);
     lines.push("  {");
@@ -216,7 +240,7 @@ function generatePerfK(values) {
     lines.push(cases.join(",\n"));
     lines.push("  };");
   }
-  lines.push("perf_ieee = ?params");
+  lines.push("perf_ieee =");
   lines.push("  {");
   lines.push("    perf_add add,");
   lines.push("    perf_sub sub,");
@@ -230,7 +254,8 @@ const perfKSource = generatePerfK(values);
 await evaluateInput(perfKSource, state);
 
 const ieeeRaw = fs.readFileSync(ieeePath, "utf8");
-// Exclude trailing unassigned expression and comment block to ensure clean parse
+// Exclude trailing unassigned expression and comment block to ensure
+// clean parse.
 const endIdx = ieeeRaw.indexOf("\n()\n");
 const ieeeBase = endIdx !== -1 ? ieeeRaw.slice(0, endIdx) : ieeeRaw;
 const fullSource = `${ieeeBase}\n${perfKSource}\nperf_ieee`;
@@ -242,18 +267,16 @@ const relation = prepareRelation(state, "perf_ieee", {
 });
 codes.load(state.codes);
 
-const float64Hash = state.typeAliases.float64;
-function float64(text) {
-  return valueForCode(parseFloat64(text), float64Hash, codes.find);
-}
-
 const paramsObj = {};
 for (let i = 0; i < values.length; i++) {
-  paramsObj[`p${i}`] = float64(values[i]);
+  paramsObj[`p${i}`] = parseFloatValue(values[i]);
 }
-const rawProduct = Value.product(paramsObj);
-const inputVal = valueForCode(rawProduct, state.typeAliases.params, codes.find);
-const { inputWire, inputPattern } = wireInput(inputVal);
+const inputVal = Value.product(paramsObj);
+const inferredPattern = inputPatternForObjectRelation(
+  relation.object,
+  relation.relationName
+);
+const { inputWire, inputPattern } = wireInput(inputVal, inferredPattern);
 
 console.log("==> Computing expected results via Native JS");
 run_converged.defs = state;
@@ -275,7 +298,8 @@ if (runLLVM) {
       cacheDir,
       sourceLabel: "@fraczak/k/Examples/ieee.k#perf_ieee",
       runtimeMode: llvmRuntimeMode,
-      clangOpt: opt
+      clangOpt: opt,
+      usePKIR: false
     });
     const singleCase = [{
       op: "perf_ieee",
@@ -292,6 +316,37 @@ if (runLLVM) {
   codes.load(state.codes);
 }
 
+// Setup LLVM-PKIR
+const llvmPkirCasesByOpt = new Map();
+if (runLLVMPKIR) {
+  for (const opt of llvmOptLevels) {
+    console.log(`==> Compiling LLVM-PKIR executable (${opt})...`);
+    const llvm = tryCompileCase({
+      object: relation.object,
+      relationName: relation.relationName,
+      relHash: relation.relHash,
+      inputPattern,
+      cacheDir,
+      sourceLabel: "@fraczak/k/Examples/ieee.k#perf_ieee",
+      runtimeMode: llvmRuntimeMode,
+      clangOpt: opt,
+      usePKIR: true
+    });
+    const singleCase = [{
+      op: "perf_ieee",
+      label: "params",
+      inputVal,
+      inputWire,
+      inputPattern,
+      expected,
+      llvm
+    }];
+    llvmPkirCasesByOpt.set(opt, singleCase);
+    printCompileFailures(singleCase);
+  }
+  codes.load(state.codes);
+}
+
 // Setup Wasm
 let wasmExports = null;
 let wasmPtrIn = null;
@@ -327,36 +382,34 @@ if (runWasm) {
     const relDef = relation.relDef;
     const graph = relDef.typePatternGraph;
 
-    const inputPatternNodeId = graph.find(relDef.def.patterns[0]);
-    const inputPat = propertyListToPattern(patternToPropertyList(exportPatternGraph(graph, inputPatternNodeId)));
-
     const outputPatternNodeId = graph.find(relDef.def.patterns[1]);
     wasmOutputPatternPropertyList = patternToPropertyList(exportPatternGraph(graph, outputPatternNodeId));
     wasmOutputPattern = propertyListToPattern(wasmOutputPatternPropertyList);
 
-    wasmPtrIn = writeValueToArena(wasmExports, inputVal, inputPat, 0);
+    wasmPtrIn = writeValueToArena(wasmExports, inputVal, propertyListToPattern(inputPattern), 0);
     wasmFuncName = cleanName(state.relAliases.perf_ieee);
   }
 }
 
-// Setup ARM64
-let arm64ExePath = null;
-let arm64CompileError = null;
-
-if (runARM64) {
-  console.log(`==> Compiling Linux ARM64 executable (${arm64OptLevel})...`);
+// Setup PKIR
+let pkirExePath = null;
+let pkirCompileError = null;
+if (runPKIR) {
+  console.log("==> Compiling PKIR executable (persistent runner)...");
   try {
-    arm64ExePath = path.join(cacheDir, "perf_ieee_arm64");
-    compileARM64ArtifactFromObject(relation.object, {
+    const pkirPath = path.join(cacheDir, "perf_ieee_pkir.wasm");
+    pkirExePath = path.join(cacheDir, "perf_ieee_pkir.exe");
+    const wasmBuf = await compileWasmArtifactFromObject(relation.object, {
       entry: "__main__",
-      inputPattern,
-      outputPath: arm64ExePath,
-      optLevel: arm64OptLevel
+      usePKIR: true
     });
+    fs.writeFileSync(pkirPath, wasmBuf);
+    const runBin = fileURLToPath(import.meta.resolve("../backends/wasm/bin/k-wasm-run.mjs"));
+    fs.writeFileSync(pkirExePath, `#!/bin/sh\nexec node "${runBin}" "${pkirPath}" "$@"\n`, { mode: 0o755 });
   } catch (error) {
-    arm64CompileError = error.stack || error.message || String(error);
-    console.log("Linux ARM64 compilation failed:");
-    console.log(arm64CompileError.split("\n").slice(0, 8).join("\n"));
+    pkirCompileError = error.stack || error.message || String(error);
+    console.log("PKIR compilation failed:");
+    console.log(pkirCompileError.split("\n").slice(0, 8).join("\n"));
   }
 }
 
@@ -369,12 +422,28 @@ function printBenchmarkDescription() {
   }
   if (runLLVM) {
     for (const opt of llvmOptLevels) {
-      const mode = llvmLaneName().replace(/^LLVM Executable\\s*\\((.*)\\)$/, "$1");
-      lanes.push(llvmOptLevels.length > 1 ? `LLVM ${opt} (${mode})` : llvmLaneName());
+      const mode = llvmLaneName()
+        .replace(/^LLVM Executable\s*\((.*)\)$/, "$1");
+      lanes.push(
+        llvmOptLevels.length > 1
+          ? `LLVM ${opt} (${mode})`
+          : llvmLaneName()
+      );
+    }
+  }
+  if (runLLVMPKIR) {
+    for (const opt of llvmOptLevels) {
+      const mode = llvmLaneName()
+        .replace(/^LLVM Executable\s*\((.*)\)$/, "$1");
+      lanes.push(
+        llvmOptLevels.length > 1
+          ? `LLVM-PKIR ${opt} (${mode})`
+          : llvmLaneName().replace("LLVM", "LLVM-PKIR")
+      );
     }
   }
   if (runWasm) lanes.push(wasmLaneName());
-  if (runARM64) lanes.push(arm64LaneName(arm64OptLevel));
+  if (runPKIR) lanes.push(pkirLaneName());
 
   console.log("==> Benchmark description");
   console.log("    source: @fraczak/k/Examples/ieee.k#perf_ieee (single program)");
@@ -387,6 +456,11 @@ function printBenchmarkDescription() {
     console.log(`    llvm clang opts: ${llvmOptLevels.join(", ")}`);
     console.log(`    llvm cache dir: ${cacheDir}`);
   }
+  if (runLLVMPKIR) {
+    console.log(`    llvm-pkir warmup iterations: ${llvmWarmupIterations}`);
+    console.log(`    llvm-pkir runtime mode: ${llvmRuntimeMode}`);
+    console.log(`    llvm-pkir clang opts: ${llvmOptLevels.join(", ")}`);
+  }
   if (runWasm) {
     console.log(`    wasm runner mode: ${wasmPipe ? "persistent pipe" : "in-process"}`);
     console.log(`    wasm warmup iterations: ${wasmWarmupIterations}`);
@@ -394,10 +468,8 @@ function printBenchmarkDescription() {
       console.log(`    wasm arena reset: ${wasmReset ? "yes" : "no"}`);
     }
   }
-  if (runARM64) {
-    console.log(`    arm64 warmup iterations: ${arm64WarmupIterations}`);
-    console.log(`    arm64 opt level: ${arm64OptLevel}`);
-    console.log(`    arm64 runner mode: ${process.env.ARM64_SPAWN_PER_CALL === "1" ? "spawn per call" : "persistent"}`);
+  if (runPKIR) {
+    console.log(`    pkir warmup iterations: ${wasmWarmupIterations}`);
   }
   console.log(`    iterations: ${iterations}`);
   console.log(`    benchmark lanes: ${lanes.join("; ")}`);
@@ -459,6 +531,28 @@ if (runLLVM) {
   }
 }
 
+// 2b. LLVM-PKIR lanes
+const llvmPkirResults = new Map();
+if (runLLVMPKIR) {
+  for (const opt of llvmOptLevels) {
+    const casesForOpt = llvmPkirCasesByOpt.get(opt);
+    const llvmRunner = createLLVMRunner(casesForOpt);
+    try {
+      if (llvmWarmupIterations > 0) {
+        console.log(`==> Warming LLVM-PKIR (${opt}) executable (${llvmWarmupIterations} iterations)...`);
+        await llvmRunner.run(llvmWarmupIterations);
+      }
+      console.log(`==> Running LLVM-PKIR (${opt}) (${iterations} iterations)...`);
+      const result = await llvmRunner.run(iterations);
+      llvmPkirResults.set(opt, result);
+    } catch (err) {
+      console.log(`==> LLVM-PKIR (${opt}) execution failed: ${err.message?.split("\n")[0]}`);
+    } finally {
+      llvmRunner.close();
+    }
+  }
+}
+
 // 3. Wasm lane
 let wasmResult = null;
 if (runWasm) {
@@ -501,24 +595,25 @@ if (runWasm) {
   }
 }
 
-// 4. Linux ARM64 lane
-let arm64Result = null;
-if (runARM64 && arm64ExePath) {
-  const arm64Runner = createARM64Runner([{
-    op: "perf_ieee",
-    inputWire,
-    arm64: { status: "ok", exePath: arm64ExePath }
-  }]);
-  try {
-    if (arm64WarmupIterations > 0) {
-      console.log(`==> Warming Linux ARM64 (${arm64WarmupIterations} iterations)...`);
-      await arm64Runner.run(arm64WarmupIterations);
+// 4. PKIR lane
+let pkirResult = null;
+if (runPKIR) {
+  if (pkirExePath) {
+    const server = new PersistentExecutable(pkirExePath);
+    try {
+      if (wasmWarmupIterations > 0) {
+        console.log(`==> Warming PKIR (${wasmWarmupIterations} iterations)...`);
+        for (let i = 0; i < wasmWarmupIterations; i++) {
+          await server.request(inputWire);
+        }
+      }
+      console.log(`==> Running PKIR (${iterations} iterations)...`);
+      pkirResult = await runTimedIterationsAsync(iterations, async () => {
+        await server.request(inputWire);
+      });
+    } finally {
+      server.close();
     }
-
-    console.log(`==> Running Linux ARM64 (${iterations} iterations)...`);
-    arm64Result = await arm64Runner.run(iterations);
-  } finally {
-    arm64Runner.close();
   }
 }
 
@@ -534,19 +629,37 @@ if (runBaselines) {
 }
 if (runLLVM) {
   for (const opt of llvmOptLevels) {
+    const mode = llvmLaneName()
+      .replace(/^LLVM Executable\s*\((.*)\)$/, "$1");
     const title = llvmOptLevels.length > 1
-      ? `LLVM ${opt} (${llvmLaneName().replace(/^LLVM Executable\\s*\\((.*)\\)$/, "$1")})`
+      ? `LLVM ${opt} (${mode})`
       : llvmLaneName();
-    console.log(`${laneIndex++}. ${title.padEnd(29)} ${formatTiming(llvmResults.get(opt))}`);
+    console.log(
+      `${laneIndex++}. ${title.padEnd(29)} ` +
+      `${formatTiming(llvmResults.get(opt))}`
+    );
+  }
+}
+if (runLLVMPKIR) {
+  for (const opt of llvmOptLevels) {
+    const mode = llvmLaneName()
+      .replace(/^LLVM Executable\s*\((.*)\)$/, "$1");
+    const title = llvmOptLevels.length > 1
+      ? `LLVM-PKIR ${opt} (${mode})`
+      : llvmLaneName().replace("LLVM", "LLVM-PKIR");
+    console.log(
+      `${laneIndex++}. ${title.padEnd(29)} ` +
+      `${formatTiming(llvmPkirResults.get(opt))}`
+    );
   }
 }
 if (runWasm) {
   const timingStr = wasmResult ? formatTiming(wasmResult) : "compile failed";
   console.log(`${laneIndex++}. ${wasmLaneName().padEnd(29)} ${timingStr}`);
 }
-if (runARM64) {
-  const timingStr = arm64Result ? formatTiming(arm64Result) : "compile failed";
-  console.log(`${laneIndex++}. ${arm64LaneName(arm64OptLevel).padEnd(29)} ${timingStr}`);
+if (runPKIR) {
+  const timingStr = pkirResult ? formatTiming(pkirResult) : "compile failed";
+  console.log(`${laneIndex++}. ${pkirLaneName().padEnd(29)} ${timingStr}`);
 }
 console.log("==============================================================\n");
 
@@ -585,6 +698,28 @@ if (runLLVM) {
   }
 }
 
+if (runLLVMPKIR) {
+  for (const opt of llvmOptLevels) {
+    const casesForOpt = llvmPkirCasesByOpt.get(opt);
+    const tc = casesForOpt[0];
+    if (tc.llvm.status !== "ok") {
+      tc.llvmConformance = "compile-failed";
+    } else {
+      try {
+        const outputWire = await runExecutable(tc.llvm.exePath, tc.inputWire);
+        const actual = decodeWire(outputWire).value;
+        assert.deepEqual(toPlainObject(actual), toPlainObject(expected));
+        tc.llvmConformance = "ok";
+      } catch (error) {
+        tc.llvmConformance = "failed";
+        tc.llvm.error = error.stack || error.message || String(error);
+        console.log(`LLVM-PKIR (${opt}) conformance failure:`);
+        console.log(tc.llvm.error.split("\n").slice(0, 8).join("\n"));
+      }
+    }
+  }
+}
+
 let wasmOk = false;
 if (runWasm) {
   if (wasmPipe) {
@@ -621,18 +756,18 @@ if (runWasm) {
   }
 }
 
-let arm64Ok = false;
-if (runARM64) {
-  if (!arm64ExePath) {
-    console.log("Linux ARM64 conformance failure: executable was not compiled");
+let pkirOk = false;
+if (runPKIR) {
+  if (!pkirExePath) {
+    console.log("PKIR conformance failure: executable was not compiled");
   } else {
     try {
-      const outputWire = await runExecutable(arm64ExePath, inputWire);
+      const outputWire = await runExecutable(pkirExePath, inputWire);
       const actual = decodeWire(outputWire).value;
       assert.deepEqual(toPlainObject(actual), toPlainObject(expected));
-      arm64Ok = true;
+      pkirOk = true;
     } catch (error) {
-      console.log("Linux ARM64 conformance failure:", error.message || error);
+      console.log("PKIR conformance failure:", error.message || error);
     }
   }
 }
@@ -646,11 +781,20 @@ if (runLLVM) {
     validationSummary.push(`LLVM ${opt} (${tc.llvmConformance === "ok" ? `all ${totalOps} ops` : tc.llvmConformance})`);
   }
 }
+if (runLLVMPKIR) {
+  for (const opt of llvmOptLevels) {
+    const casesForOpt = llvmPkirCasesByOpt.get(opt);
+    const tc = casesForOpt[0];
+    validationSummary.push(
+      `LLVM-PKIR ${opt} (${tc.llvmConformance === "ok" ? `all ${totalOps} ops` : tc.llvmConformance})`
+    );
+  }
+}
 if (runWasm) {
   validationSummary.push(`Wasm (${wasmOk ? `all ${totalOps} ops` : "failed"})`);
 }
-if (runARM64) {
-  validationSummary.push(`Linux ARM64 (${arm64Ok ? `all ${totalOps} ops` : "failed"})`);
+if (runPKIR) {
+  validationSummary.push(`PKIR (${pkirOk ? `all ${totalOps} ops` : "failed"})`);
 }
 
 console.log(`Conformance validation: ${validationSummary.join(", ")} match expected values.`);
@@ -660,5 +804,11 @@ if (runLLVM) {
     if (shouldStrictFail(casesForOpt)) process.exitCode = 1;
   }
 }
+if (runLLVMPKIR) {
+  for (const opt of llvmOptLevels) {
+    const casesForOpt = llvmPkirCasesByOpt.get(opt);
+    if (shouldStrictFail(casesForOpt)) process.exitCode = 1;
+  }
+}
 if (runWasm && !wasmOk) process.exitCode = 1;
-if (runARM64 && !arm64Ok) process.exitCode = 1;
+if (runPKIR && !pkirOk) process.exitCode = 1;