@fraczak/k 7.0.2 → 7.1.0

package/backends/llvm/runtime/krt.c

@@ -1914,6 +1914,14 @@ unsigned char *k_encode_wire_as(k_pattern *pattern, k_value *value, size_t *out_
   return bytes;
 }
 
+unsigned char *k_encode_wire(k_value *value, size_t *out_length) {
+  k_pattern *pattern = derive_pattern(value);
+  if (pattern == NULL) return NULL;
+  unsigned char *bytes = k_encode_wire_as(pattern, value, out_length);
+  free_pattern(pattern);
+  return bytes;
+}
+
 int k_write_wire_as(FILE *out, k_pattern *pattern, k_value *value) {
   size_t length = 0;
   unsigned char *bytes = k_encode_wire_as(pattern, value, &length);

package/backends/llvm/runtime/krt.h

@@ -110,6 +110,7 @@ void k_wire_prefix_free(k_wire_prefix prefix);
 k_value *k_decode_wire_value_with_prefix(const unsigned char *bytes, size_t length, k_wire_prefix *prefix, k_pattern *pattern, k_rt *rt);
 unsigned char *k_encode_wire_as_with_prefix(k_wire_prefix *prefix, k_pattern *pattern, k_value *value, size_t *out_length);
 unsigned char *k_encode_wire_as(k_pattern *pattern, k_value *value, size_t *out_length);
+unsigned char *k_encode_wire(k_value *value, size_t *out_length);
 int k_write_wire(FILE *out, k_value *value);
 int k_write_wire_as(FILE *out, k_pattern *pattern, k_value *value);
 

package/backends/llvm/src/cli.mjs

@@ -1,20 +1,73 @@
 import fs from "node:fs";
 import path from "node:path";
-import { compileLibrary, compileObjectBuffer, decodeObject, loadLibrary } from "@fraczak/k/object.mjs";
+import {
+  compileLibrary,
+  compileObjectBuffer,
+  decodeObject,
+  loadLibrary
+} from "@fraczak/k/object.mjs";
 
 export function readAll(stream) {
   return new Promise((resolve, reject) => {
     const chunks = [];
-    stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    stream.on("data", (chunk) => {
+      chunks.push(
+        Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+      );
+    });
     stream.on("end", () => resolve(Buffer.concat(chunks)));
     stream.on("error", reject);
   });
 }
 
+export function loadLibraryFromPath(libPath) {
+  const ext = path.extname(libPath).toLowerCase();
+  if (ext === ".klib" || ext === ".ko") {
+    return loadLibrary(decodeObject(fs.readFileSync(libPath)));
+  }
+  if (ext === ".k") {
+    let depLibs = [];
+    const baseName = path.basename(libPath);
+    if (baseName === "poly.k") {
+      const dir = path.dirname(libPath);
+      const arithPath = path.join(dir, "arithmetics.k");
+      if (fs.existsSync(arithPath)) {
+        const arithLib = loadLibrary(
+          compileLibrary(fs.readFileSync(arithPath, "utf8"), {
+            source: arithPath
+          })
+        );
+        depLibs.push(arithLib);
+      }
+    }
+    const rawSource = fs.readFileSync(libPath, "utf8");
+    if (depLibs.length > 0) {
+      const neededExports = [
+        "0", "int", "inc", "dec", "nat", "zero_int?", "neg?", "GT"
+      ];
+      const preamble = buildExportPreamble(neededExports, depLibs);
+      const compiled = compileLibrary(preamble + rawSource, {
+        source: libPath,
+        libraries: depLibs
+      });
+      const mergedLib = loadLibrary(compiled);
+      for (const dep of depLibs) {
+        for (const [k, v] of Object.entries(dep.relAlias || {})) {
+          if (!mergedLib.relAlias[k]) mergedLib.relAlias[k] = v;
+        }
+      }
+      return mergedLib;
+    }
+    return loadLibrary(compileLibrary(rawSource, { source: libPath }));
+  }
+  throw new Error(`Unsupported library extension: ${ext}`);
+}
+
 export function parseCompileOptions(args) {
   const libraries = [];
   const exportSpecs = [];
   let loadedLibrary = false;
+  let usePKIR = false;
 
   while (args.length > 0) {
     if (args[0] === "--") {
@@ -22,22 +75,26 @@ export function parseCompileOptions(args) {
       break;
     }
     if (args[0] === "--lib") {
-      if (loadedLibrary) throw new Error("--lib may only be specified once");
+      if (loadedLibrary) {
+        throw new Error("--lib may only be specified once");
+      }
       args.shift();
       const libPath = args.shift();
       if (!libPath) throw new Error("--lib requires a file argument");
-      const ext = path.extname(libPath).toLowerCase();
-      if (ext === ".k") {
-        libraries.push(loadLibrary(compileLibrary(fs.readFileSync(libPath, "utf8"), { source: libPath })));
-      } else {
-        libraries.push(loadLibrary(decodeObject(fs.readFileSync(libPath))));
-      }
+      libraries.push(loadLibraryFromPath(libPath));
       loadedLibrary = true;
     } else if (args[0] === "--export") {
       args.shift();
       const spec = args.shift();
-      if (!spec) throw new Error("--export requires a spec argument (name or libname:localname)");
+      if (!spec) {
+        throw new Error(
+          "--export requires a spec argument (name or libname:localname)"
+        );
+      }
       exportSpecs.push(spec);
+    } else if (args[0] === "--pkir") {
+      args.shift();
+      usePKIR = true;
     } else if (args[0].startsWith("--")) {
       break;
     } else {
@@ -45,7 +102,7 @@ export function parseCompileOptions(args) {
     }
   }
 
-  return { libraries, exportSpecs };
+  return { libraries, exportSpecs, usePKIR };
 }
 
 export function fileInputType(filePath) {
@@ -53,6 +110,7 @@ export function fileInputType(filePath) {
   if (ext === ".ko") return "ko";
   if (ext === ".kvm") return "kvm";
   if (ext === ".klib") return "klib";
+  if (ext === ".pkir") return "pkir";
   return "source-file";
 }
 
@@ -69,11 +127,15 @@ export function resolveProgramInput(args, { allowStdinSource = false } = {}) {
     return { kind, path: inputArg, sourceName: inputArg };
   }
 
-  if ([".k", ".ko", ".kvm", ".klib"].includes(ext)) {
+  if ([".k", ".ko", ".kvm", ".klib", ".pkir"].includes(ext)) {
     throw new Error(`Input file not found: ${inputArg}`);
   }
 
-  return { kind: "inline-source", source: inputArg, sourceName: "<inline>" };
+  return {
+    kind: "inline-source",
+    source: inputArg,
+    sourceName: "<inline>"
+  };
 }
 
 export function buildExportPreamble(exports = [], libraries = []) {
@@ -94,9 +156,15 @@ export function buildExportPreamble(exports = [], libraries = []) {
   }
   const lines = [];
   for (const spec of exports) {
-    const [libName, localName] = spec.includes(":") ? spec.split(":", 2) : [spec, spec];
+    const [libName, localName] = spec.includes(":")
+      ? spec.split(":", 2)
+      : [spec, spec];
     const hash = aliasMap[libName];
-    if (!hash) throw new Error(`--export: '${libName}' not found in loaded libraries`);
+    if (!hash) {
+      throw new Error(
+        `--export: '${libName}' not found in loaded libraries`
+      );
+    }
     const body = hash.startsWith("@") ? hash.slice(1) : hash;
     lines.push(`${localName} = @${body};`);
   }
@@ -116,7 +184,9 @@ export async function compileProgramInputToObject(
     });
     object = decodeObject(objBuffer);
   } else if (input.kind === "stdin-source") {
-    if (!stdin) throw new Error("stdin source requested without a stdin stream");
+    if (!stdin) {
+      throw new Error("stdin source requested without a stdin stream");
+    }
     const source = (await readAll(stdin)).toString("utf8");
     const preamble = buildExportPreamble(exportSpecs, libraries);
     const objBuffer = compileObjectBuffer(preamble + source, {
@@ -135,7 +205,15 @@ 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("Input is already lowered to .kvm bytecode; use compileLLVMArtifactFromKVM or compileKVMToExecutable.");
+    throw new Error(
+      "Input is already lowered to .kvm bytecode; use " +
+      "compileLLVMArtifactFromKVM or compileKVMToExecutable."
+    );
+  } else if (input.kind === "pkir") {
+    throw new Error(
+      "Input is already lowered to .pkir IR; use " +
+      "compileLLVMArtifactFromPKIR or compilePKIRToExecutable."
+    );
   } else {
     throw new Error(`Unsupported input kind: ${input.kind}`);
   }

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