removing spirv headers dependencies, reworking architecture

src/Interpreter.zig

@@ -1,9 +0,0 @@
-const Self = @This();
-
-pub fn init() !Self {
-    return .{};
-}
-
-pub fn deinit(self: *const Self) void {
-    _ = self;
-}

src/Module.zig

@@ -1,14 +1,17 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const lib = @import("lib.zig");
-const spv_data = @import("spv_data.zig");
+const spv = @import("spv.zig");
+const op = @import("opcodes.zig");
 
-const SpvVoid = lib.SpvVoid;
-const SpvByte = lib.SpvByte;
-const SpvWord = lib.SpvWord;
-const SpvBool = lib.SpvBool;
-const spv = lib.spv;
+const SpvVoid = spv.SpvVoid;
+const SpvByte = spv.SpvByte;
+const SpvWord = spv.SpvWord;
+const SpvBool = spv.SpvBool;
+
+const SpvMember = spv.SpvMember;
+const SpvBinding = spv.SpvBinding;
 
-const Interpreter = @import("Interpreter.zig");
 const WordIterator = @import("WordIterator.zig");
 
 const Self = @This();
@@ -24,11 +27,10 @@ const SpvEntryPoint = struct {
 const ModuleError = error{
     InvalidSpirV,
     InvalidMagic,
+    UnsupportedEndianness,
     OutOfMemory,
 };
 
-ctx: *const Interpreter,
-
 it: WordIterator,
 
 version_major: SpvByte,
@@ -51,20 +53,32 @@ local_size_x: SpvWord,
 local_size_y: SpvWord,
 local_size_z: SpvWord,
 
-pub fn init(allocator: std.mem.Allocator, ctx: *const Interpreter, source: []const SpvWord) ModuleError!Self {
+input_locations: std.AutoHashMap(SpvWord, *SpvMember),
+output_locations: std.AutoHashMap(SpvWord, *SpvMember),
+bindings: std.AutoHashMap(SpvBinding, *SpvMember),
+push_constants: []SpvMember,
+
+pub fn init(allocator: std.mem.Allocator, source: []const SpvWord) ModuleError!Self {
     var self: Self = std.mem.zeroInit(Self, .{
-        .ctx = ctx,
         .code = allocator.dupe(SpvWord, source) catch return ModuleError.OutOfMemory,
         .local_size_x = 1,
         .local_size_y = 1,
         .local_size_z = 1,
+        .input_locations = std.AutoHashMap(SpvWord, *SpvMember).init(allocator),
+        .output_locations = std.AutoHashMap(SpvWord, *SpvMember).init(allocator),
+        .bindings = std.AutoHashMap(SpvBinding, *SpvMember).init(allocator),
     });
     errdefer allocator.free(self.code);
 
     self.it = WordIterator.init(self.code);
 
     const magic = self.it.next() orelse return ModuleError.InvalidSpirV;
-    if (magic != lib.spv.SpvMagicNumber) return ModuleError.InvalidMagic;
+    if (magic != spv.SpvMagicNumber) {
+        return ModuleError.InvalidMagic;
+    }
+    if (!checkEndiannessFromSpvMagic(magic)) {
+        return ModuleError.UnsupportedEndianness;
+    }
 
     const version = self.it.next() orelse return ModuleError.InvalidSpirV;
     self.version_major = @intCast((version & 0x00FF0000) >> 16);
@@ -78,14 +92,22 @@ pub fn init(allocator: std.mem.Allocator, ctx: *const Interpreter, source: []con
 
     _ = self.it.skip(); // Skip schema
 
+    while (self.it.next()) |opcode| {
+        if (std.enums.fromInt(spv.SpvOp, opcode)) |spv_op| {
+            if (op.SetupDispatcher.get(spv_op)) |pfn| {
+                pfn(0, &self);
+            }
+        }
+    }
+
     std.log.scoped(.SPIRV_Interpreter).debug(
         \\Loaded shader module with infos:
         \\    SPIR-V version: {d}.{d}
-        \\    Generator:      {s} (ID {d}), encoded version {d}
+        \\    Generator:      {s} (ID {d}), encoded version 0x{X}
     , .{
         self.version_major,
         self.version_minor,
-        spv_data.vendorName(self.generator_id),
+        spv.vendorName(self.generator_id),
         self.generator_id,
         self.generator_version,
     });
@@ -93,6 +115,20 @@ pub fn init(allocator: std.mem.Allocator, ctx: *const Interpreter, source: []con
     return self;
 }
 
-pub fn deinit(self: *const Self, allocator: std.mem.Allocator) void {
-    allocator.free(self.code);
+fn checkEndiannessFromSpvMagic(magic: SpvWord) bool {
+    const bytes: [4]u8 = @bitCast(magic);
+    if (0x03 == bytes[0] and 0x02 == bytes[1] and 0x23 == bytes[2] and 0x07 == bytes[3]) {
+        return builtin.cpu.arch.endian() == .little;
+    }
+    if (0x07 == bytes[0] and 0x23 == bytes[1] and 0x02 == bytes[2] and 0x03 == bytes[3]) {
+        return builtin.cpu.arch.endian() == .big;
+    }
+    return false;
+}
+
+pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
+    allocator.free(self.code);
+    self.input_locations.deinit();
+    self.output_locations.deinit();
+    self.bindings.deinit();
 }

src/Runtime.zig

@@ -0,0 +1,41 @@
+const std = @import("std");
+const spv = @import("spv.zig");
+
+const SpvVoid = spv.SpvVoid;
+const SpvByte = spv.SpvByte;
+const SpvWord = spv.SpvWord;
+const SpvBool = spv.SpvBool;
+
+const Module = @import("Module.zig");
+const WordIterator = @import("WordIterator.zig");
+
+const Self = @This();
+
+pub const CallError = error{
+    Unreachable,
+    Killed,
+    Error,
+    InitEnd,
+    ExecEnd,
+};
+
+module: *Module,
+it: WordIterator,
+stack_frames: std.SinglyLinkedList,
+
+pub fn init(module: *Module) !Self {
+    return .{
+        .module = module,
+        .it = module.it,
+        .stack_frames = .{},
+    };
+}
+
+pub fn deinit(self: *const Self) void {
+    _ = self;
+}
+
+pub fn callEntryPoint(self: *Self, entry: SpvWord) CallError!void {
+    _ = self;
+    _ = entry;
+}

src/State.zig

@@ -1,9 +0,0 @@
-const std = @import("std");
-
-const Interpreter = @import("Interpreter.zig");
-const Module = @import("Module.zig");
-
-const Self = @This();
-
-ctx: *Interpreter,
-owner: *Module,

src/WordIterator.zig

@@ -1,6 +1,6 @@
-const lib = @import("lib.zig");
+const spv = @import("spv.zig");
 
-const SpvWord = lib.SpvWord;
+const SpvWord = spv.SpvWord;
 
 const Self = @This();
 

src/lib.zig

@@ -1,24 +1,16 @@
 const std = @import("std");
-pub const spv = @cImport(@cInclude("spirv.h"));
 
 pub const Image = @import("Image.zig");
-pub const Interpreter = @import("Interpreter.zig");
 pub const Module = @import("Module.zig");
-pub const State = @import("State.zig");
+pub const Runtime = @import("Runtime.zig");
 
-const opcode = @import("opcode.zig");
-const spv_data = @import("spv_data.zig");
-
-pub const SpvVoid = void;
-pub const SpvByte = u8;
-pub const SpvWord = u32;
-pub const SpvBool = bool;
+const opcodes = @import("opcodes.zig");
+const spv = @import("spv.zig");
 
 test {
     std.testing.refAllDecls(Image);
-    std.testing.refAllDecls(Interpreter);
     std.testing.refAllDecls(Module);
-    std.testing.refAllDecls(State);
-    std.testing.refAllDecls(opcode);
-    std.testing.refAllDecls(spv_data);
+    std.testing.refAllDecls(Runtime);
+    std.testing.refAllDecls(opcodes);
+    std.testing.refAllDecls(spv);
 }

src/opcodes.zig

@@ -0,0 +1,26 @@
+const std = @import("std");
+const spv = @import("spv.zig");
+
+const Module = @import("Module.zig");
+const Runtime = @import("Runtime.zig");
+
+const SpvVoid = spv.SpvVoid;
+const SpvByte = spv.SpvByte;
+const SpvWord = spv.SpvWord;
+const SpvBool = spv.SpvBool;
+
+pub const OpCodeSetupFunc = *const fn (SpvWord, *Module) void;
+pub const OpCodeExecFunc = *const fn (SpvWord, *Runtime) void;
+
+pub const SetupDispatcher = block: {
+    @setEvalBranchQuota(65535);
+    break :block std.EnumMap(spv.SpvOp, OpCodeSetupFunc).init(.{
+        .Capability = OpCapability,
+    });
+};
+
+fn OpCapability(word_count: SpvWord, mod: *Module) void {
+    _ = word_count;
+    _ = mod;
+    std.debug.print("test\n", .{});
+}

src/spv_data.zig

@@ -1,76 +0,0 @@
-const lib = @import("lib.zig");
-const spv = lib.spv;
-
-pub const SourceLanguage = enum(u32) {
-    Unknown = 0,
-    ESSL = 1,
-    GLSL = 2,
-    OpenCL_C = 3,
-    OpenCL_CPP = 4,
-    HLSL = 5,
-    CPP_for_OpenCL = 6,
-    SYCL = 7,
-    HERO_C = 8,
-    NZSL = 9,
-    WGSL = 10,
-    Slang = 11,
-    Zig = 12,
-    Rust = 13,
-};
-
-pub fn vendorName(id: u32) []const u8 {
-    return switch (id) {
-        0 => "Khronos",
-        1 => "LunarG",
-        2 => "Valve",
-        3 => "Codeplay",
-        4 => "NVIDIA",
-        5 => "ARM",
-        6 => "Khronos LLVM/SPIR-V Translator",
-        7 => "Khronos SPIR-V Tools Assembler",
-        8 => "Khronos Glslang Reference Front End",
-        9 => "Qualcomm",
-        10 => "AMD",
-        11 => "Intel",
-        12 => "Imagination",
-        13 => "Google Shaderc over Glslang",
-        14 => "Google spiregg",
-        15 => "Google rspirv",
-        16 => "X-LEGEND Mesa-IR/SPIR-V Translator",
-        17 => "Khronos SPIR-V Tools Linker",
-        18 => "Wine VKD3D Shader Compiler",
-        19 => "Tellusim Clay Shader Compiler",
-        20 => "W3C WebGPU Group WHLSL Shader Translator",
-        21 => "Google Clspv",
-        22 => "LLVM MLIR SPIR-V Serializer",
-        23 => "Google Tint Compiler",
-        24 => "Google ANGLE Shader Compiler",
-        25 => "Netease Games Messiah Shader Compiler",
-        26 => "Xenia Xenia Emulator Microcode Translator",
-        27 => "Embark Studios Rust GPU Compiler Backend",
-        28 => "gfx-rs community Naga",
-        29 => "Mikkosoft Productions MSP Shader Compiler",
-        30 => "SpvGenTwo community SpvGenTwo SPIR-V IR Tools",
-        31 => "Google Skia SkSL",
-        32 => "TornadoVM Beehive SPIRV Toolkit",
-        33 => "DragonJoker ShaderWriter",
-        34 => "Rayan Hatout SPIRVSmith",
-        35 => "Saarland University Shady",
-        36 => "Taichi Graphics Taichi",
-        37 => "heroseh Hero C Compiler",
-        38 => "Meta SparkSL",
-        39 => "SirLynix Nazara ShaderLang Compiler",
-        40 => "Khronos Slang Compiler",
-        41 => "Zig Software Foundation Zig Compiler",
-        42 => "Rendong Liang spq",
-        43 => "LLVM LLVM SPIR-V Backend",
-        44 => "Robert Konrad Kongruent",
-        45 => "Kitsunebi Games Nuvk SPIR-V Emitter and DLSL compiler",
-        46 => "Nintendo",
-        47 => "ARM",
-        48 => "Goopax",
-        49 => "Icyllis Milica Arc3D Shader Compiler",
-
-        else => "Unknown",
-    };
-}