@fraczak/k 7.0.1 → 7.1.0

package/backends/arm64/src/arm64.mjs

@@ -1,229 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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
-};