build.mcpp

#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <sstream>
#include <stdexcept>
#include <string>

namespace fs = std::filesystem;

static std::string read_all(const fs::path & path) {
    std::ifstream in(path, std::ios::binary);
    if (!in) throw std::runtime_error("cannot read " + path.string());
    return {std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>()};
}

static void write_all(const fs::path & path, const std::string & value) {
    fs::create_directories(path.parent_path());
    std::ofstream out(path, std::ios::binary | std::ios::trunc);
    out.write(value.data(), static_cast<std::streamsize>(value.size()));
    if (!out) throw std::runtime_error("cannot write " + path.string());
}

static void replace_once(
    std::string & value,
    const std::string & marker,
    const std::string & replacement
) {
    auto first = value.find(marker);
    if (first == std::string::npos
        || value.find(marker, first + marker.size()) != std::string::npos) {
        throw std::runtime_error("expected exactly one marker: " + marker);
    }
    value.replace(first, marker.size(), replacement);
}

static std::string asm_quote(std::string value) {
    std::string out;
    for (char c : value) {
        if (c == '\\' || c == '"') out.push_back('\\');
        out.push_back(c);
    }
    return out;
}

static int validate_features() {
    const char * raw = std::getenv("MCPP_FEATURES");
    if (!raw || *raw == '\0') return 0;
    std::istringstream input(raw);
    std::string feature;
    while (std::getline(input, feature, ',')) {
        if (feature.empty()
            || feature == "backend-cpu"
            || feature == "backend-metal") {
            continue;
        }
        std::fprintf(
            stderr,
            "mcpplibs:llamacpp: unsupported feature '%s' "
            "(supported features: backend-cpu, backend-metal)\n",
            feature.c_str()
        );
        return 2;
    }
    return 0;
}

int main() try {
    if (int result = validate_features(); result != 0) return result;
    const char * enabled = std::getenv("MCPP_FEATURE_BACKEND_METAL");
    if (!enabled || std::string(enabled) != "1") return 0;

    const char * os = std::getenv("MCPP_TARGET_OS");
    const char * arch = std::getenv("MCPP_TARGET_ARCH");
    const char * manifest = std::getenv("MCPP_MANIFEST_DIR");
    const char * out_env = std::getenv("MCPP_OUT_DIR");
    if (!os || std::string(os) != "macos") {
        std::fprintf(stderr, "mcpplibs:llamacpp requires target_os=macos\n");
        return 2;
    }
    if (!arch || std::string(arch) != "aarch64") {
        std::fprintf(stderr, "mcpplibs:llamacpp requires target_arch=aarch64\n");
        return 2;
    }
    if (!manifest || !out_env) {
        std::fprintf(
            stderr,
            "mcpplibs:llamacpp requires MCPP_MANIFEST_DIR and MCPP_OUT_DIR\n"
        );
        return 2;
    }

    const fs::path root = fs::path(manifest) / "third_party/llama.cpp";
    if (!fs::exists(root / "ggml/src/ggml-common.h")) {
        throw std::runtime_error("vendored llama.cpp source root not found");
    }
    const fs::path common = root / "ggml/src/ggml-common.h";
    const fs::path metal = root / "ggml/src/ggml-metal/ggml-metal.metal";
    const fs::path impl = root / "ggml/src/ggml-metal/ggml-metal-impl.h";
    const fs::path out = out_env;
    const fs::path merged = out / "ggml-metal-embed.metal";
    const fs::path assembly = out / "ggml-metal-embed.s";

    std::string source = read_all(metal);
    replace_once(source, "__embed_ggml-common.h__", read_all(common));
    replace_once(source, "#include \"ggml-metal-impl.h\"", read_all(impl));
    write_all(merged, source);

    std::ostringstream body;
    body << ".section __DATA,__ggml_metallib\n"
         << ".globl _ggml_metallib_start\n"
         << "_ggml_metallib_start:\n"
         << ".incbin \"" << asm_quote(merged.string()) << "\"\n"
         << ".globl _ggml_metallib_end\n"
         << "_ggml_metallib_end:\n";
    write_all(assembly, body.str());

    std::printf("mcpp:generated=%s\n", assembly.string().c_str());
    std::printf("mcpp:cfg=GGML_METAL_EMBED_LIBRARY\n");
    for (const fs::path & input : {common, metal, impl}) {
        std::printf("mcpp:rerun-if-changed=%s\n", input.string().c_str());
    }
    std::fflush(stdout);
    return 0;
} catch (const std::exception & error) {
    std::fprintf(stderr, "mcpplibs:llamacpp build.mcpp: %s\n", error.what());
    return 1;
}