@fraczak/k 7.0.2 → 7.2.0

package/backends/llvm/src/executable.mjs

@@ -7,7 +7,8 @@ import { isProduct, isVariant } from "@fraczak/k/Value.mjs";
 import { exportPatternGraph } from "@fraczak/k/codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "@fraczak/k/codecs/runtime/pattern-json.mjs";
 import { specializeKVM } from "@fraczak/k/kvm.mjs";
-import { compileObjectToLLVM } from "./llvm.mjs";
+import { lowerPKIRToKVM } from "@fraczak/k/backend-api.mjs";
+import { compileObjectToLLVM, compileLLVMArtifactFromPKIR } from "./llvm.mjs";
 import { compileKVMModuleToLLVM } from "./kvm2llvm.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -263,6 +264,9 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "static int write_frame(k_wire_prefix *prefix, k_pattern *pattern, k_value *value) {",
     "  size_t length = 0;",
     "  unsigned char *payload = k_encode_wire_as_with_prefix(prefix, pattern, value, &length);",
+    "  if (payload == NULL) {",
+    "    payload = k_encode_wire(value, &length);",
+    "  }",
     "  if (payload == NULL || length > UINT32_MAX) {",
     "    free(payload);",
     "    return 0;",
@@ -376,6 +380,9 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    }",
     "    size_t out_len = 0;",
     "    unsigned char *out_payload = k_encode_wire_as_with_prefix(&output_prefix, &compiled_output_pattern, result.value, &out_len);",
+    "    if (out_payload == NULL) {",
+    "      out_payload = k_encode_wire(result.value, &out_len);",
+    "    }",
     "    if (tracing) t4 = monotonic_ns();",
     "    int ok = 0;",
     "    uint64_t write_start = t4;",
@@ -495,6 +502,9 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "  }",
     "  size_t output_length = 0;",
     "  unsigned char *output_payload = k_encode_wire_as_with_prefix(&output_prefix, &compiled_output_pattern, result.value, &output_length);",
+    "  if (output_payload == NULL) {",
+    "    output_payload = k_encode_wire(result.value, &output_length);",
+    "  }",
     "  if (tracing) t3 = monotonic_ns();",
     "  int ok = output_payload != NULL && fwrite(output_payload, 1, output_length, stdout) == output_length && fflush(stdout) == 0;",
     "  if (tracing) {",
@@ -540,12 +550,25 @@ export function compileLLVMToExecutable(llvm, outputPath, { driver = stdioDriver
   }
 }
 
-export function compileObjectToExecutable(object, outputPath, { relation = object.main, inputPattern = null, runtimeMode = "fast", clangOpt = "-O3" } = {}) {
-  const { inputPattern: compiledInputPattern, outputPattern, llvm } = compileObjectToLLVM(object, {
-    relation,
-    inputPattern: inputPattern || inputPatternForObjectRelation(object, relation),
-    runtimeMode
-  });
+export function compileObjectToExecutable(
+  object,
+  outputPath,
+  {
+    relation = object.main,
+    inputPattern = null,
+    runtimeMode = "fast",
+    clangOpt = "-O3",
+    usePKIR = false
+  } = {}
+) {
+  const { inputPattern: compiledInputPattern, outputPattern, llvm } =
+    compileObjectToLLVM(object, {
+      relation,
+      inputPattern:
+        inputPattern || inputPatternForObjectRelation(object, relation),
+      runtimeMode,
+      usePKIR
+    });
   compileLLVMToExecutable(llvm, outputPath, {
     driver: stdioDriverSource({
       inputPattern: compiledInputPattern,
@@ -559,7 +582,8 @@ export function compileKVMToExecutable(kvmInput, outputPath, {
   entry = null,
   inputPattern = null,
   runtimeMode = "fast",
-  clangOpt = "-O3"
+  clangOpt = "-O3",
+  usePKIR = false
 } = {}) {
   let kvm = kvmInput;
   if (kvm?.format === "k-vm") {
@@ -578,7 +602,8 @@ export function compileKVMToExecutable(kvmInput, outputPath, {
     relation: entryFunc,
     inputPattern: compiledInputPattern,
     outputPattern,
-    runtimeMode
+    runtimeMode,
+    usePKIR
   });
   compileLLVMToExecutable(llvm, outputPath, {
     driver: stdioDriverSource({
@@ -589,10 +614,102 @@ export function compileKVMToExecutable(kvmInput, outputPath, {
   });
 }
 
-export function compileObjectAndRun(object, { relation = object.main, input, expected = null, inputPattern = null }) {
+export function compilePKIRToExecutable(
+  pkirInput,
+  outputPath,
+  {
+    entry = null,
+    inputPattern = null,
+    runtimeMode = "fast",
+    clangOpt = "-O3"
+  } = {}
+) {
+  let kvmProgram;
+  let entryFunc;
+  if (
+    (pkirInput.format === "pk-ir" || pkirInput.format === "k-pkir") &&
+    pkirInput.functions
+  ) {
+    kvmProgram = {};
+    for (const [name, f] of Object.entries(pkirInput.functions)) {
+      kvmProgram[name] = lowerPKIRToKVM(f);
+    }
+    entryFunc =
+      entry ||
+      pkirInput.entry ||
+      Object.keys(kvmProgram)[0] ||
+      "__main__";
+  } else if (pkirInput.instructions) {
+    const kvm = lowerPKIRToKVM(pkirInput);
+    entryFunc = pkirInput.name || entry || "__main__";
+    kvmProgram = { [entryFunc]: kvm };
+    const scan = (insts) => {
+      for (const inst of insts || []) {
+        if (inst.op === "call" && inst.func && !kvmProgram[inst.func]) {
+          kvmProgram[inst.func] = kvm;
+        }
+        if (inst.branches) {
+          for (const b of inst.branches) scan(b.body);
+        }
+      }
+    };
+    scan(kvm.body);
+  } else if (pkirInput.functions) {
+    kvmProgram = {};
+    for (const [name, f] of Object.entries(pkirInput.functions)) {
+      kvmProgram[name] = lowerPKIRToKVM(f);
+    }
+    entryFunc =
+      entry ||
+      pkirInput.entry ||
+      Object.keys(kvmProgram)[0] ||
+      "__main__";
+  } else {
+    const kvm = lowerPKIRToKVM(pkirInput);
+    entryFunc = pkirInput.name || entry || "__main__";
+    kvmProgram = { [entryFunc]: kvm };
+  }
+  return compileKVMToExecutable(
+    {
+      format: "k-vm",
+      layer: "KVM",
+      entry: entryFunc,
+      functions: kvmProgram
+    },
+    outputPath,
+    {
+      entry: entryFunc,
+      inputPattern,
+      runtimeMode,
+      clangOpt,
+      usePKIR: true
+    }
+  );
+}
+
+export function compileObjectAndRun(
+  object,
+  {
+    relation = object.main,
+    input,
+    expected = null,
+    inputPattern = null,
+    usePKIR = false
+  }
+) {
   const { llvm } = compileObjectToLLVM(object, {
     relation,
-    inputPattern: inputPattern || inputPatternForObjectValue(object, input, relation)
+    inputPattern:
+      inputPattern || inputPatternForObjectValue(object, input, relation),
+    usePKIR
   });
   return compileAndRunLLVM(llvm, { input, expected });
 }
+
+export function compilePKIRAndRun(
+  pkirInput,
+  { input, expected = null, options = {} } = {}
+) {
+  const llvm = compileLLVMArtifactFromPKIR(pkirInput, options);
+  return compileAndRunLLVM(llvm, { input, expected });
+}

package/backends/llvm/src/kvm2llvm.mjs

@@ -451,12 +451,15 @@ function hasSelfTailCall(insts, funcName, isTail = true) {
   return false;
 }
 
-function getFieldEdgeIndex(inst, regPatterns, kvmFunc) {
+function getFieldEdgeIndex(inst, regPatterns, kvmFunc, ctx = {}) {
   const srcReg = cleanReg(inst.src);
   const srcPattern = regPatterns.get(srcReg) || (srcReg === "in" ? kvmFunc.inputPattern : null);
   if (Array.isArray(srcPattern) && srcPattern.length > 0) {
     const root = srcPattern[0];
-    if ((root[0] === "open-product" || root[0] === "closed-product") && Array.isArray(root[1])) {
+    const allowed = ctx.usePKIR
+      ? root[0] === "closed-product"
+      : (root[0] === "open-product" || root[0] === "closed-product");
+    if (allowed && Array.isArray(root[1])) {
       const idx = root[1].findIndex(([l]) => l === inst.label);
       if (idx >= 0) return idx;
     }
@@ -514,6 +517,7 @@ export function compileKVMModuleToLLVM(entryName, kvmProgram, options = {}) {
     labels,
     functionNames,
     runtimeMode,
+    usePKIR: Boolean(options.usePKIR),
     armIndex: 0,
     unionExprIndex: 0,
     syntheticFunctions: [],
@@ -584,6 +588,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
     labels: moduleCtx.labels,
     functionNames: moduleCtx.functionNames,
     runtimeMode: moduleCtx.runtimeMode,
+    usePKIR: moduleCtx.usePKIR,
     allocas: [],
     lines: [],
     currentBlock: "entry",
@@ -675,7 +680,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
         case "project_field": {
           const input = getReg(inst.src);
           nullCheck(ctx, input, failTarget);
-          const edgeIndex = getFieldEdgeIndex(inst, regPatterns, kvmFunc);
+          const edgeIndex = getFieldEdgeIndex(inst, regPatterns, kvmFunc, ctx);
           const label = ctx.labelRef(inst.label);
           let val;
           if (edgeIndex >= 0 && ctx.runtimeMode !== "compact") {
@@ -865,7 +870,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
             const exprName = `@k_union_expr_${exprIndex}`;
             const exprFunc = {
               name: `union_expr_${exprIndex}`,
-              inputPattern: kvmFunc.inputPattern,
+              inputPattern: regPatterns.get(cleanReg(inst.src)) || null,
               outputPattern: kvmFunc.outputPattern,
               body: [
                 { op: "id", dest: "%v0", src: "%in" },
@@ -899,7 +904,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
 
             const armFunc = {
               name: `union_arm_${armIndex}`,
-              inputPattern: kvmFunc.inputPattern,
+              inputPattern: regPatterns.get(cleanReg(inst.src)) || null,
               outputPattern: kvmFunc.outputPattern,
               body: branch.body
             };

package/backends/llvm/src/llvm.mjs

@@ -7,7 +7,11 @@ import {
   objectToKVMArtifact,
   specializeKVM,
   lowerKIRToKVM,
-  objectToKIRP
+  objectToKIRP,
+  compileRelationToPKIR,
+  lowerPKIRToKVM,
+  exportPatternGraph,
+  patternToPropertyList
 } from "@fraczak/k/backend-api.mjs";
 import { compileKVMModuleToLLVM } from "./kvm2llvm.mjs";
 
@@ -923,7 +927,8 @@ function emitFunctionBody(symbol, body, ctx, linkage = "", options = {}) {
   }
   const value = lowerExpr(ctx, body, input, { tail: options.tail !== false });
   if (value === false) {
-    // The expression emitted complete control flow, including all returns.
+    // The expression emitted complete control flow, including all
+    // returns.
   } else if (value == null) {
     unsupported(ctx);
   } else {
@@ -1010,25 +1015,74 @@ export function emitLLVMModule(input, options = {}) {
 }
 
 export function compileObjectToLLVM(object, options = {}) {
-  const inputPattern = options.inputPattern ? readPattern(options.inputPattern) : null;
+  const inputPattern = options.inputPattern
+    ? readPattern(options.inputPattern)
+    : null;
   const relation = options.relation || object.main;
   let targetObject = object;
   let entryInputPattern = inputPattern;
   let outputPattern = null;
 
-  if (inputPattern) {
-    const retyped = retypeObjectRelationForBackend(object, relation, inputPattern, {
-      source: options.source || "<k-llvm>"
-    });
+  if (options.usePKIR) {
+    const rel = object.rels?.[relation] ||
+      (object.relAlias?.[relation] &&
+       object.rels?.[object.relAlias[relation]]) ||
+      object.rels?.[object.main];
+    if (rel?.typePatternGraph) {
+      const graph = rel.typePatternGraph;
+      if (!entryInputPattern &&
+          rel.def?.patterns?.[0] !== undefined) {
+        const inId = graph.find(rel.def.patterns[0]);
+        entryInputPattern =
+          patternToPropertyList(exportPatternGraph(graph, inId));
+      }
+      if (rel.def?.patterns?.[1] !== undefined) {
+        const outId = graph.find(rel.def.patterns[1]);
+        outputPattern =
+          patternToPropertyList(exportPatternGraph(graph, outId));
+      }
+    }
+  } else if (inputPattern) {
+    const retyped = retypeObjectRelationForBackend(
+      object, relation, inputPattern, {
+        source: options.source || "<k-llvm>"
+      }
+    );
     targetObject = retyped.retypedObject;
     entryInputPattern = retyped.inputPattern;
     outputPattern = retyped.outputPattern;
   }
 
-  const retypedKir = objectToKIRP(targetObject);
-  const functions = lowerKIRToKVM(retypedKir);
+  let functions;
+  let retypedKir = null;
   const entry = relation || targetObject.main || "__main__";
 
+  if (options.usePKIR) {
+    functions = {};
+    for (const [name, relDef] of Object.entries(targetObject.rels || {})) {
+      const pkir = compileRelationToPKIR(relDef, name);
+      functions[name] = lowerPKIRToKVM(pkir);
+    }
+    for (const [alias, target] of Object.entries(targetObject.relAlias || {})) {
+      if (functions[target] && !functions[alias]) {
+        functions[alias] = functions[target];
+      }
+      const stripped = target.startsWith("@") ? target.slice(1) : target;
+      if (functions[stripped] && !functions[alias]) {
+        functions[alias] = functions[stripped];
+      }
+      if (functions[alias] && !functions[target]) {
+        functions[target] = functions[alias];
+      }
+    }
+    if (relation && !functions[relation] && functions[targetObject.main]) {
+      functions[relation] = functions[targetObject.main];
+    }
+  } else {
+    retypedKir = objectToKIRP(targetObject);
+    functions = lowerKIRToKVM(retypedKir);
+  }
+
   const specializedKvm = {
     format: "k-vm",
     version: 1,
@@ -1065,6 +1119,63 @@ export function compileLLVMArtifactFromKVM(kvmInput, options = {}) {
   return compileKVMModuleToLLVM(entry, functions, options);
 }
 
+export function compileLLVMArtifactFromPKIR(pkirInput, options = {}) {
+  let kvmProgram;
+  let entry;
+  if (
+    (pkirInput.format === "pk-ir" || pkirInput.format === "k-pkir") &&
+    pkirInput.functions
+  ) {
+    entry =
+      pkirInput.entry ||
+      options.entry ||
+      Object.keys(pkirInput.functions)[0] ||
+      "__main__";
+    kvmProgram = {};
+    for (const [name, f] of Object.entries(pkirInput.functions)) {
+      kvmProgram[name] = lowerPKIRToKVM(f);
+    }
+  } else if (pkirInput.instructions) {
+    const kvm = lowerPKIRToKVM(pkirInput);
+    entry = pkirInput.name || options.entry || "__main__";
+    kvmProgram = { [entry]: kvm };
+    const scan = (insts) => {
+      for (const inst of insts || []) {
+        if (inst.op === "call" && inst.func && !kvmProgram[inst.func]) {
+          kvmProgram[inst.func] = kvm;
+        }
+        if (inst.branches) {
+          for (const b of inst.branches) scan(b.body);
+        }
+      }
+    };
+    scan(kvm.body);
+  } else if (pkirInput.functions) {
+    entry =
+      pkirInput.entry ||
+      options.entry ||
+      Object.keys(pkirInput.functions)[0] ||
+      "__main__";
+    kvmProgram = {};
+    for (const [name, f] of Object.entries(pkirInput.functions)) {
+      kvmProgram[name] = lowerPKIRToKVM(f);
+    }
+  } else {
+    const kvm = lowerPKIRToKVM(pkirInput);
+    entry = pkirInput.name || options.entry || "__main__";
+    kvmProgram = { [entry]: kvm };
+  }
+  return compileLLVMArtifactFromKVM(
+    {
+      format: "k-vm",
+      layer: "KVM",
+      entry,
+      functions: kvmProgram
+    },
+    options
+  );
+}
+
 export function compileLLVMArtifactFromObject(object, options = {}) {
   return compileObjectToLLVM(object, options);
 }
@@ -1080,6 +1191,7 @@ export default {
   compileBufferToLLVM,
   compileObjectToLLVM,
   compileLLVMArtifactFromKVM,
+  compileLLVMArtifactFromPKIR,
   compileLLVMArtifactFromObject,
   emitLLVMModule,
   llvmIdentifier

package/backends/llvm/tests/integration.sh

@@ -72,19 +72,19 @@ node ./bin/k-llvm-compile.mjs --help | grep -q 'Compile a k .ko/.klib object'
 
 node ./bin/k-llvm-build.mjs --help | grep -q 'binary k pattern+value envelope'
 
-node ./bin/k-llvm-jit.mjs --help | grep -q 'stdin binary envelope'
+node ./bin/k-llvm.mjs --help | grep -q 'binary pattern+value wire stream'
 
-node ./bin/k-llvm-run.mjs --help | grep -q 'Compile and execute a k .ko/.klib object'
+node ./tests/k-llvm-run.mjs --help | grep -q 'Compile and execute a k .ko/.klib object'
 
 node ../../objects/compile.mjs '.x' "$TMP_DIR/run.ko"
 printf '{"x":"left","y":"right"}' > "$TMP_DIR/run-input.kv"
 printf '"left"' > "$TMP_DIR/run-expected.kv"
-node ./bin/k-llvm-run.mjs --expect "$TMP_DIR/run-expected.kv" "$TMP_DIR/run.ko" "$TMP_DIR/run-input.kv" | grep -qx 'OK'
-node ./bin/k-llvm-run.mjs "$TMP_DIR/run.ko" "$TMP_DIR/run-input.kv" | grep -qx '"left"'
+node ./tests/k-llvm-run.mjs --expect "$TMP_DIR/run-expected.kv" "$TMP_DIR/run.ko" "$TMP_DIR/run-input.kv" | grep -qx 'OK'
+node ./tests/k-llvm-run.mjs "$TMP_DIR/run.ko" "$TMP_DIR/run-input.kv" | grep -qx '"left"'
 
 node ../../objects/compile.mjs '{ .x fieldA, .y fieldB }' "$TMP_DIR/run-product.ko"
 printf '{"x":"left","y":"right"}' > "$TMP_DIR/run-product-input.kv"
-node ./bin/k-llvm-run.mjs "$TMP_DIR/run-product.ko" "$TMP_DIR/run-product-input.kv" | grep -qx '{"fieldA":"left","fieldB":"right"}'
+node ./tests/k-llvm-run.mjs "$TMP_DIR/run-product.ko" "$TMP_DIR/run-product-input.kv" | grep -qx '{"fieldA":"left","fieldB":"right"}'
 
 node ./bin/k-llvm-build.mjs '?{<{}=X0 left, ...> x, <X0 right, ...> y} .x' -o "$TMP_DIR/run-exe"
 printf '{"x":"left","y":"right"}' \
@@ -130,31 +130,31 @@ printf '987654321' \
 
 printf '{"x":"left","y":"right"}' \
   | node ../../codecs/k-parse.mjs \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/run.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/run.ko" \
   | node ../../codecs/k-print.mjs \
   | grep -qx '"left"'
 
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const pattern = [[\"open-union\",[[\"left\",1],[\"right\",1]]],[\"closed-product\",[]]]; stdout.write(encodeToWire(Value.variant(\"left\", Value.product({}), pattern), pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
   | node --input-type=module -e "import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; stdin.on('data', (chunk) => chunks.push(chunk)); stdin.on('end', () => console.log(JSON.stringify(decodeWire(Buffer.concat(chunks)).pattern)));" \
   | grep -Fqx '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]'
 
 node ../../objects/compile.mjs '/"ह" |"😀"' "$TMP_DIR/unicode-variant.ko"
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const pattern = [[\"closed-union\", [[\"ह\", 1]]], [\"closed-product\", []]]; stdout.write(encodeToWire(Value.variant('ह', Value.product({}), pattern), pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/unicode-variant.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/unicode-variant.ko" \
   | node ../../codecs/k-print.mjs \
   | grep -qx '"😀"'
 
 node ../../objects/compile.mjs '/"a\u0000b" |"nul-ok"' "$TMP_DIR/nul-variant.ko"
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const tag = 'a\u0000b'; const pattern = [[\"closed-union\", [[tag, 1]]], [\"closed-product\", []]]; stdout.write(encodeToWire(Value.variant(tag, Value.product({}), pattern), pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/nul-variant.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/nul-variant.ko" \
   | node ../../codecs/k-print.mjs \
   | grep -qx '"nul-ok"'
 
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const labels = ['a', 'é', 'ह', '\uE000', '😀', '𠀀', 'a\u0000b']; const pattern = [[\"closed-product\", labels.map((label) => [label, 1])], [\"closed-product\", []]]; const value = Value.product(Object.fromEntries(labels.map((label) => [label, Value.product({})])), pattern); stdout.write(encodeToWire(value, pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
   | node --input-type=module -e "import assert from 'node:assert/strict'; import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; for await (const chunk of stdin) chunks.push(chunk); const labels = ['a', 'é', 'ह', '\uE000', '😀', '𠀀', 'a\u0000b']; const { pattern } = decodeWire(Buffer.concat(chunks)); assert.equal(pattern[0][0], 'closed-product'); assert.deepEqual(new Set(pattern[0][1].map(([label]) => label)), new Set(labels));"
 
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const labels = ['a', 'é', 'ह', '\uE000', '😀', '𠀀', 'a\u0000b']; const pattern = [[\"open-union\", labels.map((label) => [label, 1])], [\"closed-product\", []]]; stdout.write(encodeToWire(Value.variant('a\u0000b', Value.product({}), pattern), pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
   | node --input-type=module -e "import assert from 'node:assert/strict'; import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; for await (const chunk of stdin) chunks.push(chunk); const labels = ['a', 'é', 'ह', '\uE000', '😀', '𠀀', 'a\u0000b']; const { pattern, value } = decodeWire(Buffer.concat(chunks)); assert.equal(pattern[0][0], 'open-union'); assert.deepEqual(new Set(pattern[0][1].map(([label]) => label)), new Set(labels)); assert.equal(value.tag, 'a\u0000b');"

package/backends/llvm/{bin → tests}/k-llvm-run.mjs

@@ -6,22 +6,35 @@ import { decodeObject } from "@fraczak/k/object.mjs";
 import { parseValue } from "@fraczak/k/valueIO.mjs";
 import { compileObjectAndRun } from "../src/executable.mjs";
 
-function usage(stream = console.error) {
+function helpText() {
   const prog = argv[1] || "k-llvm-run.mjs";
-  stream(`Usage: node ${prog} [options] object-file [input.kv]`);
-  stream("Compile and execute a k .ko/.klib object through LLVM.");
-  stream("");
-  stream("Arguments:");
-  stream("  object-file     Input .ko or .klib file.");
-  stream("  input.kv        Input value. Reads text from stdin when omitted.");
-  stream("");
-  stream("Options:");
-  stream("  --retype rel            Relation to specialize. Defaults to object main.");
-  stream("  --input-pattern value   Input pattern property-list JSON, or a file containing it.");
-  stream("  --expect value          Expected output value JSON/k-value text, or a file containing it.");
-  stream("  -h, --help              Show this help.");
-  stream("");
-  stream("Without --expect, the runner prints the result value as compact JSON.");
+  return [
+    "Compile and execute a k .ko/.klib object through LLVM.",
+    "",
+    `Usage: ${prog} [options] object-file [input.kv]`,
+    "",
+    "Arguments:",
+    "  object-file     Input .ko or .klib file.",
+    "  input.kv        Input value. Reads text from stdin when omitted.",
+    "",
+    "Options:",
+    "  --retype rel            Relation to specialize (default: main).",
+    "  --input-pattern value   Input pattern property-list JSON or file.",
+    "  --expect value          Expected output value JSON/text or file.",
+    "  --pkir                  Lower via Polymorphic K IR (PKIR).",
+    "  -h, --help              Show this help.",
+    "",
+    "Without --expect, the runner prints the result as compact JSON.",
+    "",
+    "Examples:",
+    `  ${prog} program.ko input.kv`,
+    `  ${prog} --expect expected.kv program.ko input.kv`,
+    `  echo '{"x":"left"}' | ${prog} program.ko`
+  ].join("\n");
+}
+
+function usage(stream = console.error) {
+  stream(helpText());
 }
 
 async function readStdinText() {
@@ -33,7 +46,9 @@ async function readStdinText() {
 }
 
 function readMaybeFile(textOrPath) {
-  return fs.existsSync(textOrPath) ? fs.readFileSync(textOrPath, "utf8") : textOrPath;
+  return fs.existsSync(textOrPath)
+    ? fs.readFileSync(textOrPath, "utf8")
+    : textOrPath;
 }
 
 function readPattern(inputPattern) {
@@ -51,6 +66,7 @@ try {
   let relation = null;
   let inputPattern = null;
   let expectedText = null;
+  let usePKIR = false;
   while (args.length > 0 && args[0].startsWith("--")) {
     const option = args.shift();
     if (option === "--retype") {
@@ -58,10 +74,16 @@ try {
       if (!relation) throw new Error("--retype requires a relation name");
     } else if (option === "--input-pattern") {
       inputPattern = args.shift();
-      if (!inputPattern) throw new Error("--input-pattern requires JSON or a file path");
+      if (!inputPattern) {
+        throw new Error("--input-pattern requires JSON or a file path");
+      }
     } else if (option === "--expect") {
       expectedText = args.shift();
-      if (!expectedText) throw new Error("--expect requires a value or file path");
+      if (!expectedText) {
+        throw new Error("--expect requires a value or file path");
+      }
+    } else if (option === "--pkir") {
+      usePKIR = true;
     } else {
       throw new Error(`Unknown option: ${option}`);
     }
@@ -73,18 +95,22 @@ try {
   if (args.length > 0) throw new Error(`Unexpected argument: ${args[0]}`);
 
   const object = decodeObject(fs.readFileSync(objectPath));
-  const inputText = inputPath == null ? await readStdinText() : fs.readFileSync(inputPath, "utf8");
+  const inputText = inputPath == null
+    ? await readStdinText()
+    : fs.readFileSync(inputPath, "utf8");
   const input = parseValue(inputText);
-  const expected = expectedText == null ? null : parseValue(readMaybeFile(expectedText));
+  const expected = expectedText == null
+    ? null
+    : parseValue(readMaybeFile(expectedText));
   const result = compileObjectAndRun(object, {
     relation: relation || object.main,
     input,
     expected,
-    inputPattern: readPattern(inputPattern)
+    inputPattern: readPattern(inputPattern),
+    usePKIR
   });
   stdout.write(expected == null ? result.stdout : "OK\n");
 } catch (error) {
   console.error(error.stack || error.message || String(error));
-  usage();
   exit(1);
 }

package/backends/llvm/tests/perf-support.mjs

@@ -148,7 +148,17 @@ export function wireInput(value, pattern = value.pattern) {
   };
 }
 
-export function compileCaseExecutable({ object, relationName, relHash, inputPattern, cacheDir, sourceLabel, runtimeMode = "fast", clangOpt = "-O3" }) {
+export function compileCaseExecutable({
+  object,
+  relationName,
+  relHash,
+  inputPattern,
+  cacheDir,
+  sourceLabel,
+  runtimeMode = "fast",
+  clangOpt = "-O3",
+  usePKIR = false
+}) {
   const key = sha256([
     "k-llvm-perf-v1",
     backendFingerprint(),
@@ -157,12 +167,23 @@ export function compileCaseExecutable({ object, relationName, relHash, inputPatt
     sourceLabel,
     relationName,
     relHash,
-    JSON.stringify(inputPattern)
+    JSON.stringify(inputPattern),
+    usePKIR ? "pkir" : "kir"
   ].join("\0"));
   const exePath = path.join(cacheDir, `${key}.exe`);
   if (!fs.existsSync(exePath)) {
     const tmpPath = path.join(cacheDir, `${key}.${process.pid}.tmp`);
-    compileObjectToExecutable(cloneObjectPayload(object), tmpPath, { relation: relationName, inputPattern, runtimeMode, clangOpt });
+    compileObjectToExecutable(
+      cloneObjectPayload(object),
+      tmpPath,
+      {
+        relation: relationName,
+        inputPattern,
+        runtimeMode,
+        clangOpt,
+        usePKIR
+      }
+    );
     fs.renameSync(tmpPath, exePath);
   }
   return exePath;