@fraczak/k 6.3.3 → 6.5.0

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

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const node = process.execPath;
+const tests = [
+  ["tests/test-arm64.mjs", node, ["tests/test-arm64.mjs"]],
+  ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
+];
+
+function formatDuration(milliseconds) {
+  if (milliseconds < 1000) return `${milliseconds.toFixed(0)} ms`;
+  return `${(milliseconds / 1000).toFixed(2)} s`;
+}
+
+const suiteStarted = performance.now();
+for (const [name, command, args] of tests) {
+  console.log(`\n==> ${name}`);
+  const started = performance.now();
+  const result = spawnSync(command, args, {
+    cwd: root,
+    stdio: "inherit"
+  });
+  const duration = formatDuration(performance.now() - started);
+
+  if (result.error) {
+    console.error(`<== ${name} FAILED (${duration})`);
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    console.error(`<== ${name} FAILED (${duration})`);
+    process.exit(result.status ?? 1);
+  }
+  console.log(`<== ${name} passed (${duration})`);
+}
+
+console.log(`\nAll ARM64 tests passed (${formatDuration(performance.now() - suiteStarted)})`);

package/backends/arm64/src/arm64.mjs

@@ -0,0 +1,229 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execFileSync, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+import {
+  decodeObject,
+  decodeWire,
+  objectToKVMArtifact,
+  specializeKVM
+} from "../../../backend-api.mjs";
+import { compileLibrary, compileObjectBuffer, loadLibrary } from "../../../object.mjs";
+
+import {
+  compileKVMModuleToARM64,
+  emitMetadataC,
+  getTagEntries,
+  resetTagIds
+} from "./kvm2arm64.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RUNTIME_C_PATH = path.resolve(__dirname, "runtime.c");
+const KRT_C_PATH = path.resolve(__dirname, "../../llvm/runtime/krt.c");
+const KRT_H_DIR = path.resolve(__dirname, "../../llvm/runtime");
+
+export const ARTIFACT_FORMAT = "k-arm64";
+export const ARTIFACT_VERSION = 1;
+
+function buildExportPreamble(exports = [], libraries = []) {
+  if (exports.length === 0) return "";
+  const aliasMap = {};
+  for (const lib of libraries) {
+    for (const [name, hash] of Object.entries(lib.relAlias || {})) {
+      if (name !== "__main__") aliasMap[name] = hash;
+    }
+    for (const [hash, entry] of Object.entries(lib.meta || {})) {
+      if (entry?.type !== "rel") continue;
+      for (const origin of entry?.origins || []) {
+        if (origin?.name && origin.name !== "__main__") {
+          aliasMap[origin.name] = hash;
+        }
+      }
+    }
+  }
+  const lines = [];
+  for (const spec of exports) {
+    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`);
+    const body = hash.startsWith("@") ? hash.slice(1) : hash;
+    lines.push(`${localName} = @${body};`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+export function compileARM64ArtifactFromKVM(kvmInput, options = {}) {
+  let kvm = kvmInput;
+  if (kvm?.format === "k-vm") {
+    if (kvm.layer === "KVM-P" && options.inputEnvelopePattern) {
+      kvm = specializeKVM(kvm, options.inputEnvelopePattern);
+    }
+  }
+
+  const functions = kvm.functions || (typeof kvm === "object" && !Array.isArray(kvm) ? kvm : null);
+  if (!functions || typeof functions !== "object") {
+    throw new Error("Expected .kvm input to contain a functions object");
+  }
+
+  const entry = options.entry || kvm.entry || "__main__";
+  const entryFunc = functions[entry];
+  if (!entryFunc) {
+    throw new Error(`kVM entry relation '${entry}' not found in program`);
+  }
+
+  const inputPattern = options.inputPattern || entryFunc.inputPattern || [];
+  const outputPattern = options.outputPattern || entryFunc.outputPattern || [];
+
+  resetTagIds();
+  const profile = Boolean(options.profile ?? (process.env.K_PROFILE === "1" || process.env.PROFILE === "1"));
+  const { assembly, entryName, profileFunctions } = compileKVMModuleToARM64(entry, functions, {
+    inputPattern,
+    outputPattern,
+    profile
+  });
+  const tags = getTagEntries();
+  const metadataC = emitMetadataC(tags, inputPattern, outputPattern, profileFunctions);
+
+  if (options.emit === "assembly" || options.assembly) {
+    return {
+      assembly,
+      metadataC,
+      entryName,
+      tags,
+      inputPattern,
+      outputPattern
+    };
+  }
+
+  // Compile to native ELF executable using gcc
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-arm64-"));
+  const asmPath = path.join(tmpDir, "prog.s");
+  const metaPath = path.join(tmpDir, "meta.c");
+  const outPath = options.outputPath || path.join(tmpDir, "prog");
+
+  try {
+    fs.writeFileSync(asmPath, assembly, "utf8");
+    fs.writeFileSync(metaPath, metadataC, "utf8");
+
+    const gcc = options.gcc || process.env.CC || "gcc";
+    const optLevel = options.optLevel ?? "-O2";
+    const args = [
+      optLevel,
+      `-DENTRY_NAME=${entryName}`,
+      asmPath,
+      metaPath,
+      RUNTIME_C_PATH,
+      KRT_C_PATH,
+      `-I${KRT_H_DIR}`,
+      "-o",
+      outPath
+    ];
+
+    execFileSync(gcc, args, { stdio: "pipe" });
+
+    if (options.outputPath) {
+      return outPath;
+    }
+
+    const binaryBuffer = fs.readFileSync(outPath);
+    return binaryBuffer;
+  } finally {
+    try {
+      if (fs.existsSync(asmPath)) fs.unlinkSync(asmPath);
+      if (fs.existsSync(metaPath)) fs.unlinkSync(metaPath);
+      if (!options.outputPath && fs.existsSync(outPath)) fs.unlinkSync(outPath);
+      if (!options.outputPath) fs.rmdirSync(tmpDir);
+    } catch {
+      // Ignore cleanup errors in temporary directory
+    }
+  }
+}
+
+export function compileARM64ArtifactFromObject(object, options = {}) {
+  const kvm = objectToKVMArtifact(object, options.entry, null, options);
+  return compileARM64ArtifactFromKVM(kvm, options);
+}
+
+export function compileARM64Artifact(source, options = {}) {
+  const libraries = (options.libraries || []).map((lib) => {
+    if (lib?.rels || lib?.meta || lib?.relAlias) return lib;
+    if (typeof lib === "string") {
+      const ext = path.extname(lib).toLowerCase();
+      if (ext === ".k") {
+        return loadLibrary(compileLibrary(fs.readFileSync(lib, "utf8"), { source: lib }));
+      }
+      return loadLibrary(decodeObject(fs.readFileSync(lib)));
+    }
+    if (Buffer.isBuffer(lib)) {
+      return loadLibrary(decodeObject(lib));
+    }
+    return lib;
+  });
+  const preamble = buildExportPreamble(options.exports || options.exportSpecs || [], libraries);
+  const fullSource = preamble + source;
+
+  const objBuffer = compileObjectBuffer(fullSource, {
+    libraries,
+    source: options.source || null
+  });
+  const object = decodeObject(objBuffer);
+  return compileARM64ArtifactFromObject(object, options);
+}
+
+export function runARM64Artifact(executablePathOrBuffer, inputBuffer, options = {}) {
+  let execPath = executablePathOrBuffer;
+  let tmpFile = null;
+
+  if (Buffer.isBuffer(executablePathOrBuffer)) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-arm64-run-"));
+    tmpFile = path.join(tmpDir, "k-exec");
+    fs.writeFileSync(tmpFile, executablePathOrBuffer, { mode: 0o755 });
+    execPath = tmpFile;
+  }
+
+  try {
+    const args = [];
+    if (options.json) {
+      args.push("--json");
+    }
+
+    const result = spawnSync(execPath, args, {
+      input: inputBuffer,
+      maxBuffer: options.maxBuffer || 64 * 1024 * 1024
+    });
+
+    if (result.error) {
+      throw result.error;
+    }
+
+    if (result.status !== 0) {
+      const stderr = result.stderr?.toString("utf8") || "";
+      throw new Error(`ARM64 executable failed with exit status ${result.status}: ${stderr}`);
+    }
+
+    if (options.json) {
+      return result.stdout.toString("utf8");
+    }
+    return result.stdout;
+  } finally {
+    if (tmpFile) {
+      try {
+        fs.unlinkSync(tmpFile);
+        fs.rmdirSync(path.dirname(tmpFile));
+      } catch {
+        // Ignore temporary cleanup errors
+      }
+    }
+  }
+}
+
+export default {
+  ARTIFACT_FORMAT,
+  ARTIFACT_VERSION,
+  compileARM64ArtifactFromKVM,
+  compileARM64ArtifactFromObject,
+  compileARM64Artifact,
+  runARM64Artifact
+};

package/backends/arm64/src/cli.mjs

@@ -0,0 +1,155 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { compileLibrary, decodeObject, loadLibrary } from "../../../backend-api.mjs";
+import {
+  compileARM64Artifact,
+  compileARM64ArtifactFromKVM,
+  compileARM64ArtifactFromObject
+} from "./arm64.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("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+
+export function parseCompileOptions(args) {
+  const libraries = [];
+  const exportSpecs = [];
+  let loadedLibrary = false;
+
+  while (args.length > 0) {
+    if (args[0] === "--") {
+      args.shift();
+      break;
+    }
+    if (args[0] === "--lib") {
+      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))));
+      }
+      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)");
+      exportSpecs.push(spec);
+    } else if (args[0].startsWith("--")) {
+      break;
+    } else {
+      break;
+    }
+  }
+
+  return { libraries, exportSpecs };
+}
+
+export function fileInputType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".ko") return "ko";
+  if (ext === ".kvm") return "kvm";
+  if (ext === ".klib") return "klib";
+  return "source-file";
+}
+
+export function resolveProgramInput(args, { allowStdinSource = false } = {}) {
+  const inputArg = args.shift() ?? null;
+  if (inputArg == null) {
+    if (!allowStdinSource) throw new Error("Missing script argument");
+    return { kind: "stdin-source", sourceName: "<stdin>" };
+  }
+
+  const ext = path.extname(inputArg).toLowerCase();
+  if (fs.existsSync(inputArg)) {
+    const kind = fileInputType(inputArg);
+    if (kind === "klib") {
+      throw new Error("Cannot compile a .klib library to ARM64 without a main relation; load it with --lib.");
+    }
+    return { kind, path: inputArg, sourceName: inputArg };
+  }
+
+  if ([".k", ".ko", ".kvm", ".klib"].includes(ext)) {
+    throw new Error(`Input file not found: ${inputArg}`);
+  }
+
+  return { kind: "inline-source", source: inputArg, sourceName: "<inline>" };
+}
+
+export async function compileProgramInput(
+  input,
+  {
+    libraries = [],
+    exportSpecs = [],
+    stdin = null,
+    inputEnvelopePattern = null,
+    entry = null,
+    emit = null,
+    outputPath = null
+  } = {}
+) {
+  const compileOptions = {
+    libraries,
+    exports: exportSpecs,
+    inputEnvelopePattern,
+    entry,
+    emit,
+    outputPath
+  };
+
+  if (input.kind === "inline-source") {
+    return compileARM64Artifact(input.source, {
+      ...compileOptions,
+      source: input.sourceName
+    });
+  }
+
+  if (input.kind === "stdin-source") {
+    if (!stdin) throw new Error("stdin source requested without a stdin stream");
+    const source = (await readAll(stdin)).toString("utf8");
+    return compileARM64Artifact(source, {
+      ...compileOptions,
+      source: input.sourceName
+    });
+  }
+
+  if (input.kind === "source-file") {
+    return compileARM64Artifact(fs.readFileSync(input.path, "utf8"), {
+      ...compileOptions,
+      source: input.sourceName
+    });
+  }
+
+  if (input.kind === "ko") {
+    return compileARM64ArtifactFromObject(
+      decodeObject(fs.readFileSync(input.path)),
+      compileOptions
+    );
+  }
+
+  if (input.kind === "kvm") {
+    return compileARM64ArtifactFromKVM(
+      JSON.parse(fs.readFileSync(input.path, "utf8")),
+      compileOptions
+    );
+  }
+
+  throw new Error(`Unsupported input kind: ${input.kind}`);
+}
+
+export default {
+  compileProgramInput,
+  fileInputType,
+  parseCompileOptions,
+  readAll,
+  resolveProgramInput
+};