3889 lines
169 KiB
Zig
3889 lines
169 KiB
Zig
const std = @import("std");
|
|
const spv = @import("spv.zig");
|
|
const zm = @import("zmath");
|
|
|
|
const GLSL_std_450 = @import("GLSL_std_450/opcodes.zig");
|
|
|
|
const Module = @import("Module.zig");
|
|
const Runtime = @import("Runtime.zig");
|
|
const Result = @import("Result.zig");
|
|
const value_ns = @import("Value.zig");
|
|
const WordIterator = @import("WordIterator.zig");
|
|
|
|
const RuntimeError = Runtime.RuntimeError;
|
|
|
|
const SpvVoid = spv.SpvVoid;
|
|
const SpvByte = spv.SpvByte;
|
|
const SpvWord = spv.SpvWord;
|
|
const SpvBool = spv.SpvBool;
|
|
|
|
const Value = value_ns.Value;
|
|
const PrimitiveType = value_ns.PrimitiveType;
|
|
|
|
const MathOp = enum {
|
|
Add,
|
|
Div,
|
|
MatrixTimesMatrix,
|
|
MatrixTimesScalar,
|
|
MatrixTimesVector,
|
|
Mod,
|
|
Mul,
|
|
Rem,
|
|
Sub,
|
|
VectorTimesMatrix,
|
|
VectorTimesScalar,
|
|
Negate,
|
|
};
|
|
|
|
const CondOp = enum {
|
|
Equal,
|
|
Greater,
|
|
GreaterEqual,
|
|
IsFinite,
|
|
IsInf,
|
|
IsNan,
|
|
IsNormal,
|
|
Less,
|
|
LessEqual,
|
|
LogicalAnd,
|
|
LogicalEqual,
|
|
LogicalNot,
|
|
LogicalNotEqual,
|
|
LogicalOr,
|
|
NotEqual,
|
|
};
|
|
|
|
const BitOp = enum {
|
|
BitCount,
|
|
BitFieldInsert,
|
|
BitFieldSExtract,
|
|
BitFieldUExtract,
|
|
BitReverse,
|
|
BitwiseAnd,
|
|
BitwiseOr,
|
|
BitwiseXor,
|
|
Not,
|
|
ShiftLeft,
|
|
ShiftRight,
|
|
ShiftRightArithmetic,
|
|
};
|
|
|
|
const ImageOp = enum {
|
|
Fetch,
|
|
Read,
|
|
Write,
|
|
SampleImplicitLod,
|
|
SampleExplicitLod,
|
|
};
|
|
|
|
pub const OpCodeFunc = *const fn (std.mem.Allocator, SpvWord, *Runtime) RuntimeError!void;
|
|
pub const OpCodeExtFunc = *const fn (std.mem.Allocator, SpvWord, SpvWord, SpvWord, *Runtime) RuntimeError!void;
|
|
|
|
pub const SetupDispatcher = block: {
|
|
@setEvalBranchQuota(65535);
|
|
break :block std.EnumMap(spv.SpvOp, OpCodeFunc).init(.{
|
|
.All = autoSetupConstant,
|
|
.Any = autoSetupConstant,
|
|
.AtomicAnd = autoSetupConstant,
|
|
.AtomicCompareExchange = autoSetupConstant,
|
|
.AtomicExchange = autoSetupConstant,
|
|
.AtomicIAdd = autoSetupConstant,
|
|
.AtomicIDecrement = autoSetupConstant,
|
|
.AtomicIIncrement = autoSetupConstant,
|
|
.AtomicISub = autoSetupConstant,
|
|
.AtomicLoad = autoSetupConstant,
|
|
.AtomicOr = autoSetupConstant,
|
|
.AtomicSMax = autoSetupConstant,
|
|
.AtomicSMin = autoSetupConstant,
|
|
.AtomicUMax = autoSetupConstant,
|
|
.AtomicUMin = autoSetupConstant,
|
|
.AtomicXor = autoSetupConstant,
|
|
.AccessChain = setupAccessChain,
|
|
.BitCount = autoSetupConstant,
|
|
.BitFieldInsert = autoSetupConstant,
|
|
.BitFieldSExtract = autoSetupConstant,
|
|
.BitFieldUExtract = autoSetupConstant,
|
|
.BitReverse = autoSetupConstant,
|
|
.Bitcast = autoSetupConstant,
|
|
.BitwiseAnd = autoSetupConstant,
|
|
.BitwiseOr = autoSetupConstant,
|
|
.BitwiseXor = autoSetupConstant,
|
|
.Capability = opCapability,
|
|
.CompositeConstruct = autoSetupConstant,
|
|
.CompositeInsert = autoSetupConstant,
|
|
.Constant = opConstant,
|
|
.ConstantComposite = opConstantComposite,
|
|
.ConvertFToS = autoSetupConstant,
|
|
.ConvertFToU = autoSetupConstant,
|
|
.ConvertPtrToU = autoSetupConstant,
|
|
.ConvertSToF = autoSetupConstant,
|
|
.ConvertUToF = autoSetupConstant,
|
|
.ConvertUToPtr = autoSetupConstant,
|
|
.Decorate = opDecorate,
|
|
.DecorationGroup = opDecorationGroup,
|
|
.Dot = autoSetupConstant,
|
|
.EntryPoint = opEntryPoint,
|
|
.ExecutionMode = opExecutionMode,
|
|
.ExtInst = autoSetupConstant,
|
|
.ExtInstImport = opExtInstImport,
|
|
.FAdd = autoSetupConstant,
|
|
.FConvert = autoSetupConstant,
|
|
.FDiv = autoSetupConstant,
|
|
.FMod = autoSetupConstant,
|
|
.FMul = autoSetupConstant,
|
|
.FNegate = autoSetupConstant,
|
|
.FOrdEqual = autoSetupConstant,
|
|
.FOrdGreaterThan = autoSetupConstant,
|
|
.FOrdGreaterThanEqual = autoSetupConstant,
|
|
.FOrdLessThan = autoSetupConstant,
|
|
.FOrdLessThanEqual = autoSetupConstant,
|
|
.FOrdNotEqual = autoSetupConstant,
|
|
.FRem = autoSetupConstant,
|
|
.FSub = autoSetupConstant,
|
|
.FUnordEqual = autoSetupConstant,
|
|
.FUnordGreaterThan = autoSetupConstant,
|
|
.FUnordGreaterThanEqual = autoSetupConstant,
|
|
.FUnordLessThan = autoSetupConstant,
|
|
.FUnordLessThanEqual = autoSetupConstant,
|
|
.FUnordNotEqual = autoSetupConstant,
|
|
.Function = opFunction,
|
|
.FunctionCall = autoSetupConstant,
|
|
.FunctionEnd = opFunctionEnd,
|
|
.FunctionParameter = opFunctionParameter,
|
|
.GroupDecorate = opGroupDecorate,
|
|
.GroupMemberDecorate = opGroupMemberDecorate,
|
|
.IAdd = autoSetupConstant,
|
|
.IAddCarry = autoSetupConstant,
|
|
.IEqual = autoSetupConstant,
|
|
.IMul = autoSetupConstant,
|
|
.INotEqual = autoSetupConstant,
|
|
.ISub = autoSetupConstant,
|
|
.ISubBorrow = autoSetupConstant,
|
|
.ImageFetch = autoSetupConstant,
|
|
.ImageRead = autoSetupConstant,
|
|
.ImageSampleExplicitLod = autoSetupConstant,
|
|
.ImageSampleImplicitLod = autoSetupConstant,
|
|
.InBoundsAccessChain = setupAccessChain,
|
|
.IsFinite = autoSetupConstant,
|
|
.IsInf = autoSetupConstant,
|
|
.IsNan = autoSetupConstant,
|
|
.IsNormal = autoSetupConstant,
|
|
.Label = opLabel,
|
|
.Load = autoSetupConstant,
|
|
.LogicalAnd = autoSetupConstant,
|
|
.LogicalEqual = autoSetupConstant,
|
|
.LogicalNot = autoSetupConstant,
|
|
.LogicalNotEqual = autoSetupConstant,
|
|
.LogicalOr = autoSetupConstant,
|
|
.MatrixTimesMatrix = autoSetupConstant,
|
|
.MatrixTimesScalar = autoSetupConstant,
|
|
.MatrixTimesVector = autoSetupConstant,
|
|
.MemberDecorate = opDecorateMember,
|
|
.MemberName = opMemberName,
|
|
.MemoryModel = opMemoryModel,
|
|
.Name = opName,
|
|
.Not = autoSetupConstant,
|
|
.Phi = autoSetupConstant,
|
|
.QuantizeToF16 = autoSetupConstant,
|
|
.SConvert = autoSetupConstant,
|
|
.SDiv = autoSetupConstant,
|
|
.SGreaterThan = autoSetupConstant,
|
|
.SGreaterThanEqual = autoSetupConstant,
|
|
.SLessThan = autoSetupConstant,
|
|
.SLessThanEqual = autoSetupConstant,
|
|
.SMod = autoSetupConstant,
|
|
.SMulExtended = autoSetupConstant,
|
|
.SNegate = autoSetupConstant,
|
|
.SRem = autoSetupConstant,
|
|
.SatConvertSToU = autoSetupConstant,
|
|
.SatConvertUToS = autoSetupConstant,
|
|
.Select = autoSetupConstant,
|
|
.ShiftLeftLogical = autoSetupConstant,
|
|
.ShiftRightArithmetic = autoSetupConstant,
|
|
.ShiftRightLogical = autoSetupConstant,
|
|
.SourceExtension = opSourceExtension,
|
|
.TypeArray = opTypeArray,
|
|
.TypeBool = opTypeBool,
|
|
.TypeFloat = opTypeFloat,
|
|
.TypeFunction = opTypeFunction,
|
|
.TypeImage = opTypeImage,
|
|
.TypeSampledImage = opTypeSampledImage,
|
|
.TypeInt = opTypeInt,
|
|
.TypeMatrix = opTypeMatrix,
|
|
.TypePointer = opTypePointer,
|
|
.TypeRuntimeArray = opTypeRuntimeArray,
|
|
.TypeStruct = opTypeStruct,
|
|
.TypeVector = opTypeVector,
|
|
.TypeVoid = opTypeVoid,
|
|
.UConvert = autoSetupConstant,
|
|
.UDiv = autoSetupConstant,
|
|
.UGreaterThan = autoSetupConstant,
|
|
.UGreaterThanEqual = autoSetupConstant,
|
|
.ULessThan = autoSetupConstant,
|
|
.ULessThanEqual = autoSetupConstant,
|
|
.UMod = autoSetupConstant,
|
|
.UMulExtended = autoSetupConstant,
|
|
.Undef = autoSetupConstant,
|
|
.Variable = opVariable,
|
|
.VectorShuffle = autoSetupConstant,
|
|
.VectorTimesMatrix = autoSetupConstant,
|
|
.VectorTimesScalar = autoSetupConstant,
|
|
});
|
|
};
|
|
|
|
/// Not an EnumMap as it is way too slow for this purpose
|
|
pub var runtime_dispatcher = [_]?OpCodeFunc{null} ** spv.SpvOpMaxValue;
|
|
|
|
pub fn initRuntimeDispatcher() void {
|
|
// zig fmt: off
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.AccessChain)] = opAccessChain;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.All)] = opAll;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Any)] = opAny;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.AtomicIAdd)] = MathEngine(.SInt, .Add, true).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.AtomicISub)] = MathEngine(.SInt, .Sub, true).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.AtomicLoad)] = opLoad;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.AtomicStore)] = opAtomicStore;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BitCount)] = BitEngine(.UInt, .BitCount).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BitFieldInsert)] = BitEngine(.UInt, .BitFieldInsert).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BitFieldSExtract)] = BitEngine(.SInt, .BitFieldSExtract).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BitFieldUExtract)] = BitEngine(.UInt, .BitFieldUExtract).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BitReverse)] = BitEngine(.UInt, .BitReverse).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Bitcast)] = opBitcast;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BitwiseAnd)] = BitEngine(.UInt, .BitwiseAnd).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BitwiseOr)] = BitEngine(.UInt, .BitwiseOr).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BitwiseXor)] = BitEngine(.UInt, .BitwiseXor).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Branch)] = opBranch;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.BranchConditional)] = opBranchConditional;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.CompositeConstruct)] = opCompositeConstruct;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.CompositeExtract)] = opCompositeExtract;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.CompositeInsert)] = opCompositeInsert;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ConvertFToS)] = ConversionEngine(.Float, .SInt).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ConvertFToU)] = ConversionEngine(.Float, .UInt).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ConvertSToF)] = ConversionEngine(.SInt, .Float).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ConvertUToF)] = ConversionEngine(.UInt, .Float).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.CopyMemory)] = opCopyMemory;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Dot)] = opDot;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ExtInst)] = opExtInst;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FAdd)] = MathEngine(.Float, .Add, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FConvert)] = ConversionEngine(.Float, .Float).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FDiv)] = MathEngine(.Float, .Div, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FMod)] = MathEngine(.Float, .Mod, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FMul)] = MathEngine(.Float, .Mul, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FNegate)] = MathEngine(.Float, .Negate, false).opSingle;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FOrdEqual)] = CondEngine(.Float, .Equal).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FOrdGreaterThan)] = CondEngine(.Float, .Greater).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FOrdGreaterThanEqual)] = CondEngine(.Float, .GreaterEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FOrdLessThan)] = CondEngine(.Float, .Less).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FOrdLessThanEqual)] = CondEngine(.Float, .LessEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FOrdNotEqual)] = CondEngine(.Float, .NotEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FRem)] = MathEngine(.Float, .Rem, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FSub)] = MathEngine(.Float, .Sub, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FUnordEqual)] = CondEngine(.Float, .Equal).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FUnordGreaterThan)] = CondEngine(.Float, .Greater).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FUnordGreaterThanEqual)] = CondEngine(.Float, .GreaterEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FUnordLessThan)] = CondEngine(.Float, .Less).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FUnordLessThanEqual)] = CondEngine(.Float, .LessEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FUnordNotEqual)] = CondEngine(.Float, .NotEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.FunctionCall)] = opFunctionCall;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.IAdd)] = MathEngine(.SInt, .Add, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.IAddCarry)] = opIAddCarry;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.IEqual)] = CondEngine(.SInt, .Equal).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.IMul)] = MathEngine(.SInt, .Mul, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.INotEqual)] = CondEngine(.SInt, .NotEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ISub)] = MathEngine(.SInt, .Sub, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ISubBorrow)] = opISubBorrow;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ImageFetch)] = ImageEngine(.Fetch).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ImageRead)] = ImageEngine(.Read).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ImageSampleExplicitLod)] = ImageEngine(.SampleExplicitLod).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ImageSampleImplicitLod)] = ImageEngine(.SampleImplicitLod).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ImageWrite)] = ImageEngine(.Write).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.InBoundsAccessChain)] = opAccessChain;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.IsFinite)] = CondEngine(.Float, .IsNan).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.IsInf)] = CondEngine(.Float, .IsInf).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.IsNan)] = CondEngine(.Float, .IsNan).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.IsNormal)] = CondEngine(.Float, .IsNan).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Kill)] = opKill;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Label)] = opLabel;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Load)] = opLoad;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.LogicalAnd)] = CondEngine(.Bool, .LogicalAnd).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.LogicalEqual)] = CondEngine(.Bool, .LogicalEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.LogicalNot)] = CondEngine(.Bool, .LogicalNot).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.LogicalNotEqual)] = CondEngine(.Bool, .LogicalNotEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.LogicalOr)] = CondEngine(.Bool, .LogicalOr).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.MatrixTimesMatrix)] = MathEngine(.Float, .MatrixTimesMatrix, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.MatrixTimesScalar)] = MathEngine(.Float, .MatrixTimesScalar, false).op; // TODO
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.MatrixTimesVector)] = MathEngine(.Float, .MatrixTimesVector, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Not)] = BitEngine(.UInt, .Not).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Phi)] = opPhi;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Return)] = opReturn;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ReturnValue)] = opReturnValue;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SConvert)] = ConversionEngine(.SInt, .SInt).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SDiv)] = MathEngine(.SInt, .Div, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SGreaterThan)] = CondEngine(.SInt, .Greater).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SGreaterThanEqual)] = CondEngine(.SInt, .GreaterEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SLessThan)] = CondEngine(.SInt, .Less).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SLessThanEqual)] = CondEngine(.SInt, .LessEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SMod)] = MathEngine(.SInt, .Mod, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SMulExtended)] = opSMulExtended;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SNegate)] = MathEngine(.SInt, .Negate, false).opSingle;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SRem)] = MathEngine(.SInt, .Rem, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Select)] = opSelect;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ShiftLeftLogical)] = BitEngine(.UInt, .ShiftLeft).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ShiftRightArithmetic)] = BitEngine(.SInt, .ShiftRightArithmetic).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ShiftRightLogical)] = BitEngine(.UInt, .ShiftRight).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SpecConstant)] = opSpecConstant;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SpecConstantComposite)] = opConstantComposite;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SpecConstantFalse)] = opSpecConstantFalse;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SpecConstantOp)] = opSpecConstantOp;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.SpecConstantTrue)] = opSpecConstantTrue;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.Store)] = opStore;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.UConvert)] = ConversionEngine(.UInt, .UInt).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.UDiv)] = MathEngine(.UInt, .Div, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.UGreaterThan)] = CondEngine(.UInt, .Greater).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.UGreaterThanEqual)] = CondEngine(.UInt, .GreaterEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ULessThan)] = CondEngine(.UInt, .Less).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.ULessThanEqual)] = CondEngine(.UInt, .LessEqual).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.UMod)] = MathEngine(.UInt, .Mod, false).op;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.UMulExtended)] = opUMulExtended;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.VectorShuffle)] = opVectorShuffle;
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.VectorTimesMatrix)] = MathEngine(.Float, .VectorTimesMatrix, false).op; // TODO
|
|
runtime_dispatcher[@intFromEnum(spv.SpvOp.VectorTimesScalar)] = MathEngine(.Float, .VectorTimesScalar, false).op;
|
|
// zig fmt: on
|
|
|
|
// Extensions init
|
|
GLSL_std_450.initRuntimeDispatcher();
|
|
}
|
|
|
|
fn extEqlName(a: []const u8, b: []const u8) bool {
|
|
for (0..@min(a.len, b.len)) |i| {
|
|
if (a[i] != b[i]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const extensions_map = std.StaticStringMapWithEql([]?OpCodeExtFunc, extEqlName).initComptime(.{
|
|
.{ "GLSL.std.450", GLSL_std_450.runtime_dispatcher[0..] },
|
|
});
|
|
|
|
fn opAll(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
const dst_value = try rt.results[try rt.it.next()].getValue();
|
|
const vec_value = try rt.results[try rt.it.next()].getValue();
|
|
|
|
switch (dst_value.*) {
|
|
.Bool => |*b| b.* = blk: {
|
|
switch (vec_value.*) {
|
|
.Vector => |vec| for (vec[0..]) |elem| {
|
|
switch (elem) {
|
|
.Bool => |val| {
|
|
if (!val)
|
|
break :blk false;
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
|
|
break :blk true;
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
|
|
fn opAny(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
const dst_value = try rt.results[try rt.it.next()].getValue();
|
|
const vec_value = try rt.results[try rt.it.next()].getValue();
|
|
|
|
switch (dst_value.*) {
|
|
.Bool => |*b| b.* = blk: {
|
|
switch (vec_value.*) {
|
|
.Vector => |vec| for (vec[0..]) |elem| {
|
|
switch (elem) {
|
|
.Bool => |val| {
|
|
if (val)
|
|
break :blk true;
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
|
|
break :blk false;
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
|
|
fn BitEngine(comptime T: PrimitiveType, comptime Op: BitOp) type {
|
|
return struct {
|
|
comptime {
|
|
if (T == .Float) @compileError("Invalid value type");
|
|
}
|
|
|
|
const max_operator_count: usize = 4;
|
|
|
|
inline fn isUnaryOp() bool {
|
|
return comptime switch (Op) {
|
|
.Not, .BitCount, .BitReverse => true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
inline fn isBinaryOp() bool {
|
|
return !isUnaryOp() and !isTernaryOp() and !isQuaternaryOp(); // flemme d'ajouter les opérateurs à chaque fois
|
|
}
|
|
|
|
inline fn isTernaryOp() bool {
|
|
return comptime switch (Op) {
|
|
.BitFieldUExtract, .BitFieldSExtract => true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
inline fn isQuaternaryOp() bool {
|
|
return comptime switch (Op) {
|
|
.BitFieldInsert => true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
inline fn getOperatorsCount() usize {
|
|
return if (isUnaryOp())
|
|
1
|
|
else if (isBinaryOp())
|
|
2
|
|
else if (isTernaryOp())
|
|
3
|
|
else
|
|
4;
|
|
}
|
|
|
|
inline fn bitInsert(comptime TT: type, base: TT, insert: TT, offset: u64, count: u64) TT {
|
|
const info = @typeInfo(TT);
|
|
if (info != .int) @compileError("must be an integer type");
|
|
|
|
const bits: u32 = info.int.bits;
|
|
const U = std.meta.Int(.unsigned, bits);
|
|
|
|
if (count == 0) return base;
|
|
|
|
const base_u: U = @bitCast(base);
|
|
const insert_u: U = @bitCast(insert);
|
|
|
|
const field_mask: U = if (count == bits)
|
|
~@as(U, 0)
|
|
else
|
|
(@as(U, 1) << @intCast(count)) - 1;
|
|
|
|
const shift: std.math.Log2Int(U) = @truncate(offset);
|
|
|
|
const positioned_mask: U = @shlWithOverflow(field_mask, shift)[0];
|
|
const positioned_insert: U = @shlWithOverflow(insert_u & field_mask, shift)[0];
|
|
|
|
return @bitCast((base_u & ~positioned_mask) | positioned_insert);
|
|
}
|
|
|
|
inline fn bitExtract(comptime TT: type, comptime signed_result: bool, base: TT, offset: u64, count: u64) TT {
|
|
const info = @typeInfo(TT);
|
|
if (info != .int) @compileError("must be an integer type");
|
|
|
|
const bits: u32 = info.int.bits;
|
|
|
|
if (count == 0) return @as(TT, 0);
|
|
|
|
const U = std.meta.Int(.unsigned, bits);
|
|
const base_u: U = @bitCast(base);
|
|
|
|
const field: U = if (count == bits)
|
|
base_u
|
|
else
|
|
(base_u >> @intCast(offset)) &
|
|
((@as(U, 1) << @intCast(count)) - 1);
|
|
|
|
const result: U = if (!signed_result or count == bits) blk: {
|
|
break :blk field;
|
|
} else blk: {
|
|
const sign_bit: U = @as(U, 1) << @intCast(count - 1);
|
|
if ((field & sign_bit) != 0) {
|
|
break :blk field | (~@as(U, 0) << @intCast(count));
|
|
}
|
|
break :blk field;
|
|
};
|
|
|
|
return @bitCast(result);
|
|
}
|
|
|
|
inline fn operationUnary(comptime TT: type, op1: TT) RuntimeError!TT {
|
|
return switch (Op) {
|
|
.BitCount => blk: {
|
|
const bit_set: std.bit_set.IntegerBitSet(@bitSizeOf(TT)) = .{
|
|
.mask = @bitCast(op1),
|
|
};
|
|
break :blk @as(TT, @intCast(bit_set.count()));
|
|
},
|
|
.BitReverse => @bitReverse(op1),
|
|
.Not => ~op1,
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
inline fn operationBinary(comptime TT: type, op1: TT, op2: TT) RuntimeError!TT {
|
|
return switch (Op) {
|
|
.BitwiseAnd => op1 & op2,
|
|
.BitwiseOr => op1 | op2,
|
|
.BitwiseXor => op1 ^ op2,
|
|
.ShiftLeft => op1 << @intCast(op2),
|
|
.ShiftRight, .ShiftRightArithmetic => op1 >> @intCast(op2),
|
|
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
inline fn operationTernary(comptime TT: type, op1: TT, op2: TT, op3: *const Value) RuntimeError!TT {
|
|
return switch (Op) {
|
|
.BitFieldSExtract => blk: {
|
|
if (T != .SInt) return RuntimeError.InvalidSpirV;
|
|
break :blk bitExtract(TT, true, op1, @intCast(op2), op3.Int.value.uint64);
|
|
},
|
|
.BitFieldUExtract => blk: {
|
|
if (T != .UInt) return RuntimeError.InvalidSpirV;
|
|
break :blk bitExtract(TT, false, op1, @intCast(op2), op3.Int.value.uint64);
|
|
},
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
inline fn operationQuaternary(comptime TT: type, op1: TT, op2: TT, op3: *const Value, op4: *const Value) RuntimeError!TT {
|
|
return switch (Op) {
|
|
.BitFieldInsert => bitInsert(TT, op1, op2, op3.Int.value.uint64, op4.Int.value.uint64),
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
fn applyScalarBits(bit_count: SpvWord, dst: *Value, ops: [max_operator_count]?*const Value) RuntimeError!void {
|
|
switch (bit_count) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
const TT = Value.getPrimitiveFieldType(T, bits);
|
|
|
|
const out: TT = blk: {
|
|
const a = try Value.readLane(T, bits, ops[0].?, 0);
|
|
|
|
if (comptime isUnaryOp()) break :blk try operationUnary(TT, a);
|
|
|
|
const b = try Value.readLane(T, bits, ops[1].?, 0);
|
|
|
|
if (comptime isBinaryOp()) break :blk try operationBinary(TT, a, b);
|
|
if (comptime isTernaryOp()) break :blk try operationTernary(TT, a, b, ops[2].?);
|
|
if (comptime isQuaternaryOp()) break :blk try operationQuaternary(TT, a, b, ops[2].?, ops[3].?);
|
|
};
|
|
|
|
try Value.writeLane(T, bits, dst, 0, out);
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn applyVectorBits(lane_bits: SpvWord, dst: *Value, ops: [max_operator_count]?*const Value) RuntimeError!void {
|
|
const dst_len = try dst.getLaneCount();
|
|
|
|
switch (lane_bits) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
const TT = Value.getPrimitiveFieldType(T, bits);
|
|
|
|
for (0..dst_len) |i| {
|
|
const out: TT = blk: {
|
|
const a = try Value.readLane(T, bits, ops[0].?, if (ops[0].?.isVector()) i else 0);
|
|
|
|
if (comptime isUnaryOp()) break :blk try operationUnary(TT, a);
|
|
|
|
const b = try Value.readLane(T, bits, ops[1].?, if (ops[1].?.isVector()) i else 0);
|
|
|
|
if (comptime isBinaryOp()) break :blk try operationBinary(TT, a, b);
|
|
if (comptime isTernaryOp()) break :blk try operationTernary(TT, a, b, ops[2].?);
|
|
if (comptime isQuaternaryOp()) break :blk try operationQuaternary(TT, a, b, ops[2].?, ops[3].?);
|
|
};
|
|
|
|
try Value.writeLane(T, bits, dst, i, out);
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn op(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target_type = (try rt.results[try rt.it.next()].getVariant()).Type;
|
|
const dst = try rt.results[try rt.it.next()].getValue();
|
|
|
|
var ops = [_]?*Value{null} ** max_operator_count;
|
|
ops[0] = try rt.results[try rt.it.next()].getValue();
|
|
|
|
if (comptime getOperatorsCount() >= 2) ops[1] = try rt.results[try rt.it.next()].getValue();
|
|
if (comptime getOperatorsCount() >= 3) ops[2] = try rt.results[try rt.it.next()].getValue();
|
|
if (comptime getOperatorsCount() >= 4) ops[3] = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const lane_bits = try Result.resolveLaneBitWidth(target_type, rt);
|
|
|
|
switch (dst.*) {
|
|
.Int => try applyScalarBits(lane_bits, dst, ops),
|
|
|
|
.Vector,
|
|
.Vector2i32,
|
|
.Vector3i32,
|
|
.Vector4i32,
|
|
.Vector2u32,
|
|
.Vector3u32,
|
|
.Vector4u32,
|
|
=> try applyVectorBits(lane_bits, dst, ops),
|
|
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
fn CondEngine(comptime T: PrimitiveType, comptime Op: CondOp) type {
|
|
return struct {
|
|
inline fn isUnaryOp() bool {
|
|
return comptime switch (Op) {
|
|
.IsFinite,
|
|
.IsInf,
|
|
.IsNan,
|
|
.IsNormal,
|
|
.LogicalNot,
|
|
=> true,
|
|
else => false,
|
|
};
|
|
}
|
|
|
|
inline fn operationBinary(comptime TT: type, a: TT, b: anytype) RuntimeError!bool {
|
|
if (comptime TT == bool and @TypeOf(b) == bool) {
|
|
switch (Op) {
|
|
.LogicalAnd => return a and b,
|
|
.LogicalOr => return a or b,
|
|
else => {},
|
|
}
|
|
}
|
|
return switch (Op) {
|
|
.Equal, .LogicalEqual => a == b,
|
|
.NotEqual, .LogicalNotEqual => a != b,
|
|
.Greater => a > b,
|
|
.GreaterEqual => a >= b,
|
|
.Less => a < b,
|
|
.LessEqual => a <= b,
|
|
else => RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
inline fn operationUnary(comptime TT: type, a: TT) RuntimeError!bool {
|
|
if (comptime TT == bool) {
|
|
switch (Op) {
|
|
.LogicalNot => return !a,
|
|
else => {},
|
|
}
|
|
}
|
|
if (comptime std.meta.activeTag(@typeInfo(TT)) == .float) {
|
|
switch (Op) {
|
|
.IsFinite => return std.math.isFinite(a),
|
|
.IsInf => return std.math.isInf(a),
|
|
.IsNan => return std.math.isNan(a),
|
|
.IsNormal => return std.math.isNormal(a),
|
|
else => {},
|
|
}
|
|
}
|
|
return RuntimeError.InvalidSpirV;
|
|
}
|
|
|
|
fn applyScalarBits(bit_count: SpvWord, dst_bool: *Value, a_v: *const Value, b_v: ?*const Value) RuntimeError!void {
|
|
switch (bit_count) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
if (bits == 8 and T == .Float) return RuntimeError.InvalidSpirV;
|
|
|
|
const TT = Value.getPrimitiveFieldType(T, bits);
|
|
const a = (try Value.getPrimitiveField(T, bits, @constCast(a_v))).*;
|
|
|
|
if (comptime isUnaryOp()) {
|
|
dst_bool.Bool = try operationUnary(TT, a);
|
|
} else {
|
|
const b_ptr = b_v orelse return RuntimeError.InvalidSpirV;
|
|
const b = (try Value.getPrimitiveField(T, bits, @constCast(b_ptr))).*;
|
|
dst_bool.Bool = try operationBinary(TT, a, b);
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
inline fn laneRhsPtr(op2_value: ?*Value, index: usize) ?*const Value {
|
|
if (comptime Op == .LogicalNot) return null;
|
|
const v = op2_value orelse return null;
|
|
return &v.Vector[index];
|
|
}
|
|
|
|
inline fn applyFixedVectorBinary(comptime ElemT: type, comptime N: usize, dst: []Value, op1: *@Vector(N, ElemT), op2: *const Value) RuntimeError!void {
|
|
inline for (0..N) |i| {
|
|
dst[i].Bool = switch (op2.*) {
|
|
.Vector4f32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .float and i < 4)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
.Vector3f32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .float and i < 3)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
.Vector2f32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .float and i < 2)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
.Vector4i32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .int and i < 4)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
.Vector3i32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .int and i < 3)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
.Vector2i32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .int and i < 2)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
.Vector4u32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .int and i < 4)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
.Vector3u32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .int and i < 3)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
.Vector2u32 => |vec| if (comptime std.meta.activeTag(@typeInfo(ElemT)) == .int and i < 2)
|
|
try operationBinary(ElemT, op1[i], vec[i])
|
|
else
|
|
return RuntimeError.InvalidSpirV,
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
};
|
|
}
|
|
}
|
|
|
|
inline fn applyFixedVectorUnary(comptime ElemT: type, comptime N: usize, dst: []Value, op1: *@Vector(N, ElemT)) RuntimeError!void {
|
|
inline for (0..N) |i| dst[i].Bool = try operationUnary(ElemT, op1[i]);
|
|
}
|
|
|
|
fn op(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
sw: switch ((try rt.results[try rt.it.next()].getVariant()).Type) {
|
|
.Vector => |v| continue :sw (try rt.results[v.components_type_word].getVariant()).Type,
|
|
.Bool => {},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
|
|
const dst = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const op1_result = &rt.results[try rt.it.next()];
|
|
const op1_type = try op1_result.getValueTypeWord();
|
|
const op1_value = try op1_result.getValue();
|
|
|
|
const op2_value: ?*Value = if (comptime isUnaryOp()) null else try rt.results[try rt.it.next()].getValue();
|
|
|
|
const lane_bits = try Result.resolveLaneBitWidth((try rt.results[op1_type].getVariant()).Type, rt);
|
|
|
|
switch (dst.*) {
|
|
.Bool => try applyScalarBits(lane_bits, dst, op1_value, op2_value),
|
|
|
|
.Vector => |dst_vec| {
|
|
switch (op1_value.*) {
|
|
.Vector => |op1_vec| for (dst_vec, op1_vec, 0..) |*d_lane, a_lane, i| {
|
|
const b_ptr = laneRhsPtr(op2_value, i);
|
|
try applyScalarBits(lane_bits, d_lane, &a_lane, b_ptr);
|
|
},
|
|
|
|
.Vector4f32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(f32, 4, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(f32, 4, dst_vec, op1_vec, op2_value.?),
|
|
|
|
.Vector3f32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(f32, 3, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(f32, 3, dst_vec, op1_vec, op2_value.?),
|
|
|
|
.Vector2f32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(f32, 2, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(f32, 2, dst_vec, op1_vec, op2_value.?),
|
|
|
|
.Vector4i32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(i32, 4, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(i32, 4, dst_vec, op1_vec, op2_value.?),
|
|
|
|
.Vector3i32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(i32, 3, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(i32, 3, dst_vec, op1_vec, op2_value.?),
|
|
|
|
.Vector2i32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(i32, 2, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(i32, 2, dst_vec, op1_vec, op2_value.?),
|
|
|
|
.Vector4u32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(u32, 4, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(u32, 4, dst_vec, op1_vec, op2_value.?),
|
|
|
|
.Vector3u32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(u32, 3, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(u32, 3, dst_vec, op1_vec, op2_value.?),
|
|
|
|
.Vector2u32 => |*op1_vec| if (comptime isUnaryOp())
|
|
try applyFixedVectorUnary(u32, 2, dst_vec, op1_vec)
|
|
else
|
|
try applyFixedVectorBinary(u32, 2, dst_vec, op1_vec, op2_value.?),
|
|
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
fn ConversionEngine(comptime from_kind: PrimitiveType, comptime to_kind: PrimitiveType) type {
|
|
return struct {
|
|
fn castLane(comptime ToT: type, from_bit_count: SpvWord, from: *Value) RuntimeError!ToT {
|
|
return switch (from_bit_count) {
|
|
inline 8, 16, 32, 64 => |bits| blk: {
|
|
if (bits == 8 and from_kind == .Float) return RuntimeError.InvalidSpirV; // No f8
|
|
const v = (try Value.getPrimitiveField(from_kind, bits, from)).*;
|
|
break :blk std.math.lossyCast(ToT, v);
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
fn applyScalar(from_bit_count: SpvWord, to_bit_count: SpvWord, dst: *Value, from: *Value) RuntimeError!void {
|
|
switch (to_bit_count) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
if (bits == 8 and to_kind == .Float) return RuntimeError.InvalidSpirV; // No f8
|
|
const ToT = Value.getPrimitiveFieldType(to_kind, bits);
|
|
(try Value.getPrimitiveField(to_kind, bits, dst)).* = try castLane(ToT, from_bit_count, from);
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn castSIMDVector(comptime ToT: type, comptime N: usize, dst_arr: *@Vector(N, ToT), src_arr: *const @Vector(N, ToT)) void {
|
|
inline for (0..N) |i| dst_arr[i] = std.math.lossyCast(ToT, src_arr[i]);
|
|
}
|
|
|
|
fn castSIMDVectorFromOther(comptime ToT: type, comptime FromT: type, comptime N: usize, dst_arr: *@Vector(N, ToT), src_arr: *const @Vector(N, FromT)) void {
|
|
inline for (0..N) |i| dst_arr[i] = std.math.lossyCast(ToT, src_arr[i]);
|
|
}
|
|
|
|
fn op(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target_type = (try rt.results[try rt.it.next()].getVariant()).Type;
|
|
const dst_value = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const src_result = &rt.results[try rt.it.next()];
|
|
const src_type_word = try src_result.getValueTypeWord();
|
|
const src_value = try src_result.getValue();
|
|
|
|
const from_bits = try Result.resolveLaneBitWidth((try rt.results[src_type_word].getVariant()).Type, rt);
|
|
const to_bits = try Result.resolveLaneBitWidth(target_type, rt);
|
|
|
|
switch (dst_value.*) {
|
|
.Float => {
|
|
if (to_kind != .Float) return RuntimeError.InvalidSpirV;
|
|
try applyScalar(from_bits, to_bits, dst_value, src_value);
|
|
},
|
|
.Int => {
|
|
if (to_kind != .SInt and to_kind != .UInt) return RuntimeError.InvalidSpirV;
|
|
try applyScalar(from_bits, to_bits, dst_value, src_value);
|
|
},
|
|
.Vector => |dst_vec| {
|
|
const src_vec = src_value.Vector;
|
|
if (dst_vec.len != src_vec.len) return RuntimeError.InvalidSpirV;
|
|
for (dst_vec, src_vec) |*d_lane, *s_lane| {
|
|
try applyScalar(from_bits, to_bits, d_lane, s_lane);
|
|
}
|
|
},
|
|
|
|
.Vector4f32 => |*dst| switch (src_value.*) {
|
|
.Vector4f32 => castSIMDVector(f32, 4, dst, &src_value.Vector4f32),
|
|
.Vector4i32 => castSIMDVectorFromOther(f32, i32, 4, dst, &src_value.Vector4i32),
|
|
.Vector4u32 => castSIMDVectorFromOther(f32, u32, 4, dst, &src_value.Vector4u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3f32 => |*dst| switch (src_value.*) {
|
|
.Vector3f32 => castSIMDVector(f32, 3, dst, &src_value.Vector3f32),
|
|
.Vector3i32 => castSIMDVectorFromOther(f32, i32, 3, dst, &src_value.Vector3i32),
|
|
.Vector3u32 => castSIMDVectorFromOther(f32, u32, 3, dst, &src_value.Vector3u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2f32 => |*dst| switch (src_value.*) {
|
|
.Vector2f32 => castSIMDVector(f32, 2, dst, &src_value.Vector2f32),
|
|
.Vector2i32 => castSIMDVectorFromOther(f32, i32, 2, dst, &src_value.Vector2i32),
|
|
.Vector2u32 => castSIMDVectorFromOther(f32, u32, 2, dst, &src_value.Vector2u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
.Vector4i32 => |*dst| switch (src_value.*) {
|
|
.Vector4f32 => castSIMDVectorFromOther(i32, f32, 4, dst, &src_value.Vector4f32),
|
|
.Vector4i32 => castSIMDVector(i32, 4, dst, &src_value.Vector4i32),
|
|
.Vector4u32 => castSIMDVectorFromOther(i32, u32, 4, dst, &src_value.Vector4u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3i32 => |*dst| switch (src_value.*) {
|
|
.Vector3f32 => castSIMDVectorFromOther(i32, f32, 3, dst, &src_value.Vector3f32),
|
|
.Vector3i32 => castSIMDVector(i32, 3, dst, &src_value.Vector3i32),
|
|
.Vector3u32 => castSIMDVectorFromOther(i32, u32, 3, dst, &src_value.Vector3u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2i32 => |*dst| switch (src_value.*) {
|
|
.Vector2f32 => castSIMDVectorFromOther(i32, f32, 2, dst, &src_value.Vector2f32),
|
|
.Vector2i32 => castSIMDVector(i32, 2, dst, &src_value.Vector2i32),
|
|
.Vector2u32 => castSIMDVectorFromOther(i32, u32, 2, dst, &src_value.Vector2u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
.Vector4u32 => |*dst| switch (src_value.*) {
|
|
.Vector4f32 => castSIMDVectorFromOther(u32, f32, 4, dst, &src_value.Vector4f32),
|
|
.Vector4i32 => castSIMDVectorFromOther(u32, i32, 4, dst, &src_value.Vector4i32),
|
|
.Vector4u32 => castSIMDVector(u32, 4, dst, &src_value.Vector4u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3u32 => |*dst| switch (src_value.*) {
|
|
.Vector3f32 => castSIMDVectorFromOther(u32, f32, 3, dst, &src_value.Vector3f32),
|
|
.Vector3i32 => castSIMDVectorFromOther(u32, i32, 3, dst, &src_value.Vector3i32),
|
|
.Vector3u32 => castSIMDVector(u32, 3, dst, &src_value.Vector3u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2u32 => |*dst| switch (src_value.*) {
|
|
.Vector2f32 => castSIMDVectorFromOther(u32, f32, 2, dst, &src_value.Vector2f32),
|
|
.Vector2i32 => castSIMDVectorFromOther(u32, i32, 2, dst, &src_value.Vector2i32),
|
|
.Vector2u32 => castSIMDVector(u32, 2, dst, &src_value.Vector2u32),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
fn ImageEngine(comptime Op: ImageOp) type {
|
|
return struct {
|
|
const ImageOperand = struct {
|
|
driver_image: *anyopaque,
|
|
dim: spv.SpvDim,
|
|
};
|
|
|
|
const SampledImageOperand = struct {
|
|
driver_image: *anyopaque,
|
|
driver_sampler: *anyopaque,
|
|
dim: spv.SpvDim,
|
|
};
|
|
|
|
fn resolveImageDim(rt: *Runtime, type_word: SpvWord) RuntimeError!spv.SpvDim {
|
|
return switch ((try rt.results[type_word].getConstVariant()).*) {
|
|
.Type => |t| switch (t) {
|
|
.Image => |i| i.dim,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
fn resolveImage(image: *Result, rt: *Runtime) RuntimeError!ImageOperand {
|
|
return switch ((try image.getValue()).*) {
|
|
.Image => |img| .{
|
|
.driver_image = img.driver_image,
|
|
.dim = try resolveImageDim(rt, img.type_word),
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
fn resolveSampledImage(image: *Result, rt: *Runtime) RuntimeError!SampledImageOperand {
|
|
return switch ((try image.getValue()).*) {
|
|
.SampledImage => |img| blk: {
|
|
const sampled_image_type = switch ((try rt.results[img.type_word].getConstVariant()).*) {
|
|
.Type => |t| switch (t) {
|
|
.SampledImage => |sampled_image| sampled_image,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
|
|
break :blk .{
|
|
.driver_image = img.driver_image,
|
|
.driver_sampler = img.driver_sampler,
|
|
.dim = try resolveImageDim(rt, sampled_image_type.image_type),
|
|
};
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
fn readStorageCoordLane(coord: *const Value, lane_index: usize) RuntimeError!i32 {
|
|
return switch (coord.*) {
|
|
.Int => |i| {
|
|
if (lane_index != 0) return RuntimeError.OutOfBounds;
|
|
return if (i.is_signed) i.value.sint32 else @intCast(i.value.uint32);
|
|
},
|
|
.Vector => |lanes| {
|
|
if (lane_index >= lanes.len) return RuntimeError.OutOfBounds;
|
|
return readStorageCoordLane(&lanes[lane_index], 0);
|
|
},
|
|
.Vector4i32 => |v| switch (lane_index) {
|
|
inline 0...3 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector3i32 => |v| switch (lane_index) {
|
|
inline 0...2 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector2i32 => |v| switch (lane_index) {
|
|
inline 0...1 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector4u32 => |v| switch (lane_index) {
|
|
inline 0...3 => |idx| @intCast(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector3u32 => |v| switch (lane_index) {
|
|
inline 0...2 => |idx| @intCast(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector2u32 => |v| switch (lane_index) {
|
|
inline 0...1 => |idx| @intCast(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
};
|
|
}
|
|
|
|
fn readSampleCoordLane(coord: *const Value, lane_index: usize) RuntimeError!f32 {
|
|
return switch (coord.*) {
|
|
.Vector => |lanes| {
|
|
if (lane_index >= lanes.len) return RuntimeError.OutOfBounds;
|
|
return readSampleCoordLane(&lanes[lane_index], 0);
|
|
},
|
|
.Vector4f32 => |v| switch (lane_index) {
|
|
inline 0...3 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector3f32 => |v| switch (lane_index) {
|
|
inline 0...2 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector2f32 => |v| switch (lane_index) {
|
|
inline 0...1 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector4i32 => |v| switch (lane_index) {
|
|
inline 0...3 => |idx| @floatFromInt(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector3i32 => |v| switch (lane_index) {
|
|
inline 0...2 => |idx| @floatFromInt(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector2i32 => |v| switch (lane_index) {
|
|
inline 0...1 => |idx| @floatFromInt(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector4u32 => |v| switch (lane_index) {
|
|
inline 0...3 => |idx| @floatFromInt(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector3u32 => |v| switch (lane_index) {
|
|
inline 0...2 => |idx| @floatFromInt(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector2u32 => |v| switch (lane_index) {
|
|
inline 0...1 => |idx| @floatFromInt(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
};
|
|
}
|
|
|
|
fn readFloatLane(texel: *const Value, lane_index: usize) RuntimeError!f32 {
|
|
return switch (texel.*) {
|
|
.Float => |f| {
|
|
if (lane_index != 0) return RuntimeError.OutOfBounds;
|
|
return f.value.float32;
|
|
},
|
|
.Vector => |lanes| {
|
|
if (lane_index >= lanes.len) return RuntimeError.OutOfBounds;
|
|
return readFloatLane(&lanes[lane_index], 0);
|
|
},
|
|
.Vector4f32 => |v| switch (lane_index) {
|
|
inline 0...3 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector3f32 => |v| switch (lane_index) {
|
|
inline 0...2 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector2f32 => |v| switch (lane_index) {
|
|
inline 0...1 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
};
|
|
}
|
|
|
|
fn readIntLane(texel: *const Value, lane_index: usize) RuntimeError!u32 {
|
|
return switch (texel.*) {
|
|
.Int => |i| {
|
|
if (lane_index != 0) return RuntimeError.OutOfBounds;
|
|
return if (i.is_signed) @bitCast(i.value.sint32) else i.value.uint32;
|
|
},
|
|
.Vector => |lanes| {
|
|
if (lane_index >= lanes.len) return RuntimeError.OutOfBounds;
|
|
return readIntLane(&lanes[lane_index], 0);
|
|
},
|
|
.Vector4i32 => |v| switch (lane_index) {
|
|
inline 0...3 => |idx| @bitCast(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector3i32 => |v| switch (lane_index) {
|
|
inline 0...2 => |idx| @bitCast(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector2i32 => |v| switch (lane_index) {
|
|
inline 0...1 => |idx| @bitCast(v[idx]),
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector4u32 => |v| switch (lane_index) {
|
|
inline 0...3 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector3u32 => |v| switch (lane_index) {
|
|
inline 0...2 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
.Vector2u32 => |v| switch (lane_index) {
|
|
inline 0...1 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
},
|
|
else => return RuntimeError.InvalidValueType,
|
|
};
|
|
}
|
|
|
|
fn readFloatTexel(texel: *const Value) RuntimeError!Runtime.Vec4(f32) {
|
|
return .{
|
|
.x = try readFloatLane(texel, 0),
|
|
.y = readFloatLane(texel, 1) catch 0.0,
|
|
.z = readFloatLane(texel, 2) catch 0.0,
|
|
.w = readFloatLane(texel, 3) catch 0.0,
|
|
};
|
|
}
|
|
|
|
fn readIntTexel(texel: *const Value) RuntimeError!Runtime.Vec4(u32) {
|
|
return .{
|
|
.x = try readIntLane(texel, 0),
|
|
.y = readIntLane(texel, 1) catch 0,
|
|
.z = readIntLane(texel, 2) catch 0,
|
|
.w = readIntLane(texel, 3) catch 0,
|
|
};
|
|
}
|
|
|
|
fn writeFloatTexel(dst: *Value, texel: Runtime.Vec4(f32)) RuntimeError!void {
|
|
switch (dst.*) {
|
|
.Vector4f32 => |*v| v.* = .{ texel.x, texel.y, texel.z, texel.w },
|
|
.Vector3f32 => |*v| v.* = .{ texel.x, texel.y, texel.z },
|
|
.Vector2f32 => |*v| v.* = .{ texel.x, texel.y },
|
|
|
|
.Vector => |lanes| {
|
|
if (lanes.len > 4) return RuntimeError.InvalidSpirV;
|
|
const values = [_]f32{ texel.x, texel.y, texel.z, texel.w };
|
|
for (lanes, 0..) |*lane, i| {
|
|
switch (lane.*) {
|
|
.Float => |*f| f.value.float32 = values[i],
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
},
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
|
|
fn writeIntTexel(dst: *Value, texel: Runtime.Vec4(u32)) RuntimeError!void {
|
|
switch (dst.*) {
|
|
.Vector4i32 => |*v| v.* = .{ @bitCast(texel.x), @bitCast(texel.y), @bitCast(texel.z), @bitCast(texel.w) },
|
|
.Vector3i32 => |*v| v.* = .{ @bitCast(texel.x), @bitCast(texel.y), @bitCast(texel.z) },
|
|
.Vector2i32 => |*v| v.* = .{ @bitCast(texel.x), @bitCast(texel.y) },
|
|
.Vector4u32 => |*v| v.* = .{ texel.x, texel.y, texel.z, texel.w },
|
|
.Vector3u32 => |*v| v.* = .{ texel.x, texel.y, texel.z },
|
|
.Vector2u32 => |*v| v.* = .{ texel.x, texel.y },
|
|
|
|
.Vector => |lanes| {
|
|
if (lanes.len > 4) return RuntimeError.InvalidSpirV;
|
|
const values = [_]u32{ texel.x, texel.y, texel.z, texel.w };
|
|
for (lanes, 0..) |*lane, i| {
|
|
switch (lane.*) {
|
|
.Int => |*int| int.value.uint32 = values[i],
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
},
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
|
|
fn readImage(rt: *Runtime, dst: *Value, driver_image: *anyopaque, dim: spv.SpvDim, x: i32, y: i32, z: i32) RuntimeError!void {
|
|
switch (dst.*) {
|
|
.Vector4f32,
|
|
.Vector3f32,
|
|
.Vector2f32,
|
|
=> try writeFloatTexel(dst, try rt.image_api.readImageFloat4(driver_image, dim, x, y, z)),
|
|
|
|
.Vector4i32,
|
|
.Vector3i32,
|
|
.Vector2i32,
|
|
.Vector4u32,
|
|
.Vector3u32,
|
|
.Vector2u32,
|
|
=> try writeIntTexel(dst, try rt.image_api.readImageInt4(driver_image, dim, x, y, z)),
|
|
|
|
.Vector => |lanes| {
|
|
if (lanes.len == 0) return RuntimeError.InvalidSpirV;
|
|
switch (lanes[0]) {
|
|
.Float => try writeFloatTexel(dst, try rt.image_api.readImageFloat4(driver_image, dim, x, y, z)),
|
|
.Int => try writeIntTexel(dst, try rt.image_api.readImageInt4(driver_image, dim, x, y, z)),
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
|
|
fn sampleImageImplicitLod(rt: *Runtime, dst: *Value, driver_image: *anyopaque, driver_sampler: *anyopaque, dim: spv.SpvDim, x: f32, y: f32, z: f32) RuntimeError!void {
|
|
switch (dst.*) {
|
|
.Vector4f32,
|
|
.Vector3f32,
|
|
.Vector2f32,
|
|
=> try writeFloatTexel(dst, try rt.image_api.sampleImageFloat4(driver_image, driver_sampler, dim, x, y, z)),
|
|
|
|
.Vector => |lanes| {
|
|
if (lanes.len == 0) return RuntimeError.InvalidSpirV;
|
|
switch (lanes[0]) {
|
|
.Float => try writeFloatTexel(dst, try rt.image_api.sampleImageFloat4(driver_image, driver_sampler, dim, x, y, z)),
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
|
|
fn sampleImageExplicitLod(rt: *Runtime, dst: *Value, driver_image: *anyopaque, driver_sampler: *anyopaque, dim: spv.SpvDim, x: f32, y: f32, z: f32) RuntimeError!void {
|
|
switch (dst.*) {
|
|
.Vector4f32,
|
|
.Vector3f32,
|
|
.Vector2f32,
|
|
=> try writeFloatTexel(dst, try rt.image_api.sampleImageFloat4(driver_image, driver_sampler, dim, x, y, z)),
|
|
|
|
.Vector => |lanes| {
|
|
if (lanes.len == 0) return RuntimeError.InvalidSpirV;
|
|
switch (lanes[0]) {
|
|
.Float => try writeFloatTexel(dst, try rt.image_api.sampleImageFloat4(driver_image, driver_sampler, dim, x, y, z)),
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
|
|
fn writeImage(rt: *Runtime, texel: *const Value, driver_image: *anyopaque, dim: spv.SpvDim, x: i32, y: i32, z: i32) RuntimeError!void {
|
|
switch (texel.*) {
|
|
.Float,
|
|
.Vector4f32,
|
|
.Vector3f32,
|
|
.Vector2f32,
|
|
=> try rt.image_api.writeImageFloat4(driver_image, dim, x, y, z, try readFloatTexel(texel)),
|
|
|
|
.Int,
|
|
.Vector4i32,
|
|
.Vector3i32,
|
|
.Vector2i32,
|
|
.Vector4u32,
|
|
.Vector3u32,
|
|
.Vector2u32,
|
|
=> try rt.image_api.writeImageInt4(driver_image, dim, x, y, z, try readIntTexel(texel)),
|
|
|
|
.Vector => |lanes| {
|
|
if (lanes.len == 0) return RuntimeError.InvalidSpirV;
|
|
switch (lanes[0]) {
|
|
.Float => try rt.image_api.writeImageFloat4(driver_image, dim, x, y, z, try readFloatTexel(texel)),
|
|
.Int => try rt.image_api.writeImageInt4(driver_image, dim, x, y, z, try readIntTexel(texel)),
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
|
|
fn op(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
if (comptime Op == .Write) {
|
|
const image = &rt.results[try rt.it.next()];
|
|
const coordinate = try rt.results[try rt.it.next()].getValue();
|
|
const texel = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const image_operand = try resolveImage(image, rt);
|
|
const x = try readStorageCoordLane(coordinate, 0);
|
|
const y = readStorageCoordLane(coordinate, 1) catch 0;
|
|
const z = readStorageCoordLane(coordinate, 2) catch 0;
|
|
|
|
return try writeImage(rt, texel, image_operand.driver_image, image_operand.dim, x, y, z);
|
|
}
|
|
|
|
_ = try rt.it.next(); // result type
|
|
const result_id = try rt.it.next();
|
|
const image = &rt.results[try rt.it.next()];
|
|
const coordinate = try rt.results[try rt.it.next()].getValue();
|
|
const dst = try rt.results[result_id].getValue();
|
|
|
|
switch (Op) {
|
|
.Fetch,
|
|
.Read,
|
|
=> {
|
|
const image_operand = try resolveImage(image, rt);
|
|
const x = try readStorageCoordLane(coordinate, 0);
|
|
const y = readStorageCoordLane(coordinate, 1) catch 0;
|
|
const z = readStorageCoordLane(coordinate, 2) catch 0;
|
|
|
|
try readImage(rt, dst, image_operand.driver_image, image_operand.dim, x, y, z);
|
|
},
|
|
|
|
.SampleImplicitLod => {
|
|
const sampled_image_operand = try resolveSampledImage(image, rt);
|
|
const x = try readSampleCoordLane(coordinate, 0);
|
|
const y = readSampleCoordLane(coordinate, 1) catch 0;
|
|
const z = readSampleCoordLane(coordinate, 2) catch 0;
|
|
|
|
try sampleImageImplicitLod(
|
|
rt,
|
|
dst,
|
|
sampled_image_operand.driver_image,
|
|
sampled_image_operand.driver_sampler,
|
|
sampled_image_operand.dim,
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
},
|
|
|
|
.SampleExplicitLod => {
|
|
const sampled_image_operand = try resolveSampledImage(image, rt);
|
|
const x = try readSampleCoordLane(coordinate, 0);
|
|
const y = readSampleCoordLane(coordinate, 1) catch 0;
|
|
const z = readSampleCoordLane(coordinate, 2) catch 0;
|
|
|
|
try sampleImageExplicitLod(
|
|
rt,
|
|
dst,
|
|
sampled_image_operand.driver_image,
|
|
sampled_image_operand.driver_sampler,
|
|
sampled_image_operand.dim,
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
},
|
|
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
fn MathEngine(comptime T: PrimitiveType, comptime Op: MathOp, comptime IsAtomic: bool) type {
|
|
return struct {
|
|
fn operation(comptime TT: type, op1: TT, op2: TT) RuntimeError!TT {
|
|
const is_int = @typeInfo(TT) == .int or (@typeInfo(TT) == .vector and @typeInfo(std.meta.Child(TT)) == .int);
|
|
const op2_is_zero = if (@typeInfo(TT) == .vector) std.simd.countElementsWithValue(op2, 0) != 0 else op2 == 0;
|
|
|
|
return switch (Op) {
|
|
.Add => if (comptime is_int) @addWithOverflow(op1, op2)[0] else op1 + op2,
|
|
.Sub => if (comptime is_int) @subWithOverflow(op1, op2)[0] else op1 - op2,
|
|
.Mul,
|
|
.MatrixTimesMatrix,
|
|
.MatrixTimesVector,
|
|
=> if (comptime is_int) @mulWithOverflow(op1, op2)[0] else op1 * op2,
|
|
.Div => blk: {
|
|
if (op2_is_zero) return RuntimeError.DivisionByZero;
|
|
break :blk if (comptime is_int) @divTrunc(op1, op2) else op1 / op2;
|
|
},
|
|
.Mod => if (op2_is_zero) return RuntimeError.DivisionByZero else @mod(op1, op2),
|
|
.Rem => if (op2_is_zero) return RuntimeError.DivisionByZero else @rem(op1, op2),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
fn applyScalarRaw(comptime BitCount: SpvWord, l: *const Value, r: *const Value) RuntimeError!Value.getPrimitiveFieldType(T, BitCount) {
|
|
const ScalarT = Value.getPrimitiveFieldType(T, BitCount);
|
|
const l_field = try Value.getPrimitiveFieldConst(T, BitCount, l);
|
|
const r_field = try Value.getPrimitiveFieldConst(T, BitCount, r);
|
|
return try operation(ScalarT, l_field.*, r_field.*);
|
|
}
|
|
|
|
fn applyScalar(bit_count: SpvWord, d: *Value, l: *const Value, r: *const Value) RuntimeError!void {
|
|
switch (bit_count) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
if (comptime bits == 8 and T == .Float) return RuntimeError.UnsupportedSpirV;
|
|
const d_field = try Value.getPrimitiveField(T, bits, d);
|
|
d_field.* = try applyScalarRaw(bits, l, r);
|
|
},
|
|
else => return RuntimeError.UnsupportedSpirV,
|
|
}
|
|
}
|
|
|
|
inline fn applyVectorTimesScalarFloat(comptime bit_count: SpvWord, d: []Value, l: []const Value, r_v: *const Value) RuntimeError!void {
|
|
for (d, l) |*d_v, l_v| {
|
|
switch (bit_count) {
|
|
inline 16 => d_v.Float.value.float16 = l_v.Float.value.float16 * r_v.Float.value.float16,
|
|
inline 32 => d_v.Float.value.float32 = l_v.Float.value.float32 * r_v.Float.value.float32,
|
|
inline 64 => d_v.Float.value.float64 = l_v.Float.value.float64 * r_v.Float.value.float64,
|
|
else => return RuntimeError.UnsupportedSpirV,
|
|
}
|
|
}
|
|
}
|
|
|
|
inline fn applySIMDVector(comptime ElemT: type, comptime N: usize, d: *@Vector(N, ElemT), l: @Vector(N, ElemT), r: @Vector(N, ElemT)) RuntimeError!void {
|
|
d.* = try operation(@Vector(N, ElemT), l, r);
|
|
}
|
|
|
|
fn applySIMDVectorf32(comptime N: usize, d: *@Vector(N, f32), l: *const Value, r: *const Value) RuntimeError!void {
|
|
switch (Op) {
|
|
.MatrixTimesVector => inline for (0..N) |i| {
|
|
d[i] = @reduce(.Add, l.Matrix[i].getVectorSpecialization(N, f32) * r.getVectorSpecialization(N, f32));
|
|
},
|
|
else => try applyDirectSIMDVectorf32(N, d, l.getVectorSpecialization(N, f32), r),
|
|
}
|
|
}
|
|
|
|
fn applyDirectSIMDVectorf32(comptime N: usize, d: *@Vector(N, f32), l: @Vector(N, f32), r: *const Value) RuntimeError!void {
|
|
switch (Op) {
|
|
.VectorTimesScalar => d.* = l * @as(@Vector(N, f32), @splat(r.Float.value.float32)),
|
|
else => try applySIMDVector(f32, N, d, l, r.getVectorSpecialization(N, f32)),
|
|
}
|
|
}
|
|
|
|
fn operationSingle(comptime TT: type, ope: TT) RuntimeError!TT {
|
|
return switch (Op) {
|
|
.Negate => if (@typeInfo(TT) == .int) std.math.negate(ope) catch return RuntimeError.InvalidSpirV else -ope,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
fn applyScalarSingle(bit_count: SpvWord, d: *Value, v: *Value) RuntimeError!void {
|
|
switch (bit_count) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
if (bits == 8 and T == .Float) return RuntimeError.InvalidSpirV;
|
|
|
|
const ScalarT = Value.getPrimitiveFieldType(T, bits);
|
|
const d_field = try Value.getPrimitiveField(T, bits, d);
|
|
const v_field = try Value.getPrimitiveField(T, bits, v);
|
|
d_field.* = try operationSingle(ScalarT, v_field.*);
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
inline fn applySIMDVectorSingle(comptime ElemT: type, comptime N: usize, d: *@Vector(N, ElemT), v: *const @Vector(N, ElemT)) RuntimeError!void {
|
|
inline for (0..N) |i| {
|
|
d[i] = try operationSingle(ElemT, v[i]);
|
|
}
|
|
}
|
|
|
|
fn op(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target_type = (try rt.results[try rt.it.next()].getVariant()).Type;
|
|
const dst = try rt.results[try rt.it.next()].getValue();
|
|
const lhs = try rt.results[try rt.it.next()].getValue();
|
|
|
|
var arena = std.heap.ArenaAllocator.init(allocator);
|
|
defer arena.deinit();
|
|
|
|
var lhs_save: ?Value = null;
|
|
|
|
if (comptime IsAtomic) {
|
|
_ = rt.it.skip(); // scope
|
|
_ = rt.it.skip(); // semantic
|
|
lhs_save = try lhs.dupe(arena.allocator());
|
|
}
|
|
|
|
const rhs = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const lane_bits = try Result.resolveLaneBitWidth(target_type, rt);
|
|
|
|
const vectorRoutines = struct {
|
|
fn routines(dst2: *Value, lhs2: *const Value, rhs2: *const Value, lane_bits2: SpvWord) RuntimeError!void {
|
|
switch (dst2.*) {
|
|
.Vector => |dst_vec| switch (Op) {
|
|
.VectorTimesScalar => switch (lane_bits2) {
|
|
inline 16, 32, 64 => |bits_count| try applyVectorTimesScalarFloat(bits_count, dst_vec, lhs2.Vector, rhs2),
|
|
else => return RuntimeError.UnsupportedSpirV,
|
|
},
|
|
.MatrixTimesVector => for (dst_vec, lhs2.Matrix) |*d_lane, *l_mat| {
|
|
switch (lane_bits2) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
if (comptime bits == 8 and T == .Float) return RuntimeError.UnsupportedSpirV;
|
|
const d_field = try Value.getPrimitiveField(T, bits, d_lane);
|
|
|
|
d_field.* = 0;
|
|
|
|
for (l_mat.Vector[0..], rhs2.Vector) |*l_lane, *r_lane| {
|
|
d_field.* += try applyScalarRaw(bits, l_lane, r_lane);
|
|
}
|
|
},
|
|
else => return RuntimeError.UnsupportedSpirV,
|
|
}
|
|
},
|
|
else => for (dst_vec, lhs2.Vector, rhs2.Vector) |*d_lane, *l_lane, *r_lane| {
|
|
try applyScalar(lane_bits2, d_lane, l_lane, r_lane);
|
|
},
|
|
},
|
|
|
|
.Vector4f32 => |*d| try applySIMDVectorf32(4, d, lhs2, rhs2),
|
|
.Vector3f32 => |*d| try applySIMDVectorf32(3, d, lhs2, rhs2),
|
|
.Vector2f32 => |*d| try applySIMDVectorf32(2, d, lhs2, rhs2),
|
|
|
|
.Vector4i32 => |*d| try applySIMDVector(i32, 4, d, lhs2.Vector4i32, rhs2.Vector4i32),
|
|
.Vector3i32 => |*d| try applySIMDVector(i32, 3, d, lhs2.Vector3i32, rhs2.Vector3i32),
|
|
.Vector2i32 => |*d| try applySIMDVector(i32, 2, d, lhs2.Vector2i32, rhs2.Vector2i32),
|
|
|
|
.Vector4u32 => |*d| try applySIMDVector(u32, 4, d, lhs2.Vector4u32, rhs2.Vector4u32),
|
|
.Vector3u32 => |*d| try applySIMDVector(u32, 3, d, lhs2.Vector3u32, rhs2.Vector3u32),
|
|
.Vector2u32 => |*d| try applySIMDVector(u32, 2, d, lhs2.Vector2u32, rhs2.Vector2u32),
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
}.routines;
|
|
|
|
switch (dst.*) {
|
|
.Int, .Float => try applyScalar(lane_bits, dst, lhs, rhs),
|
|
|
|
.Matrix => |dst_m| switch (Op) {
|
|
.MatrixTimesMatrix => {
|
|
for (dst_m, lhs.Matrix, rhs.Matrix) |*dst_vec, *lhs_vec, *rhs_vec| {
|
|
try vectorRoutines(dst_vec, lhs_vec, rhs_vec, lane_bits);
|
|
}
|
|
},
|
|
// TODO : matrix times scalar
|
|
else => return RuntimeError.ToDo,
|
|
},
|
|
|
|
else => try vectorRoutines(dst, lhs, rhs, lane_bits),
|
|
}
|
|
|
|
if (comptime IsAtomic) {
|
|
try copyValue(lhs, dst);
|
|
try copyValue(dst, &lhs_save.?);
|
|
try lhs.flushPtr(allocator);
|
|
}
|
|
}
|
|
|
|
fn opSingle(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target_type = (try rt.results[try rt.it.next()].getVariant()).Type;
|
|
const dst = try rt.results[try rt.it.next()].getValue();
|
|
const val = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const lane_bits = try Result.resolveLaneBitWidth(target_type, rt);
|
|
|
|
switch (dst.*) {
|
|
.Int, .Float => try applyScalarSingle(lane_bits, dst, val),
|
|
|
|
.Vector => |dst_vec| for (dst_vec, val.Vector) |*d_lane, *v_lane| {
|
|
try applyScalarSingle(lane_bits, d_lane, v_lane);
|
|
},
|
|
|
|
.Vector4f32 => |*d| try applySIMDVectorSingle(f32, 4, d, &val.Vector4f32),
|
|
.Vector3f32 => |*d| try applySIMDVectorSingle(f32, 3, d, &val.Vector3f32),
|
|
.Vector2f32 => |*d| try applySIMDVectorSingle(f32, 2, d, &val.Vector2f32),
|
|
|
|
.Vector4i32 => |*d| try applySIMDVectorSingle(i32, 4, d, &val.Vector4i32),
|
|
.Vector3i32 => |*d| try applySIMDVectorSingle(i32, 3, d, &val.Vector3i32),
|
|
.Vector2i32 => |*d| try applySIMDVectorSingle(i32, 2, d, &val.Vector2i32),
|
|
|
|
.Vector4u32 => |*d| try applySIMDVectorSingle(u32, 4, d, &val.Vector4u32),
|
|
.Vector3u32 => |*d| try applySIMDVectorSingle(u32, 3, d, &val.Vector3u32),
|
|
.Vector2u32 => |*d| try applySIMDVectorSingle(u32, 2, d, &val.Vector2u32),
|
|
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
fn addDecoration(allocator: std.mem.Allocator, rt: *Runtime, target: SpvWord, decoration_type: spv.SpvDecoration, member: ?SpvWord) RuntimeError!void {
|
|
var decoration = rt.results[target].decorations.addOne(allocator) catch return RuntimeError.OutOfMemory;
|
|
decoration.rtype = decoration_type;
|
|
decoration.index = if (member) |memb| memb else 0;
|
|
|
|
switch (decoration_type) {
|
|
.Alignment,
|
|
.AlignmentId,
|
|
.ArrayStride,
|
|
.Binding,
|
|
.BuiltIn,
|
|
.Component,
|
|
.CounterBuffer,
|
|
.DescriptorSet,
|
|
.FPFastMathMode,
|
|
.FPRoundingMode,
|
|
.FuncParamAttr,
|
|
.Index,
|
|
.InputAttachmentIndex,
|
|
.Location,
|
|
.MatrixStride,
|
|
.MaxByteOffset,
|
|
.MaxByteOffsetId,
|
|
.Offset,
|
|
.SecondaryViewportRelativeNV,
|
|
.SpecId,
|
|
.Stream,
|
|
.UniformId,
|
|
.UserSemantic,
|
|
.UserTypeGOOGLE,
|
|
.XfbBuffer,
|
|
.XfbStride,
|
|
=> {
|
|
decoration.literal_1 = try rt.it.next();
|
|
decoration.literal_2 = null;
|
|
},
|
|
.LinkageAttributes => {
|
|
decoration.literal_1 = try rt.it.next();
|
|
decoration.literal_2 = try rt.it.next();
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
fn cloneDecorationTo(allocator: std.mem.Allocator, rt: *Runtime, target: SpvWord, decoration: *const Result.Decoration, member: ?SpvWord) RuntimeError!void {
|
|
const out = rt.results[target].decorations.addOne(allocator) catch return RuntimeError.OutOfMemory;
|
|
out.* = decoration.*;
|
|
out.index = if (member) |m| m else decoration.index;
|
|
}
|
|
|
|
fn autoSetupConstant(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = try setupConstant(allocator, rt);
|
|
}
|
|
|
|
fn setupAccessChain(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const var_type = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
const base_id = try rt.it.next();
|
|
|
|
const index_count: usize = @intCast(word_count - 3);
|
|
const indexes = allocator.alloc(SpvWord, index_count) catch return RuntimeError.OutOfMemory;
|
|
errdefer allocator.free(indexes);
|
|
|
|
for (indexes) |*index| {
|
|
index.* = try rt.it.next();
|
|
}
|
|
|
|
if (rt.results[id].variant) |*variant| {
|
|
switch (variant.*) {
|
|
.AccessChain => |*a| {
|
|
allocator.free(a.indexes);
|
|
a.value.deinit(allocator);
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
rt.results[id].variant = .{
|
|
.AccessChain = .{
|
|
.target = var_type,
|
|
.base = base_id,
|
|
.indexes = indexes,
|
|
.value = try Value.initUnresolved(allocator, rt.results, var_type, false),
|
|
},
|
|
};
|
|
}
|
|
|
|
fn copyValue(dst: *Value, src: *const Value) RuntimeError!void {
|
|
const helpers = struct {
|
|
inline fn copySlice(dst_slice: []Value, src_slice: []const Value) RuntimeError!void {
|
|
for (0..@min(dst_slice.len, src_slice.len)) |i| {
|
|
try copyValue(&dst_slice[i], &src_slice[i]);
|
|
}
|
|
}
|
|
|
|
inline fn getDstSlice(v: *Value) ?[]Value {
|
|
return switch (v.*) {
|
|
.Vector, .Matrix => |s| s,
|
|
.Array => |a| a.values,
|
|
.Structure => |s| s.values,
|
|
else => null,
|
|
};
|
|
}
|
|
|
|
inline fn writeF32(dst_f32_ptr: *f32, src_v: *const Value) RuntimeError!void {
|
|
switch (src_v.*) {
|
|
.Pointer => |src_ptr| switch (src_ptr.ptr) {
|
|
.f32_ptr => |src_f32_ptr| dst_f32_ptr.* = src_f32_ptr.*,
|
|
.common => |src_val_ptr| dst_f32_ptr.* = src_val_ptr.Float.value.float32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Float => |f| dst_f32_ptr.* = f.value.float32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
inline fn writeI32(dst_i32_ptr: *i32, src_v: *const Value) RuntimeError!void {
|
|
switch (src_v.*) {
|
|
.Pointer => |src_ptr| switch (src_ptr.ptr) {
|
|
.i32_ptr => |src_i32_ptr| dst_i32_ptr.* = src_i32_ptr.*,
|
|
.common => |src_val_ptr| dst_i32_ptr.* = src_val_ptr.Int.value.sint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Int => |i| dst_i32_ptr.* = i.value.sint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
inline fn writeU32(dst_u32_ptr: *u32, src_v: *const Value) RuntimeError!void {
|
|
switch (src_v.*) {
|
|
.Pointer => |src_ptr| switch (src_ptr.ptr) {
|
|
.u32_ptr => |src_u32_ptr| dst_u32_ptr.* = src_u32_ptr.*,
|
|
.common => |src_val_ptr| dst_u32_ptr.* = src_val_ptr.Int.value.uint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Int => |i| dst_u32_ptr.* = i.value.uint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
inline fn readF32(dst_v: *Value, src_f32_ptr: *const f32) RuntimeError!void {
|
|
switch (dst_v.*) {
|
|
.Pointer => |dst_ptr| switch (dst_ptr.ptr) {
|
|
.f32_ptr => |dst_f32_ptr| dst_f32_ptr.* = src_f32_ptr.*,
|
|
.common => |dst_val_ptr| dst_val_ptr.Float.value.float32 = src_f32_ptr.*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Float => |*f| f.value.float32 = src_f32_ptr.*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
inline fn readI32(dst_v: *Value, src_i32_ptr: *const i32) RuntimeError!void {
|
|
switch (dst_v.*) {
|
|
.Pointer => |dst_ptr| switch (dst_ptr.ptr) {
|
|
.i32_ptr => |dst_i32_ptr| dst_i32_ptr.* = src_i32_ptr.*,
|
|
.common => |dst_val_ptr| dst_val_ptr.Int.value.sint32 = src_i32_ptr.*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Int => |*i| i.value.sint32 = src_i32_ptr.*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
inline fn readU32(dst_v: *Value, src_u32_ptr: *const u32) RuntimeError!void {
|
|
switch (dst_v.*) {
|
|
.Pointer => |dst_ptr| switch (dst_ptr.ptr) {
|
|
.u32_ptr => |dst_u32_ptr| dst_u32_ptr.* = src_u32_ptr.*,
|
|
.common => |dst_val_ptr| dst_val_ptr.Int.value.uint32 = src_u32_ptr.*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Int => |*i| i.value.uint32 = src_u32_ptr.*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
};
|
|
|
|
if (std.meta.activeTag(dst.*) == .Pointer) {
|
|
switch (dst.Pointer.ptr) {
|
|
.common => |dst_val_ptr| return switch (src.*) {
|
|
.Pointer => |src_ptr| switch (src_ptr.ptr) {
|
|
.common => |src_val_ptr| try copyValue(dst_val_ptr, src_val_ptr),
|
|
else => dst_val_ptr.* = src.*,
|
|
},
|
|
else => try copyValue(dst_val_ptr, src),
|
|
},
|
|
.f32_ptr => |dst_f32_ptr| try helpers.writeF32(dst_f32_ptr, src),
|
|
.i32_ptr => |dst_i32_ptr| try helpers.writeI32(dst_i32_ptr, src),
|
|
.u32_ptr => |dst_u32_ptr| try helpers.writeU32(dst_u32_ptr, src),
|
|
}
|
|
}
|
|
|
|
switch (src.*) {
|
|
.Vector, .Matrix => |src_slice| {
|
|
const dst_slice = helpers.getDstSlice(dst);
|
|
try helpers.copySlice(dst_slice.?, src_slice);
|
|
},
|
|
.Array => |a| {
|
|
const dst_slice = helpers.getDstSlice(dst);
|
|
try helpers.copySlice(dst_slice.?, a.values);
|
|
},
|
|
.Structure => |s| {
|
|
const dst_slice = helpers.getDstSlice(dst);
|
|
try helpers.copySlice(dst_slice.?, s.values);
|
|
},
|
|
.Pointer => |ptr| switch (ptr.ptr) {
|
|
.common => |src_val_ptr| try copyValue(dst, src_val_ptr),
|
|
.f32_ptr => |src_f32_ptr| try helpers.readF32(dst, src_f32_ptr),
|
|
.i32_ptr => |src_i32_ptr| try helpers.readI32(dst, src_i32_ptr),
|
|
.u32_ptr => |src_u32_ptr| try helpers.readU32(dst, src_u32_ptr),
|
|
},
|
|
.RuntimeArray => |src_arr| switch (dst.*) {
|
|
.RuntimeArray => |dst_arr| @memcpy(dst_arr.data, src_arr.data),
|
|
.Pointer => |dst_ptr| switch (dst_ptr.ptr) {
|
|
.common => |dst_ptr_ptr| switch (dst_ptr_ptr.*) {
|
|
.RuntimeArray => |dst_arr| @memcpy(dst_arr.data, src_arr.data),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => dst.* = src.*,
|
|
}
|
|
}
|
|
|
|
fn opAccessChain(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const var_type = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
const base_id = try rt.it.next();
|
|
|
|
const base = &rt.results[base_id];
|
|
var value_ptr = try base.getValue();
|
|
|
|
const index_count: usize = @intCast(word_count - 3);
|
|
|
|
const indexes, const free_responsability = blk: {
|
|
if (rt.results[id].variant) |*variant| {
|
|
switch (variant.*) {
|
|
.AccessChain => |*a| {
|
|
if (a.indexes.len != index_count)
|
|
return RuntimeError.InvalidSpirV;
|
|
try a.value.flushPtr(allocator);
|
|
a.value.deinit(allocator);
|
|
break :blk .{ a.indexes, false };
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
break :blk .{ allocator.alloc(SpvWord, index_count) catch return RuntimeError.OutOfMemory, true };
|
|
};
|
|
errdefer if (free_responsability) allocator.free(indexes);
|
|
|
|
rt.results[id].variant = .{
|
|
.AccessChain = .{
|
|
.target = var_type,
|
|
.base = base_id,
|
|
.indexes = indexes,
|
|
.value = blk: {
|
|
const helpers = struct {
|
|
fn advanceWindow(window: ?[]u8, offset: usize) RuntimeError!?[]u8 {
|
|
if (window) |w| {
|
|
if (offset > w.len) return RuntimeError.OutOfBounds;
|
|
return w[offset..];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
fn advanceWindowSized(window: ?[]u8, offset: usize, size: usize) RuntimeError!?[]u8 {
|
|
if (window) |w| {
|
|
if (offset > w.len or size > w.len - offset) return RuntimeError.OutOfBounds;
|
|
return w[offset .. offset + size];
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
|
|
var uniform_slice_window: ?[]u8 = null;
|
|
var uniform_backing_value: ?*Value = null;
|
|
|
|
if (std.meta.activeTag(value_ptr.*) == .Pointer) {
|
|
const ptr = value_ptr.Pointer;
|
|
uniform_slice_window = ptr.uniform_slice_window;
|
|
uniform_backing_value = ptr.uniform_backing_value;
|
|
switch (ptr.ptr) {
|
|
.common => |common| value_ptr = common,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
for (0..index_count) |index| {
|
|
const index_id = try rt.it.next();
|
|
indexes[index] = index_id;
|
|
const member = &rt.results[index_id];
|
|
const member_value = switch ((try member.getVariant()).*) {
|
|
.Constant => |c| &c.value,
|
|
.Variable => |v| &v.value,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
|
|
switch (member_value.*) {
|
|
.Int => |i| {
|
|
if (std.meta.activeTag(value_ptr.*) == .Pointer) {
|
|
const ptr = value_ptr.Pointer;
|
|
uniform_slice_window = ptr.uniform_slice_window;
|
|
uniform_backing_value = ptr.uniform_backing_value;
|
|
switch (ptr.ptr) {
|
|
.common => |common| value_ptr = common,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
const component_index: usize = @intCast(i.value.uint32);
|
|
|
|
switch (value_ptr.*) {
|
|
.Vector, .Matrix => |v| {
|
|
if (component_index >= v.len) return RuntimeError.OutOfBounds;
|
|
var offset: usize = 0;
|
|
for (v[0..component_index]) |*element| {
|
|
offset += try element.getPlainMemorySize();
|
|
}
|
|
uniform_slice_window = try helpers.advanceWindow(uniform_slice_window, offset);
|
|
value_ptr = &v[component_index];
|
|
},
|
|
.Array => |a| {
|
|
if (component_index >= a.values.len) return RuntimeError.OutOfBounds;
|
|
uniform_slice_window = try helpers.advanceWindow(uniform_slice_window, component_index * a.stride);
|
|
value_ptr = &a.values[component_index];
|
|
},
|
|
.Structure => |s| {
|
|
if (component_index >= s.values.len) return RuntimeError.OutOfBounds;
|
|
var end_offset: usize = 0;
|
|
for (s.values[0..component_index], 0..) |*field, field_index| {
|
|
const field_offset: usize = @intCast(s.offsets[field_index] orelse end_offset);
|
|
end_offset = @max(end_offset, field_offset + try field.getPlainMemorySize());
|
|
}
|
|
const member_offset: usize = @intCast(s.offsets[component_index] orelse end_offset);
|
|
|
|
if (uniform_slice_window != null) {
|
|
uniform_slice_window = try helpers.advanceWindow(uniform_slice_window, member_offset);
|
|
} else if (s.external_data) |data| {
|
|
uniform_slice_window = data[0..];
|
|
}
|
|
|
|
value_ptr = &s.values[component_index];
|
|
},
|
|
.RuntimeArray => |*arr| {
|
|
if (component_index >= arr.getLen()) return RuntimeError.OutOfBounds;
|
|
|
|
const element_offset = arr.getOffsetOfIndex(component_index);
|
|
if (element_offset > arr.data.len or arr.stride > arr.data.len - element_offset)
|
|
return RuntimeError.OutOfBounds;
|
|
|
|
const backing = try arr.createValueFromIndex(allocator, rt.results, component_index);
|
|
errdefer {
|
|
backing.deinit(allocator);
|
|
allocator.destroy(backing);
|
|
}
|
|
|
|
if (uniform_backing_value) |old_backing| {
|
|
old_backing.deinit(allocator);
|
|
allocator.destroy(old_backing);
|
|
}
|
|
|
|
value_ptr = backing;
|
|
uniform_backing_value = backing;
|
|
uniform_slice_window = arr.data[element_offset .. element_offset + arr.stride];
|
|
},
|
|
.Vector4f32 => |*v| switch (component_index) {
|
|
inline 0...3 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .f32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(f32), @sizeOf(f32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3f32 => |*v| switch (component_index) {
|
|
inline 0...2 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .f32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(f32), @sizeOf(f32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2f32 => |*v| switch (component_index) {
|
|
inline 0...1 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .f32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(f32), @sizeOf(f32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector4i32 => |*v| switch (component_index) {
|
|
inline 0...3 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .i32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(i32), @sizeOf(i32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3i32 => |*v| switch (component_index) {
|
|
inline 0...2 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .i32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(i32), @sizeOf(i32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2i32 => |*v| switch (component_index) {
|
|
inline 0...1 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .i32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(i32), @sizeOf(i32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector4u32 => |*v| switch (component_index) {
|
|
inline 0...3 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .u32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(u32), @sizeOf(u32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3u32 => |*v| switch (component_index) {
|
|
inline 0...2 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .u32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(u32), @sizeOf(u32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2u32 => |*v| switch (component_index) {
|
|
inline 0...1 => |idx| break :blk .{ .Pointer = .{
|
|
.ptr = .{ .u32_ptr = &v[idx] },
|
|
.uniform_slice_window = try helpers.advanceWindowSized(uniform_slice_window, idx * @sizeOf(u32), @sizeOf(u32)),
|
|
.uniform_backing_value = uniform_backing_value,
|
|
} },
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
break :blk .{
|
|
.Pointer = .{
|
|
.ptr = .{ .common = value_ptr },
|
|
.uniform_slice_window = uniform_slice_window,
|
|
.uniform_backing_value = uniform_backing_value,
|
|
},
|
|
};
|
|
},
|
|
},
|
|
};
|
|
}
|
|
fn opAtomicStore(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const ptr_id = try rt.it.next();
|
|
_ = rt.it.skip(); // scope
|
|
_ = rt.it.skip(); // semantic
|
|
const val_id = try rt.it.next();
|
|
try copyValue(try rt.results[ptr_id].getValue(), try rt.results[val_id].getValue());
|
|
}
|
|
|
|
fn opBitcast(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
const to_value = try rt.results[try rt.it.next()].getValue();
|
|
const from_value = try rt.results[try rt.it.next()].getValue();
|
|
|
|
var arena: std.heap.ArenaAllocator = .init(allocator);
|
|
defer arena.deinit();
|
|
const local_allocator = arena.allocator();
|
|
|
|
const size = try to_value.getPlainMemorySize();
|
|
const bytes = local_allocator.alloc(u8, size) catch return RuntimeError.OutOfMemory;
|
|
_ = try from_value.read(bytes);
|
|
_ = try to_value.write(bytes);
|
|
}
|
|
|
|
fn opBranch(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.previous_label = rt.current_label;
|
|
_ = rt.it.jumpToSourceLocation(switch ((try rt.results[id].getVariant()).*) {
|
|
.Label => |l| l.source_location,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
});
|
|
}
|
|
|
|
fn opBranchConditional(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const cond_value = try rt.results[try rt.it.next()].getValue();
|
|
const true_branch = switch ((try rt.results[try rt.it.next()].getVariant()).*) {
|
|
.Label => |l| l.source_location,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
const false_branch = switch ((try rt.results[try rt.it.next()].getVariant()).*) {
|
|
.Label => |l| l.source_location,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
rt.previous_label = rt.current_label;
|
|
if (cond_value.Bool) {
|
|
_ = rt.it.jumpToSourceLocation(true_branch);
|
|
} else {
|
|
_ = rt.it.jumpToSourceLocation(false_branch);
|
|
}
|
|
}
|
|
|
|
fn opCapability(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
rt.mod.capabilities.insert(try rt.it.nextAs(spv.SpvCapability));
|
|
}
|
|
|
|
fn opCompositeConstruct(_: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
const id = try rt.it.next();
|
|
|
|
const index_count = word_count - 2;
|
|
const value = &(try rt.results[id].getVariant()).Constant.value;
|
|
if (value.getCompositeDataOrNull()) |target| {
|
|
for (target[0..index_count]) |*elem| {
|
|
const elem_value = (try rt.results[try rt.it.next()].getVariant()).Constant.value;
|
|
elem.* = elem_value;
|
|
}
|
|
return;
|
|
}
|
|
|
|
const vectorRoutines = struct {
|
|
fn routines(value2: *Value, rt2: *Runtime) RuntimeError!void {
|
|
switch (value2.*) {
|
|
.Vector4f32 => |*vec| inline for (0..4) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector4f32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Float => |f| vec[i] = f.value.float32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
.Vector3f32 => |*vec| inline for (0..3) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector3f32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Float => |f| vec[i] = f.value.float32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
.Vector2f32 => |*vec| inline for (0..2) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector2f32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Float => |f| vec[i] = f.value.float32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
.Vector4i32 => |*vec| inline for (0..4) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector4i32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Int => |int| vec[i] = int.value.sint32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
.Vector3i32 => |*vec| inline for (0..3) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector3i32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Int => |int| vec[i] = int.value.sint32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
.Vector2i32 => |*vec| inline for (0..2) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector2i32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Int => |int| vec[i] = int.value.sint32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
.Vector4u32 => |*vec| inline for (0..4) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector4u32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Int => |int| vec[i] = int.value.uint32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
.Vector3u32 => |*vec| inline for (0..3) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector3u32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Int => |int| vec[i] = int.value.uint32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
.Vector2u32 => |*vec| inline for (0..2) |i| {
|
|
switch ((try rt2.results[try rt2.it.next()].getVariant()).Constant.value) {
|
|
.Vector2u32 => |v| {
|
|
vec.* = v;
|
|
return;
|
|
},
|
|
.Int => |int| vec[i] = int.value.uint32,
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
},
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
}.routines;
|
|
|
|
switch (value.*) {
|
|
.Matrix => |*m| {
|
|
var index: SpvWord = 0;
|
|
for (m.*[0..]) |*mat_elem| {
|
|
if (mat_elem.getCompositeDataOrNull()) |vec| {
|
|
for (vec[0..]) |*elem| {
|
|
const elem_value = (try rt.results[try rt.it.next()].getVariant()).Constant.value;
|
|
elem.* = elem_value;
|
|
index += 1;
|
|
if (index == index_count)
|
|
return;
|
|
}
|
|
} else {
|
|
try vectorRoutines(mat_elem, rt);
|
|
}
|
|
}
|
|
},
|
|
.RuntimeArray => |arr| {
|
|
_ = arr;
|
|
return RuntimeError.ToDo;
|
|
},
|
|
|
|
else => try vectorRoutines(value, rt),
|
|
}
|
|
}
|
|
|
|
fn opCompositeExtract(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const res_type = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
const composite_id = try rt.it.next();
|
|
const index_count: usize = @intCast(word_count - 3);
|
|
|
|
var arena = std.heap.ArenaAllocator.init(allocator);
|
|
defer arena.deinit();
|
|
|
|
const arena_allocator = arena.allocator();
|
|
|
|
rt.results[id].variant = .{
|
|
.Constant = .{
|
|
.type_word = res_type,
|
|
.type = switch ((try rt.results[res_type].getVariant()).*) {
|
|
.Type => |t| @as(Result.Type, t),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.value = blk: {
|
|
var composite = (try rt.results[composite_id].getVariant()).Constant.value;
|
|
for (0..index_count) |_| {
|
|
const member_id = try rt.it.next();
|
|
if (composite.getCompositeDataOrNull()) |v| {
|
|
composite = v[member_id];
|
|
continue;
|
|
}
|
|
switch (composite) {
|
|
.RuntimeArray => |arr| composite = try arr.createLocalValueFromIndex(arena_allocator, rt.results, member_id),
|
|
.Vector4f32 => |v| break :blk .{ .Float = .{ .bit_count = 32, .value = .{ .float32 = switch (member_id) {
|
|
inline 0...3 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
.Vector3f32 => |v| break :blk .{ .Float = .{ .bit_count = 32, .value = .{ .float32 = switch (member_id) {
|
|
inline 0...2 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
.Vector2f32 => |v| break :blk .{ .Float = .{ .bit_count = 32, .value = .{ .float32 = switch (member_id) {
|
|
inline 0...1 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
.Vector4i32 => |v| break :blk .{ .Int = .{ .bit_count = 32, .is_signed = true, .value = .{ .sint32 = switch (member_id) {
|
|
inline 0...3 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
.Vector3i32 => |v| break :blk .{ .Int = .{ .bit_count = 32, .is_signed = true, .value = .{ .sint32 = switch (member_id) {
|
|
inline 0...2 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
.Vector2i32 => |v| break :blk .{ .Int = .{ .bit_count = 32, .is_signed = true, .value = .{ .sint32 = switch (member_id) {
|
|
inline 0...1 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
.Vector4u32 => |v| break :blk .{ .Int = .{ .bit_count = 32, .is_signed = false, .value = .{ .uint32 = switch (member_id) {
|
|
inline 0...3 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
.Vector3u32 => |v| break :blk .{ .Int = .{ .bit_count = 32, .is_signed = false, .value = .{ .uint32 = switch (member_id) {
|
|
inline 0...2 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
.Vector2u32 => |v| break :blk .{ .Int = .{ .bit_count = 32, .is_signed = false, .value = .{ .uint32 = switch (member_id) {
|
|
inline 0...1 => |idx| v[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} } } },
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
break :blk try composite.dupe(allocator);
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opCompositeInsert(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
const object = try rt.results[try rt.it.next()].getValue();
|
|
const composite = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const target = try rt.results[id].getValue();
|
|
|
|
try copyValue(target, composite);
|
|
|
|
const index_count = word_count - 4;
|
|
|
|
var arena = std.heap.ArenaAllocator.init(allocator);
|
|
defer arena.deinit();
|
|
|
|
const helpers = struct {
|
|
fn insertAt(
|
|
alloc: std.mem.Allocator,
|
|
results: []const Result,
|
|
current: *Value,
|
|
object_value: *const Value,
|
|
indices: []const SpvWord,
|
|
) RuntimeError!void {
|
|
if (indices.len == 0) {
|
|
try copyValue(current, object_value);
|
|
return;
|
|
}
|
|
|
|
const index = indices[0];
|
|
|
|
if (current.getCompositeDataOrNull()) |children| {
|
|
if (index >= children.len) return RuntimeError.OutOfBounds;
|
|
return insertAt(alloc, results, &children[index], object_value, indices[1..]);
|
|
}
|
|
|
|
switch (current.*) {
|
|
.Structure => |*s| {
|
|
if (index >= s.values.len) return RuntimeError.OutOfBounds;
|
|
return insertAt(alloc, results, &s.values[index], object_value, indices[1..]);
|
|
},
|
|
|
|
.RuntimeArray => |*arr| {
|
|
if (index >= arr.getLen()) return RuntimeError.OutOfBounds;
|
|
|
|
const elem_offset = arr.getOffsetOfIndex(index);
|
|
|
|
if (indices.len == 1) {
|
|
_ = try object_value.read(arr.data[elem_offset..]);
|
|
return;
|
|
}
|
|
|
|
var elem_value = try arr.createLocalValueFromIndex(alloc, results, elem_offset);
|
|
try insertAt(alloc, results, &elem_value, object_value, indices[1..]);
|
|
_ = try elem_value.read(arr.data[elem_offset..]);
|
|
},
|
|
|
|
.Vector4f32 => |*v| switch (index) {
|
|
inline 0...3 => |i| v[i] = (try Value.getPrimitiveField(.Float, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3f32 => |*v| switch (index) {
|
|
inline 0...2 => |i| v[i] = (try Value.getPrimitiveField(.Float, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2f32 => |*v| switch (index) {
|
|
inline 0...1 => |i| v[i] = (try Value.getPrimitiveField(.Float, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
.Vector4i32 => |*v| switch (index) {
|
|
inline 0...3 => |i| v[i] = (try Value.getPrimitiveField(.SInt, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3i32 => |*v| switch (index) {
|
|
inline 0...2 => |i| v[i] = (try Value.getPrimitiveField(.SInt, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2i32 => |*v| switch (index) {
|
|
inline 0...1 => |i| v[i] = (try Value.getPrimitiveField(.SInt, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
.Vector4u32 => |*v| switch (index) {
|
|
inline 0...3 => |i| v[i] = (try Value.getPrimitiveField(.UInt, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3u32 => |*v| switch (index) {
|
|
inline 0...2 => |i| v[i] = (try Value.getPrimitiveField(.UInt, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2u32 => |*v| switch (index) {
|
|
inline 0...1 => |i| v[i] = (try Value.getPrimitiveField(.UInt, 32, @constCast(object_value))).*,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
else => return RuntimeError.InvalidValueType,
|
|
}
|
|
}
|
|
};
|
|
|
|
const indices = try arena.allocator().alloc(SpvWord, index_count);
|
|
for (indices) |*idx| idx.* = try rt.it.next();
|
|
|
|
try helpers.insertAt(arena.allocator(), rt.results, target, object, indices);
|
|
}
|
|
|
|
fn opConstant(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target = try setupConstant(allocator, rt);
|
|
switch (target.variant.?.Constant.value) {
|
|
.Int => |*i| {
|
|
if (word_count - 2 != 1) {
|
|
const low = @as(u64, try rt.it.next());
|
|
const high = @as(u64, try rt.it.next());
|
|
i.value.uint64 = (high << 32) | low;
|
|
} else {
|
|
i.value.uint32 = try rt.it.next();
|
|
}
|
|
},
|
|
.Float => |*f| {
|
|
if (word_count - 2 != 1) {
|
|
const low = @as(u64, try rt.it.next());
|
|
const high = @as(u64, try rt.it.next());
|
|
f.value.float64 = @bitCast((high << 32) | low);
|
|
} else {
|
|
f.value.float32 = @bitCast(try rt.it.next());
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn opConstantComposite(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target = try setupConstant(allocator, rt);
|
|
const target_value = try target.getValue();
|
|
if (target_value.getCompositeDataOrNull()) |*values| {
|
|
for (values.*) |*element| {
|
|
try copyValue(element, try rt.results[try rt.it.next()].getValue());
|
|
}
|
|
return;
|
|
}
|
|
|
|
switch (target_value.*) {
|
|
.Vector4f32 => |*v| inline for (0..4) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Float.value.float32;
|
|
},
|
|
.Vector3f32 => |*v| inline for (0..3) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Float.value.float32;
|
|
},
|
|
.Vector2f32 => |*v| inline for (0..2) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Float.value.float32;
|
|
},
|
|
.Vector4i32 => |*v| inline for (0..4) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Int.value.sint32;
|
|
},
|
|
.Vector3i32 => |*v| inline for (0..3) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Int.value.sint32;
|
|
},
|
|
.Vector2i32 => |*v| inline for (0..2) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Int.value.sint32;
|
|
},
|
|
.Vector4u32 => |*v| inline for (0..4) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Int.value.uint32;
|
|
},
|
|
.Vector3u32 => |*v| inline for (0..3) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Int.value.uint32;
|
|
},
|
|
.Vector2u32 => |*v| inline for (0..2) |i| {
|
|
v[i] = (try rt.results[try rt.it.next()].getValue()).Int.value.uint32;
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn writeMulExtendedBits(comptime bits: u32, dst: *Value, lane_index: usize, value: Value.getPrimitiveFieldType(.UInt, bits)) RuntimeError!void {
|
|
switch (dst.*) {
|
|
.Int => |*i| {
|
|
if (i.bit_count != bits) return RuntimeError.InvalidSpirV;
|
|
if (i.is_signed) {
|
|
switch (bits) {
|
|
8 => i.value.sint8 = @bitCast(value),
|
|
16 => i.value.sint16 = @bitCast(value),
|
|
32 => i.value.sint32 = @bitCast(value),
|
|
64 => i.value.sint64 = @bitCast(value),
|
|
else => unreachable,
|
|
}
|
|
} else {
|
|
switch (bits) {
|
|
8 => i.value.uint8 = value,
|
|
16 => i.value.uint16 = value,
|
|
32 => i.value.uint32 = value,
|
|
64 => i.value.uint64 = value,
|
|
else => unreachable,
|
|
}
|
|
}
|
|
},
|
|
.Vector => |lanes| try writeMulExtendedBits(bits, &lanes[lane_index], 0, value),
|
|
.Vector2i32 => |*v| switch (lane_index) {
|
|
inline 0...1 => |i| if (bits == 32) {
|
|
v[i] = @bitCast(value);
|
|
} else {
|
|
return RuntimeError.InvalidSpirV;
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3i32 => |*v| switch (lane_index) {
|
|
inline 0...2 => |i| if (bits == 32) {
|
|
v[i] = @bitCast(value);
|
|
} else {
|
|
return RuntimeError.InvalidSpirV;
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector4i32 => |*v| switch (lane_index) {
|
|
inline 0...3 => |i| if (bits == 32) {
|
|
v[i] = @bitCast(value);
|
|
} else {
|
|
return RuntimeError.InvalidSpirV;
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector2u32 => |*v| switch (lane_index) {
|
|
inline 0...1 => |i| if (bits == 32) {
|
|
v[i] = @bitCast(value);
|
|
} else {
|
|
return RuntimeError.InvalidSpirV;
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3u32 => |*v| switch (lane_index) {
|
|
inline 0...2 => |i| if (bits == 32) {
|
|
v[i] = @bitCast(value);
|
|
} else {
|
|
return RuntimeError.InvalidSpirV;
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector4u32 => |*v| switch (lane_index) {
|
|
inline 0...3 => |i| if (bits == 32) {
|
|
v[i] = @bitCast(value);
|
|
} else {
|
|
return RuntimeError.InvalidSpirV;
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn opMulExtended(comptime is_signed: bool, rt: *Runtime) RuntimeError!void {
|
|
_ = try rt.it.next(); // result Type
|
|
const result_id = try rt.it.next();
|
|
const lhs = try rt.results[try rt.it.next()].getValue();
|
|
const rhs = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const result = try rt.results[result_id].getValue();
|
|
const result_members = switch (result.*) {
|
|
.Structure => |*s| s.values,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
if (result_members.len != 2) return RuntimeError.InvalidSpirV;
|
|
|
|
const low_dst = &result_members[0];
|
|
const high_dst = &result_members[1];
|
|
|
|
const lane_count = try lhs.resolveLaneCount();
|
|
if (try rhs.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
if (try low_dst.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
if (try high_dst.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
|
|
const lane_bits = try lhs.resolveLaneBitWidth();
|
|
if (try rhs.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
if (try low_dst.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
if (try high_dst.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
|
|
switch (lane_bits) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
const UIntT = Value.getPrimitiveFieldType(.UInt, bits);
|
|
const WideUIntT = std.meta.Int(.unsigned, bits * 2);
|
|
|
|
for (0..lane_count) |lane_index| {
|
|
const product_bits: WideUIntT = if (is_signed) blk: {
|
|
const SIntT = Value.getPrimitiveFieldType(.SInt, bits);
|
|
const WideSIntT = std.meta.Int(.signed, bits * 2);
|
|
const l: SIntT = try Value.readLane(.SInt, bits, lhs, lane_index);
|
|
const r: SIntT = try Value.readLane(.SInt, bits, rhs, lane_index);
|
|
const product: WideSIntT = @as(WideSIntT, l) * @as(WideSIntT, r);
|
|
break :blk @bitCast(product);
|
|
} else blk: {
|
|
const l: UIntT = try Value.readLane(.UInt, bits, lhs, lane_index);
|
|
const r: UIntT = try Value.readLane(.UInt, bits, rhs, lane_index);
|
|
break :blk @as(WideUIntT, l) * @as(WideUIntT, r);
|
|
};
|
|
|
|
const low: UIntT = @truncate(product_bits);
|
|
const high: UIntT = @truncate(product_bits >> bits);
|
|
|
|
try writeMulExtendedBits(bits, low_dst, lane_index, low);
|
|
try writeMulExtendedBits(bits, high_dst, lane_index, high);
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn opIAddCarry(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = try rt.it.next(); // result Type
|
|
const result_id = try rt.it.next();
|
|
const lhs = try rt.results[try rt.it.next()].getValue();
|
|
const rhs = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const result = try rt.results[result_id].getValue();
|
|
const result_members = switch (result.*) {
|
|
.Structure => |*s| s.values,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
if (result_members.len != 2) return RuntimeError.InvalidSpirV;
|
|
|
|
const value_dst = &result_members[0];
|
|
const carry_dst = &result_members[1];
|
|
|
|
const lane_count = try lhs.resolveLaneCount();
|
|
if (try rhs.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
if (try value_dst.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
if (try carry_dst.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
|
|
const lane_bits = try lhs.resolveLaneBitWidth();
|
|
if (try rhs.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
if (try value_dst.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
if (try carry_dst.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
|
|
switch (lane_bits) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
const UIntT = Value.getPrimitiveFieldType(.UInt, bits);
|
|
|
|
for (0..lane_count) |lane_index| {
|
|
const l: UIntT = try Value.readLane(.UInt, bits, lhs, lane_index);
|
|
const r: UIntT = try Value.readLane(.UInt, bits, rhs, lane_index);
|
|
const add_result = @addWithOverflow(l, r);
|
|
const sum = add_result[0];
|
|
const carry: UIntT = @intCast(add_result[1]);
|
|
|
|
try writeMulExtendedBits(bits, value_dst, lane_index, sum);
|
|
try writeMulExtendedBits(bits, carry_dst, lane_index, carry);
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn opISubBorrow(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = try rt.it.next(); // result Type
|
|
const result_id = try rt.it.next();
|
|
const lhs = try rt.results[try rt.it.next()].getValue();
|
|
const rhs = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const result = try rt.results[result_id].getValue();
|
|
const result_members = switch (result.*) {
|
|
.Structure => |*s| s.values,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
if (result_members.len != 2) return RuntimeError.InvalidSpirV;
|
|
|
|
const value_dst = &result_members[0];
|
|
const borrow_dst = &result_members[1];
|
|
|
|
const lane_count = try lhs.resolveLaneCount();
|
|
if (try rhs.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
if (try value_dst.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
if (try borrow_dst.resolveLaneCount() != lane_count) return RuntimeError.InvalidSpirV;
|
|
|
|
const lane_bits = try lhs.resolveLaneBitWidth();
|
|
if (try rhs.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
if (try value_dst.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
if (try borrow_dst.resolveLaneBitWidth() != lane_bits) return RuntimeError.InvalidSpirV;
|
|
|
|
switch (lane_bits) {
|
|
inline 8, 16, 32, 64 => |bits| {
|
|
const UIntT = Value.getPrimitiveFieldType(.UInt, bits);
|
|
|
|
for (0..lane_count) |lane_index| {
|
|
const l: UIntT = try Value.readLane(.UInt, bits, lhs, lane_index);
|
|
const r: UIntT = try Value.readLane(.UInt, bits, rhs, lane_index);
|
|
const sub_result = @subWithOverflow(l, r);
|
|
const diff = sub_result[0];
|
|
const borrow: UIntT = @intCast(sub_result[1]);
|
|
|
|
try writeMulExtendedBits(bits, value_dst, lane_index, diff);
|
|
try writeMulExtendedBits(bits, borrow_dst, lane_index, borrow);
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn opUMulExtended(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
try opMulExtended(false, rt);
|
|
}
|
|
|
|
fn opSMulExtended(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
try opMulExtended(true, rt);
|
|
}
|
|
|
|
fn opSpecConstant(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const location = rt.it.emitSourceLocation();
|
|
_ = rt.it.skip();
|
|
const result_id = try rt.it.next();
|
|
_ = rt.it.goToSourceLocation(location);
|
|
|
|
try opConstant(allocator, word_count, rt);
|
|
|
|
const result = &rt.results[result_id];
|
|
|
|
for (result.decorations.items) |decoration| {
|
|
if (decoration.rtype == .SpecId) {
|
|
if (rt.specialization_constants.get(decoration.literal_1)) |data| {
|
|
_ = try (try result.getValue()).write(data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn opSpecConstantTrue(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target = try setupConstant(allocator, rt);
|
|
switch (target.variant.?.Constant.value) {
|
|
.Bool => |*b| b.* = true,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
|
|
for (target.decorations.items) |decoration| {
|
|
if (decoration.rtype == .SpecId) {
|
|
if (rt.specialization_constants.get(decoration.literal_1)) |data| {
|
|
_ = try (try target.getValue()).write(data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn opSpecConstantFalse(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target = try setupConstant(allocator, rt);
|
|
switch (target.variant.?.Constant.value) {
|
|
.Bool => |*b| b.* = false,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
|
|
for (target.decorations.items) |decoration| {
|
|
if (decoration.rtype == .SpecId) {
|
|
if (rt.specialization_constants.get(decoration.literal_1)) |data| {
|
|
_ = try (try target.getValue()).write(data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn opSpecConstantOp(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
if (word_count < 3)
|
|
return RuntimeError.InvalidSpirV;
|
|
|
|
const start_location = rt.it.emitSourceLocation();
|
|
|
|
_ = try setupConstant(allocator, rt);
|
|
const inner_op = try rt.it.nextAs(spv.SpvOp);
|
|
|
|
_ = rt.it.goToSourceLocation(start_location);
|
|
rt.it.forceSkipIndex(2);
|
|
|
|
const pfn = runtime_dispatcher[@intFromEnum(inner_op)] orelse return RuntimeError.UnsupportedSpirV;
|
|
try pfn(allocator, word_count - 1, rt);
|
|
}
|
|
|
|
fn opCopyMemory(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target = try rt.it.next();
|
|
const source = try rt.it.next();
|
|
try copyValue(try rt.results[target].getValue(), try rt.results[source].getValue());
|
|
}
|
|
|
|
fn opDecorate(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target = try rt.it.next();
|
|
const decoration_type = try rt.it.nextAs(spv.SpvDecoration);
|
|
try addDecoration(allocator, rt, target, decoration_type, null);
|
|
}
|
|
|
|
fn opDecorateMember(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target = try rt.it.next();
|
|
const member = try rt.it.next();
|
|
const decoration_type = try rt.it.nextAs(spv.SpvDecoration);
|
|
try addDecoration(allocator, rt, target, decoration_type, member);
|
|
}
|
|
|
|
fn opDecorationGroup(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
}
|
|
|
|
fn opGroupDecorate(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const decoration_group = try rt.it.next();
|
|
|
|
if (word_count < 2) return RuntimeError.InvalidSpirV;
|
|
|
|
const group_result = &rt.results[decoration_group];
|
|
|
|
for (0..(word_count - 1)) |_| {
|
|
const target = try rt.it.next();
|
|
|
|
for (group_result.decorations.items) |*decoration| {
|
|
try cloneDecorationTo(allocator, rt, target, decoration, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn opGroupMemberDecorate(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const decoration_group = try rt.it.next();
|
|
|
|
if (word_count < 3) return RuntimeError.InvalidSpirV;
|
|
if (((word_count - 1) % 2) != 0) return RuntimeError.InvalidSpirV;
|
|
|
|
const group_result = &rt.results[decoration_group];
|
|
const pair_count = @divExact(word_count - 1, 2);
|
|
|
|
for (0..pair_count) |_| {
|
|
const target = try rt.it.next();
|
|
const member = try rt.it.next();
|
|
|
|
for (group_result.decorations.items) |*decoration| {
|
|
try cloneDecorationTo(allocator, rt, target, decoration, member);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn opDot(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target_type = (try rt.results[try rt.it.next()].getVariant()).Type;
|
|
var value = try rt.results[try rt.it.next()].getValue();
|
|
const op1_value = try rt.results[try rt.it.next()].getValue();
|
|
const op2_value = try rt.results[try rt.it.next()].getValue();
|
|
|
|
const size = switch (target_type) {
|
|
.Float => |f| f.bit_length,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
|
|
value.Float.value.float64 = 0.0;
|
|
|
|
switch (op1_value.*) {
|
|
.Vector => |vec| for (vec, op2_value.Vector) |*op1_v, *op2_v| {
|
|
switch (size) {
|
|
inline 16, 32, 64 => |i| {
|
|
(try Value.getPrimitiveField(.Float, i, value)).* += (try Value.getPrimitiveField(.Float, i, op1_v)).* * (try Value.getPrimitiveField(.Float, i, op2_v)).*;
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
.Vector4f32 => |vec| value.Float.value.float32 = zm.dot4(vec, op2_value.Vector4f32)[0],
|
|
.Vector3f32 => |vec| {
|
|
const op2_vec = op2_value.Vector3f32;
|
|
value.Float.value.float32 = zm.dot3(zm.f32x4(vec[0], vec[1], vec[2], 0.0), zm.f32x4(op2_vec[0], op2_vec[1], op2_vec[2], 0.0))[0];
|
|
},
|
|
.Vector2f32 => |vec| {
|
|
const op2_vec = op2_value.Vector2f32;
|
|
value.Float.value.float32 = zm.dot2(zm.f32x4(vec[0], vec[1], 0.0, 0.0), zm.f32x4(op2_vec[0], op2_vec[1], 0.0, 0.0))[0];
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn opEntryPoint(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const entry = rt.mod.entry_points.addOne(allocator) catch return RuntimeError.OutOfMemory;
|
|
entry.exec_model = try rt.it.nextAs(spv.SpvExecutionModel);
|
|
entry.id = try rt.it.next();
|
|
entry.name = try readString(allocator, &rt.it);
|
|
|
|
var interface_count = word_count - @divExact(entry.name.len, 4) - 2;
|
|
entry.globals = try allocator.alloc(SpvWord, interface_count);
|
|
if (interface_count != 0) {
|
|
var interface_index: u32 = 0;
|
|
while (interface_count != 0) {
|
|
entry.globals[interface_index] = try rt.it.next();
|
|
interface_index += 1;
|
|
interface_count -= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn opExecutionMode(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
const mode = try rt.it.nextAs(spv.SpvExecutionMode);
|
|
|
|
switch (mode) {
|
|
.LocalSize => {
|
|
rt.mod.local_size_x = try rt.it.next();
|
|
rt.mod.local_size_y = try rt.it.next();
|
|
rt.mod.local_size_z = try rt.it.next();
|
|
},
|
|
.Invocations => rt.mod.geometry_invocations = try rt.it.next(),
|
|
.OutputVertices => rt.mod.geometry_output_count = try rt.it.next(),
|
|
.InputPoints,
|
|
.InputLines,
|
|
.Triangles,
|
|
.InputLinesAdjacency,
|
|
.InputTrianglesAdjacency,
|
|
=> rt.mod.geometry_input = @intFromEnum(mode),
|
|
.OutputPoints,
|
|
.OutputLineStrip,
|
|
.OutputTriangleStrip,
|
|
=> rt.mod.geometry_output = @intFromEnum(mode),
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
fn opExtInst(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const target_type = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
const set = try rt.it.next();
|
|
const inst = try rt.it.next();
|
|
|
|
switch ((try rt.results[set].getVariant()).*) {
|
|
.Extension => |ext| if (ext.dispatcher[inst]) |pfn| {
|
|
try pfn(allocator, target_type, id, word_count, rt);
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn opExtInstImport(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
const name = try readStringN(allocator, &rt.it, word_count - 1);
|
|
rt.results[id].name = name;
|
|
rt.results[id].variant = .{
|
|
.Extension = .{
|
|
.dispatcher = if (extensions_map.get(name)) |map| map else return RuntimeError.UnsupportedExtension,
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opFunction(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const return_type = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
_ = rt.it.skip(); // Skip function control
|
|
const function_type_id = try rt.it.next();
|
|
|
|
const source_location = rt.it.emitSourceLocation();
|
|
|
|
rt.results[id].variant = .{
|
|
.Function = .{
|
|
.source_location = source_location,
|
|
.return_type = return_type,
|
|
.function_type = function_type_id,
|
|
.params = params: {
|
|
if (rt.results[function_type_id].variant) |variant| {
|
|
const params_count = switch (variant) {
|
|
.Type => |t| switch (t) {
|
|
.Function => |f| f.params.len,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
break :params allocator.alloc(SpvWord, params_count) catch return RuntimeError.OutOfMemory;
|
|
}
|
|
return RuntimeError.InvalidSpirV;
|
|
},
|
|
},
|
|
};
|
|
|
|
rt.results[function_type_id].variant.?.Type.Function.source_location = source_location;
|
|
|
|
rt.current_function = &rt.results[id];
|
|
rt.current_parameter_index = 0;
|
|
}
|
|
|
|
fn opFunctionCall(allocator: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
const ret = &rt.results[try rt.it.next()];
|
|
const func = &rt.results[try rt.it.next()];
|
|
|
|
for ((try func.getVariant()).Function.params) |param| {
|
|
const arg = &rt.results[try rt.it.next()];
|
|
((try rt.results[param].getVariant()).*).FunctionParameter.value_ptr = try arg.getValue();
|
|
}
|
|
rt.function_stack.items[rt.function_stack.items.len - 1].source_location = rt.it.emitSourceLocation();
|
|
const source_location = (try func.getVariant()).Function.source_location;
|
|
rt.function_stack.append(allocator, .{
|
|
.source_location = source_location,
|
|
.result = func,
|
|
.ret = ret,
|
|
}) catch return RuntimeError.OutOfMemory;
|
|
if (!rt.it.jumpToSourceLocation(source_location)) return RuntimeError.InvalidSpirV;
|
|
rt.current_parameter_index = 0;
|
|
}
|
|
|
|
fn opFunctionEnd(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
rt.current_function = null;
|
|
}
|
|
|
|
fn opFunctionParameter(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const var_type = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
|
|
const target = &rt.results[id];
|
|
|
|
const resolved = rt.results[var_type].resolveType(rt.results);
|
|
const member_count = resolved.getMemberCounts();
|
|
if (member_count == 0) {
|
|
return RuntimeError.InvalidSpirV;
|
|
}
|
|
target.variant = .{
|
|
.FunctionParameter = .{
|
|
.type_word = var_type,
|
|
.type = switch ((try resolved.getConstVariant()).*) {
|
|
.Type => |t| @as(Result.Type, t),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.value_ptr = null,
|
|
},
|
|
};
|
|
(try (rt.current_function orelse return RuntimeError.InvalidSpirV).getVariant()).Function.params[rt.current_parameter_index] = id;
|
|
rt.current_parameter_index += 1;
|
|
}
|
|
|
|
fn opLabel(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.current_label = id;
|
|
if (rt.results[id].variant == null) {
|
|
rt.results[id].variant = .{
|
|
.Label = .{
|
|
.source_location = rt.it.emitSourceLocation() - 2, // Original label location
|
|
},
|
|
};
|
|
}
|
|
}
|
|
|
|
fn opKill(_: std.mem.Allocator, _: SpvWord, _: *Runtime) RuntimeError!void {
|
|
return RuntimeError.Killed;
|
|
}
|
|
|
|
fn opLoad(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
const id = try rt.it.next();
|
|
const ptr_id = try rt.it.next();
|
|
try copyValue(try rt.results[id].getValue(), try rt.results[ptr_id].getValue());
|
|
}
|
|
|
|
fn opMemberName(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
const memb = try rt.it.next();
|
|
|
|
var result = &rt.results[id];
|
|
|
|
if (result.variant == null) {
|
|
result.variant = .{
|
|
.Type = .{
|
|
.Structure = .{
|
|
.members_type_word = undefined,
|
|
.members_offsets = undefined,
|
|
.member_names = .empty,
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
switch (result.variant.?) {
|
|
.Type => |*t| switch (t.*) {
|
|
.Structure => |*s| {
|
|
if (memb + 1 > s.member_names.items.len) {
|
|
_ = s.member_names.resize(allocator, memb + 1) catch return RuntimeError.OutOfMemory;
|
|
}
|
|
const slen = word_count - 2;
|
|
s.member_names.items[memb] = try readStringN(allocator, &rt.it, slen);
|
|
},
|
|
else => unreachable,
|
|
},
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
fn opMemoryModel(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
rt.mod.addressing = try rt.it.nextAs(spv.SpvAddressingModel);
|
|
rt.mod.memory_model = try rt.it.nextAs(spv.SpvMemoryModel);
|
|
}
|
|
|
|
fn opName(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
var result = &rt.results[id];
|
|
result.name = try readStringN(allocator, &rt.it, word_count - 1);
|
|
}
|
|
|
|
fn opPhi(_: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = try rt.it.next(); // result type
|
|
const id = try rt.it.next();
|
|
|
|
const predecessor = rt.previous_label orelse return RuntimeError.InvalidSpirV;
|
|
const pair_count = @divExact(word_count - 2, 2);
|
|
|
|
for (0..pair_count) |_| {
|
|
const value_id = try rt.it.next();
|
|
const parent_label_id = try rt.it.next();
|
|
|
|
if (parent_label_id == predecessor) {
|
|
try copyValue(try rt.results[id].getValue(), try rt.results[value_id].getValue());
|
|
return;
|
|
}
|
|
}
|
|
return RuntimeError.InvalidSpirV;
|
|
}
|
|
|
|
fn opReturn(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.function_stack.pop();
|
|
if (rt.function_stack.getLastOrNull()) |function| {
|
|
_ = rt.it.jumpToSourceLocation(function.source_location);
|
|
rt.current_function = function.result;
|
|
} else {
|
|
rt.current_function = null;
|
|
rt.it.skipToEnd();
|
|
}
|
|
}
|
|
|
|
fn opReturnValue(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
if (rt.function_stack.getLastOrNull()) |function| {
|
|
var ret_res = rt.results[try rt.it.next()];
|
|
try copyValue(try function.ret.getValue(), try ret_res.getValue());
|
|
} else {
|
|
return RuntimeError.InvalidSpirV; // No current function ???
|
|
}
|
|
|
|
_ = rt.function_stack.pop();
|
|
if (rt.function_stack.getLastOrNull()) |function| {
|
|
_ = rt.it.jumpToSourceLocation(function.source_location);
|
|
rt.current_function = function.result;
|
|
} else {
|
|
rt.current_function = null;
|
|
rt.it.skipToEnd();
|
|
}
|
|
}
|
|
|
|
fn opSelect(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = rt.it.skip();
|
|
const id = try rt.it.next();
|
|
const cond = try rt.it.next();
|
|
const obj1 = try rt.it.next();
|
|
const obj2 = try rt.it.next();
|
|
|
|
const target_val = try rt.results[id].getValue();
|
|
const cond_val = try rt.results[cond].getValue();
|
|
const obj1_val = try rt.results[obj1].getValue();
|
|
const obj2_val = try rt.results[obj2].getValue();
|
|
|
|
if (target_val.getCompositeDataOrNull()) |*targets| {
|
|
for (
|
|
targets.*,
|
|
cond_val.getCompositeDataOrNull().?,
|
|
obj1_val.getCompositeDataOrNull().?,
|
|
obj2_val.getCompositeDataOrNull().?,
|
|
) |*t, c, o1, o2| {
|
|
try copyValue(t, if (c.Bool) &o1 else &o2);
|
|
}
|
|
return;
|
|
}
|
|
|
|
switch (target_val.*) {
|
|
.Bool, .Int, .Float => try copyValue(target_val, if (cond_val.Bool) obj1_val else obj2_val),
|
|
|
|
.Vector4f32 => |*v| {
|
|
const cond_vec = @Vector(4, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
cond_val.Vector[2].Bool,
|
|
cond_val.Vector[3].Bool,
|
|
};
|
|
v.* = @select(f32, cond_vec, obj1_val.Vector4f32, obj2_val.Vector4f32);
|
|
},
|
|
.Vector3f32 => |*v| {
|
|
const cond_vec = @Vector(3, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
cond_val.Vector[2].Bool,
|
|
};
|
|
v.* = @select(f32, cond_vec, obj1_val.Vector3f32, obj2_val.Vector3f32);
|
|
},
|
|
.Vector2f32 => |*v| {
|
|
const cond_vec = @Vector(2, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
};
|
|
v.* = @select(f32, cond_vec, obj1_val.Vector2f32, obj2_val.Vector2f32);
|
|
},
|
|
|
|
.Vector4i32 => |*v| {
|
|
const cond_vec = @Vector(4, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
cond_val.Vector[2].Bool,
|
|
cond_val.Vector[3].Bool,
|
|
};
|
|
v.* = @select(i32, cond_vec, obj1_val.Vector4i32, obj2_val.Vector4i32);
|
|
},
|
|
.Vector3i32 => |*v| {
|
|
const cond_vec = @Vector(3, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
cond_val.Vector[2].Bool,
|
|
};
|
|
v.* = @select(i32, cond_vec, obj1_val.Vector3i32, obj2_val.Vector3i32);
|
|
},
|
|
.Vector2i32 => |*v| {
|
|
const cond_vec = @Vector(2, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
};
|
|
v.* = @select(i32, cond_vec, obj1_val.Vector2i32, obj2_val.Vector2i32);
|
|
},
|
|
|
|
.Vector4u32 => |*v| {
|
|
const cond_vec = @Vector(4, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
cond_val.Vector[2].Bool,
|
|
cond_val.Vector[3].Bool,
|
|
};
|
|
v.* = @select(u32, cond_vec, obj1_val.Vector4u32, obj2_val.Vector4u32);
|
|
},
|
|
.Vector3u32 => |*v| {
|
|
const cond_vec = @Vector(3, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
cond_val.Vector[2].Bool,
|
|
};
|
|
v.* = @select(u32, cond_vec, obj1_val.Vector3u32, obj2_val.Vector3u32);
|
|
},
|
|
.Vector2u32 => |*v| {
|
|
const cond_vec = @Vector(2, bool){
|
|
cond_val.Vector[0].Bool,
|
|
cond_val.Vector[1].Bool,
|
|
};
|
|
v.* = @select(u32, cond_vec, obj1_val.Vector2u32, obj2_val.Vector2u32);
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
|
|
fn opSourceExtension(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
rt.mod.extensions.append(allocator, try readStringN(allocator, &rt.it, word_count)) catch return RuntimeError.OutOfMemory;
|
|
}
|
|
|
|
fn opStore(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const ptr_id = try rt.it.next();
|
|
const val_id = try rt.it.next();
|
|
try copyValue(try rt.results[ptr_id].getValue(), try rt.results[val_id].getValue());
|
|
}
|
|
|
|
fn opTypeArray(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
var target = &rt.results[id];
|
|
const components_type_word = try rt.it.next();
|
|
const components_type_data = &((try rt.results[components_type_word].getVariant()).*).Type;
|
|
target.variant = .{
|
|
.Type = .{
|
|
.Array = .{
|
|
.components_type_word = components_type_word,
|
|
.components_type = switch ((try rt.results[components_type_word].getVariant()).*) {
|
|
.Type => |t| @as(Result.Type, t),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.member_count = switch ((try rt.results[try rt.it.next()].getValue()).*) {
|
|
.Int => |i| if (!i.is_signed) @intCast(i.value.uint64) else switch (i.bit_count) {
|
|
8 => @intCast(i.value.sint8),
|
|
16 => @intCast(i.value.sint8),
|
|
32 => @intCast(i.value.sint8),
|
|
64 => @intCast(i.value.sint8),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.stride = blk: {
|
|
for (target.decorations.items) |decoration| {
|
|
if (decoration.rtype == .ArrayStride)
|
|
break :blk decoration.literal_1;
|
|
}
|
|
break :blk @intCast(components_type_data.getSize(rt.results));
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeBool(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Bool = .{},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeFloat(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Float = .{
|
|
.bit_length = try rt.it.next(),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeFunction(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Function = .{
|
|
.source_location = 0,
|
|
.return_type = try rt.it.next(),
|
|
.params = blk: {
|
|
const params = allocator.alloc(SpvWord, word_count - 2) catch return RuntimeError.OutOfMemory;
|
|
errdefer allocator.free(params);
|
|
for (params) |*param| {
|
|
param.* = try rt.it.next();
|
|
}
|
|
break :blk params;
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeImage(_: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
_ = rt.it.skip(); // TODO: sampled type management
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Image = .{
|
|
.dim = try rt.it.nextAs(spv.SpvDim),
|
|
.depth = @truncate(try rt.it.next()),
|
|
.arrayed = @truncate(try rt.it.next()),
|
|
.ms = @truncate(try rt.it.next()),
|
|
.sampled = @truncate(try rt.it.next()),
|
|
.format = try rt.it.nextAs(spv.SpvImageFormat),
|
|
.access = null,
|
|
},
|
|
},
|
|
};
|
|
if (word_count > 8) {
|
|
rt.results[id].variant.?.Type.Image.access = try rt.it.nextAs(spv.SpvAccessQualifier);
|
|
}
|
|
}
|
|
|
|
fn opTypeSampledImage(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.SampledImage = .{
|
|
.image_type = try rt.it.next(),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeInt(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Int = .{
|
|
.bit_length = try rt.it.next(),
|
|
.is_signed = if (try rt.it.next() != 0) true else false,
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeMatrix(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
const column_type_word = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Matrix = .{
|
|
.column_type_word = column_type_word,
|
|
.column_type = switch ((try rt.results[column_type_word].getVariant()).*) {
|
|
.Type => |t| @as(Result.Type, t),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.member_count = try rt.it.next(),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypePointer(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Pointer = .{
|
|
.storage_class = try rt.it.nextAs(spv.SpvStorageClass),
|
|
.target = try rt.it.next(),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeRuntimeArray(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
var target = &rt.results[id];
|
|
const components_type_word = try rt.it.next();
|
|
const components_type_data = &((try rt.results[components_type_word].getVariant()).*).Type;
|
|
target.variant = .{
|
|
.Type = .{
|
|
.RuntimeArray = .{
|
|
.components_type_word = components_type_word,
|
|
.components_type = @as(Result.Type, components_type_data.*),
|
|
.stride = blk: {
|
|
for (target.decorations.items) |decoration| {
|
|
if (decoration.rtype == .ArrayStride)
|
|
break :blk decoration.literal_1;
|
|
}
|
|
break :blk @intCast(components_type_data.getSize(rt.results));
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeStruct(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
const members_type_word = blk: {
|
|
const members_type_word = allocator.alloc(SpvWord, word_count - 1) catch return RuntimeError.OutOfMemory;
|
|
errdefer allocator.free(members_type_word);
|
|
|
|
for (members_type_word) |*member_type_word| {
|
|
member_type_word.* = try rt.it.next();
|
|
}
|
|
break :blk members_type_word;
|
|
};
|
|
const members_offsets = allocator.alloc(?SpvWord, word_count - 1) catch return RuntimeError.OutOfMemory;
|
|
@memset(members_offsets, null);
|
|
|
|
if (rt.results[id].variant) |*variant| {
|
|
switch (variant.*) {
|
|
.Type => |*t| switch (t.*) {
|
|
.Structure => |*s| {
|
|
s.members_type_word = members_type_word;
|
|
s.members_offsets = members_offsets;
|
|
},
|
|
else => unreachable,
|
|
},
|
|
else => unreachable,
|
|
}
|
|
} else {
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Structure = .{
|
|
.members_type_word = members_type_word,
|
|
.members_offsets = members_offsets,
|
|
.member_names = .empty,
|
|
},
|
|
},
|
|
};
|
|
}
|
|
}
|
|
|
|
fn opTypeVector(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
const components_type_word = try rt.it.next();
|
|
var components_type_size: usize = 0;
|
|
const components_type_concrete = try rt.results[components_type_word].getVariant();
|
|
const components_type = switch (components_type_concrete.*) {
|
|
.Type => |t| blk: {
|
|
switch (t) {
|
|
.Int => |i| components_type_size = i.bit_length,
|
|
.Float => |f| components_type_size = f.bit_length,
|
|
else => {},
|
|
}
|
|
break :blk @as(Result.Type, t);
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
const member_count = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = blk: {
|
|
if (components_type_size == 32 and rt.mod.options.use_simd_vectors_specializations) {
|
|
switch (components_type) {
|
|
.Float => switch (member_count) {
|
|
2 => break :blk .{ .Vector2f32 = .{} },
|
|
3 => break :blk .{ .Vector3f32 = .{} },
|
|
4 => break :blk .{ .Vector4f32 = .{} },
|
|
else => {},
|
|
},
|
|
.Int => {
|
|
const is_signed = components_type_concrete.Type.Int.is_signed;
|
|
switch (member_count) {
|
|
2 => break :blk if (is_signed) .{ .Vector2i32 = .{} } else .{ .Vector2u32 = .{} },
|
|
3 => break :blk if (is_signed) .{ .Vector3i32 = .{} } else .{ .Vector3u32 = .{} },
|
|
4 => break :blk if (is_signed) .{ .Vector4i32 = .{} } else .{ .Vector4u32 = .{} },
|
|
else => {},
|
|
}
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
break :blk .{
|
|
.Vector = .{
|
|
.components_type_word = components_type_word,
|
|
.components_type = components_type,
|
|
.member_count = member_count,
|
|
},
|
|
};
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opTypeVoid(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const id = try rt.it.next();
|
|
rt.results[id].variant = .{
|
|
.Type = .{
|
|
.Void = .{},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn opVariable(allocator: std.mem.Allocator, word_count: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
const var_type = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
const storage_class = try rt.it.nextAs(spv.SpvStorageClass);
|
|
const initializer: ?SpvWord = if (word_count >= 4) try rt.it.next() else null;
|
|
|
|
const target = &rt.results[id];
|
|
|
|
const resolved_word = if (rt.results[var_type].resolveTypeWordOrNull()) |word| word else var_type;
|
|
const resolved = &rt.results[resolved_word];
|
|
|
|
const resolved_type = switch ((try resolved.getConstVariant()).*) {
|
|
.Type => |t| @as(Result.Type, t),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
|
|
const externally_visible_data_storages = [_]spv.SpvStorageClass{
|
|
.Uniform,
|
|
.StorageBuffer,
|
|
.PushConstant,
|
|
};
|
|
|
|
const is_externally_visible = std.mem.containsAtLeastScalar(spv.SpvStorageClass, &externally_visible_data_storages, 1, storage_class);
|
|
|
|
target.variant = .{
|
|
.Variable = .{
|
|
.storage_class = storage_class,
|
|
.type_word = resolved_word,
|
|
.type = resolved_type,
|
|
.value = try Value.init(allocator, rt.results, resolved_word, is_externally_visible),
|
|
},
|
|
};
|
|
|
|
_ = initializer;
|
|
}
|
|
|
|
fn opVectorShuffle(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
|
|
_ = try rt.it.next();
|
|
|
|
const result_id = try rt.it.next();
|
|
const vector_1_id = try rt.it.next();
|
|
const vector_2_id = try rt.it.next();
|
|
|
|
const dst = try rt.results[result_id].getValue();
|
|
const vector_1 = try rt.results[vector_1_id].getValue();
|
|
const vector_2 = try rt.results[vector_2_id].getValue();
|
|
|
|
const Impl = struct {
|
|
fn readLane(src: *const Value, lane_index: usize) RuntimeError!Value {
|
|
return switch (src.*) {
|
|
.Vector => |lanes| {
|
|
if (lane_index >= lanes.len) return RuntimeError.InvalidSpirV;
|
|
return lanes[lane_index];
|
|
},
|
|
|
|
.Vector2f32 => |lanes| return .{ .Float = .{
|
|
.bit_count = 32,
|
|
.value = .{ .float32 = switch (lane_index) {
|
|
inline 0...1 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
.Vector3f32 => |lanes| return .{ .Float = .{
|
|
.bit_count = 32,
|
|
.value = .{ .float32 = switch (lane_index) {
|
|
inline 0...2 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
.Vector4f32 => |lanes| return .{ .Float = .{
|
|
.bit_count = 32,
|
|
.value = .{ .float32 = switch (lane_index) {
|
|
inline 0...3 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
|
|
.Vector2i32 => |lanes| return .{ .Int = .{
|
|
.bit_count = 32,
|
|
.is_signed = true,
|
|
.value = .{ .sint32 = switch (lane_index) {
|
|
inline 0...1 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
.Vector3i32 => |lanes| return .{ .Int = .{
|
|
.bit_count = 32,
|
|
.is_signed = true,
|
|
.value = .{ .sint32 = switch (lane_index) {
|
|
inline 0...2 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
.Vector4i32 => |lanes| return .{ .Int = .{
|
|
.bit_count = 32,
|
|
.is_signed = true,
|
|
.value = .{ .sint32 = switch (lane_index) {
|
|
inline 0...3 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
|
|
.Vector2u32 => |lanes| return .{ .Int = .{
|
|
.bit_count = 32,
|
|
.is_signed = false,
|
|
.value = .{ .uint32 = switch (lane_index) {
|
|
inline 0...1 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
.Vector3u32 => |lanes| return .{ .Int = .{
|
|
.bit_count = 32,
|
|
.is_signed = false,
|
|
.value = .{ .uint32 = switch (lane_index) {
|
|
inline 0...2 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
.Vector4u32 => |lanes| return .{ .Int = .{
|
|
.bit_count = 32,
|
|
.is_signed = false,
|
|
.value = .{ .uint32 = switch (lane_index) {
|
|
inline 0...3 => |idx| lanes[idx],
|
|
else => return RuntimeError.OutOfBounds,
|
|
} },
|
|
} },
|
|
|
|
else => return RuntimeError.InvalidSpirV,
|
|
};
|
|
}
|
|
|
|
fn writeLane(dst_value: *Value, lane_index: usize, lane_value: Value) RuntimeError!void {
|
|
switch (dst_value.*) {
|
|
.Vector => |lanes| {
|
|
if (lane_index >= lanes.len) return RuntimeError.InvalidSpirV;
|
|
lanes[lane_index] = lane_value;
|
|
},
|
|
|
|
.Vector2f32 => |*lanes| switch (lane_value) {
|
|
.Float => |f| {
|
|
if (f.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...1 => |i| lanes[i] = f.value.float32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3f32 => |*lanes| switch (lane_value) {
|
|
.Float => |f| {
|
|
if (f.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...2 => |i| lanes[i] = f.value.float32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector4f32 => |*lanes| switch (lane_value) {
|
|
.Float => |f| {
|
|
if (f.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...3 => |i| lanes[i] = f.value.float32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
.Vector2i32 => |*lanes| switch (lane_value) {
|
|
.Int => |i| {
|
|
if (i.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...1 => |idx| lanes[idx] = i.value.sint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3i32 => |*lanes| switch (lane_value) {
|
|
.Int => |i| {
|
|
if (i.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...2 => |idx| lanes[idx] = i.value.sint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector4i32 => |*lanes| switch (lane_value) {
|
|
.Int => |i| {
|
|
if (i.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...3 => |idx| lanes[idx] = i.value.sint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
.Vector2u32 => |*lanes| switch (lane_value) {
|
|
.Int => |i| {
|
|
if (i.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...1 => |idx| lanes[idx] = i.value.uint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector3u32 => |*lanes| switch (lane_value) {
|
|
.Int => |i| {
|
|
if (i.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...2 => |idx| lanes[idx] = i.value.uint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
.Vector4u32 => |*lanes| switch (lane_value) {
|
|
.Int => |i| {
|
|
if (i.bit_count != 32) return RuntimeError.InvalidSpirV;
|
|
switch (lane_index) {
|
|
inline 0...3 => |idx| lanes[idx] = i.value.uint32,
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
},
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
|
|
else => return RuntimeError.InvalidSpirV,
|
|
}
|
|
}
|
|
};
|
|
|
|
const dst_lane_count = try dst.resolveLaneCount();
|
|
const vector_1_lane_count = try vector_1.resolveLaneCount();
|
|
const vector_2_lane_count = try vector_2.resolveLaneCount();
|
|
|
|
for (0..dst_lane_count) |lane_index| {
|
|
const selector = try rt.it.next();
|
|
|
|
if (selector == std.math.maxInt(u32)) {
|
|
continue;
|
|
}
|
|
|
|
const lane_value = if (selector < vector_1_lane_count)
|
|
try Impl.readLane(vector_1, selector)
|
|
else blk: {
|
|
const rhs_index = selector - vector_1_lane_count;
|
|
if (rhs_index >= vector_2_lane_count) return RuntimeError.InvalidSpirV;
|
|
break :blk try Impl.readLane(vector_2, rhs_index);
|
|
};
|
|
|
|
try Impl.writeLane(dst, lane_index, lane_value);
|
|
}
|
|
}
|
|
|
|
fn readString(allocator: std.mem.Allocator, it: *WordIterator) RuntimeError![]const u8 {
|
|
var str: std.ArrayList(u8) = .empty;
|
|
while (it.nextOrNull()) |word| {
|
|
if (word == 0) break;
|
|
(str.addOne(allocator) catch return RuntimeError.OutOfMemory).* = @truncate(word & 0x000000FF);
|
|
(str.addOne(allocator) catch return RuntimeError.OutOfMemory).* = @truncate((word & 0x0000FF00) >> 8);
|
|
(str.addOne(allocator) catch return RuntimeError.OutOfMemory).* = @truncate((word & 0x00FF0000) >> 16);
|
|
(str.addOne(allocator) catch return RuntimeError.OutOfMemory).* = @truncate((word & 0xFF000000) >> 24);
|
|
if (str.getLast() == 0) break;
|
|
}
|
|
return str.toOwnedSlice(allocator);
|
|
}
|
|
|
|
fn readStringN(allocator: std.mem.Allocator, it: *WordIterator, n: usize) RuntimeError![]const u8 {
|
|
var str = std.ArrayList(u8).initCapacity(allocator, n * 4) catch return RuntimeError.OutOfMemory;
|
|
for (0..n) |_| {
|
|
if (it.nextOrNull()) |word| {
|
|
if (word == 0) break;
|
|
str.addOneAssumeCapacity().* = @truncate(word & 0x000000FF);
|
|
str.addOneAssumeCapacity().* = @truncate((word & 0x0000FF00) >> 8);
|
|
str.addOneAssumeCapacity().* = @truncate((word & 0x00FF0000) >> 16);
|
|
str.addOneAssumeCapacity().* = @truncate((word & 0xFF000000) >> 24);
|
|
if (str.getLast() == 0) break;
|
|
}
|
|
}
|
|
return str.toOwnedSlice(allocator);
|
|
}
|
|
|
|
fn setupConstant(allocator: std.mem.Allocator, rt: *Runtime) RuntimeError!*Result {
|
|
const res_type = try rt.it.next();
|
|
const id = try rt.it.next();
|
|
const target = &rt.results[id];
|
|
|
|
const resolved = rt.results[res_type].resolveType(rt.results);
|
|
target.variant = .{
|
|
.Constant = .{
|
|
.value = try Value.init(allocator, rt.results, res_type, false),
|
|
.type_word = res_type,
|
|
.type = switch ((try resolved.getConstVariant()).*) {
|
|
.Type => |t| @as(Result.Type, t),
|
|
else => return RuntimeError.InvalidSpirV,
|
|
},
|
|
},
|
|
};
|
|
return target;
|
|
}
|