@fraczak/k 6.10.3 → 6.10.4

package/backends/llvm/src/executable.mjs

@@ -6,7 +6,9 @@ import { fileURLToPath } from "node:url";
 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 { compileKVMModuleToLLVM } from "./kvm2llvm.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -553,6 +555,40 @@ export function compileObjectToExecutable(object, outputPath, { relation = objec
   });
 }
 
+export function compileKVMToExecutable(kvmInput, outputPath, {
+  entry = null,
+  inputPattern = null,
+  runtimeMode = "fast",
+  clangOpt = "-O3"
+} = {}) {
+  let kvm = kvmInput;
+  if (kvm?.format === "k-vm") {
+    if (kvm.layer === "KVM-P" && inputPattern) {
+      kvm = specializeKVM(kvm, inputPattern);
+    }
+  }
+  const functions = kvm.functions || (typeof kvm === "object" && !Array.isArray(kvm) ? kvm : null);
+  if (!functions) throw new Error("Expected .kvm input to contain a functions object");
+  const entryFunc = entry || kvm.entry || kvm.relation || "__main__";
+  const mainFunc = functions[entryFunc];
+  if (!mainFunc) throw new Error(`No kVM entry function '${entryFunc}' found`);
+  const compiledInputPattern = inputPattern || mainFunc?.inputPattern || kvm.inputPattern;
+  const outputPattern = mainFunc?.outputPattern || kvm.outputPattern;
+  const llvm = compileKVMModuleToLLVM(entryFunc, functions, {
+    relation: entryFunc,
+    inputPattern: compiledInputPattern,
+    outputPattern,
+    runtimeMode
+  });
+  compileLLVMToExecutable(llvm, outputPath, {
+    driver: stdioDriverSource({
+      inputPattern: compiledInputPattern,
+      outputPattern
+    }),
+    clangOpt
+  });
+}
+
 export function compileObjectAndRun(object, { relation = object.main, input, expected = null, inputPattern = null }) {
   const { llvm } = compileObjectToLLVM(object, {
     relation,

package/backends/llvm/src/kvm2llvm.mjs

@@ -49,6 +49,7 @@ function cStringBytes(text) {
 export function runtimeDeclarations() {
   return [
     "%k_rt_mark = type { ptr, i64 }",
+    "%k_rt_tail_mark = type { %k_rt_mark, %k_rt_mark }",
     "%k_result = type { i32, ptr }",
     "",
     "declare %k_rt_mark @k_rt_mark(ptr)",
@@ -316,7 +317,7 @@ function lowerRtCompact(ctx, val, tailMarkSlot = "%tail_mark_slot") {
   const hasBlock = ctx.tempName("has_block");
   const markBlockPtr = ctx.tempName("mark_block_ptr");
   ctx.lines.push(`  ${hasBlock} = icmp ne ptr ${curBlock}, null`);
-  ctx.lines.push(`  ${markBlockPtr} = getelementptr inbounds %k_rt_mark, ptr ${tailMarkSlot}, i32 0, i32 0`);
+  ctx.lines.push(`  ${markBlockPtr} = getelementptr inbounds %k_rt_tail_mark, ptr ${tailMarkSlot}, i32 0, i32 1, i32 0`);
   const markBlock = ctx.tempName("mark_block");
   ctx.lines.push(`  ${markBlock} = load ptr, ptr ${markBlockPtr}`);
 
@@ -340,7 +341,7 @@ function lowerRtCompact(ctx, val, tailMarkSlot = "%tail_mark_slot") {
   ctx.lines.push(`${loadGrowthBlock}:`);
   const curUsed = loadI64At(ctx, curBlock, K_ARENA_BLOCK_USED_OFFSET, "cur_used");
   const markUsedPtr = ctx.tempName("mark_used_ptr");
-  ctx.lines.push(`  ${markUsedPtr} = getelementptr inbounds %k_rt_mark, ptr ${tailMarkSlot}, i32 0, i32 1`);
+  ctx.lines.push(`  ${markUsedPtr} = getelementptr inbounds %k_rt_tail_mark, ptr ${tailMarkSlot}, i32 0, i32 1, i32 1`);
   const markUsed = ctx.tempName("mark_used");
   ctx.lines.push(`  ${markUsed} = load i64, ptr ${markUsedPtr}`);
   const growth = ctx.tempName("arena_growth");
@@ -605,11 +606,16 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
 
   if (isCatchTail) {
     ctx.allocas.push("  %tail_input_slot = alloca ptr");
-    ctx.allocas.push("  %tail_mark_slot = alloca %k_rt_mark");
+    ctx.allocas.push("  %tail_mark_slot = alloca %k_rt_tail_mark");
     ctx.lines.push("  store ptr %input, ptr %tail_input_slot");
     const initMark = ctx.tempName("init_mark");
     ctx.lines.push(`  ${initMark} = call %k_rt_mark @k_rt_mark(ptr %rt)`);
-    ctx.lines.push(`  store %k_rt_mark ${initMark}, ptr %tail_mark_slot`);
+    const baseMarkPtr = ctx.tempName("base_mark_ptr");
+    const lastMarkPtr = ctx.tempName("last_mark_ptr");
+    ctx.lines.push(`  ${baseMarkPtr} = getelementptr inbounds %k_rt_tail_mark, ptr %tail_mark_slot, i32 0, i32 0`);
+    ctx.lines.push(`  store %k_rt_mark ${initMark}, ptr ${baseMarkPtr}`);
+    ctx.lines.push(`  ${lastMarkPtr} = getelementptr inbounds %k_rt_tail_mark, ptr %tail_mark_slot, i32 0, i32 1`);
+    ctx.lines.push(`  store %k_rt_mark ${initMark}, ptr ${lastMarkPtr}`);
     ctx.lines.push("  br label %tail_loop");
     ctx.lines.push("tail_loop:");
     ctx.lines.push("  %tail_input = load ptr, ptr %tail_input_slot");

package/backends/llvm/tests/integration.sh

@@ -95,6 +95,17 @@ printf '{"x":"left","y":"right"}' \
 
 printf '{"x":"left"}' | node ../../codecs/k-parse.mjs | "$TMP_DIR/run-exe" && exit 1 || test "$?" -eq 5
 
+node ../../objects/compile.mjs '?{<{}=X0 left, ...> x, <X0 right, ...> y} .x' "$TMP_DIR/run-proj.kvm"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/run-proj.kvm" "$TMP_DIR/run-proj-kvm.ll"
+grep -q '@k_llvm_metadata' "$TMP_DIR/run-proj-kvm.ll"
+grep -q 'define %k_result @k_main' "$TMP_DIR/run-proj-kvm.ll"
+node ./bin/k-llvm-build.mjs "$TMP_DIR/run-proj.kvm" -o "$TMP_DIR/run-kvm-exe"
+printf '{"x":"left","y":"right"}' \
+  | node ../../codecs/k-parse.mjs \
+  | "$TMP_DIR/run-kvm-exe" \
+  | node ../../codecs/k-print.mjs \
+  | grep -qx '"left"'
+
 node ./bin/k-llvm-build.mjs '?<{} left, {} right, ...>' -o "$TMP_DIR/id-exe"
 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));" \
   | "$TMP_DIR/id-exe" \

package/backends/llvm/tests/test-llvm.mjs

@@ -1,6 +1,7 @@
 import assert from "node:assert";
 import { compileObjectBuffer, decodeObject } from "@fraczak/k/object.mjs";
-import { compileObjectToLLVM, emitLLVMModule, llvmIdentifier } from "../src/llvm.mjs";
+import { compileObjectToLLVM, compileLLVMArtifactFromKVM, emitLLVMModule, llvmIdentifier } from "../src/llvm.mjs";
+import { objectToKVMArtifact } from "@fraczak/k/kvm.mjs";
 
 function kirP(body, { patternGraph = null } = {}) {
   return {
@@ -256,4 +257,17 @@ const { llvm: productRecurseLLVM } = compileObjectToLLVM(productRecurseObject, {
 // Calls inside product fields must not return tail status (i32 2)
 assert.doesNotMatch(productRecurseLLVM, /insertvalue %k_result undef, i32 2, 0/);
 
+const kvmArtifact = objectToKVMArtifact(productObject, "__main__");
+assert.equal(kvmArtifact.format, "k-vm");
+const kvmLLVM = compileLLVMArtifactFromKVM(kvmArtifact, {
+  inputPattern: [
+    ["closed-product", [["x", 1], ["y", 2]]],
+    ["closed-product", [["valA", 1]]],
+    ["closed-product", [["valB", 2]]]
+  ]
+});
+assert.match(kvmLLVM, /source_filename = "k-llvm:__main__"/);
+assert.match(kvmLLVM, /define %k_result @k_main/);
+assert.match(kvmLLVM, /store ptr %product_fields\d+, ptr %ptr_slot\d+/);
+
 console.log("OK");

package/backends/wasm/scripts/run-tests.mjs

@@ -6,6 +6,22 @@ import { fileURLToPath } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const node = process.execPath;
+
+function printHelp() {
+  console.log(`Usage: node backends/wasm/scripts/run-tests.mjs [options]
+
+Runs WebAssembly backend test suite and integration tests.
+
+Options:
+  -h, --help
+      Show this help message and exit.`);
+}
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  printHelp();
+  process.exit(0);
+}
+
 const tests = [
   ["tests/test-wasm.mjs", node, ["tests/test-wasm.mjs"]],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]