spirv: refactor

src/Zcu/PerThread.zig

@@ -4398,13 +4398,10 @@ fn runCodegenInner(pt: Zcu.PerThread, func_index: InternPool.Index, air: *Air) e
 
     const lf = comp.bin_file orelse return error.NoLinkFile;
 
-    // TODO: self-hosted codegen should always have a type of MIR; codegen should produce that MIR,
+    // Just like LLVM, the SPIR-V backend can't multi-threaded due to SPIR-V design limitations.
-    // and the linker should consume it. However, our SPIR-V backend is currently tightly coupled
-    // with our SPIR-V linker, so needs to work more like the LLVM backend. This should be fixed to
-    // unblock threaded codegen for SPIR-V.
     if (lf.cast(.spirv)) |spirv_file| {
         assert(pt.tid == .main); // SPIR-V has a lot of shared state
-        spirv_file.object.updateFunc(pt, func_index, air, &liveness) catch |err| {
+        spirv_file.updateFunc(pt, func_index, air, &liveness) catch |err| {
             switch (err) {
                 error.OutOfMemory => comp.link_diags.setAllocFailure(),
             }

src/arch/spirv/Module.zig

@@ -0,0 +1,755 @@
+//! This structure represents a SPIR-V (sections) module being compiled, and keeps
+//! track of all relevant information. That includes the actual instructions, the
+//! current result-id bound, and data structures for querying result-id's of data
+//! which needs to be persistent over different calls to Decl code generation.
+//!
+//! A SPIR-V binary module supports both little- and big endian layout. The layout
+//! is detected by the magic word in the header. Therefore, we can ignore any byte
+//! order throughout the implementation, and just use the host byte order, and make
+//! this a problem for the consumer.
+const Module = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
+const autoHashStrat = std.hash.autoHashStrat;
+const Wyhash = std.hash.Wyhash;
+
+const InternPool = @import("../../InternPool.zig");
+const spec = @import("spec.zig");
+const Word = spec.Word;
+const Id = spec.Id;
+
+const Section = @import("Section.zig");
+
+/// Declarations, both functions and globals, can have dependencies. These are used for 2 things:
+/// - Globals must be declared before they are used, also between globals. The compiler processes
+///   globals unordered, so we must use the dependencies here to figure out how to order the globals
+///   in the final module. The Globals structure is also used for that.
+/// - Entry points must declare the complete list of OpVariable instructions that they access.
+///   For these we use the same dependency structure.
+/// In this mechanism, globals will only depend on other globals, while functions may depend on
+/// globals or other functions.
+pub const Decl = struct {
+    /// Index to refer to a Decl by.
+    pub const Index = enum(u32) { _ };
+
+    /// Useful to tell what kind of decl this is, and hold the result-id or field index
+    /// to be used for this decl.
+    pub const Kind = enum {
+        func,
+        global,
+        invocation_global,
+    };
+
+    /// See comment on Kind
+    kind: Kind,
+    /// The result-id associated to this decl. The specific meaning of this depends on `kind`:
+    /// - For `func`, this is the result-id of the associated OpFunction instruction.
+    /// - For `global`, this is the result-id of the associated OpVariable instruction.
+    /// - For `invocation_global`, this is the result-id of the associated InvocationGlobal instruction.
+    result_id: Id,
+    /// The offset of the first dependency of this decl in the `decl_deps` array.
+    begin_dep: u32,
+    /// The past-end offset of the dependencies of this decl in the `decl_deps` array.
+    end_dep: u32,
+};
+
+/// This models a kernel entry point.
+pub const EntryPoint = struct {
+    /// The declaration that should be exported.
+    decl_index: Decl.Index,
+    /// The name of the kernel to be exported.
+    name: []const u8,
+    /// Calling Convention
+    exec_model: spec.ExecutionModel,
+    exec_mode: ?spec.ExecutionMode = null,
+};
+
+gpa: Allocator,
+target: *const std.Target,
+nav_link: std.AutoHashMapUnmanaged(InternPool.Nav.Index, Decl.Index) = .empty,
+uav_link: std.AutoHashMapUnmanaged(struct { InternPool.Index, spec.StorageClass }, Decl.Index) = .empty,
+intern_map: std.AutoHashMapUnmanaged(struct { InternPool.Index, Repr }, Id) = .empty,
+decls: std.ArrayListUnmanaged(Decl) = .empty,
+decl_deps: std.ArrayListUnmanaged(Decl.Index) = .empty,
+entry_points: std.AutoArrayHashMapUnmanaged(Id, EntryPoint) = .empty,
+/// This map serves a dual purpose:
+/// - It keeps track of pointers that are currently being emitted, so that we can tell
+///   if they are recursive and need an OpTypeForwardPointer.
+/// - It caches pointers by child-type. This is required because sometimes we rely on
+///   ID-equality for pointers, and pointers constructed via `ptrType()` aren't interned
+///   via the usual `intern_map` mechanism.
+ptr_types: std.AutoHashMapUnmanaged(
+    struct { InternPool.Index, spec.StorageClass, Repr },
+    struct { ty_id: Id, fwd_emitted: bool },
+) = .{},
+/// For test declarations compiled for Vulkan target, we have to add a buffer.
+/// We only need to generate this once, this holds the link information related to that.
+error_buffer: ?Decl.Index = null,
+/// SPIR-V instructions return result-ids.
+/// This variable holds the module-wide counter for these.
+next_result_id: Word = 1,
+/// Some types shouldn't be emitted more than one time, but cannot be caught by
+/// the `intern_map` during codegen. Sometimes, IDs are compared to check if
+/// types are the same, so we can't delay until the dedup pass. Therefore,
+/// this is an ad-hoc structure to cache types where required.
+/// According to the SPIR-V specification, section 2.8, this includes all non-aggregate
+/// non-pointer types.
+/// Additionally, this is used for other values which can be cached, for example,
+/// built-in variables.
+cache: struct {
+    bool_type: ?Id = null,
+    void_type: ?Id = null,
+    int_types: std.AutoHashMapUnmanaged(std.builtin.Type.Int, Id) = .empty,
+    float_types: std.AutoHashMapUnmanaged(std.builtin.Type.Float, Id) = .empty,
+    vector_types: std.AutoHashMapUnmanaged(struct { Id, u32 }, Id) = .empty,
+    array_types: std.AutoHashMapUnmanaged(struct { Id, Id }, Id) = .empty,
+
+    capabilities: std.AutoHashMapUnmanaged(spec.Capability, void) = .empty,
+    extensions: std.StringHashMapUnmanaged(void) = .empty,
+    extended_instruction_set: std.AutoHashMapUnmanaged(spec.InstructionSet, Id) = .empty,
+    decorations: std.AutoHashMapUnmanaged(struct { Id, spec.Decoration }, void) = .empty,
+    builtins: std.AutoHashMapUnmanaged(struct { Id, spec.BuiltIn }, Decl.Index) = .empty,
+
+    bool_const: [2]?Id = .{ null, null },
+} = .{},
+/// Module layout, according to SPIR-V Spec section 2.4, "Logical Layout of a Module".
+sections: struct {
+    capabilities: Section = .{},
+    extensions: Section = .{},
+    extended_instruction_set: Section = .{},
+    memory_model: Section = .{},
+    execution_modes: Section = .{},
+    debug_strings: Section = .{},
+    debug_names: Section = .{},
+    annotations: Section = .{},
+    globals: Section = .{},
+    functions: Section = .{},
+} = .{},
+
+/// Data can be lowered into in two basic representations: indirect, which is when
+/// a type is stored in memory, and direct, which is how a type is stored when its
+/// a direct SPIR-V value.
+pub const Repr = enum {
+    /// A SPIR-V value as it would be used in operations.
+    direct,
+    /// A SPIR-V value as it is stored in memory.
+    indirect,
+};
+
+pub fn deinit(module: *Module) void {
+    module.nav_link.deinit(module.gpa);
+    module.uav_link.deinit(module.gpa);
+    module.intern_map.deinit(module.gpa);
+    module.ptr_types.deinit(module.gpa);
+
+    module.sections.capabilities.deinit(module.gpa);
+    module.sections.extensions.deinit(module.gpa);
+    module.sections.extended_instruction_set.deinit(module.gpa);
+    module.sections.memory_model.deinit(module.gpa);
+    module.sections.execution_modes.deinit(module.gpa);
+    module.sections.debug_strings.deinit(module.gpa);
+    module.sections.debug_names.deinit(module.gpa);
+    module.sections.annotations.deinit(module.gpa);
+    module.sections.globals.deinit(module.gpa);
+    module.sections.functions.deinit(module.gpa);
+
+    module.cache.int_types.deinit(module.gpa);
+    module.cache.float_types.deinit(module.gpa);
+    module.cache.vector_types.deinit(module.gpa);
+    module.cache.array_types.deinit(module.gpa);
+    module.cache.capabilities.deinit(module.gpa);
+    module.cache.extensions.deinit(module.gpa);
+    module.cache.extended_instruction_set.deinit(module.gpa);
+    module.cache.decorations.deinit(module.gpa);
+    module.cache.builtins.deinit(module.gpa);
+
+    module.decls.deinit(module.gpa);
+    module.decl_deps.deinit(module.gpa);
+
+    for (module.entry_points.values()) |ep| {
+        module.gpa.free(ep.name);
+    }
+    module.entry_points.deinit(module.gpa);
+
+    module.* = undefined;
+}
+
+/// Fetch or allocate a result id for nav index. This function also marks the nav as alive.
+/// Note: Function does not actually generate the nav, it just allocates an index.
+pub fn resolveNav(module: *Module, ip: *InternPool, nav_index: InternPool.Nav.Index) !Decl.Index {
+    const entry = try module.nav_link.getOrPut(module.gpa, nav_index);
+    if (!entry.found_existing) {
+        const nav = ip.getNav(nav_index);
+        // TODO: Extern fn?
+        const kind: Decl.Kind = if (ip.isFunctionType(nav.typeOf(ip)))
+            .func
+        else switch (nav.getAddrspace()) {
+            .generic => .invocation_global,
+            else => .global,
+        };
+
+        entry.value_ptr.* = try module.allocDecl(kind);
+    }
+
+    return entry.value_ptr.*;
+}
+
+pub fn allocIds(module: *Module, n: u32) spec.IdRange {
+    defer module.next_result_id += n;
+    return .{ .base = module.next_result_id, .len = n };
+}
+
+pub fn allocId(module: *Module) Id {
+    return module.allocIds(1).at(0);
+}
+
+pub fn idBound(module: Module) Word {
+    return module.next_result_id;
+}
+
+pub fn addEntryPointDeps(
+    module: *Module,
+    decl_index: Decl.Index,
+    seen: *std.DynamicBitSetUnmanaged,
+    interface: *std.ArrayList(Id),
+) !void {
+    const decl = module.declPtr(decl_index);
+    const deps = module.decl_deps.items[decl.begin_dep..decl.end_dep];
+
+    if (seen.isSet(@intFromEnum(decl_index))) {
+        return;
+    }
+
+    seen.set(@intFromEnum(decl_index));
+
+    if (decl.kind == .global) {
+        try interface.append(decl.result_id);
+    }
+
+    for (deps) |dep| {
+        try module.addEntryPointDeps(dep, seen, interface);
+    }
+}
+
+fn entryPoints(module: *Module) !Section {
+    var entry_points = Section{};
+    errdefer entry_points.deinit(module.gpa);
+
+    var interface = std.ArrayList(Id).init(module.gpa);
+    defer interface.deinit();
+
+    var seen = try std.DynamicBitSetUnmanaged.initEmpty(module.gpa, module.decls.items.len);
+    defer seen.deinit(module.gpa);
+
+    for (module.entry_points.keys(), module.entry_points.values()) |entry_point_id, entry_point| {
+        interface.items.len = 0;
+        seen.setRangeValue(.{ .start = 0, .end = module.decls.items.len }, false);
+
+        try module.addEntryPointDeps(entry_point.decl_index, &seen, &interface);
+        try entry_points.emit(module.gpa, .OpEntryPoint, .{
+            .execution_model = entry_point.exec_model,
+            .entry_point = entry_point_id,
+            .name = entry_point.name,
+            .interface = interface.items,
+        });
+
+        if (entry_point.exec_mode == null and entry_point.exec_model == .fragment) {
+            switch (module.target.os.tag) {
+                .vulkan, .opengl => |tag| {
+                    try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{
+                        .entry_point = entry_point_id,
+                        .mode = if (tag == .vulkan) .origin_upper_left else .origin_lower_left,
+                    });
+                },
+                .opencl => {},
+                else => unreachable,
+            }
+        }
+    }
+
+    return entry_points;
+}
+
+pub fn finalize(module: *Module, gpa: Allocator) ![]Word {
+    const target = module.target;
+
+    // Emit capabilities and extensions
+    switch (target.os.tag) {
+        .opengl => {
+            try module.addCapability(.shader);
+            try module.addCapability(.matrix);
+        },
+        .vulkan => {
+            try module.addCapability(.shader);
+            try module.addCapability(.matrix);
+            if (target.cpu.arch == .spirv64) {
+                try module.addExtension("SPV_KHR_physical_storage_buffer");
+                try module.addCapability(.physical_storage_buffer_addresses);
+            }
+        },
+        .opencl, .amdhsa => {
+            try module.addCapability(.kernel);
+            try module.addCapability(.addresses);
+        },
+        else => unreachable,
+    }
+    if (target.cpu.arch == .spirv64) try module.addCapability(.int64);
+    if (target.cpu.has(.spirv, .int64)) try module.addCapability(.int64);
+    if (target.cpu.has(.spirv, .float16)) try module.addCapability(.float16);
+    if (target.cpu.has(.spirv, .float64)) try module.addCapability(.float64);
+    if (target.cpu.has(.spirv, .generic_pointer)) try module.addCapability(.generic_pointer);
+    if (target.cpu.has(.spirv, .vector16)) try module.addCapability(.vector16);
+    if (target.cpu.has(.spirv, .storage_push_constant16)) {
+        try module.addExtension("SPV_KHR_16bit_storage");
+        try module.addCapability(.storage_push_constant16);
+    }
+    if (target.cpu.has(.spirv, .arbitrary_precision_integers)) {
+        try module.addExtension("SPV_INTEL_arbitrary_precision_integers");
+        try module.addCapability(.arbitrary_precision_integers_intel);
+    }
+    if (target.cpu.has(.spirv, .variable_pointers)) {
+        try module.addExtension("SPV_KHR_variable_pointers");
+        try module.addCapability(.variable_pointers_storage_buffer);
+        try module.addCapability(.variable_pointers);
+    }
+    // These are well supported
+    try module.addCapability(.int8);
+    try module.addCapability(.int16);
+
+    // Emit memory model
+    const addressing_model: spec.AddressingModel = switch (target.os.tag) {
+        .opengl => .logical,
+        .vulkan => if (target.cpu.arch == .spirv32) .logical else .physical_storage_buffer64,
+        .opencl => if (target.cpu.arch == .spirv32) .physical32 else .physical64,
+        .amdhsa => .physical64,
+        else => unreachable,
+    };
+    try module.sections.memory_model.emit(module.gpa, .OpMemoryModel, .{
+        .addressing_model = addressing_model,
+        .memory_model = switch (target.os.tag) {
+            .opencl => .open_cl,
+            .vulkan, .opengl => .glsl450,
+            else => unreachable,
+        },
+    });
+
+    var entry_points = try module.entryPoints();
+    defer entry_points.deinit(module.gpa);
+
+    const version: spec.Version = .{
+        .major = 1,
+        .minor = blk: {
+            // Prefer higher versions
+            if (target.cpu.has(.spirv, .v1_6)) break :blk 6;
+            if (target.cpu.has(.spirv, .v1_5)) break :blk 5;
+            if (target.cpu.has(.spirv, .v1_4)) break :blk 4;
+            if (target.cpu.has(.spirv, .v1_3)) break :blk 3;
+            if (target.cpu.has(.spirv, .v1_2)) break :blk 2;
+            if (target.cpu.has(.spirv, .v1_1)) break :blk 1;
+            break :blk 0;
+        },
+    };
+
+    const header = [_]Word{
+        spec.magic_number,
+        version.toWord(),
+        spec.zig_generator_id,
+        module.idBound(),
+        0, // Schema (currently reserved for future use)
+    };
+
+    var source = Section{};
+    defer source.deinit(module.gpa);
+    try module.sections.debug_strings.emit(module.gpa, .OpSource, .{
+        .source_language = .zig,
+        .version = 0,
+        // We cannot emit these because the Khronos translator does not parse this instruction
+        // correctly.
+        // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/2188
+        .file = null,
+        .source = null,
+    });
+
+    // Note: needs to be kept in order according to section 2.3!
+    const buffers = &[_][]const Word{
+        &header,
+        module.sections.capabilities.toWords(),
+        module.sections.extensions.toWords(),
+        module.sections.extended_instruction_set.toWords(),
+        module.sections.memory_model.toWords(),
+        entry_points.toWords(),
+        module.sections.execution_modes.toWords(),
+        source.toWords(),
+        module.sections.debug_strings.toWords(),
+        module.sections.debug_names.toWords(),
+        module.sections.annotations.toWords(),
+        module.sections.globals.toWords(),
+        module.sections.functions.toWords(),
+    };
+
+    var total_result_size: usize = 0;
+    for (buffers) |buffer| {
+        total_result_size += buffer.len;
+    }
+    const result = try gpa.alloc(Word, total_result_size);
+    errdefer comptime unreachable;
+
+    var offset: usize = 0;
+    for (buffers) |buffer| {
+        @memcpy(result[offset..][0..buffer.len], buffer);
+        offset += buffer.len;
+    }
+
+    return result;
+}
+
+pub fn addCapability(module: *Module, cap: spec.Capability) !void {
+    const entry = try module.cache.capabilities.getOrPut(module.gpa, cap);
+    if (entry.found_existing) return;
+    try module.sections.capabilities.emit(module.gpa, .OpCapability, .{ .capability = cap });
+}
+
+pub fn addExtension(module: *Module, ext: []const u8) !void {
+    const entry = try module.cache.extensions.getOrPut(module.gpa, ext);
+    if (entry.found_existing) return;
+    try module.sections.extensions.emit(module.gpa, .OpExtension, .{ .name = ext });
+}
+
+/// Imports or returns the existing id of an extended instruction set
+pub fn importInstructionSet(module: *Module, set: spec.InstructionSet) !Id {
+    assert(set != .core);
+
+    const gop = try module.cache.extended_instruction_set.getOrPut(module.gpa, set);
+    if (gop.found_existing) return gop.value_ptr.*;
+
+    const result_id = module.allocId();
+    try module.sections.extended_instruction_set.emit(module.gpa, .OpExtInstImport, .{
+        .id_result = result_id,
+        .name = @tagName(set),
+    });
+    gop.value_ptr.* = result_id;
+
+    return result_id;
+}
+
+pub fn structType(module: *Module, result_id: Id, types: []const Id, maybe_names: ?[]const []const u8) !void {
+    try module.sections.globals.emit(module.gpa, .OpTypeStruct, .{
+        .id_result = result_id,
+        .id_ref = types,
+    });
+
+    if (maybe_names) |names| {
+        assert(names.len == types.len);
+        for (names, 0..) |name, i| {
+            try module.memberDebugName(result_id, @intCast(i), name);
+        }
+    }
+}
+
+pub fn boolType(module: *Module) !Id {
+    if (module.cache.bool_type) |id| return id;
+
+    const result_id = module.allocId();
+    try module.sections.globals.emit(module.gpa, .OpTypeBool, .{
+        .id_result = result_id,
+    });
+    module.cache.bool_type = result_id;
+    return result_id;
+}
+
+pub fn voidType(module: *Module) !Id {
+    if (module.cache.void_type) |id| return id;
+
+    const result_id = module.allocId();
+    try module.sections.globals.emit(module.gpa, .OpTypeVoid, .{
+        .id_result = result_id,
+    });
+    module.cache.void_type = result_id;
+    try module.debugName(result_id, "void");
+    return result_id;
+}
+
+pub fn intType(module: *Module, signedness: std.builtin.Signedness, bits: u16) !Id {
+    assert(bits > 0);
+    const entry = try module.cache.int_types.getOrPut(module.gpa, .{ .signedness = signedness, .bits = bits });
+    if (!entry.found_existing) {
+        const result_id = module.allocId();
+        entry.value_ptr.* = result_id;
+        try module.sections.globals.emit(module.gpa, .OpTypeInt, .{
+            .id_result = result_id,
+            .width = bits,
+            .signedness = switch (signedness) {
+                .signed => 1,
+                .unsigned => 0,
+            },
+        });
+
+        switch (signedness) {
+            .signed => try module.debugNameFmt(result_id, "i{}", .{bits}),
+            .unsigned => try module.debugNameFmt(result_id, "u{}", .{bits}),
+        }
+    }
+    return entry.value_ptr.*;
+}
+
+pub fn floatType(module: *Module, bits: u16) !Id {
+    assert(bits > 0);
+    const entry = try module.cache.float_types.getOrPut(module.gpa, .{ .bits = bits });
+    if (!entry.found_existing) {
+        const result_id = module.allocId();
+        entry.value_ptr.* = result_id;
+        try module.sections.globals.emit(module.gpa, .OpTypeFloat, .{
+            .id_result = result_id,
+            .width = bits,
+        });
+        try module.debugNameFmt(result_id, "f{}", .{bits});
+    }
+    return entry.value_ptr.*;
+}
+
+pub fn vectorType(module: *Module, len: u32, child_ty_id: Id) !Id {
+    const entry = try module.cache.vector_types.getOrPut(module.gpa, .{ child_ty_id, len });
+    if (!entry.found_existing) {
+        const result_id = module.allocId();
+        entry.value_ptr.* = result_id;
+        try module.sections.globals.emit(module.gpa, .OpTypeVector, .{
+            .id_result = result_id,
+            .component_type = child_ty_id,
+            .component_count = len,
+        });
+    }
+    return entry.value_ptr.*;
+}
+
+pub fn arrayType(module: *Module, len_id: Id, child_ty_id: Id) !Id {
+    const entry = try module.cache.array_types.getOrPut(module.gpa, .{ child_ty_id, len_id });
+    if (!entry.found_existing) {
+        const result_id = module.allocId();
+        entry.value_ptr.* = result_id;
+        try module.sections.globals.emit(module.gpa, .OpTypeArray, .{
+            .id_result = result_id,
+            .element_type = child_ty_id,
+            .length = len_id,
+        });
+    }
+    return entry.value_ptr.*;
+}
+
+pub fn functionType(module: *Module, return_ty_id: Id, param_type_ids: []const Id) !Id {
+    const result_id = module.allocId();
+    try module.sections.globals.emit(module.gpa, .OpTypeFunction, .{
+        .id_result = result_id,
+        .return_type = return_ty_id,
+        .id_ref_2 = param_type_ids,
+    });
+    return result_id;
+}
+
+pub fn constant(module: *Module, result_ty_id: Id, value: spec.LiteralContextDependentNumber) !Id {
+    const result_id = module.allocId();
+    const section = &module.sections.globals;
+    try section.emit(module.gpa, .OpConstant, .{
+        .id_result_type = result_ty_id,
+        .id_result = result_id,
+        .value = value,
+    });
+    return result_id;
+}
+
+pub fn constBool(module: *Module, value: bool) !Id {
+    if (module.cache.bool_const[@intFromBool(value)]) |b| return b;
+
+    const result_ty_id = try module.boolType();
+    const result_id = module.allocId();
+    module.cache.bool_const[@intFromBool(value)] = result_id;
+
+    switch (value) {
+        inline else => |value_ct| try module.sections.globals.emit(
+            module.gpa,
+            if (value_ct) .OpConstantTrue else .OpConstantFalse,
+            .{
+                .id_result_type = result_ty_id,
+                .id_result = result_id,
+            },
+        ),
+    }
+
+    return result_id;
+}
+
+/// Return a pointer to a builtin variable. `result_ty_id` must be a **pointer**
+/// with storage class `.Input`.
+pub fn builtin(module: *Module, result_ty_id: Id, spirv_builtin: spec.BuiltIn) !Decl.Index {
+    const entry = try module.cache.builtins.getOrPut(module.gpa, .{ result_ty_id, spirv_builtin });
+    if (!entry.found_existing) {
+        const decl_index = try module.allocDecl(.global);
+        const result_id = module.declPtr(decl_index).result_id;
+        entry.value_ptr.* = decl_index;
+        try module.sections.globals.emit(module.gpa, .OpVariable, .{
+            .id_result_type = result_ty_id,
+            .id_result = result_id,
+            .storage_class = .input,
+        });
+        try module.decorate(result_id, .{ .built_in = .{ .built_in = spirv_builtin } });
+        try module.declareDeclDeps(decl_index, &.{});
+    }
+    return entry.value_ptr.*;
+}
+
+pub fn constUndef(module: *Module, ty_id: Id) !Id {
+    const result_id = module.allocId();
+    try module.sections.globals.emit(module.gpa, .OpUndef, .{
+        .id_result_type = ty_id,
+        .id_result = result_id,
+    });
+    return result_id;
+}
+
+pub fn constNull(module: *Module, ty_id: Id) !Id {
+    const result_id = module.allocId();
+    try module.sections.globals.emit(module.gpa, .OpConstantNull, .{
+        .id_result_type = ty_id,
+        .id_result = result_id,
+    });
+    return result_id;
+}
+
+/// Decorate a result-id.
+pub fn decorate(
+    module: *Module,
+    target: Id,
+    decoration: spec.Decoration.Extended,
+) !void {
+    const entry = try module.cache.decorations.getOrPut(module.gpa, .{ target, decoration });
+    if (!entry.found_existing) {
+        try module.sections.annotations.emit(module.gpa, .OpDecorate, .{
+            .target = target,
+            .decoration = decoration,
+        });
+    }
+}
+
+/// Decorate a result-id which is a member of some struct.
+/// We really don't have to and shouldn't need to cache this.
+pub fn decorateMember(
+    module: *Module,
+    structure_type: Id,
+    member: u32,
+    decoration: spec.Decoration.Extended,
+) !void {
+    try module.sections.annotations.emit(module.gpa, .OpMemberDecorate, .{
+        .structure_type = structure_type,
+        .member = member,
+        .decoration = decoration,
+    });
+}
+
+pub fn allocDecl(module: *Module, kind: Decl.Kind) !Decl.Index {
+    try module.decls.append(module.gpa, .{
+        .kind = kind,
+        .result_id = module.allocId(),
+        .begin_dep = undefined,
+        .end_dep = undefined,
+    });
+
+    return @as(Decl.Index, @enumFromInt(@as(u32, @intCast(module.decls.items.len - 1))));
+}
+
+pub fn declPtr(module: *Module, index: Decl.Index) *Decl {
+    return &module.decls.items[@intFromEnum(index)];
+}
+
+/// Declare ALL dependencies for a decl.
+pub fn declareDeclDeps(module: *Module, decl_index: Decl.Index, deps: []const Decl.Index) !void {
+    const begin_dep: u32 = @intCast(module.decl_deps.items.len);
+    try module.decl_deps.appendSlice(module.gpa, deps);
+    const end_dep: u32 = @intCast(module.decl_deps.items.len);
+
+    const decl = module.declPtr(decl_index);
+    decl.begin_dep = begin_dep;
+    decl.end_dep = end_dep;
+}
+
+/// Declare a SPIR-V function as an entry point. This causes an extra wrapper
+/// function to be generated, which is then exported as the real entry point. The purpose of this
+/// wrapper is to allocate and initialize the structure holding the instance globals.
+pub fn declareEntryPoint(
+    module: *Module,
+    decl_index: Decl.Index,
+    name: []const u8,
+    exec_model: spec.ExecutionModel,
+    exec_mode: ?spec.ExecutionMode,
+) !void {
+    const gop = try module.entry_points.getOrPut(module.gpa, module.declPtr(decl_index).result_id);
+    gop.value_ptr.decl_index = decl_index;
+    gop.value_ptr.name = name;
+    gop.value_ptr.exec_model = exec_model;
+    // Might've been set by assembler
+    if (!gop.found_existing) gop.value_ptr.exec_mode = exec_mode;
+}
+
+pub fn debugName(module: *Module, target: Id, name: []const u8) !void {
+    try module.sections.debug_names.emit(module.gpa, .OpName, .{
+        .target = target,
+        .name = name,
+    });
+}
+
+pub fn debugNameFmt(module: *Module, target: Id, comptime fmt: []const u8, args: anytype) !void {
+    const name = try std.fmt.allocPrint(module.gpa, fmt, args);
+    defer module.gpa.free(name);
+    try module.debugName(target, name);
+}
+
+pub fn memberDebugName(module: *Module, target: Id, member: u32, name: []const u8) !void {
+    try module.sections.debug_names.emit(module.gpa, .OpMemberName, .{
+        .type = target,
+        .member = member,
+        .name = name,
+    });
+}
+
+pub fn storageClass(module: *Module, as: std.builtin.AddressSpace) spec.StorageClass {
+    return switch (as) {
+        .generic => if (module.target.cpu.has(.spirv, .generic_pointer)) .generic else .function,
+        .global => switch (module.target.os.tag) {
+            .opencl, .amdhsa => .cross_workgroup,
+            else => .storage_buffer,
+        },
+        .push_constant => {
+            return .push_constant;
+        },
+        .output => {
+            return .output;
+        },
+        .uniform => {
+            return .uniform;
+        },
+        .storage_buffer => {
+            return .storage_buffer;
+        },
+        .physical_storage_buffer => {
+            return .physical_storage_buffer;
+        },
+        .constant => .uniform_constant,
+        .shared => .workgroup,
+        .local => .function,
+        .input => .input,
+        .gs,
+        .fs,
+        .ss,
+        .param,
+        .flash,
+        .flash1,
+        .flash2,
+        .flash3,
+        .flash4,
+        .flash5,
+        .cog,
+        .lut,
+        .hub,
+        => unreachable,
+    };
+}

src/arch/spirv/Section.zig

@@ -13,8 +13,6 @@ const Log2Word = std.math.Log2Int(Word);
 
 const Opcode = spec.Opcode;
 
-/// The instructions in this section. Memory is owned by the Module
-/// externally associated to this Section.
 instructions: std.ArrayListUnmanaged(Word) = .empty,
 
 pub fn deinit(section: *Section, allocator: Allocator) void {
@@ -22,7 +20,6 @@ pub fn deinit(section: *Section, allocator: Allocator) void {
     section.* = undefined;
 }
 
-/// Clear the instructions in this section
 pub fn reset(section: *Section) void {
     section.instructions.items.len = 0;
 }
@@ -36,9 +33,12 @@ pub fn append(section: *Section, allocator: Allocator, other_section: Section) !
     try section.instructions.appendSlice(allocator, other_section.instructions.items);
 }
 
-/// Ensure capacity of at least `capacity` more words in this section.
+pub fn ensureUnusedCapacity(
-pub fn ensureUnusedCapacity(section: *Section, allocator: Allocator, capacity: usize) !void {
+    section: *Section,
-    try section.instructions.ensureUnusedCapacity(allocator, capacity);
+    allocator: Allocator,
+    words: usize,
+) !void {
+    try section.instructions.ensureUnusedCapacity(allocator, words);
 }
 
 /// Write an instruction and size, operands are to be inserted manually.
@@ -46,7 +46,7 @@ pub fn emitRaw(
     section: *Section,
     allocator: Allocator,
     opcode: Opcode,
-    operand_words: usize, // opcode itself not included
+    operand_words: usize,
 ) !void {
     const word_count = 1 + operand_words;
     try section.instructions.ensureUnusedCapacity(allocator, word_count);
@@ -64,6 +64,16 @@ pub fn emitRawInstruction(
     section.writeWords(operands);
 }
 
+pub fn emitAssumeCapacity(
+    section: *Section,
+    comptime opcode: spec.Opcode,
+    operands: opcode.Operands(),
+) !void {
+    const word_count = instructionSize(opcode, operands);
+    section.writeWord(@as(Word, @intCast(word_count << 16)) | @intFromEnum(opcode));
+    section.writeOperands(opcode.Operands(), operands);
+}
+
 pub fn emit(
     section: *Section,
     allocator: Allocator,
@@ -86,25 +96,6 @@ pub fn emitBranch(
     });
 }
 
-pub fn emitSpecConstantOp(
-    section: *Section,
-    allocator: Allocator,
-    comptime opcode: spec.Opcode,
-    operands: opcode.Operands(),
-) !void {
-    const word_count = operandsSize(opcode.Operands(), operands);
-    try section.emitRaw(allocator, .OpSpecConstantOp, 1 + word_count);
-    section.writeOperand(spec.Id, operands.id_result_type);
-    section.writeOperand(spec.Id, operands.id_result);
-    section.writeOperand(Opcode, opcode);
-
-    const fields = @typeInfo(opcode.Operands()).@"struct".fields;
-    // First 2 fields are always id_result_type and id_result.
-    inline for (fields[2..]) |field| {
-        section.writeOperand(field.type, @field(operands, field.name));
-    }
-}
-
 pub fn writeWord(section: *Section, word: Word) void {
     section.instructions.appendAssumeCapacity(word);
 }
@@ -126,7 +117,6 @@ fn writeOperands(section: *Section, comptime Operands: type, operands: Operands)
         .void => return,
         else => unreachable,
     };
-
     inline for (fields) |field| {
         section.writeOperand(field.type, @field(operands, field.name));
     }
@@ -134,30 +124,18 @@ fn writeOperands(section: *Section, comptime Operands: type, operands: Operands)
 
 pub fn writeOperand(section: *Section, comptime Operand: type, operand: Operand) void {
     switch (Operand) {
+        spec.LiteralSpecConstantOpInteger => unreachable,
         spec.Id => section.writeWord(@intFromEnum(operand)),
-
         spec.LiteralInteger => section.writeWord(operand),
-
         spec.LiteralString => section.writeString(operand),
-
         spec.LiteralContextDependentNumber => section.writeContextDependentNumber(operand),
-
         spec.LiteralExtInstInteger => section.writeWord(operand.inst),
-
-        // TODO: Where this type is used (OpSpecConstantOp) is currently not correct in the spec json,
-        // so it most likely needs to be altered into something that can actually describe the entire
-        // instruction in which it is used.
-        spec.LiteralSpecConstantOpInteger => section.writeWord(@intFromEnum(operand.opcode)),
-
         spec.PairLiteralIntegerIdRef => section.writeWords(&.{ operand.value, @enumFromInt(operand.label) }),
         spec.PairIdRefLiteralInteger => section.writeWords(&.{ @intFromEnum(operand.target), operand.member }),
         spec.PairIdRefIdRef => section.writeWords(&.{ @intFromEnum(operand[0]), @intFromEnum(operand[1]) }),
-
         else => switch (@typeInfo(Operand)) {
             .@"enum" => section.writeWord(@intFromEnum(operand)),
-            .optional => |info| if (operand) |child| {
+            .optional => |info| if (operand) |child| section.writeOperand(info.child, child),
-                section.writeOperand(info.child, child);
-            },
             .pointer => |info| {
                 std.debug.assert(info.size == .slice); // Should be no other pointer types in the spec.
                 for (operand) |item| {
@@ -178,18 +156,14 @@ pub fn writeOperand(section: *Section, comptime Operand: type, operand: Operand)
 }
 
 fn writeString(section: *Section, str: []const u8) void {
-    // TODO: Not actually sure whether this is correct for big-endian.
-    // See https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#Literal
     const zero_terminated_len = str.len + 1;
     var i: usize = 0;
     while (i < zero_terminated_len) : (i += @sizeOf(Word)) {
         var word: Word = 0;
-
         var j: usize = 0;
         while (j < @sizeOf(Word) and i + j < str.len) : (j += 1) {
             word |= @as(Word, str[i + j]) << @as(Log2Word, @intCast(j * @bitSizeOf(u8)));
         }
-
         section.instructions.appendAssumeCapacity(word);
     }
 }
@@ -233,20 +207,19 @@ fn writeExtendedMask(section: *Section, comptime Operand: type, operand: Operand
 }
 
 fn writeExtendedUnion(section: *Section, comptime Operand: type, operand: Operand) void {
-    const tag = std.meta.activeTag(operand);
+    return switch (operand) {
-    section.writeWord(@intFromEnum(tag));
+        inline else => |op, tag| {
-
+            section.writeWord(@intFromEnum(tag));
-    inline for (@typeInfo(Operand).@"union".fields) |field| {
+            section.writeOperands(
-        if (@field(Operand, field.name) == tag) {
+                @FieldType(Operand, @tagName(tag)),
-            section.writeOperands(field.type, @field(operand, field.name));
+                op,
-            return;
+            );
-        }
+        },
-    }
+    };
-    unreachable;
 }
 
 fn instructionSize(comptime opcode: spec.Opcode, operands: opcode.Operands()) usize {
-    return 1 + operandsSize(opcode.Operands(), operands);
+    return operandsSize(opcode.Operands(), operands) + 1;
 }
 
 fn operandsSize(comptime Operands: type, operands: Operands) usize {
@@ -266,28 +239,14 @@ fn operandsSize(comptime Operands: type, operands: Operands) usize {
 
 fn operandSize(comptime Operand: type, operand: Operand) usize {
     return switch (Operand) {
-        spec.Id,
+        spec.LiteralSpecConstantOpInteger => unreachable,
-        spec.LiteralInteger,
+        spec.Id, spec.LiteralInteger, spec.LiteralExtInstInteger => 1,
-        spec.LiteralExtInstInteger,
+        spec.LiteralString => std.math.divCeil(usize, operand.len + 1, @sizeOf(Word)) catch unreachable,
-        => 1,
-
-        spec.LiteralString => std.math.divCeil(usize, operand.len + 1, @sizeOf(Word)) catch unreachable, // Add one for zero-terminator
-
         spec.LiteralContextDependentNumber => switch (operand) {
             .int32, .uint32, .float32 => 1,
             .int64, .uint64, .float64 => 2,
         },
-
+        spec.PairLiteralIntegerIdRef, spec.PairIdRefLiteralInteger, spec.PairIdRefIdRef => 2,
-        // TODO: Where this type is used (OpSpecConstantOp) is currently not correct in the spec
-        // json, so it most likely needs to be altered into something that can actually
-        // describe the entire insturction in which it is used.
-        spec.LiteralSpecConstantOpInteger => 1,
-
-        spec.PairLiteralIntegerIdRef,
-        spec.PairIdRefLiteralInteger,
-        spec.PairIdRefIdRef,
-        => 2,
-
         else => switch (@typeInfo(Operand)) {
             .@"enum" => 1,
             .optional => |info| if (operand) |child| operandSize(info.child, child) else 0,
@@ -299,133 +258,25 @@ fn operandSize(comptime Operand: type, operand: Operand) usize {
                 }
                 break :blk total;
             },
-            .@"struct" => |info| if (info.layout == .@"packed") 1 else extendedMaskSize(Operand, operand),
+            .@"struct" => |struct_info| {
-            .@"union" => extendedUnionSize(Operand, operand),
+                if (struct_info.layout == .@"packed") return 1;
+
+                var total: usize = 0;
+                inline for (@typeInfo(Operand).@"struct".fields) |field| {
+                    switch (@typeInfo(field.type)) {
+                        .optional => |info| if (@field(operand, field.name)) |child| {
+                            total += operandsSize(info.child, child);
+                        },
+                        .bool => {},
+                        else => unreachable,
+                    }
+                }
+                return total + 1; // Add one for the mask itself.
+            },
+            .@"union" => switch (operand) {
+                inline else => |op, tag| operandsSize(@FieldType(Operand, @tagName(tag)), op) + 1,
+            },
             else => unreachable,
         },
     };
 }
-
-fn extendedMaskSize(comptime Operand: type, operand: Operand) usize {
-    var total: usize = 0;
-    var any_set = false;
-    inline for (@typeInfo(Operand).@"struct".fields) |field| {
-        switch (@typeInfo(field.type)) {
-            .optional => |info| if (@field(operand, field.name)) |child| {
-                total += operandsSize(info.child, child);
-                any_set = true;
-            },
-            .bool => if (@field(operand, field.name)) {
-                any_set = true;
-            },
-            else => unreachable,
-        }
-    }
-    return total + 1; // Add one for the mask itself.
-}
-
-fn extendedUnionSize(comptime Operand: type, operand: Operand) usize {
-    const tag = std.meta.activeTag(operand);
-    inline for (@typeInfo(Operand).@"union".fields) |field| {
-        if (@field(Operand, field.name) == tag) {
-            // Add one for the tag itself.
-            return 1 + operandsSize(field.type, @field(operand, field.name));
-        }
-    }
-    unreachable;
-}
-
-test "SPIR-V Section emit() - no operands" {
-    var section = Section{};
-    defer section.deinit(std.testing.allocator);
-
-    try section.emit(std.testing.allocator, .OpNop, {});
-
-    try testing.expect(section.instructions.items[0] == (@as(Word, 1) << 16) | @intFromEnum(Opcode.OpNop));
-}
-
-test "SPIR-V Section emit() - simple" {
-    var section = Section{};
-    defer section.deinit(std.testing.allocator);
-
-    try section.emit(std.testing.allocator, .OpUndef, .{
-        .id_result_type = @enumFromInt(0),
-        .id_result = @enumFromInt(1),
-    });
-
-    try testing.expectEqualSlices(Word, &.{
-        (@as(Word, 3) << 16) | @intFromEnum(Opcode.OpUndef),
-        0,
-        1,
-    }, section.instructions.items);
-}
-
-test "SPIR-V Section emit() - string" {
-    var section = Section{};
-    defer section.deinit(std.testing.allocator);
-
-    try section.emit(std.testing.allocator, .OpSource, .{
-        .source_language = .Unknown,
-        .version = 123,
-        .file = @enumFromInt(256),
-        .source = "pub fn main() void {}",
-    });
-
-    try testing.expectEqualSlices(Word, &.{
-        (@as(Word, 10) << 16) | @intFromEnum(Opcode.OpSource),
-        @intFromEnum(spec.SourceLanguage.Unknown),
-        123,
-        456,
-        std.mem.bytesToValue(Word, "pub "),
-        std.mem.bytesToValue(Word, "fn m"),
-        std.mem.bytesToValue(Word, "ain("),
-        std.mem.bytesToValue(Word, ") vo"),
-        std.mem.bytesToValue(Word, "id {"),
-        std.mem.bytesToValue(Word, "}\x00\x00\x00"),
-    }, section.instructions.items);
-}
-
-test "SPIR-V Section emit() - extended mask" {
-    var section = Section{};
-    defer section.deinit(std.testing.allocator);
-
-    try section.emit(std.testing.allocator, .OpLoopMerge, .{
-        .merge_block = @enumFromInt(10),
-        .continue_target = @enumFromInt(20),
-        .loop_control = .{
-            .Unroll = true,
-            .DependencyLength = .{
-                .literal_integer = 2,
-            },
-        },
-    });
-
-    try testing.expectEqualSlices(Word, &.{
-        (@as(Word, 5) << 16) | @intFromEnum(Opcode.OpLoopMerge),
-        10,
-        20,
-        @as(Word, @bitCast(spec.LoopControl{ .Unroll = true, .DependencyLength = true })),
-        2,
-    }, section.instructions.items);
-}
-
-test "SPIR-V Section emit() - extended union" {
-    var section = Section{};
-    defer section.deinit(std.testing.allocator);
-
-    try section.emit(std.testing.allocator, .OpExecutionMode, .{
-        .entry_point = @enumFromInt(888),
-        .mode = .{
-            .LocalSize = .{ .x_size = 4, .y_size = 8, .z_size = 16 },
-        },
-    });
-
-    try testing.expectEqualSlices(Word, &.{
-        (@as(Word, 6) << 16) | @intFromEnum(Opcode.OpExecutionMode),
-        888,
-        @intFromEnum(spec.ExecutionMode.LocalSize),
-        4,
-        8,
-        16,
-    }, section.instructions.items);
-}

src/arch/spirv/spec.zig

@@ -26,6 +26,16 @@ pub const Id = enum(Word) {
     }
 };
 
+pub const IdRange = struct {
+    base: u32,
+    len: u32,
+
+    pub fn at(range: IdRange, i: usize) Id {
+        std.debug.assert(i < range.len);
+        return @enumFromInt(range.base + i);
+    }
+};
+
 pub const LiteralInteger = Word;
 pub const LiteralFloat = Word;
 pub const LiteralString = []const u8;
@@ -5799,20 +5809,20 @@ pub const @"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" = enum(u32) {
 };
 pub const InstructionSet = enum {
     core,
-    spv_amd_shader_trinary_minmax,
+    SPV_AMD_shader_trinary_minmax,
-    spv_ext_inst_type_tosa_001000_1,
+    SPV_EXT_INST_TYPE_TOSA_001000_1,
-    non_semantic_vksp_reflection,
+    @"NonSemantic.VkspReflection",
-    spv_amd_shader_explicit_vertex_parameter,
+    SPV_AMD_shader_explicit_vertex_parameter,
-    debug_info,
+    DebugInfo,
-    non_semantic_debug_break,
+    @"NonSemantic.DebugBreak",
-    open_cl_debug_info_100,
+    @"OpenCL.DebugInfo.100",
-    non_semantic_clspv_reflection_6,
+    @"NonSemantic.ClspvReflection.6",
-    glsl_std_450,
+    @"GLSL.std.450",
-    spv_amd_shader_ballot,
+    SPV_AMD_shader_ballot,
-    non_semantic_debug_printf,
+    @"NonSemantic.DebugPrintf",
-    spv_amd_gcn_shader,
+    SPV_AMD_gcn_shader,
-    open_cl_std,
+    @"OpenCL.std",
-    non_semantic_shader_debug_info_100,
+    @"NonSemantic.Shader.DebugInfo.100",
     zig,
 
     pub fn instructions(self: InstructionSet) []const Instruction {
@@ -14078,7 +14088,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .spv_amd_shader_trinary_minmax => &.{
+            .SPV_AMD_shader_trinary_minmax => &.{
                 .{
                     .name = "FMin3AMD",
                     .opcode = 1,
@@ -14161,7 +14171,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .spv_ext_inst_type_tosa_001000_1 => &.{
+            .SPV_EXT_INST_TYPE_TOSA_001000_1 => &.{
                 .{
                     .name = "ARGMAX",
                     .opcode = 0,
@@ -14743,7 +14753,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .non_semantic_vksp_reflection => &.{
+            .@"NonSemantic.VkspReflection" => &.{
                 .{
                     .name = "Configuration",
                     .opcode = 1,
@@ -14878,7 +14888,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .spv_amd_shader_explicit_vertex_parameter => &.{
+            .SPV_AMD_shader_explicit_vertex_parameter => &.{
                 .{
                     .name = "InterpolateAtVertexAMD",
                     .opcode = 1,
@@ -14888,7 +14898,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .debug_info => &.{
+            .DebugInfo => &.{
                 .{
                     .name = "DebugInfoNone",
                     .opcode = 0,
@@ -15235,14 +15245,14 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .non_semantic_debug_break => &.{
+            .@"NonSemantic.DebugBreak" => &.{
                 .{
                     .name = "DebugBreak",
                     .opcode = 1,
                     .operands = &.{},
                 },
             },
-            .open_cl_debug_info_100 => &.{
+            .@"OpenCL.DebugInfo.100" => &.{
                 .{
                     .name = "DebugInfoNone",
                     .opcode = 0,
@@ -15629,7 +15639,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .non_semantic_clspv_reflection_6 => &.{
+            .@"NonSemantic.ClspvReflection.6" => &.{
                 .{
                     .name = "Kernel",
                     .opcode = 1,
@@ -16044,7 +16054,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .glsl_std_450 => &.{
+            .@"GLSL.std.450" => &.{
                 .{
                     .name = "Round",
                     .opcode = 1,
@@ -16652,7 +16662,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .spv_amd_shader_ballot => &.{
+            .SPV_AMD_shader_ballot => &.{
                 .{
                     .name = "SwizzleInvocationsAMD",
                     .opcode = 1,
@@ -16686,7 +16696,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .non_semantic_debug_printf => &.{
+            .@"NonSemantic.DebugPrintf" => &.{
                 .{
                     .name = "DebugPrintf",
                     .opcode = 1,
@@ -16696,7 +16706,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .spv_amd_gcn_shader => &.{
+            .SPV_AMD_gcn_shader => &.{
                 .{
                     .name = "CubeFaceIndexAMD",
                     .opcode = 1,
@@ -16717,7 +16727,7 @@ pub const InstructionSet = enum {
                     .operands = &.{},
                 },
             },
-            .open_cl_std => &.{
+            .@"OpenCL.std" => &.{
                 .{
                     .name = "acos",
                     .opcode = 0,
@@ -17967,7 +17977,7 @@ pub const InstructionSet = enum {
                     },
                 },
             },
-            .non_semantic_shader_debug_info_100 => &.{
+            .@"NonSemantic.Shader.DebugInfo.100" => &.{
                 .{
                     .name = "DebugInfoNone",
                     .opcode = 0,

src/codegen.zig

@@ -57,7 +57,7 @@ fn importBackend(comptime backend: std.builtin.CompilerBackend) type {
         .stage2_powerpc => unreachable,
         .stage2_riscv64 => @import("arch/riscv64/CodeGen.zig"),
         .stage2_sparc64 => @import("arch/sparc64/CodeGen.zig"),
-        .stage2_spirv => @import("codegen/spirv.zig"),
+        .stage2_spirv => @import("arch/spirv/CodeGen.zig"),
         .stage2_wasm => @import("arch/wasm/CodeGen.zig"),
         .stage2_x86, .stage2_x86_64 => @import("arch/x86_64/CodeGen.zig"),
         _ => unreachable,

src/codegen/spirv/Module.zig

@@ -1,782 +0,0 @@
-//! This structure represents a SPIR-V (sections) module being compiled, and keeps track of all relevant information.
-//! That includes the actual instructions, the current result-id bound, and data structures for querying result-id's
-//! of data which needs to be persistent over different calls to Decl code generation.
-//!
-//! A SPIR-V binary module supports both little- and big endian layout. The layout is detected by the magic word in the
-//! header. Therefore, we can ignore any byte order throughout the implementation, and just use the host byte order,
-//! and make this a problem for the consumer.
-const Module = @This();
-
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-const assert = std.debug.assert;
-const autoHashStrat = std.hash.autoHashStrat;
-const Wyhash = std.hash.Wyhash;
-
-const spec = @import("spec.zig");
-const Word = spec.Word;
-const Id = spec.Id;
-
-const Section = @import("Section.zig");
-
-/// This structure represents a function that isc in-progress of being emitted.
-/// Commonly, the contents of this structure will be merged with the appropriate
-/// sections of the module and re-used. Note that the SPIR-V module system makes
-/// no attempt of compacting result-id's, so any Fn instance should ultimately
-/// be merged into the module it's result-id's are allocated from.
-pub const Fn = struct {
-    /// The prologue of this function; this section contains the function's
-    /// OpFunction, OpFunctionParameter, OpLabel and OpVariable instructions, and
-    /// is separated from the actual function contents as OpVariable instructions
-    /// must appear in the first block of a function definition.
-    prologue: Section = .{},
-    /// The code of the body of this function.
-    /// This section should also contain the OpFunctionEnd instruction marking
-    /// the end of this function definition.
-    body: Section = .{},
-    /// The decl dependencies that this function depends on.
-    decl_deps: std.AutoArrayHashMapUnmanaged(Decl.Index, void) = .empty,
-
-    /// Reset this function without deallocating resources, so that
-    /// it may be used to emit code for another function.
-    pub fn reset(self: *Fn) void {
-        self.prologue.reset();
-        self.body.reset();
-        self.decl_deps.clearRetainingCapacity();
-    }
-
-    /// Free the resources owned by this function.
-    pub fn deinit(self: *Fn, a: Allocator) void {
-        self.prologue.deinit(a);
-        self.body.deinit(a);
-        self.decl_deps.deinit(a);
-        self.* = undefined;
-    }
-};
-
-/// Declarations, both functions and globals, can have dependencies. These are used for 2 things:
-/// - Globals must be declared before they are used, also between globals. The compiler processes
-///   globals unordered, so we must use the dependencies here to figure out how to order the globals
-///   in the final module. The Globals structure is also used for that.
-/// - Entry points must declare the complete list of OpVariable instructions that they access.
-///   For these we use the same dependency structure.
-/// In this mechanism, globals will only depend on other globals, while functions may depend on
-/// globals or other functions.
-pub const Decl = struct {
-    /// Index to refer to a Decl by.
-    pub const Index = enum(u32) { _ };
-
-    /// Useful to tell what kind of decl this is, and hold the result-id or field index
-    /// to be used for this decl.
-    pub const Kind = enum {
-        func,
-        global,
-        invocation_global,
-    };
-
-    /// See comment on Kind
-    kind: Kind,
-    /// The result-id associated to this decl. The specific meaning of this depends on `kind`:
-    /// - For `func`, this is the result-id of the associated OpFunction instruction.
-    /// - For `global`, this is the result-id of the associated OpVariable instruction.
-    /// - For `invocation_global`, this is the result-id of the associated InvocationGlobal instruction.
-    result_id: Id,
-    /// The offset of the first dependency of this decl in the `decl_deps` array.
-    begin_dep: u32,
-    /// The past-end offset of the dependencies of this decl in the `decl_deps` array.
-    end_dep: u32,
-};
-
-/// This models a kernel entry point.
-pub const EntryPoint = struct {
-    /// The declaration that should be exported.
-    decl_index: ?Decl.Index = null,
-    /// The name of the kernel to be exported.
-    name: ?[]const u8 = null,
-    /// Calling Convention
-    exec_model: ?spec.ExecutionModel = null,
-    exec_mode: ?spec.ExecutionMode = null,
-};
-
-/// A general-purpose allocator which may be used to allocate resources for this module
-gpa: Allocator,
-
-/// Arena for things that need to live for the length of this program.
-arena: std.heap.ArenaAllocator,
-
-/// Target info
-target: *const std.Target,
-
-/// The target SPIR-V version
-version: spec.Version,
-
-/// Module layout, according to SPIR-V Spec section 2.4, "Logical Layout of a Module".
-sections: struct {
-    /// Capability instructions
-    capabilities: Section = .{},
-    /// OpExtension instructions
-    extensions: Section = .{},
-    /// OpExtInstImport
-    extended_instruction_set: Section = .{},
-    /// memory model defined by target
-    memory_model: Section = .{},
-    /// OpEntryPoint instructions - Handled by `self.entry_points`.
-    /// OpExecutionMode and OpExecutionModeId instructions.
-    execution_modes: Section = .{},
-    /// OpString, OpSourcExtension, OpSource, OpSourceContinued.
-    debug_strings: Section = .{},
-    // OpName, OpMemberName.
-    debug_names: Section = .{},
-    // OpModuleProcessed - skip for now.
-    /// Annotation instructions (OpDecorate etc).
-    annotations: Section = .{},
-    /// Type declarations, constants, global variables
-    /// From this section, OpLine and OpNoLine is allowed.
-    /// According to the SPIR-V documentation, this section normally
-    /// also holds type and constant instructions. These are managed
-    /// via the cache instead, which is the sole structure that
-    /// manages that section. These will be inserted between this and
-    /// the previous section when emitting the final binary.
-    /// TODO: Do we need this section? Globals are also managed with another mechanism.
-    types_globals_constants: Section = .{},
-    // Functions without a body - skip for now.
-    /// Regular function definitions.
-    functions: Section = .{},
-} = .{},
-
-/// SPIR-V instructions return result-ids. This variable holds the module-wide counter for these.
-next_result_id: Word,
-
-/// Cache for results of OpString instructions.
-strings: std.StringArrayHashMapUnmanaged(Id) = .empty,
-
-/// Some types shouldn't be emitted more than one time, but cannot be caught by
-/// the `intern_map` during codegen. Sometimes, IDs are compared to check if
-/// types are the same, so we can't delay until the dedup pass. Therefore,
-/// this is an ad-hoc structure to cache types where required.
-/// According to the SPIR-V specification, section 2.8, this includes all non-aggregate
-/// non-pointer types.
-/// Additionally, this is used for other values which can be cached, for example,
-/// built-in variables.
-cache: struct {
-    bool_type: ?Id = null,
-    void_type: ?Id = null,
-    int_types: std.AutoHashMapUnmanaged(std.builtin.Type.Int, Id) = .empty,
-    float_types: std.AutoHashMapUnmanaged(std.builtin.Type.Float, Id) = .empty,
-    vector_types: std.AutoHashMapUnmanaged(struct { Id, u32 }, Id) = .empty,
-    array_types: std.AutoHashMapUnmanaged(struct { Id, Id }, Id) = .empty,
-
-    capabilities: std.AutoHashMapUnmanaged(spec.Capability, void) = .empty,
-    extensions: std.StringHashMapUnmanaged(void) = .empty,
-    extended_instruction_set: std.AutoHashMapUnmanaged(spec.InstructionSet, Id) = .empty,
-    decorations: std.AutoHashMapUnmanaged(struct { Id, spec.Decoration }, void) = .empty,
-    builtins: std.AutoHashMapUnmanaged(struct { Id, spec.BuiltIn }, Decl.Index) = .empty,
-
-    bool_const: [2]?Id = .{ null, null },
-} = .{},
-
-/// Set of Decls, referred to by Decl.Index.
-decls: std.ArrayListUnmanaged(Decl) = .empty,
-
-/// List of dependencies, per decl. This list holds all the dependencies, sliced by the
-/// begin_dep and end_dep in `self.decls`.
-decl_deps: std.ArrayListUnmanaged(Decl.Index) = .empty,
-
-/// The list of entry points that should be exported from this module.
-entry_points: std.AutoArrayHashMapUnmanaged(Id, EntryPoint) = .empty,
-
-pub fn init(gpa: Allocator, target: *const std.Target) Module {
-    const version_minor: u8 = blk: {
-        // Prefer higher versions
-        if (target.cpu.has(.spirv, .v1_6)) break :blk 6;
-        if (target.cpu.has(.spirv, .v1_5)) break :blk 5;
-        if (target.cpu.has(.spirv, .v1_4)) break :blk 4;
-        if (target.cpu.has(.spirv, .v1_3)) break :blk 3;
-        if (target.cpu.has(.spirv, .v1_2)) break :blk 2;
-        if (target.cpu.has(.spirv, .v1_1)) break :blk 1;
-        break :blk 0;
-    };
-
-    return .{
-        .gpa = gpa,
-        .arena = std.heap.ArenaAllocator.init(gpa),
-        .target = target,
-        .version = .{ .major = 1, .minor = version_minor },
-        .next_result_id = 1, // 0 is an invalid SPIR-V result id, so start counting at 1.
-    };
-}
-
-pub fn deinit(self: *Module) void {
-    self.sections.capabilities.deinit(self.gpa);
-    self.sections.extensions.deinit(self.gpa);
-    self.sections.extended_instruction_set.deinit(self.gpa);
-    self.sections.memory_model.deinit(self.gpa);
-    self.sections.execution_modes.deinit(self.gpa);
-    self.sections.debug_strings.deinit(self.gpa);
-    self.sections.debug_names.deinit(self.gpa);
-    self.sections.annotations.deinit(self.gpa);
-    self.sections.types_globals_constants.deinit(self.gpa);
-    self.sections.functions.deinit(self.gpa);
-
-    self.strings.deinit(self.gpa);
-
-    self.cache.int_types.deinit(self.gpa);
-    self.cache.float_types.deinit(self.gpa);
-    self.cache.vector_types.deinit(self.gpa);
-    self.cache.array_types.deinit(self.gpa);
-    self.cache.capabilities.deinit(self.gpa);
-    self.cache.extensions.deinit(self.gpa);
-    self.cache.extended_instruction_set.deinit(self.gpa);
-    self.cache.decorations.deinit(self.gpa);
-    self.cache.builtins.deinit(self.gpa);
-
-    self.decls.deinit(self.gpa);
-    self.decl_deps.deinit(self.gpa);
-    self.entry_points.deinit(self.gpa);
-
-    self.arena.deinit();
-
-    self.* = undefined;
-}
-
-pub const IdRange = struct {
-    base: u32,
-    len: u32,
-
-    pub fn at(range: IdRange, i: usize) Id {
-        assert(i < range.len);
-        return @enumFromInt(range.base + i);
-    }
-};
-
-pub fn allocIds(self: *Module, n: u32) IdRange {
-    defer self.next_result_id += n;
-    return .{
-        .base = self.next_result_id,
-        .len = n,
-    };
-}
-
-pub fn allocId(self: *Module) Id {
-    return self.allocIds(1).at(0);
-}
-
-pub fn idBound(self: Module) Word {
-    return self.next_result_id;
-}
-
-pub fn hasFeature(self: *Module, feature: std.Target.spirv.Feature) bool {
-    return self.target.cpu.has(.spirv, feature);
-}
-
-fn addEntryPointDeps(
-    self: *Module,
-    decl_index: Decl.Index,
-    seen: *std.DynamicBitSetUnmanaged,
-    interface: *std.ArrayList(Id),
-) !void {
-    const decl = self.declPtr(decl_index);
-    const deps = self.decl_deps.items[decl.begin_dep..decl.end_dep];
-
-    if (seen.isSet(@intFromEnum(decl_index))) {
-        return;
-    }
-
-    seen.set(@intFromEnum(decl_index));
-
-    if (decl.kind == .global) {
-        try interface.append(decl.result_id);
-    }
-
-    for (deps) |dep| {
-        try self.addEntryPointDeps(dep, seen, interface);
-    }
-}
-
-fn entryPoints(self: *Module) !Section {
-    var entry_points = Section{};
-    errdefer entry_points.deinit(self.gpa);
-
-    var interface = std.ArrayList(Id).init(self.gpa);
-    defer interface.deinit();
-
-    var seen = try std.DynamicBitSetUnmanaged.initEmpty(self.gpa, self.decls.items.len);
-    defer seen.deinit(self.gpa);
-
-    for (self.entry_points.keys(), self.entry_points.values()) |entry_point_id, entry_point| {
-        interface.items.len = 0;
-        seen.setRangeValue(.{ .start = 0, .end = self.decls.items.len }, false);
-
-        try self.addEntryPointDeps(entry_point.decl_index.?, &seen, &interface);
-        try entry_points.emit(self.gpa, .OpEntryPoint, .{
-            .execution_model = entry_point.exec_model.?,
-            .entry_point = entry_point_id,
-            .name = entry_point.name.?,
-            .interface = interface.items,
-        });
-
-        if (entry_point.exec_mode == null and entry_point.exec_model == .fragment) {
-            switch (self.target.os.tag) {
-                .vulkan, .opengl => |tag| {
-                    try self.sections.execution_modes.emit(self.gpa, .OpExecutionMode, .{
-                        .entry_point = entry_point_id,
-                        .mode = if (tag == .vulkan) .origin_upper_left else .origin_lower_left,
-                    });
-                },
-                .opencl => {},
-                else => unreachable,
-            }
-        }
-    }
-
-    return entry_points;
-}
-
-pub fn finalize(self: *Module, a: Allocator) ![]Word {
-    // Emit capabilities and extensions
-    switch (self.target.os.tag) {
-        .opengl => {
-            try self.addCapability(.shader);
-            try self.addCapability(.matrix);
-        },
-        .vulkan => {
-            try self.addCapability(.shader);
-            try self.addCapability(.matrix);
-            if (self.target.cpu.arch == .spirv64) {
-                try self.addExtension("SPV_KHR_physical_storage_buffer");
-                try self.addCapability(.physical_storage_buffer_addresses);
-            }
-        },
-        .opencl, .amdhsa => {
-            try self.addCapability(.kernel);
-            try self.addCapability(.addresses);
-        },
-        else => unreachable,
-    }
-    if (self.target.cpu.arch == .spirv64) try self.addCapability(.int64);
-    if (self.target.cpu.has(.spirv, .int64)) try self.addCapability(.int64);
-    if (self.target.cpu.has(.spirv, .float16)) try self.addCapability(.float16);
-    if (self.target.cpu.has(.spirv, .float64)) try self.addCapability(.float64);
-    if (self.target.cpu.has(.spirv, .generic_pointer)) try self.addCapability(.generic_pointer);
-    if (self.target.cpu.has(.spirv, .vector16)) try self.addCapability(.vector16);
-    if (self.target.cpu.has(.spirv, .storage_push_constant16)) {
-        try self.addExtension("SPV_KHR_16bit_storage");
-        try self.addCapability(.storage_push_constant16);
-    }
-    if (self.target.cpu.has(.spirv, .arbitrary_precision_integers)) {
-        try self.addExtension("SPV_INTEL_arbitrary_precision_integers");
-        try self.addCapability(.arbitrary_precision_integers_intel);
-    }
-    if (self.target.cpu.has(.spirv, .variable_pointers)) {
-        try self.addExtension("SPV_KHR_variable_pointers");
-        try self.addCapability(.variable_pointers_storage_buffer);
-        try self.addCapability(.variable_pointers);
-    }
-    // These are well supported
-    try self.addCapability(.int8);
-    try self.addCapability(.int16);
-
-    // Emit memory model
-    const addressing_model: spec.AddressingModel = switch (self.target.os.tag) {
-        .opengl => .logical,
-        .vulkan => if (self.target.cpu.arch == .spirv32) .logical else .physical_storage_buffer64,
-        .opencl => if (self.target.cpu.arch == .spirv32) .physical32 else .physical64,
-        .amdhsa => .physical64,
-        else => unreachable,
-    };
-    try self.sections.memory_model.emit(self.gpa, .OpMemoryModel, .{
-        .addressing_model = addressing_model,
-        .memory_model = switch (self.target.os.tag) {
-            .opencl => .open_cl,
-            .vulkan, .opengl => .glsl450,
-            else => unreachable,
-        },
-    });
-
-    // See SPIR-V Spec section 2.3, "Physical Layout of a SPIR-V Module and Instruction"
-    // TODO: Audit calls to allocId() in this function to make it idempotent.
-    var entry_points = try self.entryPoints();
-    defer entry_points.deinit(self.gpa);
-
-    const header = [_]Word{
-        spec.magic_number,
-        self.version.toWord(),
-        spec.zig_generator_id,
-        self.idBound(),
-        0, // Schema (currently reserved for future use)
-    };
-
-    var source = Section{};
-    defer source.deinit(self.gpa);
-    try self.sections.debug_strings.emit(self.gpa, .OpSource, .{
-        .source_language = .zig,
-        .version = 0,
-        // We cannot emit these because the Khronos translator does not parse this instruction
-        // correctly.
-        // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/2188
-        .file = null,
-        .source = null,
-    });
-
-    // Note: needs to be kept in order according to section 2.3!
-    const buffers = &[_][]const Word{
-        &header,
-        self.sections.capabilities.toWords(),
-        self.sections.extensions.toWords(),
-        self.sections.extended_instruction_set.toWords(),
-        self.sections.memory_model.toWords(),
-        entry_points.toWords(),
-        self.sections.execution_modes.toWords(),
-        source.toWords(),
-        self.sections.debug_strings.toWords(),
-        self.sections.debug_names.toWords(),
-        self.sections.annotations.toWords(),
-        self.sections.types_globals_constants.toWords(),
-        self.sections.functions.toWords(),
-    };
-
-    var total_result_size: usize = 0;
-    for (buffers) |buffer| {
-        total_result_size += buffer.len;
-    }
-    const result = try a.alloc(Word, total_result_size);
-    errdefer a.free(result);
-
-    var offset: usize = 0;
-    for (buffers) |buffer| {
-        @memcpy(result[offset..][0..buffer.len], buffer);
-        offset += buffer.len;
-    }
-
-    return result;
-}
-
-/// Merge the sections making up a function declaration into this module.
-pub fn addFunction(self: *Module, decl_index: Decl.Index, func: Fn) !void {
-    try self.sections.functions.append(self.gpa, func.prologue);
-    try self.sections.functions.append(self.gpa, func.body);
-    try self.declareDeclDeps(decl_index, func.decl_deps.keys());
-}
-
-pub fn addCapability(self: *Module, cap: spec.Capability) !void {
-    const entry = try self.cache.capabilities.getOrPut(self.gpa, cap);
-    if (entry.found_existing) return;
-    try self.sections.capabilities.emit(self.gpa, .OpCapability, .{ .capability = cap });
-}
-
-pub fn addExtension(self: *Module, ext: []const u8) !void {
-    const entry = try self.cache.extensions.getOrPut(self.gpa, ext);
-    if (entry.found_existing) return;
-    try self.sections.extensions.emit(self.gpa, .OpExtension, .{ .name = ext });
-}
-
-/// Imports or returns the existing id of an extended instruction set
-pub fn importInstructionSet(self: *Module, set: spec.InstructionSet) !Id {
-    assert(set != .core);
-
-    const gop = try self.cache.extended_instruction_set.getOrPut(self.gpa, set);
-    if (gop.found_existing) return gop.value_ptr.*;
-
-    const result_id = self.allocId();
-    try self.sections.extended_instruction_set.emit(self.gpa, .OpExtInstImport, .{
-        .id_result = result_id,
-        .name = @tagName(set),
-    });
-    gop.value_ptr.* = result_id;
-
-    return result_id;
-}
-
-/// Fetch the result-id of an instruction corresponding to a string.
-pub fn resolveString(self: *Module, string: []const u8) !Id {
-    if (self.strings.get(string)) |id| {
-        return id;
-    }
-
-    const id = self.allocId();
-    try self.strings.put(self.gpa, try self.arena.allocator().dupe(u8, string), id);
-
-    try self.sections.debug_strings.emit(self.gpa, .OpString, .{
-        .id_result = id,
-        .string = string,
-    });
-
-    return id;
-}
-
-pub fn structType(self: *Module, result_id: Id, types: []const Id, maybe_names: ?[]const []const u8) !void {
-    try self.sections.types_globals_constants.emit(self.gpa, .OpTypeStruct, .{
-        .id_result = result_id,
-        .id_ref = types,
-    });
-
-    if (maybe_names) |names| {
-        assert(names.len == types.len);
-        for (names, 0..) |name, i| {
-            try self.memberDebugName(result_id, @intCast(i), name);
-        }
-    }
-}
-
-pub fn boolType(self: *Module) !Id {
-    if (self.cache.bool_type) |id| return id;
-
-    const result_id = self.allocId();
-    try self.sections.types_globals_constants.emit(self.gpa, .OpTypeBool, .{
-        .id_result = result_id,
-    });
-    self.cache.bool_type = result_id;
-    return result_id;
-}
-
-pub fn voidType(self: *Module) !Id {
-    if (self.cache.void_type) |id| return id;
-
-    const result_id = self.allocId();
-    try self.sections.types_globals_constants.emit(self.gpa, .OpTypeVoid, .{
-        .id_result = result_id,
-    });
-    self.cache.void_type = result_id;
-    try self.debugName(result_id, "void");
-    return result_id;
-}
-
-pub fn intType(self: *Module, signedness: std.builtin.Signedness, bits: u16) !Id {
-    assert(bits > 0);
-    const entry = try self.cache.int_types.getOrPut(self.gpa, .{ .signedness = signedness, .bits = bits });
-    if (!entry.found_existing) {
-        const result_id = self.allocId();
-        entry.value_ptr.* = result_id;
-        try self.sections.types_globals_constants.emit(self.gpa, .OpTypeInt, .{
-            .id_result = result_id,
-            .width = bits,
-            .signedness = switch (signedness) {
-                .signed => 1,
-                .unsigned => 0,
-            },
-        });
-
-        switch (signedness) {
-            .signed => try self.debugNameFmt(result_id, "i{}", .{bits}),
-            .unsigned => try self.debugNameFmt(result_id, "u{}", .{bits}),
-        }
-    }
-    return entry.value_ptr.*;
-}
-
-pub fn floatType(self: *Module, bits: u16) !Id {
-    assert(bits > 0);
-    const entry = try self.cache.float_types.getOrPut(self.gpa, .{ .bits = bits });
-    if (!entry.found_existing) {
-        const result_id = self.allocId();
-        entry.value_ptr.* = result_id;
-        try self.sections.types_globals_constants.emit(self.gpa, .OpTypeFloat, .{
-            .id_result = result_id,
-            .width = bits,
-        });
-        try self.debugNameFmt(result_id, "f{}", .{bits});
-    }
-    return entry.value_ptr.*;
-}
-
-pub fn vectorType(self: *Module, len: u32, child_ty_id: Id) !Id {
-    const entry = try self.cache.vector_types.getOrPut(self.gpa, .{ child_ty_id, len });
-    if (!entry.found_existing) {
-        const result_id = self.allocId();
-        entry.value_ptr.* = result_id;
-        try self.sections.types_globals_constants.emit(self.gpa, .OpTypeVector, .{
-            .id_result = result_id,
-            .component_type = child_ty_id,
-            .component_count = len,
-        });
-    }
-    return entry.value_ptr.*;
-}
-
-pub fn arrayType(self: *Module, len_id: Id, child_ty_id: Id) !Id {
-    const entry = try self.cache.array_types.getOrPut(self.gpa, .{ child_ty_id, len_id });
-    if (!entry.found_existing) {
-        const result_id = self.allocId();
-        entry.value_ptr.* = result_id;
-        try self.sections.types_globals_constants.emit(self.gpa, .OpTypeArray, .{
-            .id_result = result_id,
-            .element_type = child_ty_id,
-            .length = len_id,
-        });
-    }
-    return entry.value_ptr.*;
-}
-
-pub fn functionType(self: *Module, return_ty_id: Id, param_type_ids: []const Id) !Id {
-    const result_id = self.allocId();
-    try self.sections.types_globals_constants.emit(self.gpa, .OpTypeFunction, .{
-        .id_result = result_id,
-        .return_type = return_ty_id,
-        .id_ref_2 = param_type_ids,
-    });
-    return result_id;
-}
-
-pub fn constant(self: *Module, result_ty_id: Id, value: spec.LiteralContextDependentNumber) !Id {
-    const result_id = self.allocId();
-    const section = &self.sections.types_globals_constants;
-    try section.emit(self.gpa, .OpConstant, .{
-        .id_result_type = result_ty_id,
-        .id_result = result_id,
-        .value = value,
-    });
-    return result_id;
-}
-
-pub fn constBool(self: *Module, value: bool) !Id {
-    if (self.cache.bool_const[@intFromBool(value)]) |b| return b;
-
-    const result_ty_id = try self.boolType();
-    const result_id = self.allocId();
-    self.cache.bool_const[@intFromBool(value)] = result_id;
-
-    switch (value) {
-        inline else => |value_ct| try self.sections.types_globals_constants.emit(
-            self.gpa,
-            if (value_ct) .OpConstantTrue else .OpConstantFalse,
-            .{
-                .id_result_type = result_ty_id,
-                .id_result = result_id,
-            },
-        ),
-    }
-
-    return result_id;
-}
-
-/// Return a pointer to a builtin variable. `result_ty_id` must be a **pointer**
-/// with storage class `.Input`.
-pub fn builtin(self: *Module, result_ty_id: Id, spirv_builtin: spec.BuiltIn) !Decl.Index {
-    const entry = try self.cache.builtins.getOrPut(self.gpa, .{ result_ty_id, spirv_builtin });
-    if (!entry.found_existing) {
-        const decl_index = try self.allocDecl(.global);
-        const result_id = self.declPtr(decl_index).result_id;
-        entry.value_ptr.* = decl_index;
-        try self.sections.types_globals_constants.emit(self.gpa, .OpVariable, .{
-            .id_result_type = result_ty_id,
-            .id_result = result_id,
-            .storage_class = .input,
-        });
-        try self.decorate(result_id, .{ .built_in = .{ .built_in = spirv_builtin } });
-        try self.declareDeclDeps(decl_index, &.{});
-    }
-    return entry.value_ptr.*;
-}
-
-pub fn constUndef(self: *Module, ty_id: Id) !Id {
-    const result_id = self.allocId();
-    try self.sections.types_globals_constants.emit(self.gpa, .OpUndef, .{
-        .id_result_type = ty_id,
-        .id_result = result_id,
-    });
-    return result_id;
-}
-
-pub fn constNull(self: *Module, ty_id: Id) !Id {
-    const result_id = self.allocId();
-    try self.sections.types_globals_constants.emit(self.gpa, .OpConstantNull, .{
-        .id_result_type = ty_id,
-        .id_result = result_id,
-    });
-    return result_id;
-}
-
-/// Decorate a result-id.
-pub fn decorate(
-    self: *Module,
-    target: Id,
-    decoration: spec.Decoration.Extended,
-) !void {
-    const entry = try self.cache.decorations.getOrPut(self.gpa, .{ target, decoration });
-    if (!entry.found_existing) {
-        try self.sections.annotations.emit(self.gpa, .OpDecorate, .{
-            .target = target,
-            .decoration = decoration,
-        });
-    }
-}
-
-/// Decorate a result-id which is a member of some struct.
-/// We really don't have to and shouldn't need to cache this.
-pub fn decorateMember(
-    self: *Module,
-    structure_type: Id,
-    member: u32,
-    decoration: spec.Decoration.Extended,
-) !void {
-    try self.sections.annotations.emit(self.gpa, .OpMemberDecorate, .{
-        .structure_type = structure_type,
-        .member = member,
-        .decoration = decoration,
-    });
-}
-
-pub fn allocDecl(self: *Module, kind: Decl.Kind) !Decl.Index {
-    try self.decls.append(self.gpa, .{
-        .kind = kind,
-        .result_id = self.allocId(),
-        .begin_dep = undefined,
-        .end_dep = undefined,
-    });
-
-    return @as(Decl.Index, @enumFromInt(@as(u32, @intCast(self.decls.items.len - 1))));
-}
-
-pub fn declPtr(self: *Module, index: Decl.Index) *Decl {
-    return &self.decls.items[@intFromEnum(index)];
-}
-
-/// Declare ALL dependencies for a decl.
-pub fn declareDeclDeps(self: *Module, decl_index: Decl.Index, deps: []const Decl.Index) !void {
-    const begin_dep: u32 = @intCast(self.decl_deps.items.len);
-    try self.decl_deps.appendSlice(self.gpa, deps);
-    const end_dep: u32 = @intCast(self.decl_deps.items.len);
-
-    const decl = self.declPtr(decl_index);
-    decl.begin_dep = begin_dep;
-    decl.end_dep = end_dep;
-}
-
-/// Declare a SPIR-V function as an entry point. This causes an extra wrapper
-/// function to be generated, which is then exported as the real entry point. The purpose of this
-/// wrapper is to allocate and initialize the structure holding the instance globals.
-pub fn declareEntryPoint(
-    self: *Module,
-    decl_index: Decl.Index,
-    name: []const u8,
-    exec_model: spec.ExecutionModel,
-    exec_mode: ?spec.ExecutionMode,
-) !void {
-    const gop = try self.entry_points.getOrPut(self.gpa, self.declPtr(decl_index).result_id);
-    gop.value_ptr.decl_index = decl_index;
-    gop.value_ptr.name = try self.arena.allocator().dupe(u8, name);
-    gop.value_ptr.exec_model = exec_model;
-    // Might've been set by assembler
-    if (!gop.found_existing) gop.value_ptr.exec_mode = exec_mode;
-}
-
-pub fn debugName(self: *Module, target: Id, name: []const u8) !void {
-    try self.sections.debug_names.emit(self.gpa, .OpName, .{
-        .target = target,
-        .name = name,
-    });
-}
-
-pub fn debugNameFmt(self: *Module, target: Id, comptime fmt: []const u8, args: anytype) !void {
-    const name = try std.fmt.allocPrint(self.gpa, fmt, args);
-    defer self.gpa.free(name);
-    try self.debugName(target, name);
-}
-
-pub fn memberDebugName(self: *Module, target: Id, member: u32, name: []const u8) !void {
-    try self.sections.debug_names.emit(self.gpa, .OpMemberName, .{
-        .type = target,
-        .member = member,
-        .name = name,
-    });
-}

src/dev.zig

@@ -191,6 +191,7 @@ pub const Env = enum {
             .spirv => switch (feature) {
                 .spirv_backend,
                 .spirv_linker,
+                .legalize,
                 => true,
                 else => Env.sema.supports(feature),
             },

src/link/SpirV.zig

@@ -1,62 +1,36 @@
-//! SPIR-V Spec documentation: https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html
-//! According to above documentation, a SPIR-V module has the following logical layout:
-//! Header.
-//! OpCapability instructions.
-//! OpExtension instructions.
-//! OpExtInstImport instructions.
-//! A single OpMemoryModel instruction.
-//! All entry points, declared with OpEntryPoint instructions.
-//! All execution-mode declarators; OpExecutionMode and OpExecutionModeId instructions.
-//! Debug instructions:
-//! - First, OpString, OpSourceExtension, OpSource, OpSourceContinued (no forward references).
-//! - OpName and OpMemberName instructions.
-//! - OpModuleProcessed instructions.
-//! All annotation (decoration) instructions.
-//! All type declaration instructions, constant instructions, global variable declarations, (preferably) OpUndef instructions.
-//! All function declarations without a body (extern functions presumably).
-//! All regular functions.
-
-// Because SPIR-V requires re-compilation anyway, and so hot swapping will not work
-// anyway, we simply generate all the code in flush. This keeps
-// things considerably simpler.
-
-const SpirV = @This();
-
 const std = @import("std");
 const Allocator = std.mem.Allocator;
+const Path = std.Build.Cache.Path;
 const assert = std.debug.assert;
 const log = std.log.scoped(.link);
-const Path = std.Build.Cache.Path;
 
 const Zcu = @import("../Zcu.zig");
 const InternPool = @import("../InternPool.zig");
 const Compilation = @import("../Compilation.zig");
 const link = @import("../link.zig");
-const codegen = @import("../codegen/spirv.zig");
-const trace = @import("../tracy.zig").trace;
-const build_options = @import("build_options");
 const Air = @import("../Air.zig");
 const Type = @import("../Type.zig");
-const Value = @import("../Value.zig");
+const BinaryModule = @import("SpirV/BinaryModule.zig");
+const CodeGen = @import("../arch/spirv/CodeGen.zig");
+const SpvModule = @import("../arch/spirv/Module.zig");
+const Section = @import("../arch/spirv/Section.zig");
+const trace = @import("../tracy.zig").trace;
 
-const SpvModule = @import("../codegen/spirv/Module.zig");
+const spec = @import("../arch/spirv/spec.zig");
-const Section = @import("../codegen/spirv/Section.zig");
-const spec = @import("../codegen/spirv/spec.zig");
 const Id = spec.Id;
 const Word = spec.Word;
 
-const BinaryModule = @import("SpirV/BinaryModule.zig");
+const Linker = @This();
 
 base: link.File,
-
+module: SpvModule,
-object: codegen.Object,
 
 pub fn createEmpty(
     arena: Allocator,
     comp: *Compilation,
     emit: Path,
     options: link.File.OpenOptions,
-) !*SpirV {
+) !*Linker {
     const gpa = comp.gpa;
     const target = &comp.root_mod.resolved_target.result;
 
@@ -72,7 +46,7 @@ pub fn createEmpty(
         else => unreachable, // Caught by Compilation.Config.resolve.
     }
 
-    const self = try arena.create(SpirV);
+    const self = try arena.create(Linker);
     self.* = .{
         .base = .{
             .tag = .spirv,
@@ -85,11 +59,10 @@ pub fn createEmpty(
             .file = null,
             .build_id = options.build_id,
         },
-        .object = codegen.Object.init(gpa, comp.getTarget()),
+        .module = .{ .gpa = gpa, .target = comp.getTarget() },
     };
     errdefer self.deinit();
 
-    // TODO: read the file and keep valid parts instead of truncating
     self.base.file = try emit.root_dir.handle.createFile(emit.sub_path, .{
         .truncate = true,
         .read = true,
@@ -103,27 +76,77 @@ pub fn open(
     comp: *Compilation,
     emit: Path,
     options: link.File.OpenOptions,
-) !*SpirV {
+) !*Linker {
     return createEmpty(arena, comp, emit, options);
 }
 
-pub fn deinit(self: *SpirV) void {
+pub fn deinit(self: *Linker) void {
-    self.object.deinit();
+    self.module.deinit();
 }
 
-pub fn updateNav(self: *SpirV, pt: Zcu.PerThread, nav: InternPool.Nav.Index) link.File.UpdateNavError!void {
+fn genNav(
-    if (build_options.skip_non_native) {
+    self: *Linker,
-        @panic("Attempted to compile for architecture that was disabled by build configuration");
+    pt: Zcu.PerThread,
-    }
+    nav_index: InternPool.Nav.Index,
+    air: Air,
+    liveness: Air.Liveness,
+    do_codegen: bool,
+) !void {
+    const zcu = pt.zcu;
+    const gpa = zcu.gpa;
+    const structured_cfg = zcu.navFileScope(nav_index).mod.?.structured_cfg;
 
+    var nav_gen: CodeGen = .{
+        .pt = pt,
+        .module = &self.module,
+        .owner_nav = nav_index,
+        .air = air,
+        .liveness = liveness,
+        .control_flow = switch (structured_cfg) {
+            true => .{ .structured = .{} },
+            false => .{ .unstructured = .{} },
+        },
+        .base_line = zcu.navSrcLine(nav_index),
+    };
+    defer nav_gen.deinit();
+
+    nav_gen.genNav(do_codegen) catch |err| switch (err) {
+        error.CodegenFail => switch (zcu.codegenFailMsg(nav_index, nav_gen.error_msg.?)) {
+            error.CodegenFail => {},
+            error.OutOfMemory => |e| return e,
+        },
+        else => |other| {
+            // There might be an error that happened *after* self.error_msg
+            // was already allocated, so be sure to free it.
+            if (nav_gen.error_msg) |error_msg| {
+                error_msg.deinit(gpa);
+            }
+
+            return other;
+        },
+    };
+}
+
+pub fn updateFunc(
+    self: *Linker,
+    pt: Zcu.PerThread,
+    func_index: InternPool.Index,
+    air: *const Air,
+    liveness: *const ?Air.Liveness,
+) !void {
+    const nav = pt.zcu.funcInfo(func_index).owner_nav;
+    // TODO: Separate types for generating decls and functions?
+    try self.genNav(pt, nav, air.*, liveness.*.?, true);
+}
+
+pub fn updateNav(self: *Linker, pt: Zcu.PerThread, nav: InternPool.Nav.Index) link.File.UpdateNavError!void {
     const ip = &pt.zcu.intern_pool;
     log.debug("lowering nav {f}({d})", .{ ip.getNav(nav).fqn.fmt(ip), nav });
-
+    try self.genNav(pt, nav, undefined, undefined, false);
-    try self.object.updateNav(pt, nav);
 }
 
 pub fn updateExports(
-    self: *SpirV,
+    self: *Linker,
     pt: Zcu.PerThread,
     exported: Zcu.Exported,
     export_indices: []const Zcu.Export.Index,
@@ -134,13 +157,13 @@ pub fn updateExports(
         .nav => |nav| nav,
         .uav => |uav| {
             _ = uav;
-            @panic("TODO: implement SpirV linker code for exporting a constant value");
+            @panic("TODO: implement Linker linker code for exporting a constant value");
         },
     };
     const nav_ty = ip.getNav(nav_index).typeOf(ip);
     const target = zcu.getTarget();
     if (ip.isFunctionType(nav_ty)) {
-        const spv_decl_index = try self.object.resolveNav(zcu, nav_index);
+        const spv_decl_index = try self.module.resolveNav(ip, nav_index);
         const cc = Type.fromInterned(nav_ty).fnCallingConvention(zcu);
         const exec_model: spec.ExecutionModel = switch (target.os.tag) {
             .vulkan, .opengl => switch (cc) {
@@ -162,7 +185,7 @@ pub fn updateExports(
 
         for (export_indices) |export_idx| {
             const exp = export_idx.ptr(zcu);
-            try self.object.spv.declareEntryPoint(
+            try self.module.declareEntryPoint(
                 spv_decl_index,
                 exp.opts.name.toSlice(ip),
                 exec_model,
@@ -175,7 +198,7 @@ pub fn updateExports(
 }
 
 pub fn flush(
-    self: *SpirV,
+    self: *Linker,
     arena: Allocator,
     tid: Zcu.PerThread.Id,
     prog_node: std.Progress.Node,
@@ -185,10 +208,6 @@ pub fn flush(
     // InternPool.
     _ = tid;
 
-    if (build_options.skip_non_native) {
-        @panic("Attempted to compile for architecture that was disabled by build configuration");
-    }
-
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -196,14 +215,13 @@ pub fn flush(
     defer sub_prog_node.end();
 
     const comp = self.base.comp;
-    const spv = &self.object.spv;
     const diags = &comp.link_diags;
     const gpa = comp.gpa;
 
     // We need to export the list of error names somewhere so that we can pretty-print them in the
     // executor. This is not really an important thing though, so we can just dump it in any old
     // nonsemantic instruction. For now, just put it in OpSourceExtension with a special name.
-    var error_info: std.io.Writer.Allocating = .init(self.object.gpa);
+    var error_info: std.io.Writer.Allocating = .init(self.module.gpa);
     defer error_info.deinit();
 
     error_info.writer.writeAll("zig_errors:") catch return error.OutOfMemory;
@@ -213,7 +231,6 @@ pub fn flush(
         // them somehow. Easiest here is to use some established scheme, one which also preseves the
         // name if it contains no strange characters is nice for debugging. URI encoding fits the bill.
         // We're using : as separator, which is a reserved character.
-
         error_info.writer.writeByte(':') catch return error.OutOfMemory;
         std.Uri.Component.percentEncode(
             &error_info.writer,
@@ -228,11 +245,11 @@ pub fn flush(
             }.isValidChar,
         ) catch return error.OutOfMemory;
     }
-    try spv.sections.debug_strings.emit(gpa, .OpSourceExtension, .{
+    try self.module.sections.debug_strings.emit(gpa, .OpSourceExtension, .{
         .extension = error_info.getWritten(),
     });
 
-    const module = try spv.finalize(arena);
+    const module = try self.module.finalize(arena);
     errdefer arena.free(module);
 
     const linked_module = self.linkModule(arena, module, sub_prog_node) catch |err| switch (err) {
@@ -244,14 +261,14 @@ pub fn flush(
         return diags.fail("failed to write: {s}", .{@errorName(err)});
 }
 
-fn linkModule(self: *SpirV, a: Allocator, module: []Word, progress: std.Progress.Node) ![]Word {
+fn linkModule(self: *Linker, arena: Allocator, module: []Word, progress: std.Progress.Node) ![]Word {
     _ = self;
 
     const lower_invocation_globals = @import("SpirV/lower_invocation_globals.zig");
     const prune_unused = @import("SpirV/prune_unused.zig");
     const dedup = @import("SpirV/deduplicate.zig");
 
-    var parser = try BinaryModule.Parser.init(a);
+    var parser = try BinaryModule.Parser.init(arena);
     defer parser.deinit();
     var binary = try parser.parse(module);
 
@@ -259,5 +276,5 @@ fn linkModule(self: *SpirV, a: Allocator, module: []Word, progress: std.Progress
     try prune_unused.run(&parser, &binary, progress);
     try dedup.run(&parser, &binary, progress);
 
-    return binary.finalize(a);
+    return binary.finalize(arena);
 }

src/link/SpirV/BinaryModule.zig

@@ -3,7 +3,7 @@ const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.spirv_parse);
 
-const spec = @import("../../codegen/spirv/spec.zig");
+const spec = @import("../../arch/spirv/spec.zig");
 const Opcode = spec.Opcode;
 const Word = spec.Word;
 const InstructionSet = spec.InstructionSet;

src/link/SpirV/deduplicate.zig

@@ -4,8 +4,8 @@ const log = std.log.scoped(.spirv_link);
 const assert = std.debug.assert;
 
 const BinaryModule = @import("BinaryModule.zig");
-const Section = @import("../../codegen/spirv/Section.zig");
+const Section = @import("../../arch/spirv/Section.zig");
-const spec = @import("../../codegen/spirv/spec.zig");
+const spec = @import("../../arch/spirv/spec.zig");
 const Opcode = spec.Opcode;
 const ResultId = spec.Id;
 const Word = spec.Word;

src/link/SpirV/lower_invocation_globals.zig

@@ -4,8 +4,8 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.spirv_link);
 
 const BinaryModule = @import("BinaryModule.zig");
-const Section = @import("../../codegen/spirv/Section.zig");
+const Section = @import("../../arch/spirv/Section.zig");
-const spec = @import("../../codegen/spirv/spec.zig");
+const spec = @import("../../arch/spirv/spec.zig");
 const ResultId = spec.Id;
 const Word = spec.Word;
 

src/link/SpirV/prune_unused.zig

@@ -12,8 +12,8 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.spirv_link);
 
 const BinaryModule = @import("BinaryModule.zig");
-const Section = @import("../../codegen/spirv/Section.zig");
+const Section = @import("../../arch/spirv/Section.zig");
-const spec = @import("../../codegen/spirv/spec.zig");
+const spec = @import("../../arch/spirv/spec.zig");
 const Opcode = spec.Opcode;
 const ResultId = spec.Id;
 const Word = spec.Word;

test/behavior/packed-union.zig

@@ -140,6 +140,7 @@ test "packed union initialized with a runtime value" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const Fields = packed struct {
         timestamp: u50,

test/behavior/slice.zig

@@ -1036,6 +1036,8 @@ test "sentinel-terminated 0-length slices" {
 }
 
 test "peer slices keep abi alignment with empty struct" {
+    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
+
     var cond: bool = undefined;
     cond = false;
     const slice = if (cond) &[1]u32{42} else &.{};

tools/gen_spirv_spec.zig

@@ -221,6 +221,16 @@ fn render(writer: *std.io.Writer, registry: CoreRegistry, extensions: []const Ex
         \\    }
         \\};
         \\
+        \\pub const IdRange = struct {
+        \\    base: u32,
+        \\    len: u32,
+        \\
+        \\    pub fn at(range: IdRange, i: usize) Id {
+        \\        std.debug.assert(i < range.len);
+        \\        return @enumFromInt(range.base + i);
+        \\    }
+        \\};
+        \\
         \\pub const LiteralInteger = Word;
         \\pub const LiteralFloat = Word;
         \\pub const LiteralString = []const u8;
@@ -324,7 +334,7 @@ fn renderInstructionSet(
     );
 
     for (extensions) |ext| {
-        try writer.print("{f},\n", .{formatId(ext.name)});
+        try writer.print("{f},\n", .{std.zig.fmtId(ext.name)});
     }
 
     try writer.writeAll(
@@ -357,7 +367,7 @@ fn renderInstructionsCase(
     // but there aren't so many total aliases and that would add more overhead in total. We will
     // just filter those out when needed.
 
-    try writer.print(".{f} => &.{{\n", .{formatId(set_name)});
+    try writer.print(".{f} => &.{{\n", .{std.zig.fmtId(set_name)});
 
     for (instructions) |inst| {
         try writer.print(