@fraczak/k 6.10.2 → 6.10.4

package/backends/llvm/bin/k-llvm-compile.mjs

@@ -7,17 +7,20 @@ import {
   parseCompileOptions,
   resolveProgramInput
 } from "../src/cli.mjs";
-import { compileObjectToLLVM } from "../src/llvm.mjs";
+import {
+  compileObjectToLLVM,
+  compileLLVMArtifactFromKVM
+} from "../src/llvm.mjs";
 import { inputPatternForObjectRelation } from "../src/executable.mjs";
 
 function usage(stream = console.error) {
   const prog = argv[1] || "k-llvm-compile.mjs";
   stream(`Usage: node ${prog} [options] [source-snippet | input-file [output.ll]]`);
-  stream("Compile a k .ko/.klib object into prototype LLVM IR.");
+  stream("Compile a k .ko/.klib object, source, or .kvm input into prototype LLVM IR.");
   stream("");
   stream("Arguments:");
   stream("  source-snippet  Inline k source, in the same style as k.mjs.");
-  stream("  input-file      Source .k, .ko, or .klib file. Reads UTF-8 source from stdin when omitted.");
+  stream("  input-file      Source .k, .ko, .klib, or .kvm file. Reads UTF-8 source from stdin when omitted.");
   stream("  output.ll       Output LLVM IR path. Writes to stdout when omitted.");
   stream("");
   stream("Options:");
@@ -55,16 +58,30 @@ try {
 
   const outputPath = explicitOutput || positionalOutput || null;
 
-  const object = await compileProgramInputToObject(input, {
-    libraries,
-    exportSpecs,
-    stdin
-  });
+  let llvm;
+  if (input.kind === "kvm") {
+    const kvm = JSON.parse(fs.readFileSync(input.path, "utf8"));
+    const entry = kvm.entry || kvm.relation || "__main__";
+    const mainFunc = kvm.functions?.[entry];
+    const artifact = compileLLVMArtifactFromKVM(kvm, {
+      relation: entry,
+      inputPattern: mainFunc?.inputPattern || kvm.inputPattern,
+      outputPattern: mainFunc?.outputPattern || kvm.outputPattern
+    });
+    llvm = typeof artifact === "string" ? artifact : artifact.llvm;
+  } else {
+    const object = await compileProgramInputToObject(input, {
+      libraries,
+      exportSpecs,
+      stdin
+    });
 
-  const { llvm } = compileObjectToLLVM(object, {
-    relation: object.main,
-    inputPattern: inputPatternForObjectRelation(object, object.main)
-  });
+    const res = compileObjectToLLVM(object, {
+      relation: object.main,
+      inputPattern: inputPatternForObjectRelation(object, object.main)
+    });
+    llvm = res.llvm;
+  }
 
   if (outputPath == null) {
     stdout.write(llvm);

package/backends/llvm/runtime/krt.c

@@ -553,17 +553,17 @@ static void rt_rewind_and_free(k_rt *rt, k_rt_checkpoint mark) {
   rt->has_reusable_blocks = 0;
 }
 
-k_value *k_rt_compact(k_rt *rt, k_value *root, k_rt_checkpoint *mark_ptr) {
-  if (rt == NULL || root == NULL || mark_ptr == NULL) return root;
+k_value *k_rt_compact(k_rt *rt, k_value *root, k_rt_tail_mark *tm) {
+  if (rt == NULL || root == NULL || tm == NULL) return root;
 
-  size_t bytes = bytes_since_mark(rt, *mark_ptr);
+  size_t bytes = bytes_since_mark(rt, tm->last_mark);
   if (bytes < 4194304) {
     return root;
   }
 
-  if (!is_after_mark(rt, root, *mark_ptr)) {
-    rt_rewind_and_free(rt, *mark_ptr);
-    *mark_ptr = k_rt_mark(rt);
+  if (!is_after_mark(rt, root, tm->base_mark)) {
+    rt_rewind_and_free(rt, tm->base_mark);
+    tm->last_mark = tm->base_mark;
     return root;
   }
 
@@ -574,14 +574,14 @@ k_value *k_rt_compact(k_rt *rt, k_value *root, k_rt_checkpoint *mark_ptr) {
 
   k_fixup_list fixups = {NULL, 0, 0};
 
-  k_value *staged_root = copy_value(rt, root, &staging, &staging_used, &staging_cap, &fixups, *mark_ptr);
+  k_value *staged_root = copy_value(rt, root, &staging, &staging_used, &staging_cap, &fixups, tm->base_mark);
 
-  rt_rewind_and_free(rt, *mark_ptr);
+  rt_rewind_and_free(rt, tm->base_mark);
 
   if (staging_used == 0) {
     free(staging);
     if (fixups.offsets != NULL) free(fixups.offsets);
-    *mark_ptr = k_rt_mark(rt);
+    tm->last_mark = tm->base_mark;
     return staged_root;
   }
 
@@ -605,7 +605,7 @@ k_value *k_rt_compact(k_rt *rt, k_value *root, k_rt_checkpoint *mark_ptr) {
   free(staging);
   if (fixups.offsets != NULL) free(fixups.offsets);
 
-  *mark_ptr = k_rt_mark(rt);
+  tm->last_mark = k_rt_mark(rt);
 
   return new_root;
 }

package/backends/llvm/runtime/krt.h

@@ -13,6 +13,11 @@ typedef struct {
   size_t used;
 } k_rt_checkpoint;
 
+typedef struct {
+  k_rt_checkpoint base_mark;
+  k_rt_checkpoint last_mark;
+} k_rt_tail_mark;
+
 typedef struct {
   const char *label;
   size_t label_length;
@@ -66,7 +71,7 @@ k_rt *k_rt_new(void);
 void k_rt_reset(k_rt *rt);
 k_rt_checkpoint k_rt_mark(k_rt *rt);
 void k_rt_rewind(k_rt *rt, k_rt_checkpoint mark);
-k_value *k_rt_compact(k_rt *rt, k_value *root, k_rt_checkpoint *mark_ptr);
+k_value *k_rt_compact(k_rt *rt, k_value *root, k_rt_tail_mark *mark_ptr);
 void *k_rt_alloc(k_rt *rt, size_t size);
 void k_rt_free(k_rt *rt);
 

package/backends/llvm/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/llvm/scripts/run-tests.mjs [options]
+
+Runs LLVM backend test suite, integration tests, and conformance suite.
+
+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-llvm.mjs", node, ["tests/test-llvm.mjs"]],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []],

package/backends/llvm/src/cli.mjs

@@ -135,7 +135,7 @@ export async function compileProgramInputToObject(
   } else if (input.kind === "ko" || input.kind === "klib") {
     object = decodeObject(fs.readFileSync(input.path));
   } else if (input.kind === "kvm") {
-    throw new Error("Compiling directly from .kvm to LLVM is not yet supported; use .k or .ko input.");
+    throw new Error("Input is already lowered to .kvm bytecode; use compileLLVMArtifactFromKVM or compileKVMToExecutable.");
   } else {
     throw new Error(`Unsupported input kind: ${input.kind}`);
   }

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"), []]