926 lines
33 KiB
Zig
926 lines
33 KiB
Zig
const std = @import("std");
|
|
const spv = @import("spv.zig");
|
|
const op = @import("opcodes.zig");
|
|
|
|
const Runtime = @import("Runtime.zig");
|
|
const RuntimeError = Runtime.RuntimeError;
|
|
|
|
const SpvVoid = spv.SpvVoid;
|
|
const SpvByte = spv.SpvByte;
|
|
const SpvWord = spv.SpvWord;
|
|
const SpvBool = spv.SpvBool;
|
|
|
|
pub const Vec4f32 = @Vector(4, f32);
|
|
pub const Vec3f32 = @Vector(3, f32);
|
|
pub const Vec2f32 = @Vector(2, f32);
|
|
|
|
pub const Vec4i32 = @Vector(4, i32);
|
|
pub const Vec3i32 = @Vector(3, i32);
|
|
pub const Vec2i32 = @Vector(2, i32);
|
|
|
|
pub const Vec4u32 = @Vector(4, u32);
|
|
pub const Vec3u32 = @Vector(3, u32);
|
|
pub const Vec2u32 = @Vector(2, u32);
|
|
|
|
pub const Variant = enum {
|
|
String,
|
|
Extension,
|
|
Type,
|
|
Variable,
|
|
Constant,
|
|
Function,
|
|
AccessChain,
|
|
FunctionParameter,
|
|
Label,
|
|
};
|
|
|
|
pub const Type = enum {
|
|
Void,
|
|
Bool,
|
|
Int,
|
|
Float,
|
|
Vector,
|
|
Vector4f32,
|
|
Vector3f32,
|
|
Vector2f32,
|
|
Vector4i32,
|
|
Vector3i32,
|
|
Vector2i32,
|
|
Vector4u32,
|
|
Vector3u32,
|
|
Vector2u32,
|
|
Matrix,
|
|
Array,
|
|
RuntimeArray,
|
|
Structure,
|
|
Function,
|
|
Image,
|
|
Sampler,
|
|
SampledImage,
|
|
Pointer,
|
|
};
|
|
|
|
const ImageInfo = struct {
|
|
dim: spv.SpvDim,
|
|
depth: SpvByte,
|
|
arrayed: SpvByte,
|
|
ms: SpvByte,
|
|
sampled: SpvByte,
|
|
format: spv.SpvImageFormat,
|
|
access: spv.SpvAccessQualifier,
|
|
};
|
|
|
|
const Decoration = struct {
|
|
rtype: spv.SpvDecoration,
|
|
literal_1: SpvWord,
|
|
literal_2: ?SpvWord,
|
|
index: SpvWord,
|
|
};
|
|
|
|
pub const Value = union(Type) {
|
|
Void: struct {},
|
|
Bool: bool,
|
|
Int: struct {
|
|
bit_count: usize,
|
|
value: extern union {
|
|
sint8: i8,
|
|
sint16: i16,
|
|
sint32: i32,
|
|
sint64: i64,
|
|
uint8: u8,
|
|
uint16: u16,
|
|
uint32: u32,
|
|
uint64: u64,
|
|
},
|
|
},
|
|
Float: struct {
|
|
bit_count: usize,
|
|
value: extern union {
|
|
float16: f16,
|
|
float32: f32,
|
|
float64: f64,
|
|
},
|
|
},
|
|
Vector: []Value,
|
|
Vector4f32: Vec4f32,
|
|
Vector3f32: Vec3f32,
|
|
Vector2f32: Vec2f32,
|
|
Vector4i32: Vec4i32,
|
|
Vector3i32: Vec3i32,
|
|
Vector2i32: Vec2i32,
|
|
Vector4u32: Vec4u32,
|
|
Vector3u32: Vec3u32,
|
|
Vector2u32: Vec2u32,
|
|
Matrix: []Value,
|
|
Array: []Value,
|
|
RuntimeArray: struct {
|
|
type_word: SpvWord,
|
|
data: []u8,
|
|
},
|
|
Structure: []Value,
|
|
Function: noreturn,
|
|
Image: struct {},
|
|
Sampler: struct {},
|
|
SampledImage: struct {},
|
|
Pointer: struct {
|
|
ptr: union(enum) {
|
|
common: *Value,
|
|
f32_ptr: *f32,
|
|
i32_ptr: *i32, //< For vector specializations
|
|
u32_ptr: *u32,
|
|
},
|
|
runtime_array_window: ?[]u8 = null,
|
|
},
|
|
|
|
pub inline fn getCompositeDataOrNull(self: *const Value) ?[]Value {
|
|
return switch (self.*) {
|
|
.Vector, .Matrix, .Array, .Structure => |v| v,
|
|
else => null,
|
|
};
|
|
}
|
|
|
|
pub fn init(allocator: std.mem.Allocator, results: []const Self, target: SpvWord) RuntimeError!Value {
|
|
const resolved = results[target].resolveType(results);
|
|
const member_count = resolved.getMemberCounts();
|
|
|
|
return switch (resolved.variant.?) {
|
|
.Type => |t| switch (t) {
|
|
.Bool => .{ .Bool = false },
|
|
.Int => |i| .{ .Int = .{
|
|
.bit_count = i.bit_length,
|
|
.value = .{ .uint64 = 0 },
|
|
} },
|
|
.Float => |f| .{ .Float = .{
|
|
.bit_count = f.bit_length,
|
|
.value = .{ .float64 = 0 },
|
|
} },
|
|
.Vector => |v| blk: {
|
|
var self: Value = .{ .Vector = allocator.alloc(Value, member_count) catch return RuntimeError.OutOfMemory };
|
|
errdefer self.deinit(allocator);
|
|
|
|
for (self.Vector) |*value| {
|
|
value.* = try Value.init(allocator, results, v.components_type_word);
|
|
}
|
|
break :blk self;
|
|
},
|
|
.Vector4f32 => .{ .Vector4f32 = Vec4f32{ 0.0, 0.0, 0.0, 0.0 } },
|
|
.Vector3f32 => .{ .Vector3f32 = Vec3f32{ 0.0, 0.0, 0.0 } },
|
|
.Vector2f32 => .{ .Vector2f32 = Vec2f32{ 0.0, 0.0 } },
|
|
.Vector4i32 => .{ .Vector4i32 = Vec4i32{ 0, 0, 0, 0 } },
|
|
.Vector3i32 => .{ .Vector3i32 = Vec3i32{ 0, 0, 0 } },
|
|
.Vector2i32 => .{ .Vector2i32 = Vec2i32{ 0, 0 } },
|
|
.Vector4u32 => .{ .Vector4u32 = Vec4u32{ 0, 0, 0, 0 } },
|
|
.Vector3u32 => .{ .Vector3u32 = Vec3u32{ 0, 0, 0 } },
|
|
.Vector2u32 => .{ .Vector2u32 = Vec2u32{ 0, 0 } },
|
|
.Matrix => |m| blk: {
|
|
var self: Value = .{ .Matrix = allocator.alloc(Value, member_count) catch return RuntimeError.OutOfMemory };
|
|
errdefer self.deinit(allocator);
|
|
|
|
for (self.Matrix) |*value| {
|
|
value.* = try Value.init(allocator, results, m.column_type_word);
|
|
}
|
|
break :blk self;
|
|
},
|
|
.Array => |a| blk: {
|
|
var self: Value = .{ .Array = allocator.alloc(Value, member_count) catch return RuntimeError.OutOfMemory };
|
|
errdefer self.deinit(allocator);
|
|
|
|
for (self.Array) |*value| {
|
|
value.* = try Value.init(allocator, results, a.components_type_word);
|
|
}
|
|
break :blk self;
|
|
},
|
|
.Structure => |s| blk: {
|
|
var self: Value = .{ .Structure = allocator.alloc(Value, member_count) catch return RuntimeError.OutOfMemory };
|
|
errdefer self.deinit(allocator);
|
|
|
|
for (self.Structure, s.members_type_word) |*value, member_type_word| {
|
|
value.* = try Value.init(allocator, results, member_type_word);
|
|
}
|
|
break :blk self;
|
|
},
|
|
.RuntimeArray => |a| .{
|
|
.RuntimeArray = .{
|
|
.type_word = a.components_type_word,
|
|
.data = &.{},
|
|
},
|
|
},
|
|
else => unreachable,
|
|
},
|
|
else => unreachable,
|
|
};
|
|
}
|
|
|
|
/// Performs a deep copy
|
|
pub fn dupe(self: *const Value, allocator: std.mem.Allocator) RuntimeError!Value {
|
|
return switch (self.*) {
|
|
.Vector => |v| .{
|
|
.Vector = blk: {
|
|
const values = allocator.dupe(Value, v) catch return RuntimeError.OutOfMemory;
|
|
for (values, v) |*new_value, value| new_value.* = try value.dupe(allocator);
|
|
break :blk values;
|
|
},
|
|
},
|
|
.Matrix => |m| .{
|
|
.Matrix = blk: {
|
|
const values = allocator.dupe(Value, m) catch return RuntimeError.OutOfMemory;
|
|
for (values, m) |*new_value, value| new_value.* = try value.dupe(allocator);
|
|
break :blk values;
|
|
},
|
|
},
|
|
.Array => |a| .{
|
|
.Array = blk: {
|
|
const values = allocator.dupe(Value, a) catch return RuntimeError.OutOfMemory;
|
|
for (values, a) |*new_value, value| new_value.* = try value.dupe(allocator);
|
|
break :blk values;
|
|
},
|
|
},
|
|
.Structure => |s| .{
|
|
.Structure = blk: {
|
|
const values = allocator.dupe(Value, s) catch return RuntimeError.OutOfMemory;
|
|
for (values, s) |*new_value, value| new_value.* = try value.dupe(allocator);
|
|
break :blk values;
|
|
},
|
|
},
|
|
else => self.*,
|
|
};
|
|
}
|
|
|
|
pub fn read(self: *const Value, output: []u8) RuntimeError!usize {
|
|
switch (self.*) {
|
|
.Bool => |b| {
|
|
output[0] = if (b == true) 1 else 0;
|
|
return 1;
|
|
},
|
|
.Int => |i| {
|
|
switch (i.bit_count) {
|
|
8 => output[0] = @bitCast(i.value.uint8),
|
|
16 => std.mem.copyForwards(u8, output[0..], std.mem.asBytes(&i.value.uint16)),
|
|
32 => std.mem.copyForwards(u8, output[0..], std.mem.asBytes(&i.value.uint32)),
|
|
64 => std.mem.copyForwards(u8, output[0..], std.mem.asBytes(&i.value.uint64)),
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
return @divExact(i.bit_count, 8);
|
|
},
|
|
.Float => |f| {
|
|
switch (f.bit_count) {
|
|
16 => std.mem.copyForwards(u8, output[0..], std.mem.asBytes(&f.value.float16)),
|
|
32 => std.mem.copyForwards(u8, output[0..], std.mem.asBytes(&f.value.float32)),
|
|
64 => std.mem.copyForwards(u8, output[0..], std.mem.asBytes(&f.value.float64)),
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
return @divExact(f.bit_count, 8);
|
|
},
|
|
.Vector4f32 => |vec| {
|
|
inline for (0..4) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 4 * 4;
|
|
},
|
|
.Vector3f32 => |vec| {
|
|
inline for (0..3) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 3 * 4;
|
|
},
|
|
.Vector2f32 => |vec| {
|
|
inline for (0..2) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 2 * 4;
|
|
},
|
|
.Vector4i32 => |vec| {
|
|
inline for (0..4) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 4 * 4;
|
|
},
|
|
.Vector3i32 => |vec| {
|
|
inline for (0..3) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 3 * 4;
|
|
},
|
|
.Vector2i32 => |vec| {
|
|
inline for (0..2) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 2 * 4;
|
|
},
|
|
.Vector4u32 => |vec| {
|
|
inline for (0..4) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 4 * 4;
|
|
},
|
|
.Vector3u32 => |vec| {
|
|
inline for (0..3) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 3 * 4;
|
|
},
|
|
.Vector2u32 => |vec| {
|
|
inline for (0..2) |i| {
|
|
std.mem.copyForwards(u8, output[(i * 4)..], std.mem.asBytes(&vec[i]));
|
|
}
|
|
return 2 * 4;
|
|
},
|
|
.Vector,
|
|
.Matrix,
|
|
.Array,
|
|
.Structure,
|
|
=> |values| {
|
|
var offset: usize = 0;
|
|
for (values) |v| {
|
|
offset += try v.read(output[offset..]);
|
|
}
|
|
return offset;
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
pub fn writeConst(self: *Value, input: []const u8) RuntimeError!usize {
|
|
return self.write(@constCast(input));
|
|
}
|
|
|
|
pub fn write(self: *Value, input: []u8) RuntimeError!usize {
|
|
switch (self.*) {
|
|
.Bool => |*b| {
|
|
b.* = if (input[0] != 0) true else false;
|
|
return 1;
|
|
},
|
|
.Int => |*i| {
|
|
switch (i.bit_count) {
|
|
8 => i.value.uint8 = @bitCast(input[0]),
|
|
16 => std.mem.copyForwards(u8, std.mem.asBytes(&i.value.uint16), input[0..2]),
|
|
32 => std.mem.copyForwards(u8, std.mem.asBytes(&i.value.uint32), input[0..4]),
|
|
64 => std.mem.copyForwards(u8, std.mem.asBytes(&i.value.uint64), input[0..8]),
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
return @divExact(i.bit_count, 8);
|
|
},
|
|
.Float => |*f| {
|
|
switch (f.bit_count) {
|
|
16 => std.mem.copyForwards(u8, std.mem.asBytes(&f.value.float16), input[0..2]),
|
|
32 => std.mem.copyForwards(u8, std.mem.asBytes(&f.value.float32), input[0..4]),
|
|
64 => std.mem.copyForwards(u8, std.mem.asBytes(&f.value.float64), input[0..8]),
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
return @divExact(f.bit_count, 8);
|
|
},
|
|
.Vector4f32 => |*vec| {
|
|
inline for (0..4) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 4 * 4;
|
|
},
|
|
.Vector3f32 => |*vec| {
|
|
inline for (0..3) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 3 * 4;
|
|
},
|
|
.Vector2f32 => |*vec| {
|
|
inline for (0..2) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 2 * 4;
|
|
},
|
|
.Vector4i32 => |*vec| {
|
|
inline for (0..4) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 4 * 4;
|
|
},
|
|
.Vector3i32 => |*vec| {
|
|
inline for (0..3) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 3 * 4;
|
|
},
|
|
.Vector2i32 => |*vec| {
|
|
inline for (0..2) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 2 * 4;
|
|
},
|
|
.Vector4u32 => |*vec| {
|
|
inline for (0..4) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 4 * 4;
|
|
},
|
|
.Vector3u32 => |*vec| {
|
|
inline for (0..3) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 3 * 4;
|
|
},
|
|
.Vector2u32 => |*vec| {
|
|
inline for (0..2) |i| {
|
|
const start = i * 4;
|
|
const end = (i + 1) * 4;
|
|
if (start >= input.len or end > input.len) return RuntimeError.OutOfBounds;
|
|
std.mem.copyForwards(u8, std.mem.asBytes(&vec[i]), input[start..end]);
|
|
}
|
|
return 2 * 4;
|
|
},
|
|
.Vector,
|
|
.Matrix,
|
|
.Array,
|
|
.Structure,
|
|
=> |*values| {
|
|
var offset: usize = 0;
|
|
for (values.*) |*v| {
|
|
offset += try v.write(input[offset..]);
|
|
}
|
|
return offset;
|
|
},
|
|
.RuntimeArray => |*arr| arr.data = input[0..],
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
pub fn flushPtr(self: *Value, allocator: std.mem.Allocator) RuntimeError!void {
|
|
switch (self.*) {
|
|
.Pointer => |*p| {
|
|
if (p.runtime_array_window) |window| {
|
|
switch (p.ptr) {
|
|
.common => |ptr| {
|
|
_ = try ptr.read(window);
|
|
ptr.deinit(allocator);
|
|
allocator.destroy(ptr);
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
p.runtime_array_window = null;
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
fn deinit(self: *Value, allocator: std.mem.Allocator) void {
|
|
switch (self.*) {
|
|
.Vector, .Matrix, .Array, .Structure => |values| {
|
|
for (values) |*value| value.deinit(allocator);
|
|
allocator.free(values);
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
};
|
|
|
|
pub const TypeData = union(Type) {
|
|
Void: struct {},
|
|
Bool: struct {},
|
|
Int: struct {
|
|
bit_length: SpvWord,
|
|
is_signed: bool,
|
|
},
|
|
Float: struct {
|
|
bit_length: SpvWord,
|
|
},
|
|
Vector: struct {
|
|
components_type_word: SpvWord,
|
|
components_type: Type,
|
|
member_count: SpvWord,
|
|
},
|
|
Vector4f32: struct {},
|
|
Vector3f32: struct {},
|
|
Vector2f32: struct {},
|
|
Vector4i32: struct {},
|
|
Vector3i32: struct {},
|
|
Vector2i32: struct {},
|
|
Vector4u32: struct {},
|
|
Vector3u32: struct {},
|
|
Vector2u32: struct {},
|
|
Matrix: struct {
|
|
column_type_word: SpvWord,
|
|
column_type: Type,
|
|
member_count: SpvWord,
|
|
},
|
|
Array: struct {
|
|
components_type_word: SpvWord,
|
|
components_type: Type,
|
|
member_count: SpvWord,
|
|
},
|
|
RuntimeArray: struct {
|
|
components_type_word: SpvWord,
|
|
components_type: Type,
|
|
},
|
|
Structure: struct {
|
|
members_type_word: []const SpvWord,
|
|
member_names: std.ArrayList([]const u8),
|
|
},
|
|
Function: struct {
|
|
source_location: usize,
|
|
return_type: SpvWord,
|
|
params: []const SpvWord,
|
|
},
|
|
Image: struct {},
|
|
Sampler: struct {},
|
|
SampledImage: struct {},
|
|
Pointer: struct {
|
|
storage_class: spv.SpvStorageClass,
|
|
target: SpvWord,
|
|
},
|
|
|
|
pub fn getSize(self: *const TypeData, results: []const Self) usize {
|
|
return switch (self.*) {
|
|
.Bool => 1,
|
|
.Int => |i| @divExact(i.bit_length, 8),
|
|
.Float => |f| @divExact(f.bit_length, 8),
|
|
.Vector => |v| results[v.components_type_word].variant.?.Type.getSize(results),
|
|
.Array => |a| results[a.components_type_word].variant.?.Type.getSize(results),
|
|
.Matrix => |m| results[m.column_type_word].variant.?.Type.getSize(results),
|
|
.RuntimeArray => |a| results[a.components_type_word].variant.?.Type.getSize(results),
|
|
.Structure => |s| blk: {
|
|
var total: usize = 0;
|
|
for (s.members_type_word) |type_word| {
|
|
total += results[type_word].variant.?.Type.getSize(results);
|
|
}
|
|
break :blk total;
|
|
},
|
|
.Vector4f32, .Vector4i32, .Vector4u32 => 4 * 4,
|
|
.Vector3f32, .Vector3i32, .Vector3u32 => 3 * 4,
|
|
.Vector2f32, .Vector2i32, .Vector2u32 => 2 * 4,
|
|
else => 0,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const VariantData = union(Variant) {
|
|
String: []const u8,
|
|
Extension: struct {
|
|
/// Should not be allocated but rather a pointer to a static array
|
|
dispatcher: []?op.OpCodeExtFunc,
|
|
},
|
|
Type: TypeData,
|
|
Variable: struct {
|
|
storage_class: spv.SpvStorageClass,
|
|
type_word: SpvWord,
|
|
type: Type,
|
|
value: Value,
|
|
},
|
|
Constant: struct {
|
|
type_word: SpvWord,
|
|
type: Type,
|
|
value: Value,
|
|
},
|
|
Function: struct {
|
|
source_location: usize,
|
|
return_type: SpvWord,
|
|
function_type: SpvWord,
|
|
params: []SpvWord,
|
|
},
|
|
AccessChain: struct {
|
|
target: SpvWord,
|
|
value: Value,
|
|
},
|
|
FunctionParameter: struct {
|
|
type_word: SpvWord,
|
|
type: Type,
|
|
value_ptr: ?*Value,
|
|
},
|
|
Label: struct {
|
|
source_location: usize,
|
|
},
|
|
};
|
|
|
|
const Self = @This();
|
|
|
|
name: ?[]const u8,
|
|
decorations: std.ArrayList(Decoration),
|
|
variant: ?VariantData,
|
|
|
|
pub fn init() Self {
|
|
return .{
|
|
.name = null,
|
|
.decorations = .empty,
|
|
.variant = null,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
|
|
if (self.name) |name| {
|
|
allocator.free(name);
|
|
}
|
|
if (self.variant) |*variant| {
|
|
switch (variant.*) {
|
|
.Type => |*t| switch (t.*) {
|
|
.Function => |data| allocator.free(data.params),
|
|
.Structure => |*data| {
|
|
allocator.free(data.members_type_word);
|
|
for (data.member_names.items) |name| {
|
|
allocator.free(name);
|
|
}
|
|
data.member_names.deinit(allocator);
|
|
},
|
|
else => {},
|
|
},
|
|
.Constant => |*c| c.value.deinit(allocator),
|
|
.Variable => |*v| v.value.deinit(allocator),
|
|
.AccessChain => |*a| a.value.deinit(allocator),
|
|
.Function => |f| allocator.free(f.params),
|
|
else => {},
|
|
}
|
|
}
|
|
self.decorations.deinit(allocator);
|
|
}
|
|
|
|
pub inline fn getValueTypeWord(self: *Self) RuntimeError!SpvWord {
|
|
return switch ((try self.getVariant()).*) {
|
|
.Variable => |v| v.type_word,
|
|
.Constant => |c| c.type_word,
|
|
.AccessChain => |a| a.target,
|
|
.FunctionParameter => |p| p.type_word,
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
pub inline fn getValueType(self: *Self) RuntimeError!Type {
|
|
return switch ((try self.getVariant()).*) {
|
|
.Variable => |v| v.type,
|
|
.Constant => |c| c.type,
|
|
.FunctionParameter => |p| p.type,
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
pub inline fn getValue(self: *Self) RuntimeError!*Value {
|
|
return switch ((try self.getVariant()).*) {
|
|
.Variable => |*v| &v.value,
|
|
.Constant => |*c| &c.value,
|
|
.AccessChain => |*a| &a.value,
|
|
.FunctionParameter => |*p| p.value_ptr orelse return RuntimeError.InvalidSpirV,
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
pub inline fn getConstValue(self: *Self) RuntimeError!*const Value {
|
|
return switch ((try self.getVariant()).*) {
|
|
.Variable => |v| &v.value,
|
|
.Constant => |c| &c.value,
|
|
.AccessChain => |a| &a.value,
|
|
.FunctionParameter => |p| p.value_ptr orelse return RuntimeError.InvalidSpirV,
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
pub inline fn getVariant(self: *Self) RuntimeError!*VariantData {
|
|
return &(self.variant orelse return RuntimeError.InvalidSpirV);
|
|
}
|
|
|
|
pub inline fn getConstVariant(self: *const Self) RuntimeError!*const VariantData {
|
|
return &(self.variant orelse return RuntimeError.InvalidSpirV);
|
|
}
|
|
|
|
/// Performs a deep copy
|
|
pub fn dupe(self: *const Self, allocator: std.mem.Allocator) RuntimeError!Self {
|
|
return .{
|
|
.name = if (self.name) |name| allocator.dupe(u8, name) catch return RuntimeError.OutOfMemory else null,
|
|
.decorations = self.decorations.clone(allocator) catch return RuntimeError.OutOfMemory,
|
|
.variant = blk: {
|
|
if (self.variant) |variant| {
|
|
switch (variant) {
|
|
.String => |s| break :blk .{
|
|
.String = allocator.dupe(u8, s) catch return RuntimeError.OutOfMemory,
|
|
},
|
|
.Type => |t| switch (t) {
|
|
.Structure => |s| break :blk .{
|
|
.Type = .{
|
|
.Structure = .{
|
|
.members_type_word = allocator.dupe(SpvWord, s.members_type_word) catch return RuntimeError.OutOfMemory,
|
|
.member_names = blk2: {
|
|
const member_names = s.member_names.clone(allocator) catch return RuntimeError.OutOfMemory;
|
|
for (member_names.items, s.member_names.items) |*new_name, name| {
|
|
new_name.* = allocator.dupe(u8, name) catch return RuntimeError.OutOfMemory;
|
|
}
|
|
break :blk2 member_names;
|
|
},
|
|
},
|
|
},
|
|
},
|
|
.Function => |f| break :blk .{
|
|
.Type = .{
|
|
.Function = .{
|
|
.source_location = f.source_location,
|
|
.return_type = f.return_type,
|
|
.params = allocator.dupe(SpvWord, f.params) catch return RuntimeError.OutOfMemory,
|
|
},
|
|
},
|
|
},
|
|
else => break :blk .{ .Type = t },
|
|
},
|
|
.Variable => |v| break :blk .{
|
|
.Variable = .{
|
|
.storage_class = v.storage_class,
|
|
.type_word = v.type_word,
|
|
.type = v.type,
|
|
.value = try v.value.dupe(allocator),
|
|
},
|
|
},
|
|
.Constant => |c| break :blk .{
|
|
.Constant = .{
|
|
.type_word = c.type_word,
|
|
.type = c.type,
|
|
.value = try c.value.dupe(allocator),
|
|
},
|
|
},
|
|
.Function => |f| break :blk .{
|
|
.Function = .{
|
|
.source_location = f.source_location,
|
|
.return_type = f.return_type,
|
|
.function_type = f.function_type,
|
|
.params = allocator.dupe(SpvWord, f.params) catch return RuntimeError.OutOfMemory,
|
|
},
|
|
},
|
|
else => break :blk variant,
|
|
}
|
|
}
|
|
break :blk null;
|
|
},
|
|
};
|
|
}
|
|
|
|
pub fn resolveLaneBitWidth(target_type: TypeData, rt: *const Runtime) RuntimeError!SpvWord {
|
|
return sw: switch (target_type) {
|
|
.Bool => 8,
|
|
.Float => |f| f.bit_length,
|
|
.Int => |i| i.bit_length,
|
|
.Vector => |v| continue :sw (try rt.results[v.components_type_word].getVariant()).Type,
|
|
.Vector4f32,
|
|
.Vector3f32,
|
|
.Vector2f32,
|
|
.Vector4i32,
|
|
.Vector3i32,
|
|
.Vector2i32,
|
|
.Vector4u32,
|
|
.Vector3u32,
|
|
.Vector2u32,
|
|
=> return 32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
pub fn resolveSign(target_type: TypeData, rt: *const Runtime) RuntimeError!enum { signed, unsigned } {
|
|
return sw: switch (target_type) {
|
|
.Int => |i| if (i.is_signed) .signed else .unsigned,
|
|
.Vector => |v| continue :sw (try rt.results[v.components_type_word].getVariant()).Type,
|
|
.Vector4i32 => .signed,
|
|
.Vector3i32 => .signed,
|
|
.Vector2i32 => .signed,
|
|
.Vector4u32 => .unsigned,
|
|
.Vector3u32 => .unsigned,
|
|
.Vector2u32 => .unsigned,
|
|
else => .unsigned,
|
|
};
|
|
}
|
|
|
|
pub inline fn resolveType(self: *const Self, results: []const Self) *const Self {
|
|
return if (self.resolveTypeWordOrNull()) |word| &results[word] else self;
|
|
}
|
|
|
|
pub fn resolveTypeWordOrNull(self: *const Self) ?SpvWord {
|
|
return if (self.variant) |variant|
|
|
switch (variant) {
|
|
.Type => |t| switch (t) {
|
|
.Pointer => |ptr| ptr.target,
|
|
else => null,
|
|
},
|
|
else => null,
|
|
}
|
|
else
|
|
null;
|
|
}
|
|
|
|
pub fn getMemberCounts(self: *const Self) usize {
|
|
if (self.variant) |variant| {
|
|
switch (variant) {
|
|
.Type => |t| switch (t) {
|
|
.Bool, .Int, .Float, .Image, .Sampler => return 1,
|
|
.Vector => |v| return v.member_count,
|
|
.Vector4f32, .Vector4i32, .Vector4u32 => return 4,
|
|
.Vector3f32, .Vector3i32, .Vector3u32 => return 3,
|
|
.Vector2f32, .Vector2i32, .Vector2u32 => return 2,
|
|
.Matrix => |m| return m.member_count,
|
|
.Array => |a| return a.member_count,
|
|
.SampledImage => return 2,
|
|
.Structure => |s| return s.members_type_word.len,
|
|
.Function => |f| return f.params.len,
|
|
else => {},
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
pub fn initValue(allocator: std.mem.Allocator, member_count: usize, results: []const Self, resolved: *const Self) RuntimeError!Value {
|
|
return switch (resolved.variant.?) {
|
|
.Type => |t| switch (t) {
|
|
.Void => .{ .Void = .{} },
|
|
.Bool => .{ .Bool = false },
|
|
.Int => |i| .{ .Int = .{
|
|
.bit_count = i.bit_length,
|
|
.value = .{ .uint64 = 0 },
|
|
} },
|
|
.Float => |f| .{ .Float = .{
|
|
.bit_count = f.bit_length,
|
|
.value = .{ .float64 = 0 },
|
|
} },
|
|
.Vector => |v| blk: {
|
|
const value: Value = .{ .Vector = allocator.alloc(Value, member_count) catch return RuntimeError.OutOfMemory };
|
|
errdefer allocator.free(value.Vector);
|
|
for (value.Vector) |*val| {
|
|
val.* = try Value.init(allocator, results, v.components_type_word);
|
|
}
|
|
break :blk value;
|
|
},
|
|
.Vector4f32 => .{ .Vector4f32 = Vec4f32{ 0.0, 0.0, 0.0, 0.0 } },
|
|
.Vector3f32 => .{ .Vector3f32 = Vec3f32{ 0.0, 0.0, 0.0 } },
|
|
.Vector2f32 => .{ .Vector2f32 = Vec2f32{ 0.0, 0.0 } },
|
|
.Vector4i32 => .{ .Vector4i32 = Vec4i32{ 0, 0, 0, 0 } },
|
|
.Vector3i32 => .{ .Vector3i32 = Vec3i32{ 0, 0, 0 } },
|
|
.Vector2i32 => .{ .Vector2i32 = Vec2i32{ 0, 0 } },
|
|
.Vector4u32 => .{ .Vector4u32 = Vec4u32{ 0, 0, 0, 0 } },
|
|
.Vector3u32 => .{ .Vector3u32 = Vec3u32{ 0, 0, 0 } },
|
|
.Vector2u32 => .{ .Vector2u32 = Vec2u32{ 0, 0 } },
|
|
.Matrix => |m| blk: {
|
|
const value: Value = .{ .Matrix = allocator.alloc(Value, member_count) catch return RuntimeError.OutOfMemory };
|
|
errdefer allocator.free(value.Matrix);
|
|
for (value.Matrix) |*v| {
|
|
v.* = try Value.init(allocator, results, m.column_type_word);
|
|
}
|
|
break :blk value;
|
|
},
|
|
.Array => |a| blk: {
|
|
const value: Value = .{ .Array = allocator.alloc(Value, member_count) catch return RuntimeError.OutOfMemory };
|
|
errdefer allocator.free(value.Array);
|
|
for (value.Array) |*val| {
|
|
val.* = try Value.init(allocator, results, a.components_type_word);
|
|
}
|
|
break :blk value;
|
|
},
|
|
.RuntimeArray => |a| .{
|
|
.RuntimeArray = .{
|
|
.type_word = a.components_type_word,
|
|
.data = &.{},
|
|
},
|
|
},
|
|
.Structure => |s| blk: {
|
|
const value: Value = .{ .Structure = allocator.alloc(Value, member_count) catch return RuntimeError.OutOfMemory };
|
|
errdefer allocator.free(value.Structure);
|
|
for (value.Structure, s.members_type_word) |*v, member_type_word| {
|
|
v.* = try Value.init(allocator, results, member_type_word);
|
|
}
|
|
break :blk value;
|
|
},
|
|
.Image => RuntimeError.ToDo,
|
|
.Sampler => RuntimeError.ToDo,
|
|
.SampledImage => RuntimeError.ToDo,
|
|
else => RuntimeError.InvalidSpirV,
|
|
},
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
pub fn flushPtr(self: *Self, allocator: std.mem.Allocator) RuntimeError!void {
|
|
if (self.variant) |*variant| {
|
|
switch (variant.*) {
|
|
.Constant => |*c| try c.value.flushPtr(allocator),
|
|
.Variable => |*v| try v.value.flushPtr(allocator),
|
|
.AccessChain => |*a| try a.value.flushPtr(allocator),
|
|
else => {},
|
|
}
|
|
}
|
|
}
|