diff options
Diffstat (limited to 'src/codegen/spirv.zig')
| -rw-r--r-- | src/codegen/spirv.zig | 85 |
1 files changed, 60 insertions, 25 deletions
diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index fd153533c8..076cce4a89 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -12,9 +12,13 @@ const LazySrcLoc = Module.LazySrcLoc; pub const TypeMap = std.HashMap(Type, u32, Type.hash, Type.eql, std.hash_map.default_max_load_percentage); -pub fn writeInstruction(code: *std.ArrayList(u32), instr: spec.Opcode, args: []const u32) !void { - const word_count = @intCast(u32, args.len + 1); - try code.append((word_count << 16) | @enumToInt(instr)); +pub fn writeOpcode(code: *std.ArrayList(u32), opcode: spec.Opcode, arg_count: u32) !void { + const word_count = arg_count + 1; + try code.append((word_count << 16) | @enumToInt(opcode)); +} + +pub fn writeInstruction(code: *std.ArrayList(u32), opcode: spec.Opcode, args: []const u32) !void { + try writeOpcode(code, opcode, @intCast(u32, args.len)); try code.appendSlice(args); } @@ -58,7 +62,12 @@ pub const DeclGen = struct { decl: *Decl, error_msg: ?*Module.ErrorMsg, - fn fail(self: *DeclGen, src: LazySrcLoc, comptime format: []const u8, args: anytype) error{ AnalysisFail, OutOfMemory } { + const Error = error{ + AnalysisFail, + OutOfMemory + }; + + fn fail(self: *DeclGen, src: LazySrcLoc, comptime format: []const u8, args: anytype) Error { @setCold(true); const src_loc = src.toSrcLocWithDecl(self.decl); self.error_msg = try Module.ErrorMsg.create(self.module.gpa, src_loc, format, args); @@ -102,24 +111,25 @@ pub const DeclGen = struct { return null; } - pub fn getOrGenType(self: *DeclGen, t: Type) !u32 { + fn getOrGenType(self: *DeclGen, ty: Type) Error!u32 { // We can't use getOrPut here so we can recursively generate types. - if (self.types.get(t)) |already_generated| { + if (self.types.get(ty)) |already_generated| { return already_generated; } - const result = self.spv.allocResultId(); + const code = &self.spv.types_and_globals; + const result_id = self.spv.allocResultId(); - switch (t.zigTypeTag()) { - .Void => try writeInstruction(&self.spv.types_and_globals, .OpTypeVoid, &[_]u32{ result }), - .Bool => try writeInstruction(&self.spv.types_and_globals, .OpTypeBool, &[_]u32{ result }), + switch (ty.zigTypeTag()) { + .Void => try writeInstruction(code, .OpTypeVoid, &[_]u32{ result_id }), + .Bool => try writeInstruction(code, .OpTypeBool, &[_]u32{ result_id }), .Int => { - const int_info = t.intInfo(self.module.getTarget()); + const int_info = ty.intInfo(self.module.getTarget()); const backing_bits = self.backingIntBits(int_info.bits) orelse return self.fail(.{.node_offset = 0}, "TODO: SPIR-V backend: implement fallback for integer of {} bits", .{ int_info.bits }); - try writeInstruction(&self.spv.types_and_globals, .OpTypeInt, &[_]u32{ - result, + try writeInstruction(code, .OpTypeInt, &[_]u32{ + result_id, backing_bits, switch (int_info.signedness) { .unsigned => 0, @@ -128,7 +138,34 @@ pub const DeclGen = struct { }); }, // TODO: Capabilities. - .Float => try writeInstruction(&self.spv.types_and_globals, .OpTypeFloat, &[_]u32{ result, t.floatBits(self.module.getTarget()) }), + .Float => try writeInstruction(code, .OpTypeFloat, &[_]u32{ result_id, ty.floatBits(self.module.getTarget()) }), + .Fn => { + // We only support zig-calling-convention functions, no varargs. + if (ty.fnCallingConvention() != .Unspecified) + return self.fail(.{.node_offset = 0}, "Invalid calling convention for SPIR-V", .{}); + if (ty.fnIsVarArgs()) + return self.fail(.{.node_offset = 0}, "VarArgs are not supported for SPIR-V", .{}); + + // In order to avoid a temporary here, first generate all the required types and then simply look them up + // when generating the function type. + const params = ty.fnParamLen(); + var i: usize = 0; + while (i < params) : (i += 1) { + _ = try self.getOrGenType(ty.fnParamType(i)); + } + + const return_type_id = try self.getOrGenType(ty.fnReturnType()); + + // result id + result type id + parameter type ids. + try writeOpcode(code, .OpTypeFunction, 2 + @intCast(u32, ty.fnParamLen()) ); + try code.appendSlice(&.{ result_id, return_type_id }); + + i = 0; + while (i < params) : (i += 1) { + const param_type_id = self.types.get(ty.fnParamType(i)).?; + try code.append(param_type_id); + } + }, .Null, .Undefined, .EnumLiteral, @@ -139,23 +176,21 @@ pub const DeclGen = struct { .BoundFn => unreachable, // this type will be deleted from the language. - else => |tag| return self.fail(.{ .node_offset = 0 }, "TODO: SPIR-V backend: implement type with tag {}", .{ tag }), + else => |tag| return self.fail(.{ .node_offset = 0 }, "TODO: SPIR-V backend: implement type {}", .{ tag }), } - try self.types.put(t, result); - return result; + try self.types.put(ty, result_id); + return result_id; } pub fn gen(self: *DeclGen) !void { - const typed_value = self.decl.typed_value.most_recent.typed_value; - - switch (typed_value.ty.zigTypeTag()) { - .Fn => { - log.debug("Generating code for function '{s}'", .{ std.mem.spanZ(self.decl.name) }); + const tv = self.decl.typed_value.most_recent.typed_value; - _ = try self.getOrGenType(typed_value.ty.fnReturnType()); - }, - else => |tag| return self.fail(.{ .node_offset = 0 }, "TODO: SPIR-V backend: generate decl with tag {}", .{ tag }), + if (tv.val.castTag(.function)) |func_payload| { + std.debug.assert(tv.ty.zigTypeTag() == .Fn); + _ = try self.getOrGenType(tv.ty); + } else { + return self.fail(.{.node_offset = 0}, "TODO: SPIR-V backend: generate decl type {}", .{ tv.ty.zigTypeTag() }); } } }; |