more zig stuff

README.md

@@ -238,12 +238,17 @@ In order to build llama.cpp you have three different options.
     cmake --build . --config Release
     ```
 
-- Using `Zig`:
+- Using `Zig` (version 0.11 or later):
+
+    Building for optimization levels and CPU features can be accomplished using standard build arguments, for example AVX2, FMA, F16C,
+    it's also possible to cross compile for other operating systems and architectures:
 
     ```bash
-    zig build -Doptimize=ReleaseFast
+    zig build -Doptimize=ReleaseFast -Dtarget=x86_64-windows-gnu -Dcpu=x86_64+avx2+fma+f16c
     ```
 
+    The `zig targets` command will give you valid options to use.
+
 -   Using `gmake` (FreeBSD):
 
     1. Install and activate [DRM in FreeBSD](https://wiki.freebsd.org/Graphics)

build.zig

@@ -1,5 +1,6 @@
 // Compatible with Zig Version 0.11.0
 const std = @import("std");
+const ArrayList = std.ArrayList;
 const Compile = std.Build.Step.Compile;
 const ConfigHeader = std.Build.Step.ConfigHeader;
 const Mode = std.builtin.Mode;
@@ -11,8 +12,20 @@ const Maker = struct {
     optimize: Mode,
     config_header: *ConfigHeader,
 
-    const cflags = .{"-std=c11"};
-    const cxxflags = .{"-std=c++11"};
+    cflags: ArrayList([]const u8),
+    cxxflags: ArrayList([]const u8),
+    objs: ArrayList(*Compile),
+
+    fn addCFlag(m: *Maker, flag: []const u8) void {
+        m.cflags.append(flag) catch @panic("OOM");
+    }
+    fn addCxxFlag(m: *Maker, flag: []const u8) void {
+        m.cxxflags.append(flag) catch @panic("OOM");
+    }
+    fn addFlag(m: *Maker, flag: []const u8) void {
+        m.addCFlag(flag);
+        m.addCxxFlag(flag);
+    }
 
     fn init(builder: *std.build.Builder) Maker {
         const commit_hash = @embedFile(".git/refs/heads/master");
@@ -23,25 +36,34 @@ const Maker = struct {
                 .BUILD_COMMIT = commit_hash[0 .. commit_hash.len - 1], // omit newline
             },
         );
-        return Maker{
+        var m = Maker{
             .builder = builder,
             .target = builder.standardTargetOptions(.{}),
             .optimize = builder.standardOptimizeOption(.{}),
             .config_header = config_header,
+            .cflags = ArrayList([]const u8).init(builder.allocator),
+            .cxxflags = ArrayList([]const u8).init(builder.allocator),
+            .objs = ArrayList(*Compile).init(builder.allocator),
         };
+        m.addCFlag("-std=c11");
+        m.addCxxFlag("-std=c++11");
+        return m;
     }
 
     fn obj(m: *const Maker, name: []const u8, src: []const u8) *Compile {
         const o = m.builder.addObject(.{ .name = name, .target = m.target, .optimize = m.optimize });
         if (std.mem.endsWith(u8, src, ".c")) {
-            o.addCSourceFiles(&.{src}, &cflags);
+            o.addCSourceFiles(&.{src}, m.cflags.items);
             o.linkLibC();
         } else {
-            o.addCSourceFiles(&.{src}, &cxxflags);
+            o.addCSourceFiles(&.{src}, m.cxxflags.items);
             o.linkLibCpp();
         }
         o.addIncludePath(.{ .path = "." });
         o.addIncludePath(.{ .path = "./examples" });
+        if (o.target.isWindows()) {
+            o.want_lto = false; // https://github.com/ziglang/zig/issues/15958
+        }
         return o;
     }
 
@@ -49,32 +71,37 @@ const Maker = struct {
         const e = m.builder.addExecutable(.{ .name = name, .target = m.target, .optimize = m.optimize });
         e.addIncludePath(.{ .path = "." });
         e.addIncludePath(.{ .path = "./examples" });
-        e.addCSourceFiles(&.{src}, &cxxflags);
+        e.addCSourceFiles(&.{src}, m.cxxflags.items);
         for (deps) |d| e.addObject(d);
+        for (m.objs.items) |o| e.addObject(o);
         e.linkLibC();
         e.linkLibCpp();
         e.addConfigHeader(m.config_header);
         m.builder.installArtifact(e);
-
-        // Currently a bug is preventing correct linking for optimized builds for Windows:
-        // https://github.com/ziglang/zig/issues/15958
         if (e.target.isWindows()) {
-            e.want_lto = false;
+            e.want_lto = false; // https://github.com/ziglang/zig/issues/15958
         }
         return e;
     }
 };
 
 pub fn build(b: *std.build.Builder) void {
-    const make = Maker.init(b);
+    var make = Maker.init(b);
+
+    if (b.option(bool, "k-quants", "Enable K-quants, (default: true)") orelse true) {
+        make.addFlag("-DGGML_USE_K_QUANTS");
+        const k_quants = make.obj("k_quants", "k_quants.c");
+        make.objs.append(k_quants) catch @panic("OOM");
+    }
 
     const ggml = make.obj("ggml", "ggml.c");
     const ggml_alloc = make.obj("ggml-alloc", "ggml-alloc.c");
     const llama = make.obj("llama", "llama.cpp");
     const common = make.obj("common", "examples/common.cpp");
+    const console = make.obj("common", "examples/console.cpp");
     const grammar_parser = make.obj("grammar-parser", "examples/grammar-parser.cpp");
 
-    _ = make.exe("main", "examples/main/main.cpp", &.{ ggml, ggml_alloc, llama, common, grammar_parser });
+    _ = make.exe("main", "examples/main/main.cpp", &.{ ggml, ggml_alloc, llama, common, console, grammar_parser });
     _ = make.exe("quantize", "examples/quantize/quantize.cpp", &.{ ggml, ggml_alloc, llama });
     _ = make.exe("perplexity", "examples/perplexity/perplexity.cpp", &.{ ggml, ggml_alloc, llama, common });
     _ = make.exe("embedding", "examples/embedding/embedding.cpp", &.{ ggml, ggml_alloc, llama, common });